blob: 51905634be23bdf0c5515732b75cbe3f93a92c88 [file] [log] [blame]
Kamil Rytarowskicb77f0d2017-05-07 23:25:26 +02001#!/usr/bin/env perl
Dave Jonesdbf004d2010-01-12 16:59:52 -05002# (c) 2001, Dave Jones. (the file handling bit)
Andy Whitcroft00df3442007-06-08 13:47:06 -07003# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
Andy Whitcroft2a5a2c22009-01-06 14:41:23 -08004# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
Andy Whitcroft015830be2010-10-26 14:23:17 -07005# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07006# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
Kamil Rytarowskicb77f0d2017-05-07 23:25:26 +02009use warnings;
Joe Perchesc707a812013-07-08 16:00:43 -070010use POSIX;
Joe Perches36061e32014-12-10 15:51:43 -080011use File::Basename;
12use Cwd 'abs_path';
Joe Perches57230292015-06-25 15:03:03 -070013use Term::ANSIColor qw(:constants);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -070014
15my $P = $0;
Joe Perches36061e32014-12-10 15:51:43 -080016my $D = dirname(abs_path($P));
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -070017
Joe Perches000d1cc12011-07-25 17:13:25 -070018my $V = '0.32';
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -070019
20use Getopt::Long qw(:config no_auto_abbrev);
21
22my $quiet = 0;
23my $tree = 1;
24my $chk_signoff = 1;
25my $chk_patch = 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -070026my $tst_only;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070027my $emacs = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080028my $terse = 0;
Joe Perches34d88152015-06-25 15:03:05 -070029my $showfile = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070030my $file = 0;
Du, Changbin4a593c32016-05-20 17:04:16 -070031my $git = 0;
Joe Perches0dea9f1e2016-05-20 17:04:19 -070032my %git_commits = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070033my $check = 0;
Joe Perches2ac73b42014-06-04 16:12:05 -070034my $check_orig = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -080035my $summary = 1;
36my $mailback = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -080037my $summary_file = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070038my $show_types = 0;
Joe Perches3beb42e2016-05-20 17:04:14 -070039my $list_types = 0;
Joe Perches3705ce52013-07-03 15:05:31 -070040my $fix = 0;
Joe Perches9624b8d2014-01-23 15:54:44 -080041my $fix_inplace = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -070042my $root;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -080043my %debug;
Joe Perches34456862013-07-03 15:05:34 -070044my %camelcase = ();
Joe Perches91bfe482013-09-11 14:23:59 -070045my %use_type = ();
46my @use = ();
47my %ignore_type = ();
Joe Perches000d1cc12011-07-25 17:13:25 -070048my @ignore = ();
Hannes Eder77f5b102009-09-21 17:04:37 -070049my $help = 0;
Joe Perches000d1cc12011-07-25 17:13:25 -070050my $configuration_file = ".checkpatch.conf";
Joe Perches6cd7f382012-12-17 16:01:54 -080051my $max_line_length = 80;
Dave Hansend62a2012013-09-11 14:23:56 -070052my $ignore_perl_version = 0;
53my $minimum_perl_version = 5.10.0;
Vadim Bendebury56193272014-10-13 15:51:48 -070054my $min_conf_desc_length = 4;
Kees Cook66b47b42014-10-13 15:51:57 -070055my $spelling_file = "$D/spelling.txt";
Joe Perchesebfd7d62015-04-16 12:44:14 -070056my $codespell = 0;
Maxim Uvarovf1a63672015-06-25 15:03:08 -070057my $codespellfile = "/usr/share/codespell/dictionary.txt";
Joe Perchesbf1fa1d2016-10-11 13:51:56 -070058my $conststructsfile = "$D/const_structs.checkpatch";
Jerome Forissier75ad8c52017-05-08 15:56:00 -070059my $typedefsfile = "";
John Brooks737c0762017-07-10 15:52:24 -070060my $color = "auto";
Joe Perchesdadf6802016-08-02 14:04:33 -070061my $allow_c99_comments = 1;
Hannes Eder77f5b102009-09-21 17:04:37 -070062
63sub help {
64 my ($exitcode) = @_;
65
66 print << "EOM";
67Usage: $P [OPTION]... [FILE]...
68Version: $V
69
70Options:
71 -q, --quiet quiet
72 --no-tree run without a kernel tree
73 --no-signoff do not check for 'Signed-off-by' line
74 --patch treat FILE as patchfile (default)
75 --emacs emacs compile window format
76 --terse one line per report
Joe Perches34d88152015-06-25 15:03:05 -070077 --showfile emit diffed file position, not input file position
Du, Changbin4a593c32016-05-20 17:04:16 -070078 -g, --git treat FILE as a single commit or git revision range
79 single git commit with:
80 <rev>
81 <rev>^
82 <rev>~n
83 multiple git commits with:
84 <rev1>..<rev2>
85 <rev1>...<rev2>
86 <rev>-<count>
87 git merges are ignored
Hannes Eder77f5b102009-09-21 17:04:37 -070088 -f, --file treat FILE as regular source file
89 --subjective, --strict enable more subjective tests
Joe Perches3beb42e2016-05-20 17:04:14 -070090 --list-types list the possible message types
Joe Perches91bfe482013-09-11 14:23:59 -070091 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Perches000d1cc12011-07-25 17:13:25 -070092 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Joe Perches3beb42e2016-05-20 17:04:14 -070093 --show-types show the specific message type in the output
Joe Perches6cd7f382012-12-17 16:01:54 -080094 --max-line-length=n set the maximum line length, if exceeded, warn
Vadim Bendebury56193272014-10-13 15:51:48 -070095 --min-conf-desc-length=n set the min description length, if shorter, warn
Hannes Eder77f5b102009-09-21 17:04:37 -070096 --root=PATH PATH to the kernel tree root
97 --no-summary suppress the per-file summary
98 --mailback only produce a report in case of warnings/errors
99 --summary-file include the filename in summary
100 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
101 'values', 'possible', 'type', and 'attr' (default
102 is all off)
103 --test-only=WORD report only warnings/errors containing WORD
104 literally
Joe Perches3705ce52013-07-03 15:05:31 -0700105 --fix EXPERIMENTAL - may create horrible results
106 If correctable single-line errors exist, create
107 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
108 with potential errors corrected to the preferred
109 checkpatch style
Joe Perches9624b8d2014-01-23 15:54:44 -0800110 --fix-inplace EXPERIMENTAL - may create horrible results
111 Is the same as --fix, but overwrites the input
112 file. It's your fault if there's no backup or git
Dave Hansend62a2012013-09-11 14:23:56 -0700113 --ignore-perl-version override checking of perl version. expect
114 runtime errors.
Joe Perchesebfd7d62015-04-16 12:44:14 -0700115 --codespell Use the codespell dictionary for spelling/typos
Maxim Uvarovf1a63672015-06-25 15:03:08 -0700116 (default:/usr/share/codespell/dictionary.txt)
Joe Perchesebfd7d62015-04-16 12:44:14 -0700117 --codespellfile Use this codespell dictionary
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700118 --typedefsfile Read additional types from this file
John Brooks737c0762017-07-10 15:52:24 -0700119 --color[=WHEN] Use colors 'always', 'never', or only when output
120 is a terminal ('auto'). Default is 'auto'.
Hannes Eder77f5b102009-09-21 17:04:37 -0700121 -h, --help, --version display this help and exit
122
123When FILE is - read standard input.
124EOM
125
126 exit($exitcode);
127}
128
Joe Perches3beb42e2016-05-20 17:04:14 -0700129sub uniq {
130 my %seen;
131 return grep { !$seen{$_}++ } @_;
132}
133
134sub list_types {
135 my ($exitcode) = @_;
136
137 my $count = 0;
138
139 local $/ = undef;
140
141 open(my $script, '<', abs_path($P)) or
142 die "$P: Can't read '$P' $!\n";
143
144 my $text = <$script>;
145 close($script);
146
147 my @types = ();
Jean Delvare0547fa52017-09-08 16:16:11 -0700148 # Also catch when type or level is passed through a variable
149 for ($text =~ /(?:(?:\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
Joe Perches3beb42e2016-05-20 17:04:14 -0700150 push (@types, $_);
151 }
152 @types = sort(uniq(@types));
153 print("#\tMessage type\n\n");
154 foreach my $type (@types) {
155 print(++$count . "\t" . $type . "\n");
156 }
157
158 exit($exitcode);
159}
160
Joe Perches000d1cc12011-07-25 17:13:25 -0700161my $conf = which_conf($configuration_file);
162if (-f $conf) {
163 my @conf_args;
164 open(my $conffile, '<', "$conf")
165 or warn "$P: Can't find a readable $configuration_file file $!\n";
166
167 while (<$conffile>) {
168 my $line = $_;
169
170 $line =~ s/\s*\n?$//g;
171 $line =~ s/^\s*//g;
172 $line =~ s/\s+/ /g;
173
174 next if ($line =~ m/^\s*#/);
175 next if ($line =~ m/^\s*$/);
176
177 my @words = split(" ", $line);
178 foreach my $word (@words) {
179 last if ($word =~ m/^#/);
180 push (@conf_args, $word);
181 }
182 }
183 close($conffile);
184 unshift(@ARGV, @conf_args) if @conf_args;
185}
186
John Brooks737c0762017-07-10 15:52:24 -0700187# Perl's Getopt::Long allows options to take optional arguments after a space.
188# Prevent --color by itself from consuming other arguments
189foreach (@ARGV) {
190 if ($_ eq "--color" || $_ eq "-color") {
191 $_ = "--color=$color";
192 }
193}
194
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700195GetOptions(
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700196 'q|quiet+' => \$quiet,
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700197 'tree!' => \$tree,
198 'signoff!' => \$chk_signoff,
199 'patch!' => \$chk_patch,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700200 'emacs!' => \$emacs,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800201 'terse!' => \$terse,
Joe Perches34d88152015-06-25 15:03:05 -0700202 'showfile!' => \$showfile,
Hannes Eder77f5b102009-09-21 17:04:37 -0700203 'f|file!' => \$file,
Du, Changbin4a593c32016-05-20 17:04:16 -0700204 'g|git!' => \$git,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700205 'subjective!' => \$check,
206 'strict!' => \$check,
Joe Perches000d1cc12011-07-25 17:13:25 -0700207 'ignore=s' => \@ignore,
Joe Perches91bfe482013-09-11 14:23:59 -0700208 'types=s' => \@use,
Joe Perches000d1cc12011-07-25 17:13:25 -0700209 'show-types!' => \$show_types,
Joe Perches3beb42e2016-05-20 17:04:14 -0700210 'list-types!' => \$list_types,
Joe Perches6cd7f382012-12-17 16:01:54 -0800211 'max-line-length=i' => \$max_line_length,
Vadim Bendebury56193272014-10-13 15:51:48 -0700212 'min-conf-desc-length=i' => \$min_conf_desc_length,
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700213 'root=s' => \$root,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800214 'summary!' => \$summary,
215 'mailback!' => \$mailback,
Andy Whitcroft13214ad2008-02-08 04:22:03 -0800216 'summary-file!' => \$summary_file,
Joe Perches3705ce52013-07-03 15:05:31 -0700217 'fix!' => \$fix,
Joe Perches9624b8d2014-01-23 15:54:44 -0800218 'fix-inplace!' => \$fix_inplace,
Dave Hansend62a2012013-09-11 14:23:56 -0700219 'ignore-perl-version!' => \$ignore_perl_version,
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800220 'debug=s' => \%debug,
Andy Whitcroft773647a2008-03-28 14:15:58 -0700221 'test-only=s' => \$tst_only,
Joe Perchesebfd7d62015-04-16 12:44:14 -0700222 'codespell!' => \$codespell,
223 'codespellfile=s' => \$codespellfile,
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700224 'typedefsfile=s' => \$typedefsfile,
John Brooks737c0762017-07-10 15:52:24 -0700225 'color=s' => \$color,
226 'no-color' => \$color, #keep old behaviors of -nocolor
227 'nocolor' => \$color, #keep old behaviors of -nocolor
Hannes Eder77f5b102009-09-21 17:04:37 -0700228 'h|help' => \$help,
229 'version' => \$help
230) or help(1);
231
232help(0) if ($help);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700233
Joe Perches3beb42e2016-05-20 17:04:14 -0700234list_types(0) if ($list_types);
235
Joe Perches9624b8d2014-01-23 15:54:44 -0800236$fix = 1 if ($fix_inplace);
Joe Perches2ac73b42014-06-04 16:12:05 -0700237$check_orig = $check;
Joe Perches9624b8d2014-01-23 15:54:44 -0800238
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700239my $exit = 0;
240
Dave Hansend62a2012013-09-11 14:23:56 -0700241if ($^V && $^V lt $minimum_perl_version) {
242 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
243 if (!$ignore_perl_version) {
244 exit(1);
245 }
246}
247
Allen Hubbe45107ff2016-08-02 14:04:47 -0700248#if no filenames are given, push '-' to read patch from stdin
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700249if ($#ARGV < 0) {
Allen Hubbe45107ff2016-08-02 14:04:47 -0700250 push(@ARGV, '-');
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700251}
252
John Brooks737c0762017-07-10 15:52:24 -0700253if ($color =~ /^[01]$/) {
254 $color = !$color;
255} elsif ($color =~ /^always$/i) {
256 $color = 1;
257} elsif ($color =~ /^never$/i) {
258 $color = 0;
259} elsif ($color =~ /^auto$/i) {
260 $color = (-t STDOUT);
261} else {
262 die "Invalid color mode: $color\n";
263}
264
Joe Perches91bfe482013-09-11 14:23:59 -0700265sub hash_save_array_words {
266 my ($hashRef, $arrayRef) = @_;
Joe Perches000d1cc12011-07-25 17:13:25 -0700267
Joe Perches91bfe482013-09-11 14:23:59 -0700268 my @array = split(/,/, join(',', @$arrayRef));
269 foreach my $word (@array) {
270 $word =~ s/\s*\n?$//g;
271 $word =~ s/^\s*//g;
272 $word =~ s/\s+/ /g;
273 $word =~ tr/[a-z]/[A-Z]/;
Joe Perches000d1cc12011-07-25 17:13:25 -0700274
Joe Perches91bfe482013-09-11 14:23:59 -0700275 next if ($word =~ m/^\s*#/);
276 next if ($word =~ m/^\s*$/);
277
278 $hashRef->{$word}++;
279 }
Joe Perches000d1cc12011-07-25 17:13:25 -0700280}
281
Joe Perches91bfe482013-09-11 14:23:59 -0700282sub hash_show_words {
283 my ($hashRef, $prefix) = @_;
284
Joe Perches3c816e42015-06-25 15:03:29 -0700285 if (keys %$hashRef) {
Joe Perchesd8469f12015-06-25 15:03:00 -0700286 print "\nNOTE: $prefix message types:";
Joe Perches58cb3cf2013-09-11 14:24:04 -0700287 foreach my $word (sort keys %$hashRef) {
Joe Perches91bfe482013-09-11 14:23:59 -0700288 print " $word";
289 }
Joe Perchesd8469f12015-06-25 15:03:00 -0700290 print "\n";
Joe Perches91bfe482013-09-11 14:23:59 -0700291 }
292}
293
294hash_save_array_words(\%ignore_type, \@ignore);
295hash_save_array_words(\%use_type, \@use);
296
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800297my $dbg_values = 0;
298my $dbg_possible = 0;
Andy Whitcroft7429c692008-07-23 21:29:06 -0700299my $dbg_type = 0;
Andy Whitcrofta1ef2772008-10-15 22:02:17 -0700300my $dbg_attr = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800301for my $key (keys %debug) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800302 ## no critic
303 eval "\${dbg_$key} = '$debug{$key}';";
304 die "$@" if ($@);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800305}
306
Andy Whitcroftd2c0a232010-10-26 14:23:12 -0700307my $rpt_cleaners = 0;
308
Andy Whitcroft8905a672007-11-28 16:21:06 -0800309if ($terse) {
310 $emacs = 1;
311 $quiet++;
312}
313
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700314if ($tree) {
315 if (defined $root) {
316 if (!top_of_kernel_tree($root)) {
317 die "$P: $root: --root does not point at a valid tree\n";
318 }
319 } else {
320 if (top_of_kernel_tree('.')) {
321 $root = '.';
322 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
323 top_of_kernel_tree($1)) {
324 $root = $1;
325 }
326 }
327
328 if (!defined $root) {
329 print "Must be run from the top-level dir. of a kernel tree\n";
330 exit(2);
331 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700332}
333
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700334my $emitted_corrupt = 0;
335
Andy Whitcroft2ceb5322009-10-26 16:50:14 -0700336our $Ident = qr{
337 [A-Za-z_][A-Za-z\d_]*
338 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
339 }x;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700340our $Storage = qr{extern|static|asmlinkage};
341our $Sparse = qr{
342 __user|
343 __kernel|
344 __force|
345 __iomem|
346 __must_check|
347 __init_refok|
Andy Whitcroft417495e2009-02-27 14:03:08 -0800348 __kprobes|
Sven Eckelmann165e72a2011-07-25 17:13:23 -0700349 __ref|
Boqun Fengad315452015-12-29 12:18:46 +0800350 __rcu|
351 __private
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700352 }x;
Joe Perchese970b8842013-11-12 15:10:10 -0800353our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
354our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
355our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
356our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
357our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Perches8716de32013-09-11 14:24:05 -0700358
Wolfram Sang52131292010-03-05 13:43:51 -0800359# Notes to $Attribute:
360# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700361our $Attribute = qr{
362 const|
Joe Perches03f1df72010-10-26 14:23:16 -0700363 __percpu|
364 __nocast|
365 __safe|
Michael S. Tsirkin46d832f2016-12-11 06:29:58 +0200366 __bitwise|
Joe Perches03f1df72010-10-26 14:23:16 -0700367 __packed__|
368 __packed2__|
369 __naked|
370 __maybe_unused|
371 __always_unused|
372 __noreturn|
373 __used|
374 __cold|
Joe Perchese23ef1f2015-02-13 14:38:24 -0800375 __pure|
Joe Perches03f1df72010-10-26 14:23:16 -0700376 __noclone|
377 __deprecated|
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700378 __read_mostly|
379 __kprobes|
Joe Perches8716de32013-09-11 14:24:05 -0700380 $InitAttribute|
Andy Whitcroft24e1d812008-10-15 22:02:18 -0700381 ____cacheline_aligned|
382 ____cacheline_aligned_in_smp|
Andy Whitcroft5fe3af12009-01-06 14:41:18 -0800383 ____cacheline_internodealigned_in_smp|
384 __weak
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700385 }x;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700386our $Modifier;
Joe Perches91cb5192014-04-03 14:49:32 -0700387our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700388our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
389our $Lval = qr{$Ident(?:$Member)*};
390
Joe Perches95e2c602013-07-03 15:05:20 -0700391our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
392our $Binary = qr{(?i)0b[01]+$Int_type?};
393our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
394our $Int = qr{[0-9]+$Int_type?};
Joe Perches24358802014-04-03 14:49:13 -0700395our $Octal = qr{0[0-7]+$Int_type?};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800396our $String = qr{"[X\t]*"};
Joe Perches326b1ff2013-02-04 14:28:51 -0800397our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
398our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
399our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
Joe Perches74349bc2012-12-17 16:02:05 -0800400our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Joe Perches24358802014-04-03 14:49:13 -0700401our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
Joe Perches326b1ff2013-02-04 14:28:51 -0800402our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Perches447432f2014-04-03 14:49:17 -0700403our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
Joe Perches23f780c2013-07-03 15:05:31 -0700404our $Arithmetic = qr{\+|-|\*|\/|%};
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700405our $Operators = qr{
406 <=|>=|==|!=|
407 =>|->|<<|>>|<|>|!|~|
Joe Perches23f780c2013-07-03 15:05:31 -0700408 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700409 }x;
410
Joe Perches91cb5192014-04-03 14:49:32 -0700411our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
412
Joe Perchesab7e23f2015-04-16 12:44:22 -0700413our $BasicType;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800414our $NonptrType;
Joe Perches18130872014-08-06 16:11:22 -0700415our $NonptrTypeMisordered;
Joe Perches8716de32013-09-11 14:24:05 -0700416our $NonptrTypeWithAttr;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800417our $Type;
Joe Perches18130872014-08-06 16:11:22 -0700418our $TypeMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800419our $Declare;
Joe Perches18130872014-08-06 16:11:22 -0700420our $DeclareMisordered;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800421
Joe Perches15662b32011-10-31 17:13:12 -0700422our $NON_ASCII_UTF8 = qr{
423 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Andy Whitcroft171ae1a2008-04-29 00:59:32 -0700424 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
425 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
426 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
427 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
428 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
429 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
430}x;
431
Joe Perches15662b32011-10-31 17:13:12 -0700432our $UTF8 = qr{
433 [\x09\x0A\x0D\x20-\x7E] # ASCII
434 | $NON_ASCII_UTF8
435}x;
436
Joe Perchese6176fa2015-06-25 15:02:49 -0700437our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
Joe Perches021158b2015-02-13 14:38:43 -0800438our $typeOtherOSTypedefs = qr{(?x:
439 u_(?:char|short|int|long) | # bsd
440 u(?:nchar|short|int|long) # sysv
441)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700442our $typeKernelTypedefs = qr{(?x:
Andy Whitcroftfb9e9092009-09-21 17:04:38 -0700443 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700444 atomic_t
445)};
Joe Perchese6176fa2015-06-25 15:02:49 -0700446our $typeTypedefs = qr{(?x:
447 $typeC99Typedefs\b|
448 $typeOtherOSTypedefs\b|
449 $typeKernelTypedefs\b
450)};
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700451
Joe Perches6d32f7a2015-11-06 16:31:37 -0800452our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
453
Joe Perches691e6692010-03-05 13:43:51 -0800454our $logFunctions = qr{(?x:
Miles Chen758d7aa2017-02-24 15:01:34 -0800455 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
Jacob Keller7d0b6592013-07-03 15:05:35 -0700456 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
Joe Perches87bd4992017-11-17 15:28:48 -0800457 TP_printk|
Joe Perches6e60c022011-07-25 17:13:27 -0700458 WARN(?:_RATELIMIT|_ONCE|)|
Joe Perchesb0531722011-05-24 17:13:40 -0700459 panic|
Joe Perches06668722013-11-12 15:10:07 -0800460 MODULE_[A-Z_]+|
461 seq_vprintf|seq_printf|seq_puts
Joe Perches691e6692010-03-05 13:43:51 -0800462)};
463
Joe Perches20112472011-07-25 17:13:23 -0700464our $signature_tags = qr{(?xi:
465 Signed-off-by:|
466 Acked-by:|
467 Tested-by:|
468 Reviewed-by:|
469 Reported-by:|
Mugunthan V N8543ae12013-04-29 16:18:17 -0700470 Suggested-by:|
Joe Perches20112472011-07-25 17:13:23 -0700471 To:|
472 Cc:
473)};
474
Joe Perches18130872014-08-06 16:11:22 -0700475our @typeListMisordered = (
476 qr{char\s+(?:un)?signed},
477 qr{int\s+(?:(?:un)?signed\s+)?short\s},
478 qr{int\s+short(?:\s+(?:un)?signed)},
479 qr{short\s+int(?:\s+(?:un)?signed)},
480 qr{(?:un)?signed\s+int\s+short},
481 qr{short\s+(?:un)?signed},
482 qr{long\s+int\s+(?:un)?signed},
483 qr{int\s+long\s+(?:un)?signed},
484 qr{long\s+(?:un)?signed\s+int},
485 qr{int\s+(?:un)?signed\s+long},
486 qr{int\s+(?:un)?signed},
487 qr{int\s+long\s+long\s+(?:un)?signed},
488 qr{long\s+long\s+int\s+(?:un)?signed},
489 qr{long\s+long\s+(?:un)?signed\s+int},
490 qr{long\s+long\s+(?:un)?signed},
491 qr{long\s+(?:un)?signed},
492);
493
Andy Whitcroft8905a672007-11-28 16:21:06 -0800494our @typeList = (
495 qr{void},
Joe Perches0c773d92014-08-06 16:11:20 -0700496 qr{(?:(?:un)?signed\s+)?char},
497 qr{(?:(?:un)?signed\s+)?short\s+int},
498 qr{(?:(?:un)?signed\s+)?short},
499 qr{(?:(?:un)?signed\s+)?int},
500 qr{(?:(?:un)?signed\s+)?long\s+int},
501 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
502 qr{(?:(?:un)?signed\s+)?long\s+long},
503 qr{(?:(?:un)?signed\s+)?long},
504 qr{(?:un)?signed},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800505 qr{float},
506 qr{double},
507 qr{bool},
Andy Whitcroft8905a672007-11-28 16:21:06 -0800508 qr{struct\s+$Ident},
509 qr{union\s+$Ident},
510 qr{enum\s+$Ident},
511 qr{${Ident}_t},
512 qr{${Ident}_handler},
513 qr{${Ident}_handler_fn},
Joe Perches18130872014-08-06 16:11:22 -0700514 @typeListMisordered,
Andy Whitcroft8905a672007-11-28 16:21:06 -0800515);
Joe Perches938224b2016-01-20 14:59:15 -0800516
517our $C90_int_types = qr{(?x:
518 long\s+long\s+int\s+(?:un)?signed|
519 long\s+long\s+(?:un)?signed\s+int|
520 long\s+long\s+(?:un)?signed|
521 (?:(?:un)?signed\s+)?long\s+long\s+int|
522 (?:(?:un)?signed\s+)?long\s+long|
523 int\s+long\s+long\s+(?:un)?signed|
524 int\s+(?:(?:un)?signed\s+)?long\s+long|
525
526 long\s+int\s+(?:un)?signed|
527 long\s+(?:un)?signed\s+int|
528 long\s+(?:un)?signed|
529 (?:(?:un)?signed\s+)?long\s+int|
530 (?:(?:un)?signed\s+)?long|
531 int\s+long\s+(?:un)?signed|
532 int\s+(?:(?:un)?signed\s+)?long|
533
534 int\s+(?:un)?signed|
535 (?:(?:un)?signed\s+)?int
536)};
537
Alex Dowad485ff232015-06-25 15:02:52 -0700538our @typeListFile = ();
Joe Perches8716de32013-09-11 14:24:05 -0700539our @typeListWithAttr = (
540 @typeList,
541 qr{struct\s+$InitAttribute\s+$Ident},
542 qr{union\s+$InitAttribute\s+$Ident},
543);
544
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700545our @modifierList = (
546 qr{fastcall},
547);
Alex Dowad485ff232015-06-25 15:02:52 -0700548our @modifierListFile = ();
Andy Whitcroft8905a672007-11-28 16:21:06 -0800549
Joe Perches24358802014-04-03 14:49:13 -0700550our @mode_permission_funcs = (
551 ["module_param", 3],
552 ["module_param_(?:array|named|string)", 4],
553 ["module_param_array_named", 5],
554 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
555 ["proc_create(?:_data|)", 2],
Joe Perches459cf0a2016-10-11 13:52:19 -0700556 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
557 ["IIO_DEV_ATTR_[A-Z_]+", 1],
558 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
559 ["SENSOR_TEMPLATE(?:_2|)", 3],
560 ["__ATTR", 2],
Joe Perches24358802014-04-03 14:49:13 -0700561);
562
Joe Perches515a2352014-04-03 14:49:24 -0700563#Create a search pattern for all these functions to speed up a loop below
564our $mode_perms_search = "";
565foreach my $entry (@mode_permission_funcs) {
566 $mode_perms_search .= '|' if ($mode_perms_search ne "");
567 $mode_perms_search .= $entry->[0];
568}
Joe Perches00180462018-02-06 15:38:55 -0800569$mode_perms_search = "(?:${mode_perms_search})";
Joe Perches515a2352014-04-03 14:49:24 -0700570
Joe Perchesb392c642015-04-16 12:44:16 -0700571our $mode_perms_world_writable = qr{
572 S_IWUGO |
573 S_IWOTH |
574 S_IRWXUGO |
575 S_IALLUGO |
576 0[0-7][0-7][2367]
577}x;
578
Joe Perchesf90774e2016-10-11 13:51:47 -0700579our %mode_permission_string_types = (
580 "S_IRWXU" => 0700,
581 "S_IRUSR" => 0400,
582 "S_IWUSR" => 0200,
583 "S_IXUSR" => 0100,
584 "S_IRWXG" => 0070,
585 "S_IRGRP" => 0040,
586 "S_IWGRP" => 0020,
587 "S_IXGRP" => 0010,
588 "S_IRWXO" => 0007,
589 "S_IROTH" => 0004,
590 "S_IWOTH" => 0002,
591 "S_IXOTH" => 0001,
592 "S_IRWXUGO" => 0777,
593 "S_IRUGO" => 0444,
594 "S_IWUGO" => 0222,
595 "S_IXUGO" => 0111,
596);
597
598#Create a search pattern for all these strings to speed up a loop below
599our $mode_perms_string_search = "";
600foreach my $entry (keys %mode_permission_string_types) {
601 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
602 $mode_perms_string_search .= $entry;
603}
Joe Perches00180462018-02-06 15:38:55 -0800604our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
605our $multi_mode_perms_string_search = qr{
606 ${single_mode_perms_string_search}
607 (?:\s*\|\s*${single_mode_perms_string_search})*
608}x;
609
610sub perms_to_octal {
611 my ($string) = @_;
612
613 return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
614
615 my $val = "";
616 my $oval = "";
617 my $to = 0;
618 my $curpos = 0;
619 my $lastpos = 0;
620 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
621 $curpos = pos($string);
622 my $match = $2;
623 my $omatch = $1;
624 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
625 $lastpos = $curpos;
626 $to |= $mode_permission_string_types{$match};
627 $val .= '\s*\|\s*' if ($val ne "");
628 $val .= $match;
629 $oval .= $omatch;
630 }
631 $oval =~ s/^\s*\|\s*//;
632 $oval =~ s/\s*\|\s*$//;
633 return sprintf("%04o", $to);
634}
Joe Perchesf90774e2016-10-11 13:51:47 -0700635
Wolfram Sang7840a942010-08-09 17:20:57 -0700636our $allowed_asm_includes = qr{(?x:
637 irq|
Sergey Ryazanovcdcee682014-10-13 15:51:44 -0700638 memory|
639 time|
640 reboot
Wolfram Sang7840a942010-08-09 17:20:57 -0700641)};
642# memory.h: ARM has a custom one
643
Kees Cook66b47b42014-10-13 15:51:57 -0700644# Load common spelling mistakes and build regular expression list.
645my $misspellings;
Kees Cook66b47b42014-10-13 15:51:57 -0700646my %spelling_fix;
Kees Cook66b47b42014-10-13 15:51:57 -0700647
Joe Perches36061e32014-12-10 15:51:43 -0800648if (open(my $spelling, '<', $spelling_file)) {
Joe Perches36061e32014-12-10 15:51:43 -0800649 while (<$spelling>) {
650 my $line = $_;
Kees Cook66b47b42014-10-13 15:51:57 -0700651
Joe Perches36061e32014-12-10 15:51:43 -0800652 $line =~ s/\s*\n?$//g;
653 $line =~ s/^\s*//g;
Kees Cook66b47b42014-10-13 15:51:57 -0700654
Joe Perches36061e32014-12-10 15:51:43 -0800655 next if ($line =~ m/^\s*#/);
656 next if ($line =~ m/^\s*$/);
Kees Cook66b47b42014-10-13 15:51:57 -0700657
Joe Perches36061e32014-12-10 15:51:43 -0800658 my ($suspect, $fix) = split(/\|\|/, $line);
659
Joe Perches36061e32014-12-10 15:51:43 -0800660 $spelling_fix{$suspect} = $fix;
661 }
662 close($spelling);
Joe Perches36061e32014-12-10 15:51:43 -0800663} else {
664 warn "No typos will be found - file '$spelling_file': $!\n";
Kees Cook66b47b42014-10-13 15:51:57 -0700665}
Kees Cook66b47b42014-10-13 15:51:57 -0700666
Joe Perchesebfd7d62015-04-16 12:44:14 -0700667if ($codespell) {
668 if (open(my $spelling, '<', $codespellfile)) {
669 while (<$spelling>) {
670 my $line = $_;
671
672 $line =~ s/\s*\n?$//g;
673 $line =~ s/^\s*//g;
674
675 next if ($line =~ m/^\s*#/);
676 next if ($line =~ m/^\s*$/);
677 next if ($line =~ m/, disabled/i);
678
679 $line =~ s/,.*$//;
680
681 my ($suspect, $fix) = split(/->/, $line);
682
683 $spelling_fix{$suspect} = $fix;
684 }
685 close($spelling);
686 } else {
687 warn "No codespell typos will be found - file '$codespellfile': $!\n";
688 }
689}
690
691$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
692
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700693sub read_words {
694 my ($wordsRef, $file) = @_;
Joe Perchesbf1fa1d2016-10-11 13:51:56 -0700695
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700696 if (open(my $words, '<', $file)) {
697 while (<$words>) {
698 my $line = $_;
Joe Perchesbf1fa1d2016-10-11 13:51:56 -0700699
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700700 $line =~ s/\s*\n?$//g;
701 $line =~ s/^\s*//g;
702
703 next if ($line =~ m/^\s*#/);
704 next if ($line =~ m/^\s*$/);
705 if ($line =~ /\s/) {
706 print("$file: '$line' invalid - ignored\n");
707 next;
708 }
709
710 $$wordsRef .= '|' if ($$wordsRef ne "");
711 $$wordsRef .= $line;
Joe Perchesbf1fa1d2016-10-11 13:51:56 -0700712 }
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700713 close($file);
714 return 1;
Joe Perchesbf1fa1d2016-10-11 13:51:56 -0700715 }
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700716
717 return 0;
Joe Perchesbf1fa1d2016-10-11 13:51:56 -0700718}
719
Jerome Forissier75ad8c52017-05-08 15:56:00 -0700720my $const_structs = "";
721read_words(\$const_structs, $conststructsfile)
722 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
723
724my $typeOtherTypedefs = "";
725if (length($typedefsfile)) {
726 read_words(\$typeOtherTypedefs, $typedefsfile)
727 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
728}
729$typeTypedefs .= '|' . $typeOtherTypedefs if ($typeOtherTypedefs ne "");
730
Andy Whitcroft8905a672007-11-28 16:21:06 -0800731sub build_types {
Alex Dowad485ff232015-06-25 15:02:52 -0700732 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
733 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
Joe Perches18130872014-08-06 16:11:22 -0700734 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
Joe Perches8716de32013-09-11 14:24:05 -0700735 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700736 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
Joe Perchesab7e23f2015-04-16 12:44:22 -0700737 $BasicType = qr{
Joe Perchesab7e23f2015-04-16 12:44:22 -0700738 (?:$typeTypedefs\b)|
739 (?:${all}\b)
740 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800741 $NonptrType = qr{
Andy Whitcroftd2172eb2008-07-23 21:29:07 -0700742 (?:$Modifier\s+|const\s+)*
Andy Whitcroftcf655042008-03-04 14:28:20 -0800743 (?:
Andy Whitcroft6b48db22012-01-10 15:10:13 -0800744 (?:typeof|__typeof__)\s*\([^\)]*\)|
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -0700745 (?:$typeTypedefs\b)|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700746 (?:${all}\b)
Andy Whitcroftcf655042008-03-04 14:28:20 -0800747 )
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700748 (?:\s+$Modifier|\s+const)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800749 }x;
Joe Perches18130872014-08-06 16:11:22 -0700750 $NonptrTypeMisordered = qr{
751 (?:$Modifier\s+|const\s+)*
752 (?:
753 (?:${Misordered}\b)
754 )
755 (?:\s+$Modifier|\s+const)*
756 }x;
Joe Perches8716de32013-09-11 14:24:05 -0700757 $NonptrTypeWithAttr = qr{
758 (?:$Modifier\s+|const\s+)*
759 (?:
760 (?:typeof|__typeof__)\s*\([^\)]*\)|
761 (?:$typeTypedefs\b)|
762 (?:${allWithAttr}\b)
763 )
764 (?:\s+$Modifier|\s+const)*
765 }x;
Andy Whitcroft8905a672007-11-28 16:21:06 -0800766 $Type = qr{
Andy Whitcroftc45dcab2008-06-05 22:46:01 -0700767 $NonptrType
Joe Perches1574a292014-08-06 16:10:50 -0700768 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -0700769 (?:\s+$Inline|\s+$Modifier)*
Andy Whitcroft8905a672007-11-28 16:21:06 -0800770 }x;
Joe Perches18130872014-08-06 16:11:22 -0700771 $TypeMisordered = qr{
772 $NonptrTypeMisordered
773 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
774 (?:\s+$Inline|\s+$Modifier)*
775 }x;
Joe Perches91cb5192014-04-03 14:49:32 -0700776 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
Joe Perches18130872014-08-06 16:11:22 -0700777 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
Andy Whitcroft8905a672007-11-28 16:21:06 -0800778}
779build_types();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700780
Joe Perches7d2367a2011-07-25 17:13:22 -0700781our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Joe Perchesd1fe9c02012-03-23 15:02:16 -0700782
783# Using $balanced_parens, $LvalOrFunc, or $FuncArg
784# requires at least perl version v5.10.0
785# Any use must be runtime checked with $^V
786
787our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
Joe Perches24358802014-04-03 14:49:13 -0700788our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
Joe Perchesc0a5c892015-02-13 14:38:21 -0800789our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
Joe Perches7d2367a2011-07-25 17:13:22 -0700790
Joe Perchesf8422302014-08-06 16:11:31 -0700791our $declaration_macros = qr{(?x:
Joe Perches3e838b62015-09-09 15:37:33 -0700792 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
Steffen Maierfe658f92017-07-10 15:52:10 -0700793 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
Joe Perchesf8422302014-08-06 16:11:31 -0700794 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
795)};
796
Joe Perches7d2367a2011-07-25 17:13:22 -0700797sub deparenthesize {
798 my ($string) = @_;
799 return "" if (!defined($string));
Joe Perches5b9553a2014-04-03 14:49:21 -0700800
801 while ($string =~ /^\s*\(.*\)\s*$/) {
802 $string =~ s@^\s*\(\s*@@;
803 $string =~ s@\s*\)\s*$@@;
804 }
805
Joe Perches7d2367a2011-07-25 17:13:22 -0700806 $string =~ s@\s+@ @g;
Joe Perches5b9553a2014-04-03 14:49:21 -0700807
Joe Perches7d2367a2011-07-25 17:13:22 -0700808 return $string;
809}
810
Joe Perches34456862013-07-03 15:05:34 -0700811sub seed_camelcase_file {
812 my ($file) = @_;
813
814 return if (!(-f $file));
815
816 local $/;
817
818 open(my $include_file, '<', "$file")
819 or warn "$P: Can't read '$file' $!\n";
820 my $text = <$include_file>;
821 close($include_file);
822
823 my @lines = split('\n', $text);
824
825 foreach my $line (@lines) {
826 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
827 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
828 $camelcase{$1} = 1;
Joe Perches11ea5162013-11-12 15:10:08 -0800829 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
830 $camelcase{$1} = 1;
831 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
Joe Perches34456862013-07-03 15:05:34 -0700832 $camelcase{$1} = 1;
833 }
834 }
835}
836
Joe Perches85b0ee12016-10-11 13:51:44 -0700837sub is_maintained_obsolete {
838 my ($filename) = @_;
839
Jerome Forissierf2c19c22016-12-12 16:46:23 -0800840 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
Joe Perches85b0ee12016-10-11 13:51:44 -0700841
Joe Perches0616efa2016-10-11 13:52:02 -0700842 my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
Joe Perches85b0ee12016-10-11 13:51:44 -0700843
844 return $status =~ /obsolete/i;
845}
846
Joe Perches34456862013-07-03 15:05:34 -0700847my $camelcase_seeded = 0;
848sub seed_camelcase_includes {
849 return if ($camelcase_seeded);
850
851 my $files;
Joe Perchesc707a812013-07-08 16:00:43 -0700852 my $camelcase_cache = "";
853 my @include_files = ();
854
855 $camelcase_seeded = 1;
Joe Perches351b2a12013-07-03 15:05:36 -0700856
Richard Genoud3645e322014-02-10 14:25:32 -0800857 if (-e ".git") {
Joe Perches351b2a12013-07-03 15:05:36 -0700858 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
859 chomp $git_last_include_commit;
Joe Perchesc707a812013-07-08 16:00:43 -0700860 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
Joe Perches34456862013-07-03 15:05:34 -0700861 } else {
Joe Perchesc707a812013-07-08 16:00:43 -0700862 my $last_mod_date = 0;
Joe Perches34456862013-07-03 15:05:34 -0700863 $files = `find $root/include -name "*.h"`;
Joe Perchesc707a812013-07-08 16:00:43 -0700864 @include_files = split('\n', $files);
865 foreach my $file (@include_files) {
866 my $date = POSIX::strftime("%Y%m%d%H%M",
867 localtime((stat $file)[9]));
868 $last_mod_date = $date if ($last_mod_date < $date);
869 }
870 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
Joe Perches34456862013-07-03 15:05:34 -0700871 }
Joe Perchesc707a812013-07-08 16:00:43 -0700872
873 if ($camelcase_cache ne "" && -f $camelcase_cache) {
874 open(my $camelcase_file, '<', "$camelcase_cache")
875 or warn "$P: Can't read '$camelcase_cache' $!\n";
876 while (<$camelcase_file>) {
877 chomp;
878 $camelcase{$_} = 1;
879 }
880 close($camelcase_file);
881
882 return;
883 }
884
Richard Genoud3645e322014-02-10 14:25:32 -0800885 if (-e ".git") {
Joe Perchesc707a812013-07-08 16:00:43 -0700886 $files = `git ls-files "include/*.h"`;
887 @include_files = split('\n', $files);
888 }
889
Joe Perches34456862013-07-03 15:05:34 -0700890 foreach my $file (@include_files) {
891 seed_camelcase_file($file);
892 }
Joe Perches351b2a12013-07-03 15:05:36 -0700893
Joe Perchesc707a812013-07-08 16:00:43 -0700894 if ($camelcase_cache ne "") {
Joe Perches351b2a12013-07-03 15:05:36 -0700895 unlink glob ".checkpatch-camelcase.*";
Joe Perchesc707a812013-07-08 16:00:43 -0700896 open(my $camelcase_file, '>', "$camelcase_cache")
897 or warn "$P: Can't write '$camelcase_cache' $!\n";
Joe Perches351b2a12013-07-03 15:05:36 -0700898 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
899 print $camelcase_file ("$_\n");
900 }
901 close($camelcase_file);
902 }
Joe Perches34456862013-07-03 15:05:34 -0700903}
904
Joe Perchesd311cd42014-08-06 16:10:57 -0700905sub git_commit_info {
906 my ($commit, $id, $desc) = @_;
907
908 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
909
910 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
911 $output =~ s/^\s*//gm;
912 my @lines = split("\n", $output);
913
Joe Perches0d7835f2015-02-13 14:38:35 -0800914 return ($id, $desc) if ($#lines < 0);
915
Joe Perchesd311cd42014-08-06 16:10:57 -0700916 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
917# Maybe one day convert this block of bash into something that returns
918# all matching commit ids, but it's very slow...
919#
920# echo "checking commits $1..."
921# git rev-list --remotes | grep -i "^$1" |
922# while read line ; do
923# git log --format='%H %s' -1 $line |
924# echo "commit $(cut -c 1-12,41-)"
925# done
926 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
Heinrich Schuchardt948b1332017-07-10 15:52:16 -0700927 $id = undef;
Joe Perchesd311cd42014-08-06 16:10:57 -0700928 } else {
929 $id = substr($lines[0], 0, 12);
930 $desc = substr($lines[0], 41);
931 }
932
933 return ($id, $desc);
934}
935
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700936$chk_signoff = 0 if ($file);
937
Andy Whitcroft00df3442007-06-08 13:47:06 -0700938my @rawlines = ();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800939my @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -0700940my @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -0700941my @fixed_inserted = ();
942my @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -0700943my $fixlinenr = -1;
944
Du, Changbin4a593c32016-05-20 17:04:16 -0700945# If input is git commits, extract all commits from the commit expressions.
946# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
947die "$P: No git repository found\n" if ($git && !-e ".git");
948
949if ($git) {
950 my @commits = ();
Joe Perches0dea9f1e2016-05-20 17:04:19 -0700951 foreach my $commit_expr (@ARGV) {
Du, Changbin4a593c32016-05-20 17:04:16 -0700952 my $git_range;
Joe Perches28898fd2016-05-20 17:04:22 -0700953 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
954 $git_range = "-$2 $1";
Du, Changbin4a593c32016-05-20 17:04:16 -0700955 } elsif ($commit_expr =~ m/\.\./) {
956 $git_range = "$commit_expr";
Du, Changbin4a593c32016-05-20 17:04:16 -0700957 } else {
Joe Perches0dea9f1e2016-05-20 17:04:19 -0700958 $git_range = "-1 $commit_expr";
959 }
960 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
961 foreach my $line (split(/\n/, $lines)) {
Joe Perches28898fd2016-05-20 17:04:22 -0700962 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
963 next if (!defined($1) || !defined($2));
Joe Perches0dea9f1e2016-05-20 17:04:19 -0700964 my $sha1 = $1;
965 my $subject = $2;
966 unshift(@commits, $sha1);
967 $git_commits{$sha1} = $subject;
Du, Changbin4a593c32016-05-20 17:04:16 -0700968 }
969 }
970 die "$P: no git commits after extraction!\n" if (@commits == 0);
971 @ARGV = @commits;
972}
973
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800974my $vname;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700975for my $filename (@ARGV) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800976 my $FILE;
Du, Changbin4a593c32016-05-20 17:04:16 -0700977 if ($git) {
978 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
979 die "$P: $filename: git format-patch failed - $!\n";
980 } elsif ($file) {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800981 open($FILE, '-|', "diff -u /dev/null $filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700982 die "$P: $filename: diff failed - $!\n";
Andy Whitcroft21caa132009-01-06 14:41:30 -0800983 } elsif ($filename eq '-') {
984 open($FILE, '<&STDIN');
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700985 } else {
Andy Whitcroft21caa132009-01-06 14:41:30 -0800986 open($FILE, '<', "$filename") ||
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700987 die "$P: $filename: open failed - $!\n";
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -0700988 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800989 if ($filename eq '-') {
990 $vname = 'Your patch';
Du, Changbin4a593c32016-05-20 17:04:16 -0700991 } elsif ($git) {
Joe Perches0dea9f1e2016-05-20 17:04:19 -0700992 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -0800993 } else {
994 $vname = $filename;
995 }
Andy Whitcroft21caa132009-01-06 14:41:30 -0800996 while (<$FILE>) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -0700997 chomp;
998 push(@rawlines, $_);
999 }
Andy Whitcroft21caa132009-01-06 14:41:30 -08001000 close($FILE);
Joe Perchesd8469f12015-06-25 15:03:00 -07001001
1002 if ($#ARGV > 0 && $quiet == 0) {
1003 print '-' x length($vname) . "\n";
1004 print "$vname\n";
1005 print '-' x length($vname) . "\n";
1006 }
1007
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001008 if (!process($filename)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001009 $exit = 1;
1010 }
1011 @rawlines = ();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001012 @lines = ();
Joe Perches3705ce52013-07-03 15:05:31 -07001013 @fixed = ();
Joe Perchesd752fcc2014-08-06 16:11:05 -07001014 @fixed_inserted = ();
1015 @fixed_deleted = ();
Joe Perches194f66f2014-08-06 16:11:03 -07001016 $fixlinenr = -1;
Alex Dowad485ff232015-06-25 15:02:52 -07001017 @modifierListFile = ();
1018 @typeListFile = ();
1019 build_types();
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001020}
1021
Joe Perchesd8469f12015-06-25 15:03:00 -07001022if (!$quiet) {
Joe Perches3c816e42015-06-25 15:03:29 -07001023 hash_show_words(\%use_type, "Used");
1024 hash_show_words(\%ignore_type, "Ignored");
1025
Joe Perchesd8469f12015-06-25 15:03:00 -07001026 if ($^V lt 5.10.0) {
1027 print << "EOM"
1028
1029NOTE: perl $^V is not modern enough to detect all possible issues.
1030 An upgrade to at least perl v5.10.0 is suggested.
1031EOM
1032 }
1033 if ($exit) {
1034 print << "EOM"
1035
1036NOTE: If any of the errors are false positives, please report
1037 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1038EOM
1039 }
1040}
1041
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001042exit($exit);
1043
1044sub top_of_kernel_tree {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001045 my ($root) = @_;
1046
1047 my @tree_check = (
1048 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1049 "README", "Documentation", "arch", "include", "drivers",
1050 "fs", "init", "ipc", "kernel", "lib", "scripts",
1051 );
1052
1053 foreach my $check (@tree_check) {
1054 if (! -e $root . '/' . $check) {
1055 return 0;
1056 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001057 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001058 return 1;
Joe Perches8f26b832012-10-04 17:13:32 -07001059}
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001060
Joe Perches20112472011-07-25 17:13:23 -07001061sub parse_email {
1062 my ($formatted_email) = @_;
1063
1064 my $name = "";
1065 my $address = "";
1066 my $comment = "";
1067
1068 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1069 $name = $1;
1070 $address = $2;
1071 $comment = $3 if defined $3;
1072 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1073 $address = $1;
1074 $comment = $2 if defined $2;
1075 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1076 $address = $1;
1077 $comment = $2 if defined $2;
1078 $formatted_email =~ s/$address.*$//;
1079 $name = $formatted_email;
Joe Perches3705ce52013-07-03 15:05:31 -07001080 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -07001081 $name =~ s/^\"|\"$//g;
1082 # If there's a name left after stripping spaces and
1083 # leading quotes, and the address doesn't have both
1084 # leading and trailing angle brackets, the address
1085 # is invalid. ie:
1086 # "joe smith joe@smith.com" bad
1087 # "joe smith <joe@smith.com" bad
1088 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1089 $name = "";
1090 $address = "";
1091 $comment = "";
1092 }
1093 }
1094
Joe Perches3705ce52013-07-03 15:05:31 -07001095 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -07001096 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -07001097 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -07001098 $address =~ s/^\<|\>$//g;
1099
1100 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1101 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1102 $name = "\"$name\"";
1103 }
1104
1105 return ($name, $address, $comment);
1106}
1107
1108sub format_email {
1109 my ($name, $address) = @_;
1110
1111 my $formatted_email;
1112
Joe Perches3705ce52013-07-03 15:05:31 -07001113 $name = trim($name);
Joe Perches20112472011-07-25 17:13:23 -07001114 $name =~ s/^\"|\"$//g;
Joe Perches3705ce52013-07-03 15:05:31 -07001115 $address = trim($address);
Joe Perches20112472011-07-25 17:13:23 -07001116
1117 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1118 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1119 $name = "\"$name\"";
1120 }
1121
1122 if ("$name" eq "") {
1123 $formatted_email = "$address";
1124 } else {
1125 $formatted_email = "$name <$address>";
1126 }
1127
1128 return $formatted_email;
1129}
1130
Joe Perchesd311cd42014-08-06 16:10:57 -07001131sub which {
Joe Perchesbd474ca2014-08-06 16:11:10 -07001132 my ($bin) = @_;
Joe Perchesd311cd42014-08-06 16:10:57 -07001133
Joe Perchesbd474ca2014-08-06 16:11:10 -07001134 foreach my $path (split(/:/, $ENV{PATH})) {
1135 if (-e "$path/$bin") {
1136 return "$path/$bin";
1137 }
Joe Perchesd311cd42014-08-06 16:10:57 -07001138 }
Joe Perchesd311cd42014-08-06 16:10:57 -07001139
Joe Perchesbd474ca2014-08-06 16:11:10 -07001140 return "";
Joe Perchesd311cd42014-08-06 16:10:57 -07001141}
1142
Joe Perches000d1cc12011-07-25 17:13:25 -07001143sub which_conf {
1144 my ($conf) = @_;
1145
1146 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1147 if (-e "$path/$conf") {
1148 return "$path/$conf";
1149 }
1150 }
1151
1152 return "";
1153}
1154
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001155sub expand_tabs {
1156 my ($str) = @_;
1157
1158 my $res = '';
1159 my $n = 0;
1160 for my $c (split(//, $str)) {
1161 if ($c eq "\t") {
1162 $res .= ' ';
1163 $n++;
1164 for (; ($n % 8) != 0; $n++) {
1165 $res .= ' ';
1166 }
1167 next;
1168 }
1169 $res .= $c;
1170 $n++;
1171 }
1172
1173 return $res;
1174}
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001175sub copy_spacing {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001176 (my $res = shift) =~ tr/\t/ /c;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001177 return $res;
1178}
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001179
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001180sub line_stats {
1181 my ($line) = @_;
1182
1183 # Drop the diff line leader and expand tabs
1184 $line =~ s/^.//;
1185 $line = expand_tabs($line);
1186
1187 # Pick the indent from the front of the line.
1188 my ($white) = ($line =~ /^(\s*)/);
1189
1190 return (length($line), length($white));
1191}
1192
Andy Whitcroft773647a2008-03-28 14:15:58 -07001193my $sanitise_quote = '';
1194
1195sub sanitise_line_reset {
1196 my ($in_comment) = @_;
1197
1198 if ($in_comment) {
1199 $sanitise_quote = '*/';
1200 } else {
1201 $sanitise_quote = '';
1202 }
1203}
Andy Whitcroft00df3442007-06-08 13:47:06 -07001204sub sanitise_line {
1205 my ($line) = @_;
1206
1207 my $res = '';
1208 my $l = '';
1209
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001210 my $qlen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001211 my $off = 0;
1212 my $c;
Andy Whitcroft00df3442007-06-08 13:47:06 -07001213
Andy Whitcroft773647a2008-03-28 14:15:58 -07001214 # Always copy over the diff marker.
1215 $res = substr($line, 0, 1);
1216
1217 for ($off = 1; $off < length($line); $off++) {
1218 $c = substr($line, $off, 1);
1219
1220 # Comments we are wacking completly including the begin
1221 # and end, all to $;.
1222 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1223 $sanitise_quote = '*/';
1224
1225 substr($res, $off, 2, "$;$;");
1226 $off++;
1227 next;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001228 }
Andy Whitcroft81bc0e02008-10-15 22:02:26 -07001229 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001230 $sanitise_quote = '';
1231 substr($res, $off, 2, "$;$;");
1232 $off++;
1233 next;
1234 }
Daniel Walker113f04a2009-09-21 17:04:35 -07001235 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1236 $sanitise_quote = '//';
1237
1238 substr($res, $off, 2, $sanitise_quote);
1239 $off++;
1240 next;
1241 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001242
1243 # A \ in a string means ignore the next character.
1244 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1245 $c eq "\\") {
1246 substr($res, $off, 2, 'XX');
1247 $off++;
1248 next;
1249 }
1250 # Regular quotes.
1251 if ($c eq "'" || $c eq '"') {
1252 if ($sanitise_quote eq '') {
1253 $sanitise_quote = $c;
1254
1255 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001256 next;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001257 } elsif ($sanitise_quote eq $c) {
1258 $sanitise_quote = '';
Andy Whitcroft00df3442007-06-08 13:47:06 -07001259 }
1260 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07001261
Andy Whitcroftfae17da2009-01-06 14:41:20 -08001262 #print "c<$c> SQ<$sanitise_quote>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001263 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1264 substr($res, $off, 1, $;);
Daniel Walker113f04a2009-09-21 17:04:35 -07001265 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1266 substr($res, $off, 1, $;);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001267 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1268 substr($res, $off, 1, 'X');
Andy Whitcroft00df3442007-06-08 13:47:06 -07001269 } else {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001270 substr($res, $off, 1, $c);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001271 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001272 }
1273
Daniel Walker113f04a2009-09-21 17:04:35 -07001274 if ($sanitise_quote eq '//') {
1275 $sanitise_quote = '';
1276 }
1277
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001278 # The pathname on a #include may be surrounded by '<' and '>'.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001279 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001280 my $clean = 'X' x length($1);
1281 $res =~ s@\<.*\>@<$clean>@;
1282
1283 # The whole of a #error is a string.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001284 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001285 my $clean = 'X' x length($1);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001286 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001287 }
1288
Joe Perchesdadf6802016-08-02 14:04:33 -07001289 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1290 my $match = $1;
1291 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1292 }
1293
Andy Whitcroft00df3442007-06-08 13:47:06 -07001294 return $res;
1295}
1296
Joe Perchesa6962d72013-04-29 16:18:13 -07001297sub get_quoted_string {
1298 my ($line, $rawline) = @_;
1299
Joe Perches33acb542015-06-25 15:02:54 -07001300 return "" if ($line !~ m/($String)/g);
Joe Perchesa6962d72013-04-29 16:18:13 -07001301 return substr($rawline, $-[0], $+[0] - $-[0]);
1302}
1303
Andy Whitcroft8905a672007-11-28 16:21:06 -08001304sub ctx_statement_block {
1305 my ($linenr, $remain, $off) = @_;
1306 my $line = $linenr - 1;
1307 my $blk = '';
1308 my $soff = $off;
1309 my $coff = $off - 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001310 my $coff_set = 0;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001311
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001312 my $loff = 0;
1313
Andy Whitcroft8905a672007-11-28 16:21:06 -08001314 my $type = '';
1315 my $level = 0;
Andy Whitcrofta2750642009-01-15 13:51:04 -08001316 my @stack = ();
Andy Whitcroftcf655042008-03-04 14:28:20 -08001317 my $p;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001318 my $c;
1319 my $len = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001320
1321 my $remainder;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001322 while (1) {
Andy Whitcrofta2750642009-01-15 13:51:04 -08001323 @stack = (['', 0]) if ($#stack == -1);
1324
Andy Whitcroft773647a2008-03-28 14:15:58 -07001325 #warn "CSB: blk<$blk> remain<$remain>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001326 # If we are about to drop off the end, pull in more
1327 # context.
1328 if ($off >= $len) {
1329 for (; $remain > 0; $line++) {
Andy Whitcroftdea33492008-10-15 22:02:25 -07001330 last if (!defined $lines[$line]);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001331 next if ($lines[$line] =~ /^-/);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001332 $remain--;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001333 $loff = $len;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001334 $blk .= $lines[$line] . "\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001335 $len = length($blk);
1336 $line++;
1337 last;
1338 }
1339 # Bail if there is no further context.
1340 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001341 if ($off >= $len) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08001342 last;
1343 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001344 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1345 $level++;
1346 $type = '#';
1347 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001348 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08001349 $p = $c;
Andy Whitcroft8905a672007-11-28 16:21:06 -08001350 $c = substr($blk, $off, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001351 $remainder = substr($blk, $off);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001352
Andy Whitcroft773647a2008-03-28 14:15:58 -07001353 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001354
1355 # Handle nested #if/#else.
1356 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1357 push(@stack, [ $type, $level ]);
1358 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1359 ($type, $level) = @{$stack[$#stack - 1]};
1360 } elsif ($remainder =~ /^#\s*endif\b/) {
1361 ($type, $level) = @{pop(@stack)};
1362 }
1363
Andy Whitcroft8905a672007-11-28 16:21:06 -08001364 # Statement ends at the ';' or a close '}' at the
1365 # outermost level.
1366 if ($level == 0 && $c eq ';') {
1367 last;
1368 }
1369
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001370 # An else is really a conditional as long as its not else if
Andy Whitcroft773647a2008-03-28 14:15:58 -07001371 if ($level == 0 && $coff_set == 0 &&
1372 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1373 $remainder =~ /^(else)(?:\s|{)/ &&
1374 $remainder !~ /^else\s+if\b/) {
1375 $coff = $off + length($1) - 1;
1376 $coff_set = 1;
1377 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1378 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001379 }
1380
Andy Whitcroft8905a672007-11-28 16:21:06 -08001381 if (($type eq '' || $type eq '(') && $c eq '(') {
1382 $level++;
1383 $type = '(';
1384 }
1385 if ($type eq '(' && $c eq ')') {
1386 $level--;
1387 $type = ($level != 0)? '(' : '';
1388
1389 if ($level == 0 && $coff < $soff) {
1390 $coff = $off;
Andy Whitcroft773647a2008-03-28 14:15:58 -07001391 $coff_set = 1;
1392 #warn "CSB: mark coff<$coff>\n";
Andy Whitcroft8905a672007-11-28 16:21:06 -08001393 }
1394 }
1395 if (($type eq '' || $type eq '{') && $c eq '{') {
1396 $level++;
1397 $type = '{';
1398 }
1399 if ($type eq '{' && $c eq '}') {
1400 $level--;
1401 $type = ($level != 0)? '{' : '';
1402
1403 if ($level == 0) {
Patrick Pannutob998e002010-08-09 17:21:03 -07001404 if (substr($blk, $off + 1, 1) eq ';') {
1405 $off++;
1406 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001407 last;
1408 }
1409 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08001410 # Preprocessor commands end at the newline unless escaped.
1411 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1412 $level--;
1413 $type = '';
1414 $off++;
1415 last;
1416 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001417 $off++;
1418 }
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001419 # We are truly at the end, so shuffle to the next line.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001420 if ($off == $len) {
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07001421 $loff = $len + 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001422 $line++;
1423 $remain--;
1424 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001425
1426 my $statement = substr($blk, $soff, $off - $soff + 1);
1427 my $condition = substr($blk, $soff, $coff - $soff + 1);
1428
1429 #warn "STATEMENT<$statement>\n";
1430 #warn "CONDITION<$condition>\n";
1431
Andy Whitcroft773647a2008-03-28 14:15:58 -07001432 #print "coff<$coff> soff<$off> loff<$loff>\n";
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001433
1434 return ($statement, $condition,
1435 $line, $remain + 1, $off - $loff + 1, $level);
1436}
1437
Andy Whitcroftcf655042008-03-04 14:28:20 -08001438sub statement_lines {
1439 my ($stmt) = @_;
1440
1441 # Strip the diff line prefixes and rip blank lines at start and end.
1442 $stmt =~ s/(^|\n)./$1/g;
1443 $stmt =~ s/^\s*//;
1444 $stmt =~ s/\s*$//;
1445
1446 my @stmt_lines = ($stmt =~ /\n/g);
1447
1448 return $#stmt_lines + 2;
1449}
1450
1451sub statement_rawlines {
1452 my ($stmt) = @_;
1453
1454 my @stmt_lines = ($stmt =~ /\n/g);
1455
1456 return $#stmt_lines + 2;
1457}
1458
1459sub statement_block_size {
1460 my ($stmt) = @_;
1461
1462 $stmt =~ s/(^|\n)./$1/g;
1463 $stmt =~ s/^\s*{//;
1464 $stmt =~ s/}\s*$//;
1465 $stmt =~ s/^\s*//;
1466 $stmt =~ s/\s*$//;
1467
1468 my @stmt_lines = ($stmt =~ /\n/g);
1469 my @stmt_statements = ($stmt =~ /;/g);
1470
1471 my $stmt_lines = $#stmt_lines + 2;
1472 my $stmt_statements = $#stmt_statements + 1;
1473
1474 if ($stmt_lines > $stmt_statements) {
1475 return $stmt_lines;
1476 } else {
1477 return $stmt_statements;
1478 }
1479}
1480
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001481sub ctx_statement_full {
1482 my ($linenr, $remain, $off) = @_;
1483 my ($statement, $condition, $level);
1484
1485 my (@chunks);
1486
Andy Whitcroftcf655042008-03-04 14:28:20 -08001487 # Grab the first conditional/block pair.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001488 ($statement, $condition, $linenr, $remain, $off, $level) =
1489 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001490 #print "F: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08001491 push(@chunks, [ $condition, $statement ]);
1492 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1493 return ($level, $linenr, @chunks);
1494 }
1495
1496 # Pull in the following conditional/block pairs and see if they
1497 # could continue the statement.
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001498 for (;;) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001499 ($statement, $condition, $linenr, $remain, $off, $level) =
1500 ctx_statement_block($linenr, $remain, $off);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001501 #print "C: c<$condition> s<$statement> remain<$remain>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07001502 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
Andy Whitcroftcf655042008-03-04 14:28:20 -08001503 #print "C: push\n";
1504 push(@chunks, [ $condition, $statement ]);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001505 }
1506
1507 return ($level, $linenr, @chunks);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001508}
1509
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001510sub ctx_block_get {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001511 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001512 my $line;
1513 my $start = $linenr - 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001514 my $blk = '';
1515 my @o;
1516 my @c;
1517 my @res = ();
1518
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001519 my $level = 0;
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001520 my @stack = ($level);
Andy Whitcroft00df3442007-06-08 13:47:06 -07001521 for ($line = $start; $remain > 0; $line++) {
1522 next if ($rawlines[$line] =~ /^-/);
1523 $remain--;
1524
1525 $blk .= $rawlines[$line];
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001526
1527 # Handle nested #if/#else.
Andy Whitcroft01464f32010-10-26 14:23:19 -07001528 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001529 push(@stack, $level);
Andy Whitcroft01464f32010-10-26 14:23:19 -07001530 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001531 $level = $stack[$#stack - 1];
Andy Whitcroft01464f32010-10-26 14:23:19 -07001532 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
Andy Whitcroft4635f4f2009-01-06 14:41:27 -08001533 $level = pop(@stack);
1534 }
1535
Andy Whitcroft01464f32010-10-26 14:23:19 -07001536 foreach my $c (split(//, $lines[$line])) {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001537 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1538 if ($off > 0) {
1539 $off--;
1540 next;
1541 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001542
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001543 if ($c eq $close && $level > 0) {
1544 $level--;
1545 last if ($level == 0);
1546 } elsif ($c eq $open) {
1547 $level++;
1548 }
1549 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001550
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001551 if (!$outer || $level <= 1) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001552 push(@res, $rawlines[$line]);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001553 }
1554
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001555 last if ($level == 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001556 }
1557
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001558 return ($level, @res);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001559}
1560sub ctx_block_outer {
1561 my ($linenr, $remain) = @_;
1562
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001563 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1564 return @r;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001565}
1566sub ctx_block {
1567 my ($linenr, $remain) = @_;
1568
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001569 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1570 return @r;
Andy Whitcroft653d4872007-06-23 17:16:34 -07001571}
1572sub ctx_statement {
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001573 my ($linenr, $remain, $off) = @_;
1574
1575 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1576 return @r;
1577}
1578sub ctx_block_level {
Andy Whitcroft653d4872007-06-23 17:16:34 -07001579 my ($linenr, $remain) = @_;
1580
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001581 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001582}
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001583sub ctx_statement_level {
1584 my ($linenr, $remain, $off) = @_;
1585
1586 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1587}
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001588
1589sub ctx_locate_comment {
1590 my ($first_line, $end_line) = @_;
1591
1592 # Catch a comment on the end of the line itself.
Andy Whitcroftbeae6332008-07-23 21:28:59 -07001593 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001594 return $current_comment if (defined $current_comment);
1595
1596 # Look through the context and try and figure out if there is a
1597 # comment.
1598 my $in_comment = 0;
1599 $current_comment = '';
1600 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07001601 my $line = $rawlines[$linenr - 1];
1602 #warn " $line\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001603 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1604 $in_comment = 1;
1605 }
1606 if ($line =~ m@/\*@) {
1607 $in_comment = 1;
1608 }
1609 if (!$in_comment && $current_comment ne '') {
1610 $current_comment = '';
1611 }
1612 $current_comment .= $line . "\n" if ($in_comment);
1613 if ($line =~ m@\*/@) {
1614 $in_comment = 0;
1615 }
1616 }
1617
1618 chomp($current_comment);
1619 return($current_comment);
1620}
1621sub ctx_has_comment {
1622 my ($first_line, $end_line) = @_;
1623 my $cmt = ctx_locate_comment($first_line, $end_line);
1624
Andy Whitcroft00df3442007-06-08 13:47:06 -07001625 ##print "LINE: $rawlines[$end_line - 1 ]\n";
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07001626 ##print "CMMT: $cmt\n";
1627
1628 return ($cmt ne '');
1629}
1630
Andy Whitcroft4d001e42008-10-15 22:02:21 -07001631sub raw_line {
1632 my ($linenr, $cnt) = @_;
1633
1634 my $offset = $linenr - 1;
1635 $cnt++;
1636
1637 my $line;
1638 while ($cnt) {
1639 $line = $rawlines[$offset++];
1640 next if (defined($line) && $line =~ /^-/);
1641 $cnt--;
1642 }
1643
1644 return $line;
1645}
1646
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001647sub cat_vet {
1648 my ($vet) = @_;
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001649 my ($res, $coded);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001650
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001651 $res = '';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001652 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1653 $res .= $1;
1654 if ($2 ne '') {
1655 $coded = sprintf("^%c", unpack('C', $2) + 64);
1656 $res .= $coded;
1657 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001658 }
1659 $res =~ s/$/\$/;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001660
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07001661 return $res;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07001662}
1663
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001664my $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001665my $av_pending;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001666my @av_paren_type;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001667my $av_pend_colon;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001668
1669sub annotate_reset {
1670 $av_preprocessor = 0;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001671 $av_pending = '_';
1672 @av_paren_type = ('E');
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001673 $av_pend_colon = 'O';
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001674}
1675
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001676sub annotate_values {
1677 my ($stream, $type) = @_;
1678
1679 my $res;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001680 my $var = '_' x length($stream);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001681 my $cur = $stream;
1682
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001683 print "$stream\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001684
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001685 while (length($cur)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001686 @av_paren_type = ('E') if ($#av_paren_type < 0);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001687 print " <" . join('', @av_paren_type) .
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001688 "> <$type> <$av_pending>" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001689 if ($cur =~ /^(\s+)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001690 print "WS($1)\n" if ($dbg_values > 1);
1691 if ($1 =~ /\n/ && $av_preprocessor) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001692 $type = pop(@av_paren_type);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001693 $av_preprocessor = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001694 }
1695
Florian Micklerc023e4732011-01-12 16:59:58 -08001696 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001697 print "CAST($1)\n" if ($dbg_values > 1);
1698 push(@av_paren_type, $type);
Andy Whitcroftaddcdce2012-01-10 15:10:11 -08001699 $type = 'c';
Andy Whitcroft9446ef52010-10-26 14:23:13 -07001700
Andy Whitcrofte91b6e22010-10-26 14:23:11 -07001701 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001702 print "DECLARE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001703 $type = 'T';
1704
Andy Whitcroft389a2fe2008-07-23 21:29:05 -07001705 } elsif ($cur =~ /^($Modifier)\s*/) {
1706 print "MODIFIER($1)\n" if ($dbg_values > 1);
1707 $type = 'T';
1708
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001709 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001710 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001711 $av_preprocessor = 1;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001712 push(@av_paren_type, $type);
1713 if ($2 ne '') {
1714 $av_pending = 'N';
1715 }
1716 $type = 'E';
1717
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001718 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001719 print "UNDEF($1)\n" if ($dbg_values > 1);
1720 $av_preprocessor = 1;
1721 push(@av_paren_type, $type);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001722
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001723 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001724 print "PRE_START($1)\n" if ($dbg_values > 1);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001725 $av_preprocessor = 1;
Andy Whitcroftcf655042008-03-04 14:28:20 -08001726
1727 push(@av_paren_type, $type);
1728 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001729 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001730
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001731 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001732 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1733 $av_preprocessor = 1;
1734
1735 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1736
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001737 $type = 'E';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001738
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001739 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001740 print "PRE_END($1)\n" if ($dbg_values > 1);
1741
1742 $av_preprocessor = 1;
1743
1744 # Assume all arms of the conditional end as this
1745 # one does, and continue as if the #endif was not here.
1746 pop(@av_paren_type);
1747 push(@av_paren_type, $type);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001748 $type = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001749
1750 } elsif ($cur =~ /^(\\\n)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001751 print "PRECONT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001752
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07001753 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1754 print "ATTR($1)\n" if ($dbg_values > 1);
1755 $av_pending = $type;
1756 $type = 'N';
1757
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001758 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001759 print "SIZEOF($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001760 if (defined $2) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001761 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001762 }
1763 $type = 'N';
1764
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001765 } elsif ($cur =~ /^(if|while|for)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001766 print "COND($1)\n" if ($dbg_values > 1);
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001767 $av_pending = 'E';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001768 $type = 'N';
1769
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001770 } elsif ($cur =~/^(case)/o) {
1771 print "CASE($1)\n" if ($dbg_values > 1);
1772 $av_pend_colon = 'C';
1773 $type = 'N';
1774
Andy Whitcroft14b111c2008-10-15 22:02:16 -07001775 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001776 print "KEYWORD($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001777 $type = 'N';
1778
1779 } elsif ($cur =~ /^(\()/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001780 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroftcf655042008-03-04 14:28:20 -08001781 push(@av_paren_type, $av_pending);
1782 $av_pending = '_';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001783 $type = 'N';
1784
1785 } elsif ($cur =~ /^(\))/o) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08001786 my $new_type = pop(@av_paren_type);
1787 if ($new_type ne '_') {
1788 $type = $new_type;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001789 print "PAREN('$1') -> $type\n"
1790 if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001791 } else {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001792 print "PAREN('$1')\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001793 }
1794
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001795 } elsif ($cur =~ /^($Ident)\s*\(/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001796 print "FUNC($1)\n" if ($dbg_values > 1);
Andy Whitcroftc8cb2ca2008-07-23 21:28:57 -07001797 $type = 'V';
Andy Whitcroftcf655042008-03-04 14:28:20 -08001798 $av_pending = 'V';
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001799
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001800 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1801 if (defined $2 && $type eq 'C' || $type eq 'T') {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001802 $av_pend_colon = 'B';
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001803 } elsif ($type eq 'E') {
1804 $av_pend_colon = 'L';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001805 }
1806 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1807 $type = 'V';
1808
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001809 } elsif ($cur =~ /^($Ident|$Constant)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001810 print "IDENT($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001811 $type = 'V';
1812
1813 } elsif ($cur =~ /^($Assignment)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001814 print "ASSIGN($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001815 $type = 'N';
1816
Andy Whitcroftcf655042008-03-04 14:28:20 -08001817 } elsif ($cur =~/^(;|{|})/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001818 print "END($1)\n" if ($dbg_values > 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001819 $type = 'E';
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001820 $av_pend_colon = 'O';
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001821
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001822 } elsif ($cur =~/^(,)/) {
1823 print "COMMA($1)\n" if ($dbg_values > 1);
1824 $type = 'C';
1825
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001826 } elsif ($cur =~ /^(\?)/o) {
1827 print "QUESTION($1)\n" if ($dbg_values > 1);
1828 $type = 'N';
1829
1830 } elsif ($cur =~ /^(:)/o) {
1831 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1832
1833 substr($var, length($res), 1, $av_pend_colon);
1834 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1835 $type = 'E';
1836 } else {
1837 $type = 'N';
1838 }
1839 $av_pend_colon = 'O';
1840
Andy Whitcroft8e761b02009-01-06 14:41:19 -08001841 } elsif ($cur =~ /^(\[)/o) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001842 print "CLOSE($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001843 $type = 'N';
1844
Andy Whitcroft0d413862008-10-15 22:02:16 -07001845 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
Andy Whitcroft74048ed2008-07-23 21:29:10 -07001846 my $variant;
1847
1848 print "OPV($1)\n" if ($dbg_values > 1);
1849 if ($type eq 'V') {
1850 $variant = 'B';
1851 } else {
1852 $variant = 'U';
1853 }
1854
1855 substr($var, length($res), 1, $variant);
1856 $type = 'N';
1857
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001858 } elsif ($cur =~ /^($Operators)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001859 print "OP($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001860 if ($1 ne '++' && $1 ne '--') {
1861 $type = 'N';
1862 }
1863
1864 } elsif ($cur =~ /(^.)/o) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08001865 print "C($1)\n" if ($dbg_values > 1);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001866 }
1867 if (defined $1) {
1868 $cur = substr($cur, length($1));
1869 $res .= $type x length($1);
1870 }
1871 }
1872
Andy Whitcroft1f65f942008-07-23 21:29:10 -07001873 return ($res, $var);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001874}
1875
Andy Whitcroft8905a672007-11-28 16:21:06 -08001876sub possible {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001877 my ($possible, $line) = @_;
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001878 my $notPermitted = qr{(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001879 ^(?:
1880 $Modifier|
1881 $Storage|
1882 $Type|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001883 DEFINE_\S+
1884 )$|
1885 ^(?:
Andy Whitcroft0776e592008-10-15 22:02:29 -07001886 goto|
1887 return|
1888 case|
1889 else|
1890 asm|__asm__|
Andy Whitcroft89a88352012-01-10 15:10:00 -08001891 do|
1892 \#|
1893 \#\#|
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001894 )(?:\s|$)|
Andy Whitcroft0776e592008-10-15 22:02:29 -07001895 ^(?:typedef|struct|enum)\b
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001896 )}x;
1897 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1898 if ($possible !~ $notPermitted) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001899 # Check for modifiers.
1900 $possible =~ s/\s*$Storage\s*//g;
1901 $possible =~ s/\s*$Sparse\s*//g;
1902 if ($possible =~ /^\s*$/) {
1903
1904 } elsif ($possible =~ /\s/) {
1905 $possible =~ s/\s*$Type\s*//g;
Andy Whitcroftd2506582008-07-23 21:29:09 -07001906 for my $modifier (split(' ', $possible)) {
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001907 if ($modifier !~ $notPermitted) {
1908 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001909 push(@modifierListFile, $modifier);
Andy Whitcroft9a974fd2009-10-26 16:50:12 -07001910 }
Andy Whitcroftd2506582008-07-23 21:29:09 -07001911 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001912
1913 } else {
1914 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
Alex Dowad485ff232015-06-25 15:02:52 -07001915 push(@typeListFile, $possible);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07001916 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08001917 build_types();
Andy Whitcroft0776e592008-10-15 22:02:29 -07001918 } else {
1919 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001920 }
1921}
1922
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07001923my $prefix = '';
1924
Joe Perches000d1cc12011-07-25 17:13:25 -07001925sub show_type {
Joe Perchescbec18a2014-04-03 14:49:19 -07001926 my ($type) = @_;
Joe Perches91bfe482013-09-11 14:23:59 -07001927
Alexey Dobriyan522b8372017-02-27 14:30:05 -08001928 $type =~ tr/[a-z]/[A-Z]/;
1929
Joe Perchescbec18a2014-04-03 14:49:19 -07001930 return defined $use_type{$type} if (scalar keys %use_type > 0);
1931
1932 return !defined $ignore_type{$type};
Joe Perches000d1cc12011-07-25 17:13:25 -07001933}
1934
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001935sub report {
Joe Perchescbec18a2014-04-03 14:49:19 -07001936 my ($level, $type, $msg) = @_;
1937
1938 if (!show_type($type) ||
1939 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07001940 return 0;
1941 }
Joe Perches57230292015-06-25 15:03:03 -07001942 my $output = '';
John Brooks737c0762017-07-10 15:52:24 -07001943 if ($color) {
Joe Perches57230292015-06-25 15:03:03 -07001944 if ($level eq 'ERROR') {
1945 $output .= RED;
1946 } elsif ($level eq 'WARNING') {
1947 $output .= YELLOW;
1948 } else {
1949 $output .= GREEN;
1950 }
Joe Perches000d1cc12011-07-25 17:13:25 -07001951 }
Joe Perches57230292015-06-25 15:03:03 -07001952 $output .= $prefix . $level . ':';
1953 if ($show_types) {
John Brooks737c0762017-07-10 15:52:24 -07001954 $output .= BLUE if ($color);
Joe Perches57230292015-06-25 15:03:03 -07001955 $output .= "$type:";
1956 }
John Brooks737c0762017-07-10 15:52:24 -07001957 $output .= RESET if ($color);
Joe Perches57230292015-06-25 15:03:03 -07001958 $output .= ' ' . $msg . "\n";
Joe Perches34d88152015-06-25 15:03:05 -07001959
1960 if ($showfile) {
1961 my @lines = split("\n", $output, -1);
1962 splice(@lines, 1, 1);
1963 $output = join("\n", @lines);
1964 }
Joe Perches57230292015-06-25 15:03:03 -07001965 $output = (split('\n', $output))[0] . "\n" if ($terse);
Andy Whitcroft8905a672007-11-28 16:21:06 -08001966
Joe Perches57230292015-06-25 15:03:03 -07001967 push(our @report, $output);
Andy Whitcroft773647a2008-03-28 14:15:58 -07001968
1969 return 1;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001970}
Joe Perchescbec18a2014-04-03 14:49:19 -07001971
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001972sub report_dump {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08001973 our @report;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07001974}
Joe Perches000d1cc12011-07-25 17:13:25 -07001975
Joe Perchesd752fcc2014-08-06 16:11:05 -07001976sub fixup_current_range {
1977 my ($lineRef, $offset, $length) = @_;
1978
1979 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1980 my $o = $1;
1981 my $l = $2;
1982 my $no = $o + $offset;
1983 my $nl = $l + $length;
1984 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1985 }
1986}
1987
1988sub fix_inserted_deleted_lines {
1989 my ($linesRef, $insertedRef, $deletedRef) = @_;
1990
1991 my $range_last_linenr = 0;
1992 my $delta_offset = 0;
1993
1994 my $old_linenr = 0;
1995 my $new_linenr = 0;
1996
1997 my $next_insert = 0;
1998 my $next_delete = 0;
1999
2000 my @lines = ();
2001
2002 my $inserted = @{$insertedRef}[$next_insert++];
2003 my $deleted = @{$deletedRef}[$next_delete++];
2004
2005 foreach my $old_line (@{$linesRef}) {
2006 my $save_line = 1;
2007 my $line = $old_line; #don't modify the array
Joe Perches323b2672015-04-16 12:44:50 -07002008 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
Joe Perchesd752fcc2014-08-06 16:11:05 -07002009 $delta_offset = 0;
2010 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2011 $range_last_linenr = $new_linenr;
2012 fixup_current_range(\$line, $delta_offset, 0);
2013 }
2014
2015 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2016 $deleted = @{$deletedRef}[$next_delete++];
2017 $save_line = 0;
2018 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2019 }
2020
2021 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2022 push(@lines, ${$inserted}{'LINE'});
2023 $inserted = @{$insertedRef}[$next_insert++];
2024 $new_linenr++;
2025 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2026 }
2027
2028 if ($save_line) {
2029 push(@lines, $line);
2030 $new_linenr++;
2031 }
2032
2033 $old_linenr++;
2034 }
2035
2036 return @lines;
2037}
2038
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07002039sub fix_insert_line {
2040 my ($linenr, $line) = @_;
2041
2042 my $inserted = {
2043 LINENR => $linenr,
2044 LINE => $line,
2045 };
2046 push(@fixed_inserted, $inserted);
2047}
2048
2049sub fix_delete_line {
2050 my ($linenr, $line) = @_;
2051
2052 my $deleted = {
2053 LINENR => $linenr,
2054 LINE => $line,
2055 };
2056
2057 push(@fixed_deleted, $deleted);
2058}
2059
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002060sub ERROR {
Joe Perchescbec18a2014-04-03 14:49:19 -07002061 my ($type, $msg) = @_;
2062
2063 if (report("ERROR", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002064 our $clean = 0;
2065 our $cnt_error++;
Joe Perches3705ce52013-07-03 15:05:31 -07002066 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002067 }
Joe Perches3705ce52013-07-03 15:05:31 -07002068 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002069}
2070sub WARN {
Joe Perchescbec18a2014-04-03 14:49:19 -07002071 my ($type, $msg) = @_;
2072
2073 if (report("WARNING", $type, $msg)) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002074 our $clean = 0;
2075 our $cnt_warn++;
Joe Perches3705ce52013-07-03 15:05:31 -07002076 return 1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002077 }
Joe Perches3705ce52013-07-03 15:05:31 -07002078 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002079}
2080sub CHK {
Joe Perchescbec18a2014-04-03 14:49:19 -07002081 my ($type, $msg) = @_;
2082
2083 if ($check && report("CHECK", $type, $msg)) {
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002084 our $clean = 0;
2085 our $cnt_chk++;
Joe Perches3705ce52013-07-03 15:05:31 -07002086 return 1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002087 }
Joe Perches3705ce52013-07-03 15:05:31 -07002088 return 0;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002089}
2090
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002091sub check_absolute_file {
2092 my ($absolute, $herecurr) = @_;
2093 my $file = $absolute;
2094
2095 ##print "absolute<$absolute>\n";
2096
2097 # See if any suffix of this path is a path within the tree.
2098 while ($file =~ s@^[^/]*/@@) {
2099 if (-f "$root/$file") {
2100 ##print "file<$file>\n";
2101 last;
2102 }
2103 }
2104 if (! -f _) {
2105 return 0;
2106 }
2107
2108 # It is, so see if the prefix is acceptable.
2109 my $prefix = $absolute;
2110 substr($prefix, -length($file)) = '';
2111
2112 ##print "prefix<$prefix>\n";
2113 if ($prefix ne ".../") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002114 WARN("USE_RELATIVE_PATH",
2115 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
Andy Whitcroft6ecd9672008-10-15 22:02:21 -07002116 }
2117}
2118
Joe Perches3705ce52013-07-03 15:05:31 -07002119sub trim {
2120 my ($string) = @_;
2121
Joe Perchesb34c6482013-09-11 14:24:01 -07002122 $string =~ s/^\s+|\s+$//g;
2123
2124 return $string;
2125}
2126
2127sub ltrim {
2128 my ($string) = @_;
2129
2130 $string =~ s/^\s+//;
2131
2132 return $string;
2133}
2134
2135sub rtrim {
2136 my ($string) = @_;
2137
2138 $string =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002139
2140 return $string;
2141}
2142
Joe Perches52ea8502013-11-12 15:10:09 -08002143sub string_find_replace {
2144 my ($string, $find, $replace) = @_;
2145
2146 $string =~ s/$find/$replace/g;
2147
2148 return $string;
2149}
2150
Joe Perches3705ce52013-07-03 15:05:31 -07002151sub tabify {
2152 my ($leading) = @_;
2153
2154 my $source_indent = 8;
2155 my $max_spaces_before_tab = $source_indent - 1;
2156 my $spaces_to_tab = " " x $source_indent;
2157
2158 #convert leading spaces to tabs
2159 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2160 #Remove spaces before a tab
2161 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2162
2163 return "$leading";
2164}
2165
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002166sub pos_last_openparen {
2167 my ($line) = @_;
2168
2169 my $pos = 0;
2170
2171 my $opens = $line =~ tr/\(/\(/;
2172 my $closes = $line =~ tr/\)/\)/;
2173
2174 my $last_openparen = 0;
2175
2176 if (($opens == 0) || ($closes >= $opens)) {
2177 return -1;
2178 }
2179
2180 my $len = length($line);
2181
2182 for ($pos = 0; $pos < $len; $pos++) {
2183 my $string = substr($line, $pos);
2184 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2185 $pos += length($1) - 1;
2186 } elsif (substr($line, $pos, 1) eq '(') {
2187 $last_openparen = $pos;
2188 } elsif (index($string, '(') == -1) {
2189 last;
2190 }
2191 }
2192
Joe Perches91cb5192014-04-03 14:49:32 -07002193 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07002194}
2195
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002196sub process {
2197 my $filename = shift;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002198
2199 my $linenr=0;
2200 my $prevline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002201 my $prevrawline="";
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002202 my $stashline="";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002203 my $stashrawline="";
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002204
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002205 my $length;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002206 my $indent;
2207 my $previndent=0;
2208 my $stashindent=0;
2209
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002210 our $clean = 1;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002211 my $signoff = 0;
2212 my $is_patch = 0;
Joe Perches29ee1b02014-08-06 16:10:35 -07002213 my $in_header_lines = $file ? 0 : 1;
Joe Perches15662b32011-10-31 17:13:12 -07002214 my $in_commit_log = 0; #Scanning lines before patch
Allen Hubbeed43c4e2016-08-02 14:04:45 -07002215 my $has_commit_log = 0; #Encountered lines before patch
Joe Perches77cb8542017-02-24 15:01:28 -08002216 my $commit_log_possible_stack_dump = 0;
Joe Perches2a076f42015-04-16 12:44:28 -07002217 my $commit_log_long_line = 0;
Joe Perchese518e9a2015-06-25 15:03:27 -07002218 my $commit_log_has_diff = 0;
Joe Perches13f19372014-08-06 16:10:59 -07002219 my $reported_maintainer_file = 0;
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002220 my $non_utf8_charset = 0;
2221
Joe Perches365dd4e2014-08-06 16:10:42 -07002222 my $last_blank_line = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08002223 my $last_coalesced_string_linenr = -1;
Joe Perches365dd4e2014-08-06 16:10:42 -07002224
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002225 our @report = ();
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002226 our $cnt_lines = 0;
2227 our $cnt_error = 0;
2228 our $cnt_warn = 0;
2229 our $cnt_chk = 0;
2230
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002231 # Trace the real file/line as we go.
2232 my $realfile = '';
2233 my $realline = 0;
2234 my $realcnt = 0;
2235 my $here = '';
Joe Perches77cb8542017-02-24 15:01:28 -08002236 my $context_function; #undef'd unless there's a known function
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002237 my $in_comment = 0;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002238 my $comment_edge = 0;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002239 my $first_line = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002240 my $p1_prefix = '';
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002241
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002242 my $prev_values = 'E';
2243
2244 # suppression flags
Andy Whitcroft773647a2008-03-28 14:15:58 -07002245 my %suppress_ifbraces;
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002246 my %suppress_whiletrailers;
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002247 my %suppress_export;
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002248 my $suppress_statement = 0;
Andy Whitcroft653d4872007-06-23 17:16:34 -07002249
Joe Perches7e51f192013-09-11 14:23:57 -07002250 my %signatures = ();
Joe Perches323c1262012-12-17 16:02:07 -08002251
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002252 # Pre-scan the patch sanitizing the lines.
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002253 # Pre-scan the patch looking for any __setup documentation.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002254 #
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002255 my @setup_docs = ();
2256 my $setup_docs = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002257
Joe Perchesd8b07712013-11-12 15:10:06 -08002258 my $camelcase_file_seeded = 0;
2259
Andy Whitcroft773647a2008-03-28 14:15:58 -07002260 sanitise_line_reset();
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002261 my $line;
2262 foreach my $rawline (@rawlines) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002263 $linenr++;
2264 $line = $rawline;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002265
Joe Perches3705ce52013-07-03 15:05:31 -07002266 push(@fixed, $rawline) if ($fix);
2267
Andy Whitcroft773647a2008-03-28 14:15:58 -07002268 if ($rawline=~/^\+\+\+\s+(\S+)/) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002269 $setup_docs = 0;
Mauro Carvalho Chehab8c27ceff32016-10-18 10:12:27 -02002270 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002271 $setup_docs = 1;
2272 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002273 #next;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002274 }
Joe Perches74fd4f32017-05-08 15:56:02 -07002275 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002276 $realline=$1-1;
2277 if (defined $2) {
2278 $realcnt=$3+1;
2279 } else {
2280 $realcnt=1+1;
2281 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07002282 $in_comment = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002283
2284 # Guestimate if this is a continuing comment. Run
2285 # the context looking for a comment "edge". If this
2286 # edge is a close comment then we must be in a comment
2287 # at context start.
2288 my $edge;
Andy Whitcroft01fa9142008-10-15 22:02:19 -07002289 my $cnt = $realcnt;
2290 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2291 next if (defined $rawlines[$ln - 1] &&
2292 $rawlines[$ln - 1] =~ /^-/);
2293 $cnt--;
2294 #print "RAW<$rawlines[$ln - 1]>\n";
Andy Whitcroft721c1cb2009-01-06 14:41:16 -08002295 last if (!defined $rawlines[$ln - 1]);
Andy Whitcroftfae17da2009-01-06 14:41:20 -08002296 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2297 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2298 ($edge) = $1;
2299 last;
2300 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002301 }
2302 if (defined $edge && $edge eq '*/') {
2303 $in_comment = 1;
2304 }
2305
2306 # Guestimate if this is a continuing comment. If this
2307 # is the start of a diff block and this line starts
2308 # ' *' then it is very likely a comment.
2309 if (!defined $edge &&
Andy Whitcroft83242e02009-01-06 14:41:17 -08002310 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
Andy Whitcroft773647a2008-03-28 14:15:58 -07002311 {
2312 $in_comment = 1;
2313 }
2314
2315 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2316 sanitise_line_reset($in_comment);
2317
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002318 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002319 # Standardise the strings and chars within the input to
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002320 # simplify matching -- only bother with positive lines.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002321 $line = sanitise_line($rawline);
2322 }
2323 push(@lines, $line);
2324
2325 if ($realcnt > 1) {
2326 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2327 } else {
2328 $realcnt = 0;
2329 }
2330
2331 #print "==>$rawline\n";
2332 #print "-->$line\n";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002333
2334 if ($setup_docs && $line =~ /^\+/) {
2335 push(@setup_docs, $line);
2336 }
2337 }
2338
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002339 $prefix = '';
2340
Andy Whitcroft773647a2008-03-28 14:15:58 -07002341 $realcnt = 0;
2342 $linenr = 0;
Joe Perches194f66f2014-08-06 16:11:03 -07002343 $fixlinenr = -1;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002344 foreach my $line (@lines) {
2345 $linenr++;
Joe Perches194f66f2014-08-06 16:11:03 -07002346 $fixlinenr++;
Joe Perches1b5539b2013-09-11 14:24:03 -07002347 my $sline = $line; #copy of $line
2348 $sline =~ s/$;/ /g; #with comments as spaces
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002349
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002350 my $rawline = $rawlines[$linenr - 1];
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002351
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002352#extract the line range in the file after the patch is applied
Joe Perchese518e9a2015-06-25 15:03:27 -07002353 if (!$in_commit_log &&
Joe Perches74fd4f32017-05-08 15:56:02 -07002354 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2355 my $context = $4;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002356 $is_patch = 1;
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002357 $first_line = $linenr + 1;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002358 $realline=$1-1;
2359 if (defined $2) {
2360 $realcnt=$3+1;
2361 } else {
2362 $realcnt=1+1;
2363 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002364 annotate_reset();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08002365 $prev_values = 'E';
2366
Andy Whitcroft773647a2008-03-28 14:15:58 -07002367 %suppress_ifbraces = ();
Andy Whitcroft170d3a22008-10-15 22:02:30 -07002368 %suppress_whiletrailers = ();
Andy Whitcroft2b474a12009-10-26 16:50:16 -07002369 %suppress_export = ();
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08002370 $suppress_statement = 0;
Joe Perches74fd4f32017-05-08 15:56:02 -07002371 if ($context =~ /\b(\w+)\s*\(/) {
2372 $context_function = $1;
2373 } else {
2374 undef $context_function;
2375 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002376 next;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002377
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002378# track the line number as we move through the hunk, note that
2379# new versions of GNU diff omit the leading space on completely
2380# blank context lines so we need to count that too.
Andy Whitcroft773647a2008-03-28 14:15:58 -07002381 } elsif ($line =~ /^( |\+|$)/) {
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002382 $realline++;
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002383 $realcnt-- if ($realcnt != 0);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002384
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002385 # Measure the line length and indent.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002386 ($length, $indent) = line_stats($rawline);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002387
2388 # Track the previous line.
2389 ($prevline, $stashline) = ($stashline, $line);
2390 ($previndent, $stashindent) = ($stashindent, $indent);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002391 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2392
Andy Whitcroft773647a2008-03-28 14:15:58 -07002393 #warn "line<$line>\n";
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002394
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002395 } elsif ($realcnt == 1) {
2396 $realcnt--;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002397 }
2398
Andy Whitcroftcc77cdc2009-10-26 16:50:13 -07002399 my $hunk_line = ($realcnt != 0);
2400
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002401 $here = "#$linenr: " if (!$file);
2402 $here = "#$realline: " if ($file);
Andy Whitcroft773647a2008-03-28 14:15:58 -07002403
Joe Perches2ac73b42014-06-04 16:12:05 -07002404 my $found_file = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07002405 # extract the filename as it passes
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002406 if ($line =~ /^diff --git.*?(\S+)$/) {
2407 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002408 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002409 $in_commit_log = 0;
Joe Perches2ac73b42014-06-04 16:12:05 -07002410 $found_file = 1;
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002411 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07002412 $realfile = $1;
Joe Perches2b7ab452013-11-12 15:10:14 -08002413 $realfile =~ s@^([^/]*)/@@ if (!$file);
Joe Perches270c49a2012-01-10 15:09:50 -08002414 $in_commit_log = 0;
Wolfram Sang1e855722009-01-06 14:41:24 -08002415
2416 $p1_prefix = $1;
Andy Whitcrofte2f7aa42009-02-27 14:03:06 -08002417 if (!$file && $tree && $p1_prefix ne '' &&
2418 -e "$root/$p1_prefix") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002419 WARN("PATCH_PREFIX",
2420 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
Wolfram Sang1e855722009-01-06 14:41:24 -08002421 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002422
Andy Whitcroftc1ab3322008-10-15 22:02:20 -07002423 if ($realfile =~ m@^include/asm/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002424 ERROR("MODIFIED_INCLUDE_ASM",
2425 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
Andy Whitcroft773647a2008-03-28 14:15:58 -07002426 }
Joe Perches2ac73b42014-06-04 16:12:05 -07002427 $found_file = 1;
2428 }
2429
Joe Perches34d88152015-06-25 15:03:05 -07002430#make up the handle for any error we report on this line
2431 if ($showfile) {
2432 $prefix = "$realfile:$realline: "
2433 } elsif ($emacs) {
Joe Perches7d3a9f62015-09-09 15:37:39 -07002434 if ($file) {
2435 $prefix = "$filename:$realline: ";
2436 } else {
2437 $prefix = "$filename:$linenr: ";
2438 }
Joe Perches34d88152015-06-25 15:03:05 -07002439 }
2440
Joe Perches2ac73b42014-06-04 16:12:05 -07002441 if ($found_file) {
Joe Perches85b0ee12016-10-11 13:51:44 -07002442 if (is_maintained_obsolete($realfile)) {
2443 WARN("OBSOLETE",
2444 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2445 }
Joe Perches7bd7e482015-09-09 15:37:44 -07002446 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
Joe Perches2ac73b42014-06-04 16:12:05 -07002447 $check = 1;
2448 } else {
2449 $check = $check_orig;
2450 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07002451 next;
2452 }
2453
Randy Dunlap389834b2007-06-08 13:47:03 -07002454 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002455
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002456 my $hereline = "$here\n$rawline\n";
2457 my $herecurr = "$here\n$rawline\n";
2458 my $hereprev = "$here\n$prevrawline\n$rawline\n";
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002459
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002460 $cnt_lines++ if ($realcnt != 0);
2461
Joe Perchese518e9a2015-06-25 15:03:27 -07002462# Check if the commit log has what seems like a diff which can confuse patch
2463 if ($in_commit_log && !$commit_log_has_diff &&
2464 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2465 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2466 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2467 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2468 ERROR("DIFF_IN_COMMIT_MSG",
2469 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2470 $commit_log_has_diff = 1;
2471 }
2472
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002473# Check for incorrect file permissions
2474 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2475 my $permhere = $here . "FILE: $realfile\n";
Joe Perches04db4d22013-04-29 16:18:14 -07002476 if ($realfile !~ m@scripts/@ &&
2477 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002478 ERROR("EXECUTE_PERMISSIONS",
2479 "do not set execute permissions for source files\n" . $permhere);
Rabin Vincent3bf9a002010-10-26 14:23:16 -07002480 }
2481 }
2482
Joe Perches20112472011-07-25 17:13:23 -07002483# Check the patch for a signoff:
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07002484 if ($line =~ /^\s*signed-off-by:/i) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07002485 $signoff++;
Joe Perches15662b32011-10-31 17:13:12 -07002486 $in_commit_log = 0;
Joe Perches20112472011-07-25 17:13:23 -07002487 }
2488
Joe Perchese0d975b2014-12-10 15:51:49 -08002489# Check if MAINTAINERS is being updated. If so, there's probably no need to
2490# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2491 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2492 $reported_maintainer_file = 1;
2493 }
2494
Joe Perches20112472011-07-25 17:13:23 -07002495# Check signature styles
Joe Perches270c49a2012-01-10 15:09:50 -08002496 if (!$in_header_lines &&
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002497 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Perches20112472011-07-25 17:13:23 -07002498 my $space_before = $1;
2499 my $sign_off = $2;
2500 my $space_after = $3;
2501 my $email = $4;
2502 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2503
Joe Perchesce0338df3c2012-07-30 14:41:18 -07002504 if ($sign_off !~ /$signature_tags/) {
2505 WARN("BAD_SIGN_OFF",
2506 "Non-standard signature: $sign_off\n" . $herecurr);
2507 }
Joe Perches20112472011-07-25 17:13:23 -07002508 if (defined $space_before && $space_before ne "") {
Joe Perches3705ce52013-07-03 15:05:31 -07002509 if (WARN("BAD_SIGN_OFF",
2510 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2511 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002512 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002513 "$ucfirst_sign_off $email";
2514 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002515 }
Joe Perches20112472011-07-25 17:13:23 -07002516 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Joe Perches3705ce52013-07-03 15:05:31 -07002517 if (WARN("BAD_SIGN_OFF",
2518 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2519 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002520 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002521 "$ucfirst_sign_off $email";
2522 }
2523
Joe Perches20112472011-07-25 17:13:23 -07002524 }
2525 if (!defined $space_after || $space_after ne " ") {
Joe Perches3705ce52013-07-03 15:05:31 -07002526 if (WARN("BAD_SIGN_OFF",
2527 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2528 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002529 $fixed[$fixlinenr] =
Joe Perches3705ce52013-07-03 15:05:31 -07002530 "$ucfirst_sign_off $email";
2531 }
Joe Perches20112472011-07-25 17:13:23 -07002532 }
2533
2534 my ($email_name, $email_address, $comment) = parse_email($email);
2535 my $suggested_email = format_email(($email_name, $email_address));
2536 if ($suggested_email eq "") {
Joe Perches000d1cc12011-07-25 17:13:25 -07002537 ERROR("BAD_SIGN_OFF",
2538 "Unrecognized email address: '$email'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002539 } else {
2540 my $dequoted = $suggested_email;
2541 $dequoted =~ s/^"//;
2542 $dequoted =~ s/" </ </;
2543 # Don't force email to have quotes
2544 # Allow just an angle bracketed address
2545 if ("$dequoted$comment" ne $email &&
2546 "<$email_address>$comment" ne $email &&
2547 "$suggested_email$comment" ne $email) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002548 WARN("BAD_SIGN_OFF",
2549 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
Joe Perches20112472011-07-25 17:13:23 -07002550 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002551 }
Joe Perches7e51f192013-09-11 14:23:57 -07002552
2553# Check for duplicate signatures
2554 my $sig_nospace = $line;
2555 $sig_nospace =~ s/\s//g;
2556 $sig_nospace = lc($sig_nospace);
2557 if (defined $signatures{$sig_nospace}) {
2558 WARN("BAD_SIGN_OFF",
2559 "Duplicate signature\n" . $herecurr);
2560 } else {
2561 $signatures{$sig_nospace} = 1;
2562 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002563 }
2564
Joe Perchesa2fe16b2015-02-13 14:39:02 -08002565# Check email subject for common tools that don't need to be mentioned
2566 if ($in_header_lines &&
2567 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2568 WARN("EMAIL_SUBJECT",
2569 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2570 }
2571
Joe Perches9b3189e2014-06-04 16:12:10 -07002572# Check for old stable address
2573 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2574 ERROR("STABLE_ADDRESS",
2575 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2576 }
2577
Christopher Covington7ebd05e2014-04-03 14:49:31 -07002578# Check for unwanted Gerrit info
2579 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2580 ERROR("GERRIT_CHANGE_ID",
2581 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2582 }
2583
Joe Perches369c8dd2015-11-06 16:31:34 -08002584# Check if the commit log is in a possible stack dump
2585 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2586 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2587 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2588 # timestamp
2589 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2590 # stack dump address
2591 $commit_log_possible_stack_dump = 1;
2592 }
2593
Joe Perches2a076f42015-04-16 12:44:28 -07002594# Check for line lengths > 75 in commit log, warn once
2595 if ($in_commit_log && !$commit_log_long_line &&
Joe Perches369c8dd2015-11-06 16:31:34 -08002596 length($line) > 75 &&
2597 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2598 # file delta changes
2599 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2600 # filename then :
2601 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2602 # A Fixes: or Link: line
2603 $commit_log_possible_stack_dump)) {
Joe Perches2a076f42015-04-16 12:44:28 -07002604 WARN("COMMIT_LOG_LONG_LINE",
2605 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2606 $commit_log_long_line = 1;
2607 }
2608
Joe Perchesbf4daf12015-09-09 15:37:50 -07002609# Reset possible stack dump if a blank line is found
Joe Perches369c8dd2015-11-06 16:31:34 -08002610 if ($in_commit_log && $commit_log_possible_stack_dump &&
2611 $line =~ /^\s*$/) {
2612 $commit_log_possible_stack_dump = 0;
2613 }
Joe Perchesbf4daf12015-09-09 15:37:50 -07002614
Joe Perches0d7835f2015-02-13 14:38:35 -08002615# Check for git id commit length and improperly formed commit descriptions
Joe Perches369c8dd2015-11-06 16:31:34 -08002616 if ($in_commit_log && !$commit_log_possible_stack_dump &&
Joe Perchesaab38f52016-08-02 14:04:36 -07002617 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
Wei Wange882dbf2017-05-08 15:55:54 -07002618 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
Joe Perchesfe043ea2015-09-09 15:37:25 -07002619 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
Joe Perchesaab38f52016-08-02 14:04:36 -07002620 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
Joe Perches369c8dd2015-11-06 16:31:34 -08002621 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2622 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
Joe Perchesfe043ea2015-09-09 15:37:25 -07002623 my $init_char = "c";
2624 my $orig_commit = "";
Joe Perches0d7835f2015-02-13 14:38:35 -08002625 my $short = 1;
2626 my $long = 0;
2627 my $case = 1;
2628 my $space = 1;
2629 my $hasdesc = 0;
Joe Perches19c146a2015-02-13 14:39:00 -08002630 my $hasparens = 0;
Joe Perches0d7835f2015-02-13 14:38:35 -08002631 my $id = '0123456789ab';
2632 my $orig_desc = "commit description";
2633 my $description = "";
2634
Joe Perchesfe043ea2015-09-09 15:37:25 -07002635 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2636 $init_char = $1;
2637 $orig_commit = lc($2);
2638 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2639 $orig_commit = lc($1);
2640 }
2641
Joe Perches0d7835f2015-02-13 14:38:35 -08002642 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2643 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2644 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2645 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2646 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2647 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002648 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002649 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2650 defined $rawlines[$linenr] &&
2651 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2652 $orig_desc = $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002653 $hasparens = 1;
Joe Perchesb671fde2015-02-13 14:38:41 -08002654 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2655 defined $rawlines[$linenr] &&
2656 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2657 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2658 $orig_desc = $1;
2659 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2660 $orig_desc .= " " . $1;
Joe Perches19c146a2015-02-13 14:39:00 -08002661 $hasparens = 1;
Joe Perches0d7835f2015-02-13 14:38:35 -08002662 }
2663
2664 ($id, $description) = git_commit_info($orig_commit,
2665 $id, $orig_desc);
2666
Heinrich Schuchardt948b1332017-07-10 15:52:16 -07002667 if (defined($id) &&
2668 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
Joe Perches0d7835f2015-02-13 14:38:35 -08002669 ERROR("GIT_COMMIT_ID",
2670 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2671 }
Joe Perchesd311cd42014-08-06 16:10:57 -07002672 }
2673
Joe Perches13f19372014-08-06 16:10:59 -07002674# Check for added, moved or deleted files
2675 if (!$reported_maintainer_file && !$in_commit_log &&
2676 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2677 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2678 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2679 (defined($1) || defined($2))))) {
Andrew Jefferya82603a2016-12-12 16:46:37 -08002680 $is_patch = 1;
Joe Perches13f19372014-08-06 16:10:59 -07002681 $reported_maintainer_file = 1;
2682 WARN("FILE_PATH_CHANGES",
2683 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2684 }
2685
Andy Whitcroft00df3442007-06-08 13:47:06 -07002686# Check for wrappage within a valid hunk of the file
Andy Whitcroft8905a672007-11-28 16:21:06 -08002687 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002688 ERROR("CORRUPTED_PATCH",
2689 "patch seems to be corrupt (line wrapped?)\n" .
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07002690 $herecurr) if (!$emitted_corrupt++);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07002691 }
2692
2693# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2694 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07002695 $rawline !~ m/^$UTF8*$/) {
2696 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2697
2698 my $blank = copy_spacing($rawline);
2699 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2700 my $hereptr = "$hereline$ptr\n";
2701
Joe Perches34d99212011-07-25 17:13:26 -07002702 CHK("INVALID_UTF8",
2703 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002704 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002705
Joe Perches15662b32011-10-31 17:13:12 -07002706# Check if it's the start of a commit log
2707# (not a header line and we haven't seen the patch filename)
2708 if ($in_header_lines && $realfile =~ /^$/ &&
Joe Percheseb3a58d2017-05-08 15:55:42 -07002709 !($rawline =~ /^\s+(?:\S|$)/ ||
2710 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
Joe Perches15662b32011-10-31 17:13:12 -07002711 $in_header_lines = 0;
2712 $in_commit_log = 1;
Allen Hubbeed43c4e2016-08-02 14:04:45 -07002713 $has_commit_log = 1;
Joe Perches15662b32011-10-31 17:13:12 -07002714 }
2715
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002716# Check if there is UTF-8 in a commit log when a mail header has explicitly
2717# declined it, i.e defined some charset where it is missing.
2718 if ($in_header_lines &&
2719 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2720 $1 !~ /utf-8/i) {
2721 $non_utf8_charset = 1;
2722 }
2723
2724 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
Joe Perches15662b32011-10-31 17:13:12 -07002725 $rawline =~ /$NON_ASCII_UTF8/) {
Pasi Savanainenfa64205d2012-10-04 17:13:29 -07002726 WARN("UTF8_BEFORE_PATCH",
Joe Perches15662b32011-10-31 17:13:12 -07002727 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2728 }
2729
Joe Perchesd6430f72016-12-12 16:46:28 -08002730# Check for absolute kernel paths in commit message
2731 if ($tree && $in_commit_log) {
2732 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2733 my $file = $1;
2734
2735 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2736 check_absolute_file($1, $herecurr)) {
2737 #
2738 } else {
2739 check_absolute_file($file, $herecurr);
2740 }
2741 }
2742 }
2743
Kees Cook66b47b42014-10-13 15:51:57 -07002744# Check for various typo / spelling mistakes
Joe Perches66d7a382015-04-16 12:44:08 -07002745 if (defined($misspellings) &&
2746 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
Joe Perchesebfd7d62015-04-16 12:44:14 -07002747 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
Kees Cook66b47b42014-10-13 15:51:57 -07002748 my $typo = $1;
2749 my $typo_fix = $spelling_fix{lc($typo)};
2750 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2751 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
Jean Delvare0675a8f2017-09-08 16:16:07 -07002752 my $msg_level = \&WARN;
2753 $msg_level = \&CHK if ($file);
2754 if (&{$msg_level}("TYPO_SPELLING",
2755 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
Kees Cook66b47b42014-10-13 15:51:57 -07002756 $fix) {
2757 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2758 }
2759 }
2760 }
2761
Andy Whitcroft306708542008-10-15 22:02:28 -07002762# ignore non-hunk lines and lines being removed
2763 next if (!$hunk_line || $line =~ /^-/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07002764
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002765#trailing whitespace
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07002766 if ($line =~ /^\+.*\015/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002767 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perchesd5e616f2013-09-11 14:23:54 -07002768 if (ERROR("DOS_LINE_ENDINGS",
2769 "DOS line endings\n" . $herevet) &&
2770 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002771 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07002772 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002773 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2774 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07002775 if (ERROR("TRAILING_WHITESPACE",
2776 "trailing whitespace\n" . $herevet) &&
2777 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002778 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perches3705ce52013-07-03 15:05:31 -07002779 }
2780
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002781 $rpt_cleaners = 1;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002782 }
Andy Whitcroft5368df202008-10-15 22:02:27 -07002783
Josh Triplett4783f892013-11-12 15:10:12 -08002784# Check for FSF mailing addresses.
Alexander Duyck109d8cb2014-01-23 15:54:50 -08002785 if ($rawline =~ /\bwrite to the Free/i ||
Matthew Wilcox1bde5612017-02-24 15:01:38 -08002786 $rawline =~ /\b675\s+Mass\s+Ave/i ||
Joe Perches3e2232f2014-01-23 15:54:48 -08002787 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2788 $rawline =~ /\b51\s+Franklin\s+St/i) {
Josh Triplett4783f892013-11-12 15:10:12 -08002789 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Jean Delvare0675a8f2017-09-08 16:16:07 -07002790 my $msg_level = \&ERROR;
2791 $msg_level = \&CHK if ($file);
2792 &{$msg_level}("FSF_MAILING_ADDRESS",
2793 "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)
Josh Triplett4783f892013-11-12 15:10:12 -08002794 }
2795
Andi Kleen33549572010-05-24 14:33:29 -07002796# check for Kconfig help text having a real description
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002797# Only applies when adding the entry originally, after that we do not have
2798# sufficient context to determine whether it is indeed long enough.
Andi Kleen33549572010-05-24 14:33:29 -07002799 if ($realfile =~ /Kconfig/ &&
Joe Perches8d73e0e2014-08-06 16:10:46 -07002800 $line =~ /^\+\s*config\s+/) {
Andi Kleen33549572010-05-24 14:33:29 -07002801 my $length = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002802 my $cnt = $realcnt;
2803 my $ln = $linenr + 1;
2804 my $f;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002805 my $is_start = 0;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002806 my $is_end = 0;
Andy Whitcrofta1385802012-01-10 15:10:03 -08002807 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002808 $f = $lines[$ln - 1];
2809 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2810 $is_end = $lines[$ln - 1] =~ /^\+/;
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002811
2812 next if ($f =~ /^-/);
Joe Perches8d73e0e2014-08-06 16:10:46 -07002813 last if (!$file && $f =~ /^\@\@/);
Andy Whitcrofta1385802012-01-10 15:10:03 -08002814
Joe Perches8d73e0e2014-08-06 16:10:46 -07002815 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002816 $is_start = 1;
Joe Perches8d73e0e2014-08-06 16:10:46 -07002817 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
Andy Whitcrofta1385802012-01-10 15:10:03 -08002818 $length = -1;
2819 }
2820
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002821 $f =~ s/^.//;
Andi Kleen33549572010-05-24 14:33:29 -07002822 $f =~ s/#.*//;
2823 $f =~ s/^\s+//;
2824 next if ($f =~ /^$/);
Andy Whitcroft9fe287d72010-10-26 14:23:15 -07002825 if ($f =~ /^\s*config\s/) {
2826 $is_end = 1;
2827 last;
2828 }
Andi Kleen33549572010-05-24 14:33:29 -07002829 $length++;
2830 }
Vadim Bendebury56193272014-10-13 15:51:48 -07002831 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2832 WARN("CONFIG_DESCRIPTION",
2833 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2834 }
Andy Whitcrofta1385802012-01-10 15:10:03 -08002835 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
Andi Kleen33549572010-05-24 14:33:29 -07002836 }
2837
Joe Perches628f91a2017-07-10 15:52:07 -07002838# check for MAINTAINERS entries that don't have the right form
2839 if ($realfile =~ /^MAINTAINERS$/ &&
2840 $rawline =~ /^\+[A-Z]:/ &&
2841 $rawline !~ /^\+[A-Z]:\t\S/) {
2842 if (WARN("MAINTAINERS_STYLE",
2843 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2844 $fix) {
2845 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2846 }
2847 }
2848
Christoph Jaeger327953e2015-02-13 14:38:29 -08002849# discourage the use of boolean for type definition attributes of Kconfig options
2850 if ($realfile =~ /Kconfig/ &&
2851 $line =~ /^\+\s*\bboolean\b/) {
2852 WARN("CONFIG_TYPE_BOOLEAN",
2853 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2854 }
2855
Arnaud Lacombec68e5872011-08-15 01:07:14 -04002856 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2857 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2858 my $flag = $1;
2859 my $replacement = {
2860 'EXTRA_AFLAGS' => 'asflags-y',
2861 'EXTRA_CFLAGS' => 'ccflags-y',
2862 'EXTRA_CPPFLAGS' => 'cppflags-y',
2863 'EXTRA_LDFLAGS' => 'ldflags-y',
2864 };
2865
2866 WARN("DEPRECATED_VARIABLE",
2867 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2868 }
2869
Rob Herringbff5da42014-01-23 15:54:51 -08002870# check for DT compatible documentation
Florian Vaussard7dd05b32014-04-03 14:49:26 -07002871 if (defined $root &&
2872 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2873 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2874
Rob Herringbff5da42014-01-23 15:54:51 -08002875 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2876
Florian Vaussardcc933192014-04-03 14:49:27 -07002877 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2878 my $vp_file = $dt_path . "vendor-prefixes.txt";
2879
Rob Herringbff5da42014-01-23 15:54:51 -08002880 foreach my $compat (@compats) {
2881 my $compat2 = $compat;
Rob Herring185d5662014-06-04 16:12:03 -07002882 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2883 my $compat3 = $compat;
2884 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2885 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
Rob Herringbff5da42014-01-23 15:54:51 -08002886 if ( $? >> 8 ) {
2887 WARN("UNDOCUMENTED_DT_STRING",
2888 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2889 }
2890
Florian Vaussard4fbf32a2014-04-03 14:49:25 -07002891 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2892 my $vendor = $1;
Florian Vaussardcc933192014-04-03 14:49:27 -07002893 `grep -Eq "^$vendor\\b" $vp_file`;
Rob Herringbff5da42014-01-23 15:54:51 -08002894 if ( $? >> 8 ) {
2895 WARN("UNDOCUMENTED_DT_STRING",
Florian Vaussardcc933192014-04-03 14:49:27 -07002896 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
Rob Herringbff5da42014-01-23 15:54:51 -08002897 }
2898 }
2899 }
2900
Andy Whitcroft5368df202008-10-15 22:02:27 -07002901# check we are in a valid source file if not then ignore this hunk
Joe Perchesd6430f72016-12-12 16:46:28 -08002902 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
Andy Whitcroft5368df202008-10-15 22:02:27 -07002903
Joe Perches47e0c882015-06-25 15:02:57 -07002904# line length limit (with some exclusions)
2905#
2906# There are a few types of lines that may extend beyond $max_line_length:
2907# logging functions like pr_info that end in a string
2908# lines with a single string
2909# #defines that are a single string
Andreas Brauchli2e4bbbc2018-02-06 15:38:45 -08002910# lines with an RFC3986 like URL
Joe Perches47e0c882015-06-25 15:02:57 -07002911#
2912# There are 3 different line length message types:
Jean Delvareab1ecab2017-09-08 16:16:04 -07002913# LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
Joe Perches47e0c882015-06-25 15:02:57 -07002914# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2915# LONG_LINE all other lines longer than $max_line_length
2916#
2917# if LONG_LINE is ignored, the other 2 types are also ignored
2918#
2919
Joe Perchesb4749e92015-07-17 16:24:01 -07002920 if ($line =~ /^\+/ && $length > $max_line_length) {
Joe Perches47e0c882015-06-25 15:02:57 -07002921 my $msg_type = "LONG_LINE";
2922
2923 # Check the allowed long line types first
2924
2925 # logging functions that end in a string that starts
2926 # before $max_line_length
2927 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2928 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2929 $msg_type = "";
2930
2931 # lines with only strings (w/ possible termination)
2932 # #defines with only strings
2933 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2934 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2935 $msg_type = "";
2936
Joe Perchescc147502017-11-17 15:28:44 -08002937 # More special cases
2938 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
2939 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
Joe Perchesd560a5f2016-08-02 14:04:31 -07002940 $msg_type = "";
2941
Andreas Brauchli2e4bbbc2018-02-06 15:38:45 -08002942 # URL ($rawline is used in case the URL is in a comment)
2943 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
2944 $msg_type = "";
2945
Joe Perches47e0c882015-06-25 15:02:57 -07002946 # Otherwise set the alternate message types
2947
2948 # a comment starts before $max_line_length
2949 } elsif ($line =~ /($;[\s$;]*)$/ &&
2950 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2951 $msg_type = "LONG_LINE_COMMENT"
2952
2953 # a quoted string starts before $max_line_length
2954 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2955 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2956 $msg_type = "LONG_LINE_STRING"
2957 }
2958
2959 if ($msg_type ne "" &&
2960 (show_type("LONG_LINE") || show_type($msg_type))) {
2961 WARN($msg_type,
2962 "line over $max_line_length characters\n" . $herecurr);
2963 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002964 }
2965
Andy Whitcroft8905a672007-11-28 16:21:06 -08002966# check for adding lines without a newline.
2967 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07002968 WARN("MISSING_EOF_NEWLINE",
2969 "adding a line without newline at end of file\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08002970 }
2971
Mike Frysinger42e41c52009-09-21 17:04:40 -07002972# Blackfin: use hi/lo macros
2973 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2974 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2975 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002976 ERROR("LO_MACRO",
2977 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002978 }
2979 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2980 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07002981 ERROR("HI_MACRO",
2982 "use the HI() macro, not (... >> 16)\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07002983 }
2984 }
2985
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07002986# check we are in a valid source file C or perl if not then ignore this hunk
Geert Uytterhoevende4c9242014-10-13 15:51:46 -07002987 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07002988
2989# at the beginning of a line any tabs must come first and anything
2990# more than 8 must use tabs.
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08002991 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2992 $rawline =~ /^\+\s* \s*/) {
2993 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07002994 $rpt_cleaners = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07002995 if (ERROR("CODE_INDENT",
2996 "code indent should use tabs where possible\n" . $herevet) &&
2997 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07002998 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07002999 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003000 }
3001
Alberto Panizzo08e44362010-03-05 13:43:54 -08003002# check for space before tabs.
3003 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3004 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003005 if (WARN("SPACE_BEFORE_TAB",
3006 "please, no space before tabs\n" . $herevet) &&
3007 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003008 while ($fixed[$fixlinenr] =~
Joe Perchesd2207cc2014-10-13 15:51:53 -07003009 s/(^\+.*) {8,8}\t/$1\t\t/) {}
Joe Perches194f66f2014-08-06 16:11:03 -07003010 while ($fixed[$fixlinenr] =~
Joe Perchesc76f4cb2014-01-23 15:54:46 -08003011 s/(^\+.*) +\t/$1\t/) {}
Joe Perches3705ce52013-07-03 15:05:31 -07003012 }
Alberto Panizzo08e44362010-03-05 13:43:54 -08003013 }
3014
Joe Perchesd1fe9c02012-03-23 15:02:16 -07003015# check for && or || at the start of a line
3016 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3017 CHK("LOGICAL_CONTINUATIONS",
3018 "Logical continuations should be on the previous line\n" . $hereprev);
3019 }
3020
Joe Perchesa91e8992016-05-20 17:04:05 -07003021# check indentation starts on a tab stop
3022 if ($^V && $^V ge 5.10.0 &&
3023 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
3024 my $indent = length($1);
3025 if ($indent % 8) {
3026 if (WARN("TABSTOP",
3027 "Statements should start on a tabstop\n" . $herecurr) &&
3028 $fix) {
3029 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
3030 }
3031 }
3032 }
3033
Joe Perchesd1fe9c02012-03-23 15:02:16 -07003034# check multi-line statement indentation matches previous line
3035 if ($^V && $^V ge 5.10.0 &&
Joe Perchesfd71f632017-07-10 15:52:30 -07003036 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07003037 $prevline =~ /^\+(\t*)(.*)$/;
3038 my $oldindent = $1;
3039 my $rest = $2;
3040
3041 my $pos = pos_last_openparen($rest);
3042 if ($pos >= 0) {
Joe Perchesb34a26f2012-07-30 14:41:16 -07003043 $line =~ /^(\+| )([ \t]*)/;
3044 my $newindent = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07003045
3046 my $goodtabindent = $oldindent .
3047 "\t" x ($pos / 8) .
3048 " " x ($pos % 8);
3049 my $goodspaceindent = $oldindent . " " x $pos;
3050
3051 if ($newindent ne $goodtabindent &&
3052 $newindent ne $goodspaceindent) {
Joe Perches3705ce52013-07-03 15:05:31 -07003053
3054 if (CHK("PARENTHESIS_ALIGNMENT",
3055 "Alignment should match open parenthesis\n" . $hereprev) &&
3056 $fix && $line =~ /^\+/) {
Joe Perches194f66f2014-08-06 16:11:03 -07003057 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003058 s/^\+[ \t]*/\+$goodtabindent/;
3059 }
Joe Perchesd1fe9c02012-03-23 15:02:16 -07003060 }
3061 }
3062 }
3063
Joe Perches6ab3a972015-04-16 12:44:05 -07003064# check for space after cast like "(int) foo" or "(struct foo) bar"
3065# avoid checking a few false positives:
3066# "sizeof(<type>)" or "__alignof__(<type>)"
3067# function pointer declarations like "(*foo)(int) = bar;"
3068# structure definitions like "(struct foo) { 0 };"
3069# multiline macros that define functions
3070# known attributes or the __attribute__ keyword
3071 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3072 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07003073 if (CHK("SPACING",
Joe Perchesf27c95d2014-08-06 16:10:52 -07003074 "No space is necessary after a cast\n" . $herecurr) &&
Joe Perches3705ce52013-07-03 15:05:31 -07003075 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003076 $fixed[$fixlinenr] =~
Joe Perchesf27c95d2014-08-06 16:10:52 -07003077 s/(\(\s*$Type\s*\))[ \t]+/$1/;
Joe Perches3705ce52013-07-03 15:05:31 -07003078 }
Joe Perchesaad4f612012-03-23 15:02:19 -07003079 }
3080
Joe Perches86406b12015-09-09 15:37:41 -07003081# Block comment styles
3082# Networking with an initial /*
Joe Perches05880602012-10-04 17:13:35 -07003083 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Joe Perchesfdb4bcd2013-07-03 15:05:23 -07003084 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
Joe Perches85ad9782014-04-03 14:49:20 -07003085 $rawline =~ /^\+[ \t]*\*/ &&
3086 $realline > 2) {
Joe Perches05880602012-10-04 17:13:35 -07003087 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3088 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3089 }
3090
Joe Perches86406b12015-09-09 15:37:41 -07003091# Block comments use * on subsequent lines
3092 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3093 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
Joe Perchesa605e322013-07-03 15:05:24 -07003094 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
Joe Perches61135e92013-09-11 14:23:59 -07003095 $rawline =~ /^\+/ && #line is new
Joe Perchesa605e322013-07-03 15:05:24 -07003096 $rawline !~ /^\+[ \t]*\*/) { #no leading *
Joe Perches86406b12015-09-09 15:37:41 -07003097 WARN("BLOCK_COMMENT_STYLE",
3098 "Block comments use * on subsequent lines\n" . $hereprev);
Joe Perchesa605e322013-07-03 15:05:24 -07003099 }
3100
Joe Perches86406b12015-09-09 15:37:41 -07003101# Block comments use */ on trailing lines
3102 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
Joe Perchesc24f9f12012-11-08 15:53:29 -08003103 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3104 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3105 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
Joe Perches86406b12015-09-09 15:37:41 -07003106 WARN("BLOCK_COMMENT_STYLE",
3107 "Block comments use a trailing */ on a separate line\n" . $herecurr);
Joe Perches05880602012-10-04 17:13:35 -07003108 }
3109
Joe Perches08eb9b82016-10-11 13:51:50 -07003110# Block comment * alignment
3111 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
Joe Perchesaf207522016-10-11 13:52:05 -07003112 $line =~ /^\+[ \t]*$;/ && #leading comment
3113 $rawline =~ /^\+[ \t]*\*/ && #leading *
3114 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
Joe Perches08eb9b82016-10-11 13:51:50 -07003115 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
Joe Perchesaf207522016-10-11 13:52:05 -07003116 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3117 my $oldindent;
Joe Perches08eb9b82016-10-11 13:51:50 -07003118 $prevrawline =~ m@^\+([ \t]*/?)\*@;
Joe Perchesaf207522016-10-11 13:52:05 -07003119 if (defined($1)) {
3120 $oldindent = expand_tabs($1);
3121 } else {
3122 $prevrawline =~ m@^\+(.*/?)\*@;
3123 $oldindent = expand_tabs($1);
3124 }
Joe Perches08eb9b82016-10-11 13:51:50 -07003125 $rawline =~ m@^\+([ \t]*)\*@;
3126 my $newindent = $1;
Joe Perches08eb9b82016-10-11 13:51:50 -07003127 $newindent = expand_tabs($newindent);
Joe Perchesaf207522016-10-11 13:52:05 -07003128 if (length($oldindent) ne length($newindent)) {
Joe Perches08eb9b82016-10-11 13:51:50 -07003129 WARN("BLOCK_COMMENT_STYLE",
3130 "Block comments should align the * on each line\n" . $hereprev);
3131 }
3132 }
3133
Joe Perches7f619192014-08-06 16:10:39 -07003134# check for missing blank lines after struct/union declarations
3135# with exceptions for various attributes and macros
3136 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3137 $line =~ /^\+/ &&
3138 !($line =~ /^\+\s*$/ ||
3139 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3140 $line =~ /^\+\s*MODULE_/i ||
3141 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3142 $line =~ /^\+[a-z_]*init/ ||
3143 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3144 $line =~ /^\+\s*DECLARE/ ||
Masahiro Yamada0bc989f2017-11-17 15:28:55 -08003145 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
Joe Perches7f619192014-08-06 16:10:39 -07003146 $line =~ /^\+\s*__setup/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003147 if (CHK("LINE_SPACING",
3148 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3149 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003150 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07003151 }
Joe Perches7f619192014-08-06 16:10:39 -07003152 }
3153
Joe Perches365dd4e2014-08-06 16:10:42 -07003154# check for multiple consecutive blank lines
3155 if ($prevline =~ /^[\+ ]\s*$/ &&
3156 $line =~ /^\+\s*$/ &&
3157 $last_blank_line != ($linenr - 1)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003158 if (CHK("LINE_SPACING",
3159 "Please don't use multiple blank lines\n" . $hereprev) &&
3160 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003161 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003162 }
3163
Joe Perches365dd4e2014-08-06 16:10:42 -07003164 $last_blank_line = $linenr;
3165 }
3166
Joe Perches3b617e32014-04-03 14:49:28 -07003167# check for missing blank lines after declarations
Joe Perches3f7bac02014-06-04 16:12:04 -07003168 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3169 # actual declarations
3170 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07003171 # function pointer declarations
3172 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07003173 # foo bar; where foo is some local typedef or #define
3174 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3175 # known declaration macros
3176 $prevline =~ /^\+\s+$declaration_macros/) &&
3177 # for "else if" which can look like "$Ident $Ident"
3178 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3179 # other possible extensions of declaration lines
3180 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3181 # not starting a section or a macro "\" extended line
3182 $prevline =~ /(?:\{\s*|\\)$/) &&
3183 # looks like a declaration
3184 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
Joe Perches5a4e1fd2014-08-06 16:10:33 -07003185 # function pointer declarations
3186 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07003187 # foo bar; where foo is some local typedef or #define
3188 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3189 # known declaration macros
3190 $sline =~ /^\+\s+$declaration_macros/ ||
3191 # start of struct or union or enum
Joe Perches3b617e32014-04-03 14:49:28 -07003192 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
Joe Perches3f7bac02014-06-04 16:12:04 -07003193 # start or end of block or continuation of declaration
3194 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3195 # bitfield continuation
3196 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3197 # other possible extensions of declaration lines
3198 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3199 # indentation of previous and current line are the same
3200 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003201 if (WARN("LINE_SPACING",
3202 "Missing a blank line after declarations\n" . $hereprev) &&
3203 $fix) {
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003204 fix_insert_line($fixlinenr, "\+");
Joe Perchesd752fcc2014-08-06 16:11:05 -07003205 }
Joe Perches3b617e32014-04-03 14:49:28 -07003206 }
3207
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07003208# check for spaces at the beginning of a line.
Andy Whitcroft6b4c5be2010-10-26 14:23:11 -07003209# Exceptions:
3210# 1) within comments
3211# 2) indented preprocessor commands
3212# 3) hanging labels
Joe Perches3705ce52013-07-03 15:05:31 -07003213 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07003214 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003215 if (WARN("LEADING_SPACE",
3216 "please, no spaces at the start of a line\n" . $herevet) &&
3217 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003218 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
Joe Perches3705ce52013-07-03 15:05:31 -07003219 }
Raffaele Recalcati5f7ddae2010-08-09 17:20:59 -07003220 }
3221
Andy Whitcroftb9ea10d2008-10-15 22:02:24 -07003222# check we are in a valid C source file if not then ignore this hunk
3223 next if ($realfile !~ /\.(h|c)$/);
3224
Joe Perches5751a242017-11-17 15:28:52 -08003225# check for unusual line ending [ or (
3226 if ($line =~ /^\+.*([\[\(])\s*$/) {
3227 CHK("OPEN_ENDED_LINE",
3228 "Lines should not end with a '$1'\n" . $herecurr);
3229 }
3230
Joe Perches4dbed762017-05-08 15:55:39 -07003231# check if this appears to be the start function declaration, save the name
3232 if ($sline =~ /^\+\{\s*$/ &&
3233 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3234 $context_function = $1;
3235 }
3236
3237# check if this appears to be the end of function declaration
3238 if ($sline =~ /^\+\}\s*$/) {
3239 undef $context_function;
3240 }
3241
Joe Perches032a4c02014-08-06 16:10:29 -07003242# check indentation of any line with a bare else
Joe Perches840080a2014-10-13 15:51:59 -07003243# (but not if it is a multiple line "if (foo) return bar; else return baz;")
Joe Perches032a4c02014-08-06 16:10:29 -07003244# if the previous line is a break or return and is indented 1 tab more...
3245 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3246 my $tabs = length($1) + 1;
Joe Perches840080a2014-10-13 15:51:59 -07003247 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3248 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3249 defined $lines[$linenr] &&
3250 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
Joe Perches032a4c02014-08-06 16:10:29 -07003251 WARN("UNNECESSARY_ELSE",
3252 "else is not generally useful after a break or return\n" . $hereprev);
3253 }
3254 }
3255
Joe Perchesc00df192014-08-06 16:11:01 -07003256# check indentation of a line with a break;
3257# if the previous line is a goto or return and is indented the same # of tabs
3258 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3259 my $tabs = $1;
3260 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3261 WARN("UNNECESSARY_BREAK",
3262 "break is not useful after a goto or return\n" . $hereprev);
3263 }
3264 }
3265
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003266# check for RCS/CVS revision markers
Andy Whitcroftcf655042008-03-04 14:28:20 -08003267 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003268 WARN("CVS_KEYWORD",
3269 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003270 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07003271
Mike Frysinger42e41c52009-09-21 17:04:40 -07003272# Blackfin: don't use __builtin_bfin_[cs]sync
3273 if ($line =~ /__builtin_bfin_csync/) {
3274 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07003275 ERROR("CSYNC",
3276 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07003277 }
3278 if ($line =~ /__builtin_bfin_ssync/) {
3279 my $herevet = "$here\n" . cat_vet($line) . "\n";
Joe Perches000d1cc12011-07-25 17:13:25 -07003280 ERROR("SSYNC",
3281 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
Mike Frysinger42e41c52009-09-21 17:04:40 -07003282 }
3283
Joe Perches56e77d72013-02-21 16:44:14 -08003284# check for old HOTPLUG __dev<foo> section markings
3285 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3286 WARN("HOTPLUG_SECTION",
3287 "Using $1 is unnecessary\n" . $herecurr);
3288 }
3289
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003290# Check for potential 'bare' types
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003291 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3292 $realline_next);
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003293#print "LINE<$line>\n";
Joe Perchesca819862017-07-10 15:52:13 -07003294 if ($linenr > $suppress_statement &&
Joe Perches1b5539b2013-09-11 14:24:03 -07003295 $realcnt && $sline =~ /.\s*\S/) {
Andy Whitcroft170d3a22008-10-15 22:02:30 -07003296 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07003297 ctx_statement_block($linenr, $realcnt, 0);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003298 $stat =~ s/\n./\n /g;
3299 $cond =~ s/\n./\n /g;
3300
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003301#print "linenr<$linenr> <$stat>\n";
3302 # If this statement has no statement boundaries within
3303 # it there is no point in retrying a statement scan
3304 # until we hit end of it.
3305 my $frag = $stat; $frag =~ s/;+\s*$//;
3306 if ($frag !~ /(?:{|;)/) {
3307#print "skip<$line_nr_next>\n";
3308 $suppress_statement = $line_nr_next;
3309 }
Andy Whitcroftf74bd192012-01-10 15:09:54 -08003310
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003311 # Find the real next line.
3312 $realline_next = $line_nr_next;
3313 if (defined $realline_next &&
3314 (!defined $lines[$realline_next - 1] ||
3315 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3316 $realline_next++;
3317 }
3318
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003319 my $s = $stat;
3320 $s =~ s/{.*$//s;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003321
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003322 # Ignore goto labels.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003323 if ($s =~ /$Ident:\*$/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003324
3325 # Ignore functions being called
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003326 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003327
Andy Whitcroft463f2862009-09-21 17:04:34 -07003328 } elsif ($s =~ /^.\s*else\b/s) {
3329
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003330 # declarations always start with types
Andy Whitcroftd2506582008-07-23 21:29:09 -07003331 } 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) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003332 my $type = $1;
3333 $type =~ s/\s+/ /g;
3334 possible($type, "A:" . $s);
3335
Andy Whitcroft8905a672007-11-28 16:21:06 -08003336 # definitions in global scope can only start with types
Andy Whitcrofta6a840622008-10-15 22:02:30 -07003337 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003338 possible($1, "B:" . $s);
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003339 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003340
3341 # any (foo ... *) is a pointer cast, and foo is a type
Andy Whitcroft65863862009-01-06 14:41:21 -08003342 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003343 possible($1, "C:" . $s);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003344 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003345
3346 # Check for any sort of function declaration.
3347 # int foo(something bar, other baz);
3348 # void (*store_gdt)(x86_descr_ptr *);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07003349 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08003350 my ($name_len) = length($1);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003351
Andy Whitcroftcf655042008-03-04 14:28:20 -08003352 my $ctx = $s;
Andy Whitcroft773647a2008-03-28 14:15:58 -07003353 substr($ctx, 0, $name_len + 1, '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08003354 $ctx =~ s/\)[^\)]*$//;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003355
Andy Whitcroft8905a672007-11-28 16:21:06 -08003356 for my $arg (split(/\s*,\s*/, $ctx)) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003357 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
Andy Whitcroft8905a672007-11-28 16:21:06 -08003358
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003359 possible($1, "D:" . $s);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003360 }
3361 }
3362 }
3363
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003364 }
3365
Andy Whitcroft653d4872007-06-23 17:16:34 -07003366#
3367# Checks which may be anchored in the context.
3368#
3369
3370# Check for switch () and associated case and default
3371# statements should be at the same indent.
Andy Whitcroft00df3442007-06-08 13:47:06 -07003372 if ($line=~/\bswitch\s*\(.*\)/) {
3373 my $err = '';
3374 my $sep = '';
3375 my @ctx = ctx_block_outer($linenr, $realcnt);
3376 shift(@ctx);
3377 for my $ctx (@ctx) {
3378 my ($clen, $cindent) = line_stats($ctx);
3379 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3380 $indent != $cindent) {
3381 $err .= "$sep$ctx\n";
3382 $sep = '';
3383 } else {
3384 $sep = "[...]\n";
3385 }
3386 }
3387 if ($err ne '') {
Joe Perches000d1cc12011-07-25 17:13:25 -07003388 ERROR("SWITCH_CASE_INDENT_LEVEL",
3389 "switch and case should be at the same indent\n$hereline$err");
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003390 }
3391 }
3392
3393# if/while/etc brace do not go on next line, unless defining a do while loop,
3394# or if that brace on the next line is for something else
Joe Perches0fe3dc22014-08-06 16:11:16 -07003395 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07003396 my $pre_ctx = "$1$2";
3397
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003398 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Joe Perches8eef05d2012-02-03 15:20:39 -08003399
3400 if ($line =~ /^\+\t{6,}/) {
3401 WARN("DEEP_INDENTATION",
3402 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3403 }
3404
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003405 my $ctx_cnt = $realcnt - $#ctx - 1;
3406 my $ctx = join("\n", @ctx);
3407
Andy Whitcroft548596d2008-07-23 21:29:01 -07003408 my $ctx_ln = $linenr;
3409 my $ctx_skip = $realcnt;
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07003410
Andy Whitcroft548596d2008-07-23 21:29:01 -07003411 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3412 defined $lines[$ctx_ln - 1] &&
3413 $lines[$ctx_ln - 1] =~ /^-/)) {
3414 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3415 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
Andy Whitcroft773647a2008-03-28 14:15:58 -07003416 $ctx_ln++;
3417 }
Andy Whitcroft548596d2008-07-23 21:29:01 -07003418
Andy Whitcroft53210162008-07-23 21:29:03 -07003419 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3420 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
Andy Whitcroft773647a2008-03-28 14:15:58 -07003421
Joe Perchesd752fcc2014-08-06 16:11:05 -07003422 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003423 ERROR("OPEN_BRACE",
3424 "that open brace { should be on the previous line\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003425 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft00df3442007-06-08 13:47:06 -07003426 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07003427 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3428 $ctx =~ /\)\s*\;\s*$/ &&
3429 defined $lines[$ctx_ln - 1])
3430 {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003431 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3432 if ($nindent > $indent) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003433 WARN("TRAILING_SEMICOLON",
3434 "trailing semicolon indicates no statements, indent implies otherwise\n" .
Andy Whitcroft01464f32010-10-26 14:23:19 -07003435 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07003436 }
3437 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003438 }
3439
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003440# Check relative indent for conditionals and blocks.
Joe Perchesf6950a72017-05-08 15:56:05 -07003441 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08003442 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3443 ctx_statement_block($linenr, $realcnt, 0)
3444 if (!defined $stat);
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003445 my ($s, $c) = ($stat, $cond);
3446
3447 substr($s, 0, length($c), '');
3448
Joe Perches9f5af482015-09-09 15:37:30 -07003449 # remove inline comments
3450 $s =~ s/$;/ /g;
3451 $c =~ s/$;/ /g;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003452
3453 # Find out how long the conditional actually is.
Andy Whitcroft6f779c12008-10-15 22:02:27 -07003454 my @newlines = ($c =~ /\n/gs);
3455 my $cond_lines = 1 + $#newlines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003456
Joe Perches9f5af482015-09-09 15:37:30 -07003457 # Make sure we remove the line prefixes as we have
3458 # none on the first line, and are going to readd them
3459 # where necessary.
3460 $s =~ s/\n./\n/gs;
3461 while ($s =~ /\n\s+\\\n/) {
3462 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3463 }
3464
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003465 # We want to check the first line inside the block
3466 # starting at the end of the conditional, so remove:
3467 # 1) any blank line termination
3468 # 2) any opening brace { on end of the line
3469 # 3) any do (...) {
3470 my $continuation = 0;
3471 my $check = 0;
3472 $s =~ s/^.*\bdo\b//;
3473 $s =~ s/^\s*{//;
3474 if ($s =~ s/^\s*\\//) {
3475 $continuation = 1;
3476 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003477 if ($s =~ s/^\s*?\n//) {
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003478 $check = 1;
3479 $cond_lines++;
3480 }
3481
3482 # Also ignore a loop construct at the end of a
3483 # preprocessor statement.
3484 if (($prevline =~ /^.\s*#\s*define\s/ ||
3485 $prevline =~ /\\\s*$/) && $continuation == 0) {
3486 $check = 0;
3487 }
3488
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003489 my $cond_ptr = -1;
Andy Whitcroft740504c2008-10-15 22:02:35 -07003490 $continuation = 0;
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003491 while ($cond_ptr != $cond_lines) {
3492 $cond_ptr = $cond_lines;
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003493
Andy Whitcroftf16fa282008-10-15 22:02:32 -07003494 # If we see an #else/#elif then the code
3495 # is not linear.
3496 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3497 $check = 0;
3498 }
3499
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003500 # Ignore:
3501 # 1) blank lines, they should be at 0,
3502 # 2) preprocessor lines, and
3503 # 3) labels.
Andy Whitcroft740504c2008-10-15 22:02:35 -07003504 if ($continuation ||
3505 $s =~ /^\s*?\n/ ||
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003506 $s =~ /^\s*#\s*?/ ||
3507 $s =~ /^\s*$Ident\s*:/) {
Andy Whitcroft740504c2008-10-15 22:02:35 -07003508 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
Andy Whitcroft30dad6e2009-09-21 17:04:36 -07003509 if ($s =~ s/^.*?\n//) {
3510 $cond_lines++;
3511 }
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003512 }
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003513 }
3514
3515 my (undef, $sindent) = line_stats("+" . $s);
3516 my $stat_real = raw_line($linenr, $cond_lines);
3517
3518 # Check if either of these lines are modified, else
3519 # this is not this patch's fault.
3520 if (!defined($stat_real) ||
3521 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3522 $check = 0;
3523 }
3524 if (defined($stat_real) && $cond_lines > 1) {
3525 $stat_real = "[...]\n$stat_real";
3526 }
3527
Andy Whitcroft9bd49ef2008-10-15 22:02:22 -07003528 #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";
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003529
Joe Perches9f5af482015-09-09 15:37:30 -07003530 if ($check && $s ne '' &&
3531 (($sindent % 8) != 0 ||
3532 ($sindent < $indent) ||
Joe Perchesf6950a72017-05-08 15:56:05 -07003533 ($sindent == $indent &&
3534 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
Joe Perches9f5af482015-09-09 15:37:30 -07003535 ($sindent > $indent + 8))) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003536 WARN("SUSPECT_CODE_INDENT",
3537 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
Andy Whitcroft4d001e42008-10-15 22:02:21 -07003538 }
3539 }
3540
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003541 # Track the 'values' across context and added lines.
3542 my $opline = $line; $opline =~ s/^./ /;
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003543 my ($curr_values, $curr_vars) =
3544 annotate_values($opline . "\n", $prev_values);
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003545 $curr_values = $prev_values . $curr_values;
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003546 if ($dbg_values) {
3547 my $outline = $opline; $outline =~ s/\t/ /g;
Andy Whitcroftcf655042008-03-04 14:28:20 -08003548 print "$linenr > .$outline\n";
3549 print "$linenr > $curr_values\n";
Andy Whitcroft1f65f942008-07-23 21:29:10 -07003550 print "$linenr > $curr_vars\n";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08003551 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003552 $prev_values = substr($curr_values, -1);
3553
Andy Whitcroft00df3442007-06-08 13:47:06 -07003554#ignore lines not being added
Joe Perches3705ce52013-07-03 15:05:31 -07003555 next if ($line =~ /^[^\+]/);
Andy Whitcroft00df3442007-06-08 13:47:06 -07003556
Joe Perches11ca40a2016-12-12 16:46:31 -08003557# check for dereferences that span multiple lines
3558 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3559 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3560 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3561 my $ref = $1;
3562 $line =~ /^.\s*($Lval)/;
3563 $ref .= $1;
3564 $ref =~ s/\s//g;
3565 WARN("MULTILINE_DEREFERENCE",
3566 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3567 }
3568
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003569# check for declarations of signed or unsigned without int
Joe Perchesc8447112016-08-02 14:04:42 -07003570 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003571 my $type = $1;
3572 my $var = $2;
Joe Perches207a8e82016-03-15 14:58:06 -07003573 $var = "" if (!defined $var);
3574 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003575 my $sign = $1;
3576 my $pointer = $2;
3577
3578 $pointer = "" if (!defined $pointer);
3579
3580 if (WARN("UNSPECIFIED_INT",
3581 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3582 $fix) {
3583 my $decl = trim($sign) . " int ";
Joe Perches207a8e82016-03-15 14:58:06 -07003584 my $comp_pointer = $pointer;
3585 $comp_pointer =~ s/\s//g;
3586 $decl .= $comp_pointer;
3587 $decl = rtrim($decl) if ($var eq "");
3588 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
Joe Perchesa1ce18e2016-03-15 14:58:03 -07003589 }
3590 }
3591 }
3592
Andy Whitcroft653d4872007-06-23 17:16:34 -07003593# TEST: allow direct testing of the type matcher.
Andy Whitcroft7429c692008-07-23 21:29:06 -07003594 if ($dbg_type) {
3595 if ($line =~ /^.\s*$Declare\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003596 ERROR("TEST_TYPE",
3597 "TEST: is type\n" . $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003598 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003599 ERROR("TEST_NOT_TYPE",
3600 "TEST: is not type ($1 is)\n". $herecurr);
Andy Whitcroft7429c692008-07-23 21:29:06 -07003601 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003602 next;
3603 }
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003604# TEST: allow direct testing of the attribute matcher.
3605 if ($dbg_attr) {
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003606 if ($line =~ /^.\s*$Modifier\s*$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003607 ERROR("TEST_ATTR",
3608 "TEST: is attr\n" . $herecurr);
Andy Whitcroft9360b0e2009-02-27 14:03:08 -08003609 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003610 ERROR("TEST_NOT_ATTR",
3611 "TEST: is not attr ($1 is)\n". $herecurr);
Andy Whitcrofta1ef2772008-10-15 22:02:17 -07003612 }
3613 next;
3614 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003615
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003616# check for initialisation to aggregates open brace on the next line
Andy Whitcroft99423c22009-10-26 16:50:15 -07003617 if ($line =~ /^.\s*{/ &&
3618 $prevline =~ /(?:^|[^=])=\s*$/) {
Joe Perchesd752fcc2014-08-06 16:11:05 -07003619 if (ERROR("OPEN_BRACE",
3620 "that open brace { should be on the previous line\n" . $hereprev) &&
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003621 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3622 fix_delete_line($fixlinenr - 1, $prevrawline);
3623 fix_delete_line($fixlinenr, $rawline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003624 my $fixedline = $prevrawline;
3625 $fixedline =~ s/\s*=\s*$/ = {/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003626 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003627 $fixedline = $line;
Cyril Bur8d81ae02017-07-10 15:52:21 -07003628 $fixedline =~ s/^(.\s*)\{\s*/$1/;
Joe Perchesf2d7e4d2014-08-06 16:11:07 -07003629 fix_insert_line($fixlinenr, $fixedline);
Joe Perchesd752fcc2014-08-06 16:11:05 -07003630 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003631 }
3632
Andy Whitcroft653d4872007-06-23 17:16:34 -07003633#
3634# Checks which are anchored on the added line.
3635#
3636
3637# check for malformed paths in #include statements (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003638 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
Andy Whitcroft653d4872007-06-23 17:16:34 -07003639 my $path = $1;
3640 if ($path =~ m{//}) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003641 ERROR("MALFORMED_INCLUDE",
Joe Perches495e9d82012-12-20 15:05:37 -08003642 "malformed #include filename\n" . $herecurr);
3643 }
3644 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3645 ERROR("UAPI_INCLUDE",
3646 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003647 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003648 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003649
3650# no C99 // comments
3651 if ($line =~ m{//}) {
Joe Perches3705ce52013-07-03 15:05:31 -07003652 if (ERROR("C99_COMMENTS",
3653 "do not use C99 // comments\n" . $herecurr) &&
3654 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003655 my $line = $fixed[$fixlinenr];
Joe Perches3705ce52013-07-03 15:05:31 -07003656 if ($line =~ /\/\/(.*)$/) {
3657 my $comment = trim($1);
Joe Perches194f66f2014-08-06 16:11:03 -07003658 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
Joe Perches3705ce52013-07-03 15:05:31 -07003659 }
3660 }
Andy Whitcroft00df3442007-06-08 13:47:06 -07003661 }
3662 # Remove C99 comments.
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003663 $line =~ s@//.*@@;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07003664 $opline =~ s@//.*@@;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003665
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003666# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3667# the whole statement.
3668#print "APW <$lines[$realline_next - 1]>\n";
3669 if (defined $realline_next &&
3670 exists $lines[$realline_next - 1] &&
3671 !defined $suppress_export{$realline_next} &&
3672 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3673 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003674 # Handle definitions which produce identifiers with
3675 # a prefix:
3676 # XXX(foo);
3677 # EXPORT_SYMBOL(something_foo);
Andy Whitcroft653d4872007-06-23 17:16:34 -07003678 my $name = $1;
Andy Whitcroft87a53872012-01-10 15:10:04 -08003679 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Andy Whitcroft3cbf62d2010-10-26 14:23:18 -07003680 $name =~ /^${Ident}_$2/) {
3681#print "FOO C name<$name>\n";
3682 $suppress_export{$realline_next} = 1;
3683
3684 } elsif ($stat !~ /(?:
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003685 \n.}\s*$|
Andy Whitcroft48012052008-10-15 22:02:34 -07003686 ^.DEFINE_$Ident\(\Q$name\E\)|
3687 ^.DECLARE_$Ident\(\Q$name\E\)|
3688 ^.LIST_HEAD\(\Q$name\E\)|
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003689 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3690 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
Andy Whitcroft48012052008-10-15 22:02:34 -07003691 )/x) {
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003692#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3693 $suppress_export{$realline_next} = 2;
3694 } else {
3695 $suppress_export{$realline_next} = 1;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003696 }
3697 }
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003698 if (!defined $suppress_export{$linenr} &&
3699 $prevline =~ /^.\s*$/ &&
3700 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3701 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3702#print "FOO B <$lines[$linenr - 1]>\n";
3703 $suppress_export{$linenr} = 2;
3704 }
3705 if (defined $suppress_export{$linenr} &&
3706 $suppress_export{$linenr} == 2) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003707 WARN("EXPORT_SYMBOL",
3708 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
Andy Whitcroft2b474a12009-10-26 16:50:16 -07003709 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003710
Joe Eloff5150bda2010-08-09 17:21:00 -07003711# check for global initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003712 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003713 if (ERROR("GLOBAL_INITIALISERS",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003714 "do not initialise globals to $1\n" . $herecurr) &&
Joe Perchesd5e616f2013-09-11 14:23:54 -07003715 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003716 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003717 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07003718 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003719# check for static initialisers.
Joe Perches6d32f7a2015-11-06 16:31:37 -08003720 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003721 if (ERROR("INITIALISED_STATIC",
Joe Perches6d32f7a2015-11-06 16:31:37 -08003722 "do not initialise statics to $1\n" .
Joe Perchesd5e616f2013-09-11 14:23:54 -07003723 $herecurr) &&
3724 $fix) {
Joe Perches6d32f7a2015-11-06 16:31:37 -08003725 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07003726 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003727 }
3728
Joe Perches18130872014-08-06 16:11:22 -07003729# check for misordered declarations of char/short/int/long with signed/unsigned
3730 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3731 my $tmp = trim($1);
3732 WARN("MISORDERED_TYPE",
3733 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3734 }
3735
Joe Perchescb710ec2010-10-26 14:23:20 -07003736# check for static const char * arrays.
3737 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003738 WARN("STATIC_CONST_CHAR_ARRAY",
3739 "static const char * array should probably be static const char * const\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003740 $herecurr);
3741 }
3742
3743# check for static char foo[] = "bar" declarations.
3744 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003745 WARN("STATIC_CONST_CHAR_ARRAY",
3746 "static char array declaration should probably be static const char\n" .
Joe Perchescb710ec2010-10-26 14:23:20 -07003747 $herecurr);
3748 }
3749
Joe Perchesab7e23f2015-04-16 12:44:22 -07003750# check for const <foo> const where <foo> is not a pointer or array type
3751 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3752 my $found = $1;
3753 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3754 WARN("CONST_CONST",
3755 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3756 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3757 WARN("CONST_CONST",
3758 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3759 }
3760 }
3761
Joe Perches9b0fa602014-04-03 14:49:18 -07003762# check for non-global char *foo[] = {"bar", ...} declarations.
3763 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3764 WARN("STATIC_CONST_CHAR_ARRAY",
3765 "char * array declaration might be better as static const\n" .
3766 $herecurr);
3767 }
3768
Joe Perchesb598b672015-04-16 12:44:36 -07003769# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3770 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3771 my $array = $1;
3772 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3773 my $array_div = $1;
3774 if (WARN("ARRAY_SIZE",
3775 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3776 $fix) {
3777 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3778 }
3779 }
3780 }
3781
Joe Perchesb36190c2014-01-27 17:07:18 -08003782# check for function declarations without arguments like "int foo()"
3783 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3784 if (ERROR("FUNCTION_WITHOUT_ARGS",
3785 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3786 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003787 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
Joe Perchesb36190c2014-01-27 17:07:18 -08003788 }
3789 }
3790
Andy Whitcroft653d4872007-06-23 17:16:34 -07003791# check for new typedefs, only function parameters and sparse annotations
3792# make sense.
3793 if ($line =~ /\btypedef\s/ &&
Andy Whitcroft80545762009-01-06 14:41:26 -08003794 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07003795 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
Andy Whitcroft8ed22ca2008-10-15 22:02:32 -07003796 $line !~ /\b$typeTypedefs\b/ &&
Michael S. Tsirkin46d832f2016-12-11 06:29:58 +02003797 $line !~ /\b__bitwise\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003798 WARN("NEW_TYPEDEFS",
3799 "do not add new typedefs\n" . $herecurr);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003800 }
3801
3802# * goes on variable not on type
Andy Whitcroft65863862009-01-06 14:41:21 -08003803 # (char*[ const])
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003804 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3805 #print "AA<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003806 my ($ident, $from, $to) = ($1, $2, $2);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003807
Andy Whitcroft65863862009-01-06 14:41:21 -08003808 # Should start with a space.
3809 $to =~ s/^(\S)/ $1/;
3810 # Should not end with a space.
3811 $to =~ s/\s+$//;
3812 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003813 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003814 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003815
Joe Perches3705ce52013-07-03 15:05:31 -07003816## print "1: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft65863862009-01-06 14:41:21 -08003817 if ($from ne $to) {
Joe Perches3705ce52013-07-03 15:05:31 -07003818 if (ERROR("POINTER_LOCATION",
3819 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3820 $fix) {
3821 my $sub_from = $ident;
3822 my $sub_to = $ident;
3823 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003824 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003825 s@\Q$sub_from\E@$sub_to@;
3826 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003827 }
Andy Whitcroftbfcb2cc2012-01-10 15:10:15 -08003828 }
3829 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3830 #print "BB<$1>\n";
Joe Perches3705ce52013-07-03 15:05:31 -07003831 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07003832
Andy Whitcroft65863862009-01-06 14:41:21 -08003833 # Should start with a space.
3834 $to =~ s/^(\S)/ $1/;
3835 # Should not end with a space.
3836 $to =~ s/\s+$//;
3837 # '*'s should not have spaces between.
Andy Whitcroftf9a0b3d2009-01-15 13:51:05 -08003838 while ($to =~ s/\*\s+\*/\*\*/) {
Andy Whitcroft65863862009-01-06 14:41:21 -08003839 }
3840 # Modifiers should have spaces.
3841 $to =~ s/(\b$Modifier$)/$1 /;
3842
Joe Perches3705ce52013-07-03 15:05:31 -07003843## print "2: from<$from> to<$to> ident<$ident>\n";
Andy Whitcroft667026e2009-02-27 14:03:08 -08003844 if ($from ne $to && $ident !~ /^$Modifier$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07003845 if (ERROR("POINTER_LOCATION",
3846 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3847 $fix) {
3848
3849 my $sub_from = $match;
3850 my $sub_to = $match;
3851 $sub_to =~ s/\Q$from\E/$to/;
Joe Perches194f66f2014-08-06 16:11:03 -07003852 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003853 s@\Q$sub_from\E@$sub_to@;
3854 }
Andy Whitcroft65863862009-01-06 14:41:21 -08003855 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003856 }
3857
Joe Perches9d3e3c72015-09-09 15:37:27 -07003858# avoid BUG() or BUG_ON()
3859 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
Jean Delvare0675a8f2017-09-08 16:16:07 -07003860 my $msg_level = \&WARN;
3861 $msg_level = \&CHK if ($file);
3862 &{$msg_level}("AVOID_BUG",
3863 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
Joe Perches9d3e3c72015-09-09 15:37:27 -07003864 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003865
Joe Perches9d3e3c72015-09-09 15:37:27 -07003866# avoid LINUX_VERSION_CODE
Andy Whitcroft8905a672007-11-28 16:21:06 -08003867 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003868 WARN("LINUX_VERSION_CODE",
3869 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08003870 }
3871
Joe Perches17441222011-06-15 15:08:17 -07003872# check for uses of printk_ratelimit
3873 if ($line =~ /\bprintk_ratelimit\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07003874 WARN("PRINTK_RATELIMITED",
Joe Perches101ee682015-02-13 14:38:54 -08003875 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
Joe Perches17441222011-06-15 15:08:17 -07003876 }
3877
Joe Percheseeef5732017-11-17 15:28:41 -08003878# printk should use KERN_* levels
3879 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
3880 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3881 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003882 }
3883
Joe Perches243f3802012-05-31 16:26:09 -07003884 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3885 my $orig = $1;
3886 my $level = lc($orig);
3887 $level = "warn" if ($level eq "warning");
Joe Perches8f26b832012-10-04 17:13:32 -07003888 my $level2 = $level;
3889 $level2 = "dbg" if ($level eq "debug");
Joe Perches243f3802012-05-31 16:26:09 -07003890 WARN("PREFER_PR_LEVEL",
Yogesh Chaudharidaa8b052014-04-03 14:49:23 -07003891 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
Joe Perches243f3802012-05-31 16:26:09 -07003892 }
3893
3894 if ($line =~ /\bpr_warning\s*\(/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07003895 if (WARN("PREFER_PR_LEVEL",
3896 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3897 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003898 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07003899 s/\bpr_warning\b/pr_warn/;
3900 }
Joe Perches243f3802012-05-31 16:26:09 -07003901 }
3902
Joe Perchesdc139312013-02-21 16:44:13 -08003903 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3904 my $orig = $1;
3905 my $level = lc($orig);
3906 $level = "warn" if ($level eq "warning");
3907 $level = "dbg" if ($level eq "debug");
3908 WARN("PREFER_DEV_LEVEL",
3909 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3910 }
3911
Andy Lutomirski91c9afa2015-04-16 12:44:44 -07003912# ENOSYS means "bad syscall nr" and nothing else. This will have a small
3913# number of false positives, but assembly files are not checked, so at
3914# least the arch entry code will not trigger this warning.
3915 if ($line =~ /\bENOSYS\b/) {
3916 WARN("ENOSYS",
3917 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3918 }
3919
Andy Whitcroft653d4872007-06-23 17:16:34 -07003920# function brace can't be on same line, except for #defines of do while,
3921# or if closed on same line
Joe Perches8d182472014-08-06 16:11:12 -07003922 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07003923 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
Joe Perches8d182472014-08-06 16:11:12 -07003924 if (ERROR("OPEN_BRACE",
3925 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3926 $fix) {
3927 fix_delete_line($fixlinenr, $rawline);
3928 my $fixed_line = $rawline;
3929 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3930 my $line1 = $1;
3931 my $line2 = $2;
3932 fix_insert_line($fixlinenr, ltrim($line1));
3933 fix_insert_line($fixlinenr, "\+{");
3934 if ($line2 !~ /^\s*$/) {
3935 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3936 }
3937 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07003938 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07003939
Andy Whitcroft8905a672007-11-28 16:21:06 -08003940# open braces for enum, union and struct go on the same line.
3941 if ($line =~ /^.\s*{/ &&
3942 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
Joe Perches8d182472014-08-06 16:11:12 -07003943 if (ERROR("OPEN_BRACE",
3944 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3945 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3946 fix_delete_line($fixlinenr - 1, $prevrawline);
3947 fix_delete_line($fixlinenr, $rawline);
3948 my $fixedline = rtrim($prevrawline) . " {";
3949 fix_insert_line($fixlinenr, $fixedline);
3950 $fixedline = $rawline;
Cyril Bur8d81ae02017-07-10 15:52:21 -07003951 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
Joe Perches8d182472014-08-06 16:11:12 -07003952 if ($fixedline !~ /^\+\s*$/) {
3953 fix_insert_line($fixlinenr, $fixedline);
3954 }
3955 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08003956 }
3957
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003958# missing space after union, struct or enum definition
Joe Perches3705ce52013-07-03 15:05:31 -07003959 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3960 if (WARN("SPACING",
3961 "missing space after $1 definition\n" . $herecurr) &&
3962 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07003963 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07003964 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3965 }
Andy Whitcroft0c73b4e2010-10-26 14:23:15 -07003966 }
3967
Joe Perches31070b52014-01-23 15:54:49 -08003968# Function pointer declarations
3969# check spacing between type, funcptr, and args
3970# canonical declaration is "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003971 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
Joe Perches31070b52014-01-23 15:54:49 -08003972 my $declare = $1;
3973 my $pre_pointer_space = $2;
3974 my $post_pointer_space = $3;
3975 my $funcname = $4;
3976 my $post_funcname_space = $5;
3977 my $pre_args_space = $6;
3978
Joe Perches91f72e92014-04-03 14:49:12 -07003979# the $Declare variable will capture all spaces after the type
3980# so check it for a missing trailing missing space but pointer return types
3981# don't need a space so don't warn for those.
3982 my $post_declare_space = "";
3983 if ($declare =~ /(\s+)$/) {
3984 $post_declare_space = $1;
3985 $declare = rtrim($declare);
3986 }
3987 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
Joe Perches31070b52014-01-23 15:54:49 -08003988 WARN("SPACING",
3989 "missing space after return type\n" . $herecurr);
Joe Perches91f72e92014-04-03 14:49:12 -07003990 $post_declare_space = " ";
Joe Perches31070b52014-01-23 15:54:49 -08003991 }
3992
3993# unnecessary space "type (*funcptr)(args...)"
Joe Perches91f72e92014-04-03 14:49:12 -07003994# This test is not currently implemented because these declarations are
3995# equivalent to
3996# int foo(int bar, ...)
3997# and this is form shouldn't/doesn't generate a checkpatch warning.
3998#
3999# elsif ($declare =~ /\s{2,}$/) {
4000# WARN("SPACING",
4001# "Multiple spaces after return type\n" . $herecurr);
4002# }
Joe Perches31070b52014-01-23 15:54:49 -08004003
4004# unnecessary space "type ( *funcptr)(args...)"
4005 if (defined $pre_pointer_space &&
4006 $pre_pointer_space =~ /^\s/) {
4007 WARN("SPACING",
4008 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4009 }
4010
4011# unnecessary space "type (* funcptr)(args...)"
4012 if (defined $post_pointer_space &&
4013 $post_pointer_space =~ /^\s/) {
4014 WARN("SPACING",
4015 "Unnecessary space before function pointer name\n" . $herecurr);
4016 }
4017
4018# unnecessary space "type (*funcptr )(args...)"
4019 if (defined $post_funcname_space &&
4020 $post_funcname_space =~ /^\s/) {
4021 WARN("SPACING",
4022 "Unnecessary space after function pointer name\n" . $herecurr);
4023 }
4024
4025# unnecessary space "type (*funcptr) (args...)"
4026 if (defined $pre_args_space &&
4027 $pre_args_space =~ /^\s/) {
4028 WARN("SPACING",
4029 "Unnecessary space before function pointer arguments\n" . $herecurr);
4030 }
4031
4032 if (show_type("SPACING") && $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004033 $fixed[$fixlinenr] =~
Joe Perches91f72e92014-04-03 14:49:12 -07004034 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
Joe Perches31070b52014-01-23 15:54:49 -08004035 }
4036 }
4037
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07004038# check for spacing round square brackets; allowed:
4039# 1. with a type on the left -- int [] a;
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07004040# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4041# 3. inside a curly brace -- = { [0...10] = 5 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07004042 while ($line =~ /(.*?\s)\[/g) {
4043 my ($where, $prefix) = ($-[1], $1);
4044 if ($prefix !~ /$Type\s+$/ &&
Andy Whitcroftfe2a7db2008-10-15 22:02:15 -07004045 ($where != 0 || $prefix !~ /^.\s+$/) &&
Andy Whitcroftdaebc532012-03-23 15:02:17 -07004046 $prefix !~ /[{,]\s+$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004047 if (ERROR("BRACKET_SPACE",
4048 "space prohibited before open square bracket '['\n" . $herecurr) &&
4049 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004050 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004051 s/^(\+.*?)\s+\[/$1\[/;
4052 }
Andy Whitcroft8d31cfc2008-07-23 21:29:02 -07004053 }
4054 }
4055
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004056# check for spaces between functions and their parentheses.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004057 while ($line =~ /($Ident)\s+\(/g) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004058 my $name = $1;
Andy Whitcroft773647a2008-03-28 14:15:58 -07004059 my $ctx_before = substr($line, 0, $-[1]);
4060 my $ctx = "$ctx_before$name";
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004061
4062 # Ignore those directives where spaces _are_ permitted.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004063 if ($name =~ /^(?:
4064 if|for|while|switch|return|case|
4065 volatile|__volatile__|
4066 __attribute__|format|__extension__|
4067 asm|__asm__)$/x)
4068 {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004069 # cpp #define statements have non-optional spaces, ie
4070 # if there is a space between the name and the open
4071 # parenthesis it is simply not a parameter group.
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004072 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004073
4074 # cpp #elif statement condition may start with a (
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004075 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004076
4077 # If this whole things ends with a type its most
4078 # likely a typedef for a function.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004079 } elsif ($ctx =~ /$Type$/) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004080
4081 } else {
Joe Perches3705ce52013-07-03 15:05:31 -07004082 if (WARN("SPACING",
4083 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4084 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004085 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004086 s/\b$name\s+\(/$name\(/;
4087 }
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004088 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004089 }
Eric Nelson9a4cad42012-05-31 16:26:09 -07004090
Andy Whitcroft653d4872007-06-23 17:16:34 -07004091# Check operator spacing.
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004092 if (!($line=~/\#\s*include/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004093 my $fixed_line = "";
4094 my $line_fixed = 0;
4095
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004096 my $ops = qr{
4097 <<=|>>=|<=|>=|==|!=|
4098 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4099 =>|->|<<|>>|<|>|=|!|~|
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004100 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Joe Perches84731622013-11-12 15:10:05 -08004101 \?:|\?|:
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004102 }x;
Andy Whitcroftcf655042008-03-04 14:28:20 -08004103 my @elements = split(/($ops|;)/, $opline);
Joe Perches3705ce52013-07-03 15:05:31 -07004104
4105## print("element count: <" . $#elements . ">\n");
4106## foreach my $el (@elements) {
4107## print("el: <$el>\n");
4108## }
4109
4110 my @fix_elements = ();
Andy Whitcroft00df3442007-06-08 13:47:06 -07004111 my $off = 0;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004112
Joe Perches3705ce52013-07-03 15:05:31 -07004113 foreach my $el (@elements) {
4114 push(@fix_elements, substr($rawline, $off, length($el)));
4115 $off += length($el);
4116 }
4117
4118 $off = 0;
4119
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004120 my $blank = copy_spacing($opline);
Joe Perchesb34c6482013-09-11 14:24:01 -07004121 my $last_after = -1;
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004122
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004123 for (my $n = 0; $n < $#elements; $n += 2) {
Joe Perches3705ce52013-07-03 15:05:31 -07004124
4125 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4126
4127## print("n: <$n> good: <$good>\n");
4128
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004129 $off += length($elements[$n]);
4130
Lucas De Marchi25985ed2011-03-30 22:57:33 -03004131 # Pick up the preceding and succeeding characters.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004132 my $ca = substr($opline, 0, $off);
4133 my $cc = '';
4134 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4135 $cc = substr($opline, $off + length($elements[$n + 1]));
4136 }
4137 my $cb = "$ca$;$cc";
4138
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004139 my $a = '';
4140 $a = 'V' if ($elements[$n] ne '');
4141 $a = 'W' if ($elements[$n] =~ /\s$/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004142 $a = 'C' if ($elements[$n] =~ /$;$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004143 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4144 $a = 'O' if ($elements[$n] eq '');
Andy Whitcroft773647a2008-03-28 14:15:58 -07004145 $a = 'E' if ($ca =~ /^\s*$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004146
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004147 my $op = $elements[$n + 1];
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004148
4149 my $c = '';
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004150 if (defined $elements[$n + 2]) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004151 $c = 'V' if ($elements[$n + 2] ne '');
4152 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
Andy Whitcroftcf655042008-03-04 14:28:20 -08004153 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004154 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4155 $c = 'O' if ($elements[$n + 2] eq '');
Andy Whitcroft8b1b3372009-01-06 14:41:27 -08004156 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004157 } else {
4158 $c = 'E';
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004159 }
4160
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004161 my $ctx = "${a}x${c}";
4162
4163 my $at = "(ctx:$ctx)";
4164
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004165 my $ptr = substr($blank, 0, $off) . "^";
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004166 my $hereptr = "$hereline$ptr\n";
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004167
Andy Whitcroft74048ed2008-07-23 21:29:10 -07004168 # Pull out the value of this operator.
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07004169 my $op_type = substr($curr_values, $off + 1, 1);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004170
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004171 # Get the full operator variant.
4172 my $opv = $op . substr($curr_vars, $off, 1);
4173
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004174 # Ignore operators passed as parameters.
4175 if ($op_type ne 'V' &&
Sam Bobroffd7fe8062015-04-16 12:44:39 -07004176 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004177
Andy Whitcroftcf655042008-03-04 14:28:20 -08004178# # Ignore comments
4179# } elsif ($op =~ /^$;+$/) {
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004180
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004181 # ; should have either the end of line or a space or \ after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004182 } elsif ($op eq ';') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004183 if ($ctx !~ /.x[WEBC]/ &&
4184 $cc !~ /^\\/ && $cc !~ /^;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004185 if (ERROR("SPACING",
4186 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004187 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07004188 $line_fixed = 1;
4189 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004190 }
4191
4192 # // is a comment
4193 } elsif ($op eq '//') {
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004194
Joe Perchesb00e4812014-04-03 14:49:33 -07004195 # : when part of a bitfield
4196 } elsif ($opv eq ':B') {
4197 # skip the bitfield test for now
4198
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004199 # No spaces for:
4200 # ->
Joe Perchesb00e4812014-04-03 14:49:33 -07004201 } elsif ($op eq '->') {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004202 if ($ctx =~ /Wx.|.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004203 if (ERROR("SPACING",
4204 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004205 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004206 if (defined $fix_elements[$n + 2]) {
4207 $fix_elements[$n + 2] =~ s/^\s+//;
4208 }
Joe Perchesb34c6482013-09-11 14:24:01 -07004209 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07004210 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004211 }
4212
Joe Perches23810972014-12-10 15:51:32 -08004213 # , must not have a space before and must have a space on the right.
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004214 } elsif ($op eq ',') {
Joe Perches23810972014-12-10 15:51:32 -08004215 my $rtrim_before = 0;
4216 my $space_after = 0;
4217 if ($ctx =~ /Wx./) {
4218 if (ERROR("SPACING",
4219 "space prohibited before that '$op' $at\n" . $hereptr)) {
4220 $line_fixed = 1;
4221 $rtrim_before = 1;
4222 }
4223 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08004224 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004225 if (ERROR("SPACING",
4226 "space required after that '$op' $at\n" . $hereptr)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004227 $line_fixed = 1;
Joe Perchesb34c6482013-09-11 14:24:01 -07004228 $last_after = $n;
Joe Perches23810972014-12-10 15:51:32 -08004229 $space_after = 1;
4230 }
4231 }
4232 if ($rtrim_before || $space_after) {
4233 if ($rtrim_before) {
4234 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4235 } else {
4236 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4237 }
4238 if ($space_after) {
4239 $good .= " ";
Joe Perches3705ce52013-07-03 15:05:31 -07004240 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004241 }
4242
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004243 # '*' as part of a type definition -- reported already.
Andy Whitcroft74048ed2008-07-23 21:29:10 -07004244 } elsif ($opv eq '*_') {
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004245 #warn "'*' is part of type\n";
4246
4247 # unary operators should have a space before and
4248 # none after. May be left adjacent to another
4249 # unary operator, or a cast
4250 } elsif ($op eq '!' || $op eq '~' ||
Andy Whitcroft74048ed2008-07-23 21:29:10 -07004251 $opv eq '*U' || $opv eq '-U' ||
Andy Whitcroft0d413862008-10-15 22:02:16 -07004252 $opv eq '&U' || $opv eq '&&U') {
Andy Whitcroftcf655042008-03-04 14:28:20 -08004253 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004254 if (ERROR("SPACING",
4255 "space required before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004256 if ($n != $last_after + 2) {
4257 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4258 $line_fixed = 1;
4259 }
Joe Perches3705ce52013-07-03 15:05:31 -07004260 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004261 }
Andy Whitcrofta3340b32009-02-27 14:03:07 -08004262 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004263 # A unary '*' may be const
4264
4265 } elsif ($ctx =~ /.xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004266 if (ERROR("SPACING",
4267 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004268 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004269 if (defined $fix_elements[$n + 2]) {
4270 $fix_elements[$n + 2] =~ s/^\s+//;
4271 }
Joe Perchesb34c6482013-09-11 14:24:01 -07004272 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07004273 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004274 }
4275
4276 # unary ++ and unary -- are allowed no space on one side.
4277 } elsif ($op eq '++' or $op eq '--') {
Andy Whitcroft773647a2008-03-28 14:15:58 -07004278 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004279 if (ERROR("SPACING",
4280 "space required one side of that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004281 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
Joe Perches3705ce52013-07-03 15:05:31 -07004282 $line_fixed = 1;
4283 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004284 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004285 if ($ctx =~ /Wx[BE]/ ||
4286 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004287 if (ERROR("SPACING",
4288 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004289 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004290 $line_fixed = 1;
4291 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07004292 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004293 if ($ctx =~ /ExW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004294 if (ERROR("SPACING",
4295 "space prohibited after that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004296 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004297 if (defined $fix_elements[$n + 2]) {
4298 $fix_elements[$n + 2] =~ s/^\s+//;
4299 }
Joe Perchesb34c6482013-09-11 14:24:01 -07004300 $line_fixed = 1;
Joe Perches3705ce52013-07-03 15:05:31 -07004301 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07004302 }
4303
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004304 # << and >> may either have or not have spaces both sides
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004305 } elsif ($op eq '<<' or $op eq '>>' or
4306 $op eq '&' or $op eq '^' or $op eq '|' or
4307 $op eq '+' or $op eq '-' or
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004308 $op eq '*' or $op eq '/' or
4309 $op eq '%')
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004310 {
Joe Perchesd2e025f2015-02-13 14:38:57 -08004311 if ($check) {
4312 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4313 if (CHK("SPACING",
4314 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4315 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4316 $fix_elements[$n + 2] =~ s/^\s+//;
4317 $line_fixed = 1;
4318 }
4319 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4320 if (CHK("SPACING",
4321 "space preferred before that '$op' $at\n" . $hereptr)) {
4322 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4323 $line_fixed = 1;
4324 }
4325 }
4326 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004327 if (ERROR("SPACING",
4328 "need consistent spacing around '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004329 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4330 if (defined $fix_elements[$n + 2]) {
4331 $fix_elements[$n + 2] =~ s/^\s+//;
4332 }
Joe Perches3705ce52013-07-03 15:05:31 -07004333 $line_fixed = 1;
4334 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004335 }
4336
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004337 # A colon needs no spaces before when it is
4338 # terminating a case value or a label.
4339 } elsif ($opv eq ':C' || $opv eq ':L') {
4340 if ($ctx =~ /Wx./) {
Joe Perches3705ce52013-07-03 15:05:31 -07004341 if (ERROR("SPACING",
4342 "space prohibited before that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004343 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004344 $line_fixed = 1;
4345 }
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004346 }
4347
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004348 # All the others need spaces both sides.
Andy Whitcroftcf655042008-03-04 14:28:20 -08004349 } elsif ($ctx !~ /[EWC]x[CWE]/) {
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004350 my $ok = 0;
4351
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004352 # Ignore email addresses <foo@bar>
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004353 if (($op eq '<' &&
4354 $cc =~ /^\S+\@\S+>/) ||
4355 ($op eq '>' &&
4356 $ca =~ /<\S+\@\S+$/))
4357 {
4358 $ok = 1;
4359 }
4360
Joe Perchese0df7e12015-04-16 12:44:53 -07004361 # for asm volatile statements
4362 # ignore a colon with another
4363 # colon immediately before or after
4364 if (($op eq ':') &&
4365 ($ca =~ /:$/ || $cc =~ /^:/)) {
4366 $ok = 1;
4367 }
4368
Joe Perches84731622013-11-12 15:10:05 -08004369 # messages are ERROR, but ?: are CHK
Andy Whitcroft1f65f942008-07-23 21:29:10 -07004370 if ($ok == 0) {
Jean Delvare0675a8f2017-09-08 16:16:07 -07004371 my $msg_level = \&ERROR;
4372 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
Joe Perches84731622013-11-12 15:10:05 -08004373
Jean Delvare0675a8f2017-09-08 16:16:07 -07004374 if (&{$msg_level}("SPACING",
4375 "spaces required around that '$op' $at\n" . $hereptr)) {
Joe Perchesb34c6482013-09-11 14:24:01 -07004376 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4377 if (defined $fix_elements[$n + 2]) {
4378 $fix_elements[$n + 2] =~ s/^\s+//;
4379 }
Joe Perches3705ce52013-07-03 15:05:31 -07004380 $line_fixed = 1;
4381 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004382 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004383 }
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004384 $off += length($elements[$n + 1]);
Joe Perches3705ce52013-07-03 15:05:31 -07004385
4386## print("n: <$n> GOOD: <$good>\n");
4387
4388 $fixed_line = $fixed_line . $good;
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004389 }
Joe Perches3705ce52013-07-03 15:05:31 -07004390
4391 if (($#elements % 2) == 0) {
4392 $fixed_line = $fixed_line . $fix_elements[$#elements];
4393 }
4394
Joe Perches194f66f2014-08-06 16:11:03 -07004395 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4396 $fixed[$fixlinenr] = $fixed_line;
Joe Perches3705ce52013-07-03 15:05:31 -07004397 }
4398
4399
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004400 }
4401
Joe Perches786b6322013-07-03 15:05:32 -07004402# check for whitespace before a non-naked semicolon
Joe Perchesd2e248e2014-01-23 15:54:41 -08004403 if ($line =~ /^\+.*\S\s+;\s*$/) {
Joe Perches786b6322013-07-03 15:05:32 -07004404 if (WARN("SPACING",
4405 "space prohibited before semicolon\n" . $herecurr) &&
4406 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004407 1 while $fixed[$fixlinenr] =~
Joe Perches786b6322013-07-03 15:05:32 -07004408 s/^(\+.*\S)\s+;/$1;/;
4409 }
4410 }
4411
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004412# check for multiple assignments
4413 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004414 CHK("MULTIPLE_ASSIGNMENTS",
4415 "multiple assignments should be avoided\n" . $herecurr);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004416 }
4417
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004418## # check for multiple declarations, allowing for a function declaration
4419## # continuation.
4420## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4421## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4422##
4423## # Remove any bracketed sections to ensure we do not
4424## # falsly report the parameters of functions.
4425## my $ln = $line;
4426## while ($ln =~ s/\([^\(\)]*\)//g) {
4427## }
4428## if ($ln =~ /,/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004429## WARN("MULTIPLE_DECLARATION",
4430## "declaring multiple variables together should be avoided\n" . $herecurr);
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004431## }
4432## }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07004433
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004434#need space before brace following if, while, etc
Geyslan G. Bem6b8c69e2016-03-15 14:58:09 -07004435 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004436 $line =~ /do\{/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004437 if (ERROR("SPACING",
4438 "space required before the open brace '{'\n" . $herecurr) &&
4439 $fix) {
Cyril Bur8d81ae02017-07-10 15:52:21 -07004440 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
Joe Perches3705ce52013-07-03 15:05:31 -07004441 }
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004442 }
4443
Joe Perchesc4a62ef2013-07-03 15:05:28 -07004444## # check for blank lines before declarations
4445## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4446## $prevrawline =~ /^.\s*$/) {
4447## WARN("SPACING",
4448## "No blank lines before declarations\n" . $hereprev);
4449## }
4450##
4451
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004452# closing brace should have a space following it when it has anything
4453# on the line
4454 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004455 if (ERROR("SPACING",
4456 "space required after that close brace '}'\n" . $herecurr) &&
4457 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004458 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004459 s/}((?!(?:,|;|\)))\S)/} $1/;
4460 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004461 }
4462
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004463# check spacing on square brackets
4464 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004465 if (ERROR("SPACING",
4466 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4467 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004468 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004469 s/\[\s+/\[/;
4470 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004471 }
4472 if ($line =~ /\s\]/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004473 if (ERROR("SPACING",
4474 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4475 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004476 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004477 s/\s+\]/\]/;
4478 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004479 }
4480
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004481# check spacing on parentheses
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07004482 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4483 $line !~ /for\s*\(\s+;/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004484 if (ERROR("SPACING",
4485 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4486 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004487 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004488 s/\(\s+/\(/;
4489 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004490 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004491 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004492 $line !~ /for\s*\(.*;\s+\)/ &&
4493 $line !~ /:\s+\)/) {
Joe Perches3705ce52013-07-03 15:05:31 -07004494 if (ERROR("SPACING",
4495 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4496 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004497 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004498 s/\s+\)/\)/;
4499 }
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07004500 }
4501
Joe Perchese2826fd2014-08-06 16:10:48 -07004502# check unnecessary parentheses around addressof/dereference single $Lvals
4503# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4504
4505 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
Joe Perchesea4acbb2014-12-10 15:51:51 -08004506 my $var = $1;
4507 if (CHK("UNNECESSARY_PARENTHESES",
4508 "Unnecessary parentheses around $var\n" . $herecurr) &&
4509 $fix) {
4510 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4511 }
4512 }
4513
4514# check for unnecessary parentheses around function pointer uses
4515# ie: (foo->bar)(); should be foo->bar();
4516# but not "if (foo->bar) (" to avoid some false positives
4517 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4518 my $var = $2;
4519 if (CHK("UNNECESSARY_PARENTHESES",
4520 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4521 $fix) {
4522 my $var2 = deparenthesize($var);
4523 $var2 =~ s/\s//g;
4524 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4525 }
4526 }
Joe Perchese2826fd2014-08-06 16:10:48 -07004527
Joe Perches63b7c732017-09-08 16:16:01 -07004528# check for unnecessary parentheses around comparisons in if uses
4529 if ($^V && $^V ge 5.10.0 && defined($stat) &&
4530 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
4531 my $if_stat = $1;
4532 my $test = substr($2, 1, -1);
4533 my $herectx;
4534 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
4535 my $match = $1;
4536 # avoid parentheses around potential macro args
4537 next if ($match =~ /^\s*\w+\s*$/);
4538 if (!defined($herectx)) {
4539 $herectx = $here . "\n";
4540 my $cnt = statement_rawlines($if_stat);
4541 for (my $n = 0; $n < $cnt; $n++) {
4542 my $rl = raw_line($linenr, $n);
4543 $herectx .= $rl . "\n";
4544 last if $rl =~ /^[ \+].*\{/;
4545 }
4546 }
4547 CHK("UNNECESSARY_PARENTHESES",
4548 "Unnecessary parentheses around '$match'\n" . $herectx);
4549 }
4550 }
4551
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004552#goto labels aren't indented, allow a single space however
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07004553 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004554 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Joe Perches3705ce52013-07-03 15:05:31 -07004555 if (WARN("INDENTED_LABEL",
4556 "labels should not be indented\n" . $herecurr) &&
4557 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004558 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004559 s/^(.)\s+/$1/;
4560 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004561 }
4562
Joe Perches5b9553a2014-04-03 14:49:21 -07004563# return is not a function
Joe Perches507e5142013-11-12 15:10:13 -08004564 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004565 my $spacing = $1;
Joe Perches507e5142013-11-12 15:10:13 -08004566 if ($^V && $^V ge 5.10.0 &&
Joe Perches5b9553a2014-04-03 14:49:21 -07004567 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4568 my $value = $1;
4569 $value = deparenthesize($value);
4570 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4571 ERROR("RETURN_PARENTHESES",
4572 "return is not a function, parentheses are not required\n" . $herecurr);
4573 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004574 } elsif ($spacing !~ /\s+/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004575 ERROR("SPACING",
4576 "space required before the open parenthesis '('\n" . $herecurr);
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004577 }
4578 }
Joe Perches507e5142013-11-12 15:10:13 -08004579
Joe Perchesb43ae212014-06-23 13:22:07 -07004580# unnecessary return in a void function
4581# at end-of-function, with the previous line a single leading tab, then return;
4582# and the line before that not a goto label target like "out:"
4583 if ($sline =~ /^[ \+]}\s*$/ &&
4584 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4585 $linenr >= 3 &&
4586 $lines[$linenr - 3] =~ /^[ +]/ &&
4587 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
Joe Perches9819cf22014-06-04 16:12:09 -07004588 WARN("RETURN_VOID",
Joe Perchesb43ae212014-06-23 13:22:07 -07004589 "void function return statements are not generally useful\n" . $hereprev);
4590 }
Joe Perches9819cf22014-06-04 16:12:09 -07004591
Joe Perches189248d2014-01-23 15:54:47 -08004592# if statements using unnecessary parentheses - ie: if ((foo == bar))
4593 if ($^V && $^V ge 5.10.0 &&
4594 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4595 my $openparens = $1;
4596 my $count = $openparens =~ tr@\(@\(@;
4597 my $msg = "";
4598 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4599 my $comp = $4; #Not $1 because of $LvalOrFunc
4600 $msg = " - maybe == should be = ?" if ($comp eq "==");
4601 WARN("UNNECESSARY_PARENTHESES",
4602 "Unnecessary parentheses$msg\n" . $herecurr);
4603 }
4604 }
4605
Joe Perchesc5595fa2015-09-09 15:37:58 -07004606# comparisons with a constant or upper case identifier on the left
4607# avoid cases like "foo + BAR < baz"
4608# only fix matches surrounded by parentheses to avoid incorrect
4609# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4610 if ($^V && $^V ge 5.10.0 &&
4611 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4612 my $lead = $1;
4613 my $const = $2;
4614 my $comp = $3;
4615 my $to = $4;
4616 my $newcomp = $comp;
Joe Perchesf39e1762016-05-20 17:04:02 -07004617 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
Joe Perchesc5595fa2015-09-09 15:37:58 -07004618 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4619 WARN("CONSTANT_COMPARISON",
4620 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4621 $fix) {
4622 if ($comp eq "<") {
4623 $newcomp = ">";
4624 } elsif ($comp eq "<=") {
4625 $newcomp = ">=";
4626 } elsif ($comp eq ">") {
4627 $newcomp = "<";
4628 } elsif ($comp eq ">=") {
4629 $newcomp = "<=";
4630 }
4631 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4632 }
4633 }
4634
Joe Perchesf34e4a42015-04-16 12:44:19 -07004635# Return of what appears to be an errno should normally be negative
4636 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004637 my $name = $1;
4638 if ($name ne 'EOF' && $name ne 'ERROR') {
Joe Perches000d1cc12011-07-25 17:13:25 -07004639 WARN("USE_NEGATIVE_ERRNO",
Joe Perchesf34e4a42015-04-16 12:44:19 -07004640 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
Andy Whitcroft53a3c442010-10-26 14:23:14 -07004641 }
4642 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004643
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004644# Need a space before open parenthesis after if, while etc
Joe Perches3705ce52013-07-03 15:05:31 -07004645 if ($line =~ /\b(if|while|for|switch)\(/) {
4646 if (ERROR("SPACING",
4647 "space required before the open parenthesis '('\n" . $herecurr) &&
4648 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004649 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07004650 s/\b(if|while|for|switch)\(/$1 \(/;
4651 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004652 }
4653
Andy Whitcroftf5fe35d2008-07-23 21:29:03 -07004654# Check for illegal assignment in if conditional -- and check for trailing
4655# statements after the conditional.
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004656 if ($line =~ /do\s*(?!{)/) {
Andy Whitcroft3e469cd2012-01-10 15:10:01 -08004657 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4658 ctx_statement_block($linenr, $realcnt, 0)
4659 if (!defined $stat);
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004660 my ($stat_next) = ctx_statement_block($line_nr_next,
4661 $remain_next, $off_next);
4662 $stat_next =~ s/\n./\n /g;
4663 ##print "stat<$stat> stat_next<$stat_next>\n";
4664
4665 if ($stat_next =~ /^\s*while\b/) {
4666 # If the statement carries leading newlines,
4667 # then count those as offsets.
4668 my ($whitespace) =
4669 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4670 my $offset =
4671 statement_rawlines($whitespace) - 1;
4672
4673 $suppress_whiletrailers{$line_nr_next +
4674 $offset} = 1;
4675 }
4676 }
4677 if (!defined $suppress_whiletrailers{$linenr} &&
Joe Perchesc11230f2013-11-21 14:31:57 -08004678 defined($stat) && defined($cond) &&
Andy Whitcroft170d3a22008-10-15 22:02:30 -07004679 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07004680 my ($s, $c) = ($stat, $cond);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004681
Andy Whitcroftb53c8e12009-01-06 14:41:29 -08004682 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004683 ERROR("ASSIGN_IN_IF",
4684 "do not use assignment in if condition\n" . $herecurr);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004685 }
4686
4687 # Find out what is on the end of the line after the
4688 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004689 substr($s, 0, length($c), '');
Andy Whitcroft8905a672007-11-28 16:21:06 -08004690 $s =~ s/\n.*//g;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004691 $s =~ s/$;//g; # Remove any comments
Andy Whitcroft53210162008-07-23 21:29:03 -07004692 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4693 $c !~ /}\s*while\s*/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07004694 {
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004695 # Find out how long the conditional actually is.
4696 my @newlines = ($c =~ /\n/gs);
4697 my $cond_lines = 1 + $#newlines;
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004698 my $stat_real = '';
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004699
Hidetoshi Seto42bdf742010-03-05 13:43:50 -08004700 $stat_real = raw_line($linenr, $cond_lines)
4701 . "\n" if ($cond_lines);
Andy Whitcroftbb44ad32008-10-15 22:02:34 -07004702 if (defined($stat_real) && $cond_lines > 1) {
4703 $stat_real = "[...]\n$stat_real";
4704 }
4705
Joe Perches000d1cc12011-07-25 17:13:25 -07004706 ERROR("TRAILING_STATEMENTS",
4707 "trailing statements should be on next line\n" . $herecurr . $stat_real);
Andy Whitcroft8905a672007-11-28 16:21:06 -08004708 }
4709 }
4710
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004711# Check for bitwise tests written as boolean
4712 if ($line =~ /
4713 (?:
4714 (?:\[|\(|\&\&|\|\|)
4715 \s*0[xX][0-9]+\s*
4716 (?:\&\&|\|\|)
4717 |
4718 (?:\&\&|\|\|)
4719 \s*0[xX][0-9]+\s*
4720 (?:\&\&|\|\||\)|\])
4721 )/x)
4722 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004723 WARN("HEXADECIMAL_BOOLEAN_TEST",
4724 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004725 }
4726
Andy Whitcroft8905a672007-11-28 16:21:06 -08004727# if and else should not have general statements after it
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004728 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4729 my $s = $1;
4730 $s =~ s/$;//g; # Remove any comments
4731 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004732 ERROR("TRAILING_STATEMENTS",
4733 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08004734 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004735 }
Andy Whitcroft39667782009-01-15 13:51:06 -08004736# if should not continue a brace
4737 if ($line =~ /}\s*if\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07004738 ERROR("TRAILING_STATEMENTS",
Rasmus Villemoes048b1232014-08-06 16:10:37 -07004739 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
Andy Whitcroft39667782009-01-15 13:51:06 -08004740 $herecurr);
4741 }
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004742# case and default should not have general statements after them
4743 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4744 $line !~ /\G(?:
Andy Whitcroft3fef12d2008-10-15 22:02:36 -07004745 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004746 \s*return\s+
4747 )/xg)
4748 {
Joe Perches000d1cc12011-07-25 17:13:25 -07004749 ERROR("TRAILING_STATEMENTS",
4750 "trailing statements should be on next line\n" . $herecurr);
Andy Whitcrofta1080bf2008-10-15 22:02:25 -07004751 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004752
4753 # Check for }<nl>else {, these must be at the same
4754 # indent level to be relevant to each other.
Joe Perches8b8856f2014-08-06 16:11:14 -07004755 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4756 $previndent == $indent) {
4757 if (ERROR("ELSE_AFTER_BRACE",
4758 "else should follow close brace '}'\n" . $hereprev) &&
4759 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4760 fix_delete_line($fixlinenr - 1, $prevrawline);
4761 fix_delete_line($fixlinenr, $rawline);
4762 my $fixedline = $prevrawline;
4763 $fixedline =~ s/}\s*$//;
4764 if ($fixedline !~ /^\+\s*$/) {
4765 fix_insert_line($fixlinenr, $fixedline);
4766 }
4767 $fixedline = $rawline;
4768 $fixedline =~ s/^(.\s*)else/$1} else/;
4769 fix_insert_line($fixlinenr, $fixedline);
4770 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004771 }
4772
Joe Perches8b8856f2014-08-06 16:11:14 -07004773 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4774 $previndent == $indent) {
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004775 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4776
4777 # Find out what is on the end of the line after the
4778 # conditional.
Andy Whitcroft773647a2008-03-28 14:15:58 -07004779 substr($s, 0, length($c), '');
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004780 $s =~ s/\n.*//g;
4781
4782 if ($s =~ /^\s*;/) {
Joe Perches8b8856f2014-08-06 16:11:14 -07004783 if (ERROR("WHILE_AFTER_BRACE",
4784 "while should follow close brace '}'\n" . $hereprev) &&
4785 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4786 fix_delete_line($fixlinenr - 1, $prevrawline);
4787 fix_delete_line($fixlinenr, $rawline);
4788 my $fixedline = $prevrawline;
4789 my $trailing = $rawline;
4790 $trailing =~ s/^\+//;
4791 $trailing = trim($trailing);
4792 $fixedline =~ s/}\s*$/} $trailing/;
4793 fix_insert_line($fixlinenr, $fixedline);
4794 }
Andy Whitcroftc2fdda02008-02-08 04:20:54 -08004795 }
4796 }
4797
Joe Perches95e2c602013-07-03 15:05:20 -07004798#Specific variable tests
Joe Perches323c1262012-12-17 16:02:07 -08004799 while ($line =~ m{($Constant|$Lval)}g) {
4800 my $var = $1;
Joe Perches95e2c602013-07-03 15:05:20 -07004801
4802#gcc binary extension
4803 if ($var =~ /^$Binary$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07004804 if (WARN("GCC_BINARY_CONSTANT",
4805 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4806 $fix) {
4807 my $hexval = sprintf("0x%x", oct($var));
Joe Perches194f66f2014-08-06 16:11:03 -07004808 $fixed[$fixlinenr] =~
Joe Perchesd5e616f2013-09-11 14:23:54 -07004809 s/\b$var\b/$hexval/;
4810 }
Joe Perches95e2c602013-07-03 15:05:20 -07004811 }
4812
4813#CamelCase
Joe Perches807bd262013-07-03 15:05:22 -07004814 if ($var !~ /^$Constant$/ &&
Joe Perchesbe797942013-07-03 15:05:20 -07004815 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004816#Ignore Page<foo> variants
Joe Perches807bd262013-07-03 15:05:22 -07004817 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
Joe Perches22735ce2013-07-03 15:05:33 -07004818#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
Julius Wernerf5123572014-12-10 15:51:54 -08004819 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4820#Ignore some three character SI units explicitly, like MiB and KHz
4821 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
Joe Perches7e781f62013-09-11 14:23:55 -07004822 while ($var =~ m{($Ident)}g) {
4823 my $word = $1;
4824 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
Joe Perchesd8b07712013-11-12 15:10:06 -08004825 if ($check) {
4826 seed_camelcase_includes();
4827 if (!$file && !$camelcase_file_seeded) {
4828 seed_camelcase_file($realfile);
4829 $camelcase_file_seeded = 1;
4830 }
4831 }
Joe Perches7e781f62013-09-11 14:23:55 -07004832 if (!defined $camelcase{$word}) {
4833 $camelcase{$word} = 1;
4834 CHK("CAMELCASE",
4835 "Avoid CamelCase: <$word>\n" . $herecurr);
4836 }
Joe Perches34456862013-07-03 15:05:34 -07004837 }
Joe Perches323c1262012-12-17 16:02:07 -08004838 }
4839 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004840
4841#no spaces allowed after \ in define
Joe Perchesd5e616f2013-09-11 14:23:54 -07004842 if ($line =~ /\#\s*define.*\\\s+$/) {
4843 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4844 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4845 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07004846 $fixed[$fixlinenr] =~ s/\s+$//;
Joe Perchesd5e616f2013-09-11 14:23:54 -07004847 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004848 }
4849
Fabian Frederick0e212e02015-04-16 12:44:25 -07004850# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4851# itself <asm/foo.h> (uses RAW line)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004852 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004853 my $file = "$1.h";
4854 my $checkfile = "include/linux/$file";
4855 if (-f "$root/$checkfile" &&
4856 $realfile ne $checkfile &&
Wolfram Sang7840a942010-08-09 17:20:57 -07004857 $1 !~ /$allowed_asm_includes/)
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004858 {
Fabian Frederick0e212e02015-04-16 12:44:25 -07004859 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4860 if ($asminclude > 0) {
4861 if ($realfile =~ m{^arch/}) {
4862 CHK("ARCH_INCLUDE_LINUX",
4863 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4864 } else {
4865 WARN("INCLUDE_LINUX",
4866 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4867 }
Andy Whitcrofte09dec42008-10-15 22:02:20 -07004868 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07004869 }
4870 }
4871
Andy Whitcroft653d4872007-06-23 17:16:34 -07004872# multi-statement macros should be enclosed in a do while loop, grab the
4873# first statement and ensure its the whole macro if its not enclosed
Andy Whitcroftcf655042008-03-04 14:28:20 -08004874# in a known good container
Andy Whitcroftb8f96a312008-07-23 21:29:07 -07004875 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4876 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004877 my $ln = $linenr;
4878 my $cnt = $realcnt;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004879 my ($off, $dstat, $dcond, $rest);
4880 my $ctx = '';
Joe Perches08a28432014-10-13 15:51:55 -07004881 my $has_flow_statement = 0;
4882 my $has_arg_concat = 0;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004883 ($dstat, $dcond, $ln, $cnt, $off) =
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004884 ctx_statement_block($linenr, $realcnt, 0);
4885 $ctx = $dstat;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004886 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
Andy Whitcrofta3bb97a2008-07-23 21:29:00 -07004887 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004888
Joe Perches08a28432014-10-13 15:51:55 -07004889 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
Joe Perches62e15a62016-01-20 14:59:18 -08004890 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
Joe Perches08a28432014-10-13 15:51:55 -07004891
Joe Perchesf59b64b2016-10-11 13:52:08 -07004892 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4893 my $define_args = $1;
4894 my $define_stmt = $dstat;
4895 my @def_args = ();
4896
4897 if (defined $define_args && $define_args ne "") {
4898 $define_args = substr($define_args, 1, length($define_args) - 2);
4899 $define_args =~ s/\s*//g;
4900 @def_args = split(",", $define_args);
4901 }
4902
Andy Whitcroft292f1a92008-07-23 21:29:11 -07004903 $dstat =~ s/$;//g;
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004904 $dstat =~ s/\\\n.//g;
4905 $dstat =~ s/^\s*//s;
4906 $dstat =~ s/\s*$//s;
4907
4908 # Flatten any parentheses and braces
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004909 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4910 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004911 $dstat =~ s/.\[[^\[\]]*\]/1/)
Andy Whitcroftbf30d6e2008-10-15 22:02:33 -07004912 {
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07004913 }
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004914
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004915 # Flatten any obvious string concatentation.
Joe Perches33acb542015-06-25 15:02:54 -07004916 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4917 $dstat =~ s/$Ident\s*($String)/$1/)
Andy Whitcrofte45bab82012-03-23 15:02:18 -07004918 {
4919 }
4920
Joe Perches42e15292016-03-15 14:58:01 -07004921 # Make asm volatile uses seem like a generic function
4922 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4923
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004924 my $exceptions = qr{
4925 $Declare|
4926 module_param_named|
Kees Cooka0a0a7a2012-10-04 17:13:38 -07004927 MODULE_PARM_DESC|
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004928 DECLARE_PER_CPU|
4929 DEFINE_PER_CPU|
Andy Whitcroft383099f2009-01-06 14:41:18 -08004930 __typeof__\(|
Stefani Seibold22fd2d32010-03-05 13:43:52 -08004931 union|
4932 struct|
Andy Whitcroftea71a0a2009-09-21 17:04:38 -07004933 \.$Ident\s*=\s*|
Vladimir Zapolskiy6b10df42016-01-20 14:59:21 -08004934 ^\"|\"$|
4935 ^\[
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07004936 }x;
Andy Whitcroft5eaa20b2010-10-26 14:23:18 -07004937 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Joe Perchesf59b64b2016-10-11 13:52:08 -07004938
4939 $ctx =~ s/\n*$//;
4940 my $herectx = $here . "\n";
4941 my $stmt_cnt = statement_rawlines($ctx);
4942
4943 for (my $n = 0; $n < $stmt_cnt; $n++) {
4944 $herectx .= raw_line($linenr, $n) . "\n";
4945 }
4946
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004947 if ($dstat ne '' &&
4948 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4949 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Joe Perches3cc4b1c2013-07-03 15:05:27 -07004950 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Joe Perches356fd392014-08-06 16:10:31 -07004951 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004952 $dstat !~ /$exceptions/ &&
4953 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Joe Perchese942e2c2013-04-17 15:58:26 -07004954 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Andy Whitcroft72f115f2012-01-10 15:10:06 -08004955 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004956 $dstat !~ /^for\s*$Constant$/ && # for (...)
4957 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4958 $dstat !~ /^do\s*{/ && # do {...
Eddie Kovsky4e5d56b2015-09-09 15:37:52 -07004959 $dstat !~ /^\(\{/ && # ({...
Joe Perchesf95a7e62013-09-11 14:24:00 -07004960 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004961 {
Joe Perchese7955562017-05-08 15:55:48 -07004962 if ($dstat =~ /^\s*if\b/) {
4963 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4964 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
4965 } elsif ($dstat =~ /;/) {
Andy Whitcroftf74bd192012-01-10 15:09:54 -08004966 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4967 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4968 } else {
Joe Perches000d1cc12011-07-25 17:13:25 -07004969 ERROR("COMPLEX_MACRO",
Andrew Morton388982b2014-10-13 15:51:40 -07004970 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
Andy Whitcroftd8aaf122007-06-23 17:16:44 -07004971 }
Joe Perchesf59b64b2016-10-11 13:52:08 -07004972
4973 }
Joe Perches52076492016-10-11 13:52:14 -07004974
4975 # Make $define_stmt single line, comment-free, etc
4976 my @stmt_array = split('\n', $define_stmt);
4977 my $first = 1;
4978 $define_stmt = "";
4979 foreach my $l (@stmt_array) {
4980 $l =~ s/\\$//;
4981 if ($first) {
4982 $define_stmt = $l;
4983 $first = 0;
4984 } elsif ($l =~ /^[\+ ]/) {
4985 $define_stmt .= substr($l, 1);
4986 }
4987 }
4988 $define_stmt =~ s/$;//g;
4989 $define_stmt =~ s/\s+/ /g;
4990 $define_stmt = trim($define_stmt);
4991
Joe Perchesf59b64b2016-10-11 13:52:08 -07004992# check if any macro arguments are reused (ignore '...' and 'type')
4993 foreach my $arg (@def_args) {
4994 next if ($arg =~ /\.\.\./);
Joe Perches9192d412016-10-11 13:52:11 -07004995 next if ($arg =~ /^type$/i);
Joe Perches7fe528a22017-07-10 15:52:27 -07004996 my $tmp_stmt = $define_stmt;
4997 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4998 $tmp_stmt =~ s/\#+\s*$arg\b//g;
4999 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5000 my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
Joe Perchesf59b64b2016-10-11 13:52:08 -07005001 if ($use_cnt > 1) {
5002 CHK("MACRO_ARG_REUSE",
5003 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
Joe Perches9192d412016-10-11 13:52:11 -07005004 }
5005# check if any macro arguments may have other precedence issues
Joe Perches7fe528a22017-07-10 15:52:27 -07005006 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
Joe Perches9192d412016-10-11 13:52:11 -07005007 ((defined($1) && $1 ne ',') ||
5008 (defined($2) && $2 ne ','))) {
5009 CHK("MACRO_ARG_PRECEDENCE",
5010 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
Joe Perchesf59b64b2016-10-11 13:52:08 -07005011 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005012 }
Joe Perches5023d342012-12-17 16:01:47 -08005013
Joe Perches08a28432014-10-13 15:51:55 -07005014# check for macros with flow control, but without ## concatenation
5015# ## concatenation is commonly a macro that defines a function so ignore those
5016 if ($has_flow_statement && !$has_arg_concat) {
5017 my $herectx = $here . "\n";
5018 my $cnt = statement_rawlines($ctx);
5019
5020 for (my $n = 0; $n < $cnt; $n++) {
5021 $herectx .= raw_line($linenr, $n) . "\n";
5022 }
5023 WARN("MACRO_WITH_FLOW_CONTROL",
5024 "Macros with flow control statements should be avoided\n" . "$herectx");
5025 }
5026
Joe Perches481eb482012-12-17 16:01:56 -08005027# check for line continuations outside of #defines, preprocessor #, and asm
Joe Perches5023d342012-12-17 16:01:47 -08005028
5029 } else {
5030 if ($prevline !~ /^..*\\$/ &&
Joe Perches481eb482012-12-17 16:01:56 -08005031 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5032 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
Joe Perches5023d342012-12-17 16:01:47 -08005033 $line =~ /^\+.*\\$/) {
5034 WARN("LINE_CONTINUATIONS",
5035 "Avoid unnecessary line continuations\n" . $herecurr);
5036 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07005037 }
5038
Joe Perchesb13edf72012-07-30 14:41:24 -07005039# do {} while (0) macro tests:
5040# single-statement macros do not need to be enclosed in do while (0) loop,
5041# macro should not end with a semicolon
5042 if ($^V && $^V ge 5.10.0 &&
5043 $realfile !~ m@/vmlinux.lds.h$@ &&
5044 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5045 my $ln = $linenr;
5046 my $cnt = $realcnt;
5047 my ($off, $dstat, $dcond, $rest);
5048 my $ctx = '';
5049 ($dstat, $dcond, $ln, $cnt, $off) =
5050 ctx_statement_block($linenr, $realcnt, 0);
5051 $ctx = $dstat;
5052
5053 $dstat =~ s/\\\n.//g;
Joe Perches1b36b202015-02-13 14:38:32 -08005054 $dstat =~ s/$;/ /g;
Joe Perchesb13edf72012-07-30 14:41:24 -07005055
5056 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5057 my $stmts = $2;
5058 my $semis = $3;
5059
5060 $ctx =~ s/\n*$//;
5061 my $cnt = statement_rawlines($ctx);
5062 my $herectx = $here . "\n";
5063
5064 for (my $n = 0; $n < $cnt; $n++) {
5065 $herectx .= raw_line($linenr, $n) . "\n";
5066 }
5067
Joe Perchesac8e97f2012-08-21 16:15:53 -07005068 if (($stmts =~ tr/;/;/) == 1 &&
5069 $stmts !~ /^\s*(if|while|for|switch)\b/) {
Joe Perchesb13edf72012-07-30 14:41:24 -07005070 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5071 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5072 }
5073 if (defined $semis && $semis ne "") {
5074 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5075 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5076 }
Joe Perchesf5ef95b2014-06-04 16:12:06 -07005077 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5078 $ctx =~ s/\n*$//;
5079 my $cnt = statement_rawlines($ctx);
5080 my $herectx = $here . "\n";
5081
5082 for (my $n = 0; $n < $cnt; $n++) {
5083 $herectx .= raw_line($linenr, $n) . "\n";
5084 }
5085
5086 WARN("TRAILING_SEMICOLON",
5087 "macros should not use a trailing semicolon\n" . "$herectx");
Joe Perchesb13edf72012-07-30 14:41:24 -07005088 }
5089 }
5090
Mike Frysinger080ba922009-01-06 14:41:25 -08005091# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5092# all assignments may have only one of the following with an assignment:
5093# .
5094# ALIGN(...)
5095# VMLINUX_SYMBOL(...)
5096 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005097 WARN("MISSING_VMLINUX_SYMBOL",
5098 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
Mike Frysinger080ba922009-01-06 14:41:25 -08005099 }
5100
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005101# check for redundant bracing round if etc
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005102 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5103 my ($level, $endln, @chunks) =
Andy Whitcroftcf655042008-03-04 14:28:20 -08005104 ctx_statement_full($linenr, $realcnt, 1);
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005105 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08005106 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5107 if ($#chunks > 0 && $level == 0) {
Joe Perchesaad4f612012-03-23 15:02:19 -07005108 my @allowed = ();
5109 my $allow = 0;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005110 my $seen = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07005111 my $herectx = $here . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08005112 my $ln = $linenr - 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005113 for my $chunk (@chunks) {
5114 my ($cond, $block) = @{$chunk};
5115
Andy Whitcroft773647a2008-03-28 14:15:58 -07005116 # If the condition carries leading newlines, then count those as offsets.
5117 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5118 my $offset = statement_rawlines($whitespace) - 1;
5119
Joe Perchesaad4f612012-03-23 15:02:19 -07005120 $allowed[$allow] = 0;
Andy Whitcroft773647a2008-03-28 14:15:58 -07005121 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5122
5123 # We have looked at and allowed this specific line.
5124 $suppress_ifbraces{$ln + $offset} = 1;
5125
5126 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08005127 $ln += statement_rawlines($block) - 1;
5128
Andy Whitcroft773647a2008-03-28 14:15:58 -07005129 substr($block, 0, length($cond), '');
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005130
5131 $seen++ if ($block =~ /^\s*{/);
5132
Joe Perchesaad4f612012-03-23 15:02:19 -07005133 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08005134 if (statement_lines($cond) > 1) {
5135 #print "APW: ALLOWED: cond<$cond>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07005136 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005137 }
5138 if ($block =~/\b(?:if|for|while)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08005139 #print "APW: ALLOWED: block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07005140 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005141 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08005142 if (statement_block_size($block) > 1) {
5143 #print "APW: ALLOWED: lines block<$block>\n";
Joe Perchesaad4f612012-03-23 15:02:19 -07005144 $allowed[$allow] = 1;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005145 }
Joe Perchesaad4f612012-03-23 15:02:19 -07005146 $allow++;
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005147 }
Joe Perchesaad4f612012-03-23 15:02:19 -07005148 if ($seen) {
5149 my $sum_allowed = 0;
5150 foreach (@allowed) {
5151 $sum_allowed += $_;
5152 }
5153 if ($sum_allowed == 0) {
5154 WARN("BRACES",
5155 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5156 } elsif ($sum_allowed != $allow &&
5157 $seen != $allow) {
5158 CHK("BRACES",
5159 "braces {} should be used on all arms of this statement\n" . $herectx);
5160 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005161 }
5162 }
5163 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005164 if (!defined $suppress_ifbraces{$linenr - 1} &&
Andy Whitcroft13214ad2008-02-08 04:22:03 -08005165 $line =~ /\b(if|while|for|else)\b/) {
Andy Whitcroftcf655042008-03-04 14:28:20 -08005166 my $allowed = 0;
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005167
Andy Whitcroftcf655042008-03-04 14:28:20 -08005168 # Check the pre-context.
5169 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5170 #print "APW: ALLOWED: pre<$1>\n";
5171 $allowed = 1;
5172 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07005173
5174 my ($level, $endln, @chunks) =
5175 ctx_statement_full($linenr, $realcnt, $-[0]);
5176
Andy Whitcroftcf655042008-03-04 14:28:20 -08005177 # Check the condition.
5178 my ($cond, $block) = @{$chunks[0]};
Andy Whitcroft773647a2008-03-28 14:15:58 -07005179 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08005180 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07005181 substr($block, 0, length($cond), '');
Andy Whitcroftcf655042008-03-04 14:28:20 -08005182 }
5183 if (statement_lines($cond) > 1) {
5184 #print "APW: ALLOWED: cond<$cond>\n";
5185 $allowed = 1;
5186 }
5187 if ($block =~/\b(?:if|for|while)\b/) {
5188 #print "APW: ALLOWED: block<$block>\n";
5189 $allowed = 1;
5190 }
5191 if (statement_block_size($block) > 1) {
5192 #print "APW: ALLOWED: lines block<$block>\n";
5193 $allowed = 1;
5194 }
5195 # Check the post-context.
5196 if (defined $chunks[1]) {
5197 my ($cond, $block) = @{$chunks[1]};
5198 if (defined $cond) {
Andy Whitcroft773647a2008-03-28 14:15:58 -07005199 substr($block, 0, length($cond), '');
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005200 }
Andy Whitcroftcf655042008-03-04 14:28:20 -08005201 if ($block =~ /^\s*\{/) {
5202 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5203 $allowed = 1;
5204 }
5205 }
5206 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Justin P. Mattock69932482011-07-26 23:06:29 -07005207 my $herectx = $here . "\n";
Andy Whitcroftf0556632008-10-15 22:02:23 -07005208 my $cnt = statement_rawlines($block);
Andy Whitcroftcf655042008-03-04 14:28:20 -08005209
Andy Whitcroftf0556632008-10-15 22:02:23 -07005210 for (my $n = 0; $n < $cnt; $n++) {
Justin P. Mattock69932482011-07-26 23:06:29 -07005211 $herectx .= raw_line($linenr, $n) . "\n";
Andy Whitcroftcf655042008-03-04 14:28:20 -08005212 }
5213
Joe Perches000d1cc12011-07-25 17:13:25 -07005214 WARN("BRACES",
5215 "braces {} are not necessary for single statement blocks\n" . $herectx);
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005216 }
5217 }
5218
Joe Perchese4c5bab2017-02-24 15:01:41 -08005219# check for single line unbalanced braces
Sven Eckelmann95330472017-02-24 15:01:43 -08005220 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5221 $sline =~ /^.\s*else\s*\{\s*$/) {
Joe Perchese4c5bab2017-02-24 15:01:41 -08005222 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5223 }
5224
Joe Perches0979ae62012-12-17 16:01:59 -08005225# check for unnecessary blank lines around braces
Joe Perches77b9a532013-07-03 15:05:29 -07005226 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08005227 if (CHK("BRACES",
5228 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5229 $fix && $prevrawline =~ /^\+/) {
5230 fix_delete_line($fixlinenr - 1, $prevrawline);
5231 }
Joe Perches0979ae62012-12-17 16:01:59 -08005232 }
Joe Perches77b9a532013-07-03 15:05:29 -07005233 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Joe Perchesf8e58212015-02-13 14:38:46 -08005234 if (CHK("BRACES",
5235 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5236 $fix) {
5237 fix_delete_line($fixlinenr, $rawline);
5238 }
Joe Perches0979ae62012-12-17 16:01:59 -08005239 }
5240
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005241# no volatiles please
Andy Whitcroft6c72ffa2007-10-18 03:05:08 -07005242 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5243 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005244 WARN("VOLATILE",
Mauro Carvalho Chehab8c27ceff32016-10-18 10:12:27 -02005245 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005246 }
5247
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005248# Check for user-visible strings broken across lines, which breaks the ability
5249# to grep for the string. Make exceptions when the previous string ends in a
5250# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5251# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Joe Perches33acb542015-06-25 15:02:54 -07005252 if ($line =~ /^\+\s*$String/ &&
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005253 $prevline =~ /"\s*$/ &&
5254 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5255 if (WARN("SPLIT_STRING",
5256 "quoted string split across lines\n" . $hereprev) &&
5257 $fix &&
5258 $prevrawline =~ /^\+.*"\s*$/ &&
5259 $last_coalesced_string_linenr != $linenr - 1) {
5260 my $extracted_string = get_quoted_string($line, $rawline);
5261 my $comma_close = "";
5262 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5263 $comma_close = $1;
5264 }
5265
5266 fix_delete_line($fixlinenr - 1, $prevrawline);
5267 fix_delete_line($fixlinenr, $rawline);
5268 my $fixedline = $prevrawline;
5269 $fixedline =~ s/"\s*$//;
5270 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5271 fix_insert_line($fixlinenr - 1, $fixedline);
5272 $fixedline = $rawline;
5273 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5274 if ($fixedline !~ /\+\s*$/) {
5275 fix_insert_line($fixlinenr, $fixedline);
5276 }
5277 $last_coalesced_string_linenr = $linenr;
5278 }
5279 }
5280
5281# check for missing a space in a string concatenation
5282 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5283 WARN('MISSING_SPACE',
5284 "break quoted strings at a space character\n" . $hereprev);
5285 }
5286
Joe Perchese4b7d302017-05-08 15:55:51 -07005287# check for an embedded function name in a string when the function is known
5288# This does not work very well for -f --file checking as it depends on patch
5289# context providing the function name or a single line form for in-file
5290# function declarations
Joe Perches77cb8542017-02-24 15:01:28 -08005291 if ($line =~ /^\+.*$String/ &&
5292 defined($context_function) &&
Joe Perchese4b7d302017-05-08 15:55:51 -07005293 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5294 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
Joe Perches77cb8542017-02-24 15:01:28 -08005295 WARN("EMBEDDED_FUNCTION_NAME",
Joe Perchese4b7d302017-05-08 15:55:51 -07005296 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
Joe Perches77cb8542017-02-24 15:01:28 -08005297 }
5298
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005299# check for spaces before a quoted newline
5300 if ($rawline =~ /^.*\".*\s\\n/) {
5301 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5302 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5303 $fix) {
5304 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5305 }
5306
5307 }
5308
Joe Perchesf17dba42014-10-13 15:51:51 -07005309# concatenated string without spaces between elements
Joe Perches33acb542015-06-25 15:02:54 -07005310 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
Joe Perchesf17dba42014-10-13 15:51:51 -07005311 CHK("CONCATENATED_STRING",
5312 "Concatenated strings should use spaces between elements\n" . $herecurr);
5313 }
5314
Joe Perches90ad30e2014-12-10 15:51:59 -08005315# uncoalesced string fragments
Joe Perches33acb542015-06-25 15:02:54 -07005316 if ($line =~ /$String\s*"/) {
Joe Perches90ad30e2014-12-10 15:51:59 -08005317 WARN("STRING_FRAGMENTS",
5318 "Consecutive strings are generally better as a single string\n" . $herecurr);
5319 }
5320
Alexey Dobriyan522b8372017-02-27 14:30:05 -08005321# check for non-standard and hex prefixed decimal printf formats
5322 my $show_L = 1; #don't show the same defect twice
5323 my $show_Z = 1;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005324 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
Alexey Dobriyan522b8372017-02-27 14:30:05 -08005325 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005326 $string =~ s/%%/__/g;
Alexey Dobriyan522b8372017-02-27 14:30:05 -08005327 # check for %L
5328 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005329 WARN("PRINTF_L",
Alexey Dobriyan522b8372017-02-27 14:30:05 -08005330 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5331 $show_L = 0;
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005332 }
Alexey Dobriyan522b8372017-02-27 14:30:05 -08005333 # check for %Z
5334 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5335 WARN("PRINTF_Z",
5336 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5337 $show_Z = 0;
5338 }
5339 # check for 0x<decimal>
5340 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5341 ERROR("PRINTF_0XDECIMAL",
Joe Perches6e300752015-09-09 15:37:47 -07005342 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5343 }
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005344 }
5345
5346# check for line continuations in quoted strings with odd counts of "
Joe Perches3f7f3352018-02-06 15:38:52 -08005347 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
Joe Perches5e4f6ba2014-12-10 15:52:05 -08005348 WARN("LINE_CONTINUATIONS",
5349 "Avoid line continuations in quoted strings\n" . $herecurr);
5350 }
5351
Andy Whitcroft00df3442007-06-08 13:47:06 -07005352# warn about #if 0
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005353 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005354 CHK("REDUNDANT_CODE",
5355 "if this code is redundant consider removing it\n" .
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005356 $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005357 }
5358
Andy Whitcroft03df4b52012-12-17 16:01:52 -08005359# check for needless "if (<foo>) fn(<foo>)" uses
5360 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
Joe Perches100425d2015-09-09 15:37:36 -07005361 my $tested = quotemeta($1);
5362 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5363 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5364 my $func = $1;
5365 if (WARN('NEEDLESS_IF',
5366 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5367 $fix) {
5368 my $do_fix = 1;
5369 my $leading_tabs = "";
5370 my $new_leading_tabs = "";
5371 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5372 $leading_tabs = $1;
5373 } else {
5374 $do_fix = 0;
5375 }
5376 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5377 $new_leading_tabs = $1;
5378 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5379 $do_fix = 0;
5380 }
5381 } else {
5382 $do_fix = 0;
5383 }
5384 if ($do_fix) {
5385 fix_delete_line($fixlinenr - 1, $prevrawline);
5386 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5387 }
5388 }
Greg Kroah-Hartman4c432a82008-07-23 21:29:04 -07005389 }
5390 }
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07005391
Joe Perchesebfdc402014-08-06 16:10:27 -07005392# check for unnecessary "Out of Memory" messages
5393 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5394 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5395 (defined $1 || defined $3) &&
5396 $linenr > 3) {
5397 my $testval = $2;
5398 my $testline = $lines[$linenr - 3];
5399
5400 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5401# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5402
Joe Perchesfb0d0e02017-07-10 15:52:04 -07005403 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|kmemdup|(?:dev_)?alloc_skb)/) {
Joe Perchesebfdc402014-08-06 16:10:27 -07005404 WARN("OOM_MESSAGE",
5405 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5406 }
5407 }
5408
Joe Perchesf78d98f2014-10-13 15:52:01 -07005409# check for logging functions with KERN_<LEVEL>
Paolo Bonzinidcaf1122015-02-13 14:38:26 -08005410 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
Joe Perchesf78d98f2014-10-13 15:52:01 -07005411 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5412 my $level = $1;
5413 if (WARN("UNNECESSARY_KERN_LEVEL",
5414 "Possible unnecessary $level\n" . $herecurr) &&
5415 $fix) {
5416 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5417 }
5418 }
5419
Joe Perches45c55e92017-02-24 15:01:31 -08005420# check for logging continuations
5421 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5422 WARN("LOGGING_CONTINUATION",
5423 "Avoid logging continuation uses where feasible\n" . $herecurr);
5424 }
5425
Joe Perchesabb08a52014-12-10 15:51:46 -08005426# check for mask then right shift without a parentheses
5427 if ($^V && $^V ge 5.10.0 &&
5428 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5429 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5430 WARN("MASK_THEN_SHIFT",
5431 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5432 }
5433
Joe Perchesb75ac612014-12-10 15:52:02 -08005434# check for pointer comparisons to NULL
5435 if ($^V && $^V ge 5.10.0) {
5436 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5437 my $val = $1;
5438 my $equal = "!";
5439 $equal = "" if ($4 eq "!=");
5440 if (CHK("COMPARISON_TO_NULL",
5441 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5442 $fix) {
5443 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5444 }
5445 }
5446 }
5447
Joe Perches8716de32013-09-11 14:24:05 -07005448# check for bad placement of section $InitAttribute (e.g.: __initdata)
5449 if ($line =~ /(\b$InitAttribute\b)/) {
5450 my $attr = $1;
5451 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5452 my $ptr = $1;
5453 my $var = $2;
5454 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5455 ERROR("MISPLACED_INIT",
5456 "$attr should be placed after $var\n" . $herecurr)) ||
5457 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5458 WARN("MISPLACED_INIT",
5459 "$attr should be placed after $var\n" . $herecurr))) &&
5460 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005461 $fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
Joe Perches8716de32013-09-11 14:24:05 -07005462 }
5463 }
5464 }
5465
Joe Perchese970b8842013-11-12 15:10:10 -08005466# check for $InitAttributeData (ie: __initdata) with const
5467 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5468 my $attr = $1;
5469 $attr =~ /($InitAttributePrefix)(.*)/;
5470 my $attr_prefix = $1;
5471 my $attr_type = $2;
5472 if (ERROR("INIT_ATTRIBUTE",
5473 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5474 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005475 $fixed[$fixlinenr] =~
Joe Perchese970b8842013-11-12 15:10:10 -08005476 s/$InitAttributeData/${attr_prefix}initconst/;
5477 }
5478 }
5479
5480# check for $InitAttributeConst (ie: __initconst) without const
5481 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5482 my $attr = $1;
5483 if (ERROR("INIT_ATTRIBUTE",
5484 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5485 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005486 my $lead = $fixed[$fixlinenr] =~
Joe Perchese970b8842013-11-12 15:10:10 -08005487 /(^\+\s*(?:static\s+))/;
5488 $lead = rtrim($1);
5489 $lead = "$lead " if ($lead !~ /^\+$/);
5490 $lead = "${lead}const ";
Joe Perches194f66f2014-08-06 16:11:03 -07005491 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
Joe Perchese970b8842013-11-12 15:10:10 -08005492 }
5493 }
5494
Joe Perchesc17893c2015-04-16 12:44:42 -07005495# check for __read_mostly with const non-pointer (should just be const)
5496 if ($line =~ /\b__read_mostly\b/ &&
5497 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5498 if (ERROR("CONST_READ_MOSTLY",
5499 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5500 $fix) {
5501 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5502 }
5503 }
5504
Joe Perchesfbdb8132014-04-03 14:49:14 -07005505# don't use __constant_<foo> functions outside of include/uapi/
5506 if ($realfile !~ m@^include/uapi/@ &&
5507 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5508 my $constant_func = $1;
5509 my $func = $constant_func;
5510 $func =~ s/^__constant_//;
5511 if (WARN("CONSTANT_CONVERSION",
5512 "$constant_func should be $func\n" . $herecurr) &&
5513 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005514 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
Joe Perchesfbdb8132014-04-03 14:49:14 -07005515 }
5516 }
5517
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005518# prefer usleep_range over udelay
Bruce Allan37581c22013-02-21 16:44:19 -08005519 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Perches43c1d772014-04-03 14:49:11 -07005520 my $delay = $1;
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005521 # ignore udelay's < 10, however
Joe Perches43c1d772014-04-03 14:49:11 -07005522 if (! ($delay < 10) ) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005523 CHK("USLEEP_RANGE",
Joe Perches43c1d772014-04-03 14:49:11 -07005524 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5525 }
5526 if ($delay > 2000) {
5527 WARN("LONG_UDELAY",
5528 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
Patrick Pannuto1a15a252010-08-09 17:21:01 -07005529 }
5530 }
5531
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005532# warn about unexpectedly long msleep's
5533 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5534 if ($1 < 20) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005535 WARN("MSLEEP",
Joe Perches43c1d772014-04-03 14:49:11 -07005536 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
Patrick Pannuto09ef8722010-08-09 17:21:02 -07005537 }
5538 }
5539
Joe Perches36ec1932013-07-03 15:05:25 -07005540# check for comparisons of jiffies
5541 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5542 WARN("JIFFIES_COMPARISON",
5543 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5544 }
5545
Joe Perches9d7a34a2013-07-03 15:05:26 -07005546# check for comparisons of get_jiffies_64()
5547 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5548 WARN("JIFFIES_COMPARISON",
5549 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5550 }
5551
Andy Whitcroft00df3442007-06-08 13:47:06 -07005552# warn about #ifdefs in C files
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005553# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
Andy Whitcroft00df3442007-06-08 13:47:06 -07005554# print "#ifdef in C files should be avoided\n";
5555# print "$herecurr";
5556# $clean = 0;
5557# }
5558
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005559# warn about spacing in #ifdefs
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005560 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Joe Perches3705ce52013-07-03 15:05:31 -07005561 if (ERROR("SPACING",
5562 "exactly one space required after that #$1\n" . $herecurr) &&
5563 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005564 $fixed[$fixlinenr] =~
Joe Perches3705ce52013-07-03 15:05:31 -07005565 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5566 }
5567
Andy Whitcroft22f2a2e2007-08-10 13:01:03 -07005568 }
5569
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005570# check for spinlock_t definitions without a comment.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005571 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5572 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005573 my $which = $1;
5574 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005575 CHK("UNCOMMENTED_DEFINITION",
5576 "$1 definition without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005577 }
5578 }
5579# check for memory barriers without a comment.
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005580
5581 my $barriers = qr{
5582 mb|
5583 rmb|
5584 wmb|
5585 read_barrier_depends
5586 }x;
5587 my $barrier_stems = qr{
5588 mb__before_atomic|
5589 mb__after_atomic|
5590 store_release|
5591 load_acquire|
5592 store_mb|
5593 (?:$barriers)
5594 }x;
5595 my $all_barriers = qr{
5596 (?:$barriers)|
Michael S. Tsirkin43e361f2016-01-04 10:00:10 +02005597 smp_(?:$barrier_stems)|
5598 virt_(?:$barrier_stems)
Michael S. Tsirkin402c2552016-01-04 09:39:01 +02005599 }x;
5600
5601 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005602 if (!ctx_has_comment($first_line, $linenr)) {
Joe Perchesc1fd7bb2013-11-12 15:10:11 -08005603 WARN("MEMORY_BARRIER",
5604 "memory barrier without comment\n" . $herecurr);
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005605 }
5606 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005607
Michael S. Tsirkinf4073b02016-01-04 09:54:51 +02005608 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5609
5610 if ($realfile !~ m@^include/asm-generic/@ &&
5611 $realfile !~ m@/barrier\.h$@ &&
5612 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5613 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5614 WARN("MEMORY_BARRIER",
5615 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5616 }
5617
Joe Perchescb426e92015-06-25 15:02:46 -07005618# check for waitqueue_active without a comment.
5619 if ($line =~ /\bwaitqueue_active\s*\(/) {
5620 if (!ctx_has_comment($first_line, $linenr)) {
5621 WARN("WAITQUEUE_ACTIVE",
5622 "waitqueue_active without comment\n" . $herecurr);
5623 }
5624 }
Paul E. McKenney3ad81772015-07-02 11:55:40 -07005625
Paul E. McKenney91db2592017-11-27 09:37:35 -08005626# check for smp_read_barrier_depends and read_barrier_depends
5627 if (!$file && $line =~ /\b(smp_|)read_barrier_depends\s*\(/) {
5628 WARN("READ_BARRIER_DEPENDS",
5629 "$1read_barrier_depends should only be used in READ_ONCE or DEC Alpha code\n" . $herecurr);
5630 }
5631
Andy Whitcroft4a0df2e2007-06-08 13:46:39 -07005632# check of hardware specific defines
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005633 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005634 CHK("ARCH_DEFINES",
5635 "architecture specific defines should be avoided\n" . $herecurr);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07005636 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07005637
Joe Perches596ed452017-07-12 14:37:02 -07005638# check that the storage class is not after a type
5639 if ($line =~ /\b($Type)\s+($Storage)\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005640 WARN("STORAGE_CLASS",
Joe Perches596ed452017-07-12 14:37:02 -07005641 "storage class '$2' should be located before type '$1'\n" . $herecurr);
5642 }
5643# Check that the storage class is at the beginning of a declaration
5644 if ($line =~ /\b$Storage\b/ &&
5645 $line !~ /^.\s*$Storage/ &&
5646 $line =~ /^.\s*(.+?)\$Storage\s/ &&
5647 $1 !~ /[\,\)]\s*$/) {
5648 WARN("STORAGE_CLASS",
5649 "storage class should be at the beginning of the declaration\n" . $herecurr);
Tobias Klauserd4977c72010-05-24 14:33:30 -07005650 }
5651
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005652# check the location of the inline attribute, that it is between
5653# storage class and type.
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07005654 if ($line =~ /\b$Type\s+$Inline\b/ ||
5655 $line =~ /\b$Inline\s+$Storage\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005656 ERROR("INLINE_LOCATION",
5657 "inline keyword should sit between storage class and type\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005658 }
5659
Andy Whitcroft8905a672007-11-28 16:21:06 -08005660# Check for __inline__ and __inline, prefer inline
Joe Perches2b7ab452013-11-12 15:10:14 -08005661 if ($realfile !~ m@\binclude/uapi/@ &&
5662 $line =~ /\b(__inline__|__inline)\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005663 if (WARN("INLINE",
5664 "plain inline is preferred over $1\n" . $herecurr) &&
5665 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005666 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005667
5668 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08005669 }
5670
Joe Perches3d130fd2011-01-12 17:00:00 -08005671# Check for __attribute__ packed, prefer __packed
Joe Perches2b7ab452013-11-12 15:10:14 -08005672 if ($realfile !~ m@\binclude/uapi/@ &&
5673 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005674 WARN("PREFER_PACKED",
5675 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
Joe Perches3d130fd2011-01-12 17:00:00 -08005676 }
5677
Joe Perches39b7e282011-07-25 17:13:24 -07005678# Check for __attribute__ aligned, prefer __aligned
Joe Perches2b7ab452013-11-12 15:10:14 -08005679 if ($realfile !~ m@\binclude/uapi/@ &&
5680 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005681 WARN("PREFER_ALIGNED",
5682 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
Joe Perches39b7e282011-07-25 17:13:24 -07005683 }
5684
Joe Perches5f14d3b2012-01-10 15:09:52 -08005685# Check for __attribute__ format(printf, prefer __printf
Joe Perches2b7ab452013-11-12 15:10:14 -08005686 if ($realfile !~ m@\binclude/uapi/@ &&
5687 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005688 if (WARN("PREFER_PRINTF",
5689 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5690 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005691 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005692
5693 }
Joe Perches5f14d3b2012-01-10 15:09:52 -08005694 }
5695
Joe Perches6061d942012-03-23 15:02:16 -07005696# Check for __attribute__ format(scanf, prefer __scanf
Joe Perches2b7ab452013-11-12 15:10:14 -08005697 if ($realfile !~ m@\binclude/uapi/@ &&
5698 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005699 if (WARN("PREFER_SCANF",
5700 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5701 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005702 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005703 }
Joe Perches6061d942012-03-23 15:02:16 -07005704 }
5705
Joe Perches619a9082014-12-10 15:51:35 -08005706# Check for __attribute__ weak, or __weak declarations (may have link issues)
5707 if ($^V && $^V ge 5.10.0 &&
5708 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5709 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5710 $line =~ /\b__weak\b/)) {
5711 ERROR("WEAK_DECLARATION",
5712 "Using weak declarations can have unintended link defects\n" . $herecurr);
5713 }
5714
Tomas Winklerfd39f902016-12-12 16:46:34 -08005715# check for c99 types like uint8_t used outside of uapi/ and tools/
Joe Perchese6176fa2015-06-25 15:02:49 -07005716 if ($realfile !~ m@\binclude/uapi/@ &&
Tomas Winklerfd39f902016-12-12 16:46:34 -08005717 $realfile !~ m@\btools/@ &&
Joe Perchese6176fa2015-06-25 15:02:49 -07005718 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5719 my $type = $1;
5720 if ($type =~ /\b($typeC99Typedefs)\b/) {
5721 $type = $1;
5722 my $kernel_type = 'u';
5723 $kernel_type = 's' if ($type =~ /^_*[si]/);
5724 $type =~ /(\d+)/;
5725 $kernel_type .= $1;
5726 if (CHK("PREFER_KERNEL_TYPES",
5727 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5728 $fix) {
5729 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5730 }
5731 }
5732 }
5733
Joe Perches938224b2016-01-20 14:59:15 -08005734# check for cast of C90 native int or longer types constants
5735 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5736 my $cast = $1;
5737 my $const = $2;
5738 if (WARN("TYPECAST_INT_CONSTANT",
5739 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5740 $fix) {
5741 my $suffix = "";
5742 my $newconst = $const;
5743 $newconst =~ s/${Int_type}$//;
5744 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5745 if ($cast =~ /\blong\s+long\b/) {
5746 $suffix .= 'LL';
5747 } elsif ($cast =~ /\blong\b/) {
5748 $suffix .= 'L';
5749 }
5750 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5751 }
5752 }
5753
Joe Perches8f53a9b2010-03-05 13:43:48 -08005754# check for sizeof(&)
5755 if ($line =~ /\bsizeof\s*\(\s*\&/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005756 WARN("SIZEOF_ADDRESS",
5757 "sizeof(& should be avoided\n" . $herecurr);
Joe Perches8f53a9b2010-03-05 13:43:48 -08005758 }
5759
Joe Perches66c80b62012-07-30 14:41:22 -07005760# check for sizeof without parenthesis
5761 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005762 if (WARN("SIZEOF_PARENTHESIS",
5763 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5764 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005765 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005766 }
Joe Perches66c80b62012-07-30 14:41:22 -07005767 }
5768
Joe Perches88982fe2012-12-17 16:02:00 -08005769# check for struct spinlock declarations
5770 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5771 WARN("USE_SPINLOCK_T",
5772 "struct spinlock should be spinlock_t\n" . $herecurr);
5773 }
5774
Joe Perchesa6962d72013-04-29 16:18:13 -07005775# check for seq_printf uses that could be seq_puts
Joe Perches06668722013-11-12 15:10:07 -08005776 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
Joe Perchesa6962d72013-04-29 16:18:13 -07005777 my $fmt = get_quoted_string($line, $rawline);
Heba Aamercaac1d52015-02-13 14:38:49 -08005778 $fmt =~ s/%%//g;
5779 if ($fmt !~ /%/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07005780 if (WARN("PREFER_SEQ_PUTS",
5781 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5782 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005783 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
Joe Perchesd5e616f2013-09-11 14:23:54 -07005784 }
Joe Perchesa6962d72013-04-29 16:18:13 -07005785 }
5786 }
5787
Joe Perches0b523762017-05-08 15:55:36 -07005788 # check for vsprintf extension %p<foo> misuses
5789 if ($^V && $^V ge 5.10.0 &&
5790 defined $stat &&
5791 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5792 $1 !~ /^_*volatile_*$/) {
5793 my $bad_extension = "";
5794 my $lc = $stat =~ tr@\n@@;
5795 $lc = $lc + $linenr;
5796 for (my $count = $linenr; $count <= $lc; $count++) {
5797 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5798 $fmt =~ s/%%//g;
Linus Torvaldsab486bc2018-02-01 13:36:15 -08005799 if ($fmt =~ /(\%[\*\d\.]*p(?![\WSsBKRraEhMmIiUDdgVCbGNOx]).)/) {
Joe Perches0b523762017-05-08 15:55:36 -07005800 $bad_extension = $1;
5801 last;
5802 }
5803 }
5804 if ($bad_extension ne "") {
5805 my $stat_real = raw_line($linenr, 0);
Sergey Senozhatsky1df73382017-11-10 08:48:30 +09005806 my $ext_type = "Invalid";
5807 my $use = "";
Joe Perches0b523762017-05-08 15:55:36 -07005808 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5809 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5810 }
Sergey Senozhatsky1df73382017-11-10 08:48:30 +09005811 if ($bad_extension =~ /p[Ff]/) {
5812 $ext_type = "Deprecated";
5813 $use = " - use %pS instead";
5814 $use =~ s/pS/ps/ if ($bad_extension =~ /pf/);
5815 }
Joe Perches0b523762017-05-08 15:55:36 -07005816 WARN("VSPRINTF_POINTER_EXTENSION",
Sergey Senozhatsky1df73382017-11-10 08:48:30 +09005817 "$ext_type vsprintf pointer extension '$bad_extension'$use\n" . "$here\n$stat_real\n");
Joe Perches0b523762017-05-08 15:55:36 -07005818 }
5819 }
5820
Andy Whitcroft554e1652012-01-10 15:09:57 -08005821# Check for misused memsets
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005822 if ($^V && $^V ge 5.10.0 &&
5823 defined $stat &&
Mateusz Kulikowski9e20a852015-06-25 15:03:16 -07005824 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
Andy Whitcroft554e1652012-01-10 15:09:57 -08005825
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005826 my $ms_addr = $2;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005827 my $ms_val = $7;
5828 my $ms_size = $12;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005829
Andy Whitcroft554e1652012-01-10 15:09:57 -08005830 if ($ms_size =~ /^(0x|)0$/i) {
5831 ERROR("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005832 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005833 } elsif ($ms_size =~ /^(0x|)1$/i) {
5834 WARN("MEMSET",
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005835 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5836 }
5837 }
5838
Joe Perches98a9bba2014-01-23 15:54:52 -08005839# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
Joe Perchesf3331952016-10-11 13:51:53 -07005840# if ($^V && $^V ge 5.10.0 &&
5841# defined $stat &&
5842# $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5843# if (WARN("PREFER_ETHER_ADDR_COPY",
5844# "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5845# $fix) {
5846# $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5847# }
5848# }
Joe Perches98a9bba2014-01-23 15:54:52 -08005849
Mateusz Kulikowskib6117d12015-06-25 15:03:13 -07005850# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
Joe Perchesf3331952016-10-11 13:51:53 -07005851# if ($^V && $^V ge 5.10.0 &&
5852# defined $stat &&
5853# $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5854# WARN("PREFER_ETHER_ADDR_EQUAL",
5855# "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5856# }
Mateusz Kulikowskib6117d12015-06-25 15:03:13 -07005857
Mateusz Kulikowski8617cd02015-06-25 15:03:19 -07005858# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5859# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
Joe Perchesf3331952016-10-11 13:51:53 -07005860# if ($^V && $^V ge 5.10.0 &&
5861# defined $stat &&
5862# $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5863#
5864# my $ms_val = $7;
5865#
5866# if ($ms_val =~ /^(?:0x|)0+$/i) {
5867# if (WARN("PREFER_ETH_ZERO_ADDR",
5868# "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5869# $fix) {
5870# $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5871# }
5872# } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5873# if (WARN("PREFER_ETH_BROADCAST_ADDR",
5874# "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5875# $fix) {
5876# $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5877# }
5878# }
5879# }
Mateusz Kulikowski8617cd02015-06-25 15:03:19 -07005880
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005881# typecasts on min/max could be min_t/max_t
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005882 if ($^V && $^V ge 5.10.0 &&
5883 defined $stat &&
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005884 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005885 if (defined $2 || defined $7) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005886 my $call = $1;
5887 my $cast1 = deparenthesize($2);
5888 my $arg1 = $3;
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005889 my $cast2 = deparenthesize($7);
5890 my $arg2 = $8;
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005891 my $cast;
5892
Joe Perchesd1fe9c02012-03-23 15:02:16 -07005893 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
Joe Perchesd7c76ba2012-01-10 15:09:58 -08005894 $cast = "$cast1 or $cast2";
5895 } elsif ($cast1 ne "") {
5896 $cast = $cast1;
5897 } else {
5898 $cast = $cast2;
5899 }
5900 WARN("MINMAX",
5901 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
Andy Whitcroft554e1652012-01-10 15:09:57 -08005902 }
5903 }
5904
Joe Perches4a273192012-07-30 14:41:20 -07005905# check usleep_range arguments
5906 if ($^V && $^V ge 5.10.0 &&
5907 defined $stat &&
5908 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5909 my $min = $1;
5910 my $max = $7;
5911 if ($min eq $max) {
5912 WARN("USLEEP_RANGE",
5913 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5914 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5915 $min > $max) {
5916 WARN("USLEEP_RANGE",
5917 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5918 }
5919 }
5920
Joe Perches823b7942013-11-12 15:10:15 -08005921# check for naked sscanf
5922 if ($^V && $^V ge 5.10.0 &&
5923 defined $stat &&
Joe Perches6c8bd702014-04-03 14:49:16 -07005924 $line =~ /\bsscanf\b/ &&
Joe Perches823b7942013-11-12 15:10:15 -08005925 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5926 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5927 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5928 my $lc = $stat =~ tr@\n@@;
5929 $lc = $lc + $linenr;
5930 my $stat_real = raw_line($linenr, 0);
5931 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5932 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5933 }
5934 WARN("NAKED_SSCANF",
5935 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5936 }
5937
Joe Perchesafc819a2014-06-04 16:12:08 -07005938# check for simple sscanf that should be kstrto<foo>
5939 if ($^V && $^V ge 5.10.0 &&
5940 defined $stat &&
5941 $line =~ /\bsscanf\b/) {
5942 my $lc = $stat =~ tr@\n@@;
5943 $lc = $lc + $linenr;
5944 my $stat_real = raw_line($linenr, 0);
5945 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5946 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5947 }
5948 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5949 my $format = $6;
5950 my $count = $format =~ tr@%@%@;
5951 if ($count == 1 &&
5952 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5953 WARN("SSCANF_TO_KSTRTO",
5954 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5955 }
5956 }
5957 }
5958
Joe Perches70dc8a42013-09-11 14:23:58 -07005959# check for new externs in .h files.
5960 if ($realfile =~ /\.h$/ &&
5961 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
Joe Perchesd1d85782013-09-24 15:27:46 -07005962 if (CHK("AVOID_EXTERNS",
5963 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
Joe Perches70dc8a42013-09-11 14:23:58 -07005964 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07005965 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
Joe Perches70dc8a42013-09-11 14:23:58 -07005966 }
5967 }
5968
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005969# check for new externs in .c files.
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005970 if ($realfile =~ /\.c$/ && defined $stat &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005971 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005972 {
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005973 my $function_name = $1;
5974 my $paren_space = $2;
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005975
5976 my $s = $stat;
5977 if (defined $cond) {
5978 substr($s, 0, length($cond), '');
5979 }
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07005980 if ($s =~ /^\s*;/ &&
5981 $function_name ne 'uninitialized_var')
5982 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005983 WARN("AVOID_EXTERNS",
5984 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005985 }
5986
5987 if ($paren_space =~ /\n/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07005988 WARN("FUNCTION_ARGUMENTS",
5989 "arguments for function declarations should follow identifier\n" . $herecurr);
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07005990 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07005991
5992 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5993 $stat =~ /^.\s*extern\s+/)
5994 {
Joe Perches000d1cc12011-07-25 17:13:25 -07005995 WARN("AVOID_EXTERNS",
5996 "externs should be avoided in .c files\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07005997 }
5998
Joe Perchesa0ad7592017-07-10 15:52:19 -07005999# check for function declarations that have arguments without identifier names
6000 if (defined $stat &&
Miles Chen25bdda22017-11-17 15:28:34 -08006001 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
Joe Perchesca0d8922016-10-11 13:52:16 -07006002 $1 ne "void") {
6003 my $args = trim($1);
6004 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6005 my $arg = trim($1);
6006 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6007 WARN("FUNCTION_ARGUMENTS",
6008 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6009 }
6010 }
6011 }
6012
Joe Perchesa0ad7592017-07-10 15:52:19 -07006013# check for function definitions
6014 if ($^V && $^V ge 5.10.0 &&
6015 defined $stat &&
6016 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6017 $context_function = $1;
6018
6019# check for multiline function definition with misplaced open brace
6020 my $ok = 0;
6021 my $cnt = statement_rawlines($stat);
6022 my $herectx = $here . "\n";
6023 for (my $n = 0; $n < $cnt; $n++) {
6024 my $rl = raw_line($linenr, $n);
6025 $herectx .= $rl . "\n";
6026 $ok = 1 if ($rl =~ /^[ \+]\{/);
6027 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6028 last if $rl =~ /^[ \+].*\{/;
6029 }
6030 if (!$ok) {
6031 ERROR("OPEN_BRACE",
6032 "open brace '{' following function definitions go on the next line\n" . $herectx);
6033 }
6034 }
6035
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07006036# checks for new __setup's
6037 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6038 my $name = $1;
6039
6040 if (!grep(/$name/, @setup_docs)) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006041 CHK("UNDOCUMENTED_SETUP",
Mauro Carvalho Chehab8c27ceff32016-10-18 10:12:27 -02006042 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
Andy Whitcroftde7d4f02007-07-15 23:37:22 -07006043 }
Andy Whitcroft653d4872007-06-23 17:16:34 -07006044 }
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07006045
6046# check for pointless casting of kmalloc return
Joe Perchescaf2a542011-01-12 16:59:56 -08006047 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006048 WARN("UNNECESSARY_CASTS",
6049 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
Andy Whitcroft9c0ca6f2007-10-16 23:29:38 -07006050 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08006051
Joe Perchesa640d252013-07-03 15:05:21 -07006052# alloc style
6053# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6054 if ($^V && $^V ge 5.10.0 &&
6055 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6056 CHK("ALLOC_SIZEOF_STRUCT",
6057 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6058 }
6059
Joe Perches60a55362014-06-04 16:12:07 -07006060# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6061 if ($^V && $^V ge 5.10.0 &&
Joe Perches1b4a2ed2017-05-08 15:55:57 -07006062 defined $stat &&
6063 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
Joe Perches60a55362014-06-04 16:12:07 -07006064 my $oldfunc = $3;
6065 my $a1 = $4;
6066 my $a2 = $10;
6067 my $newfunc = "kmalloc_array";
6068 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
Joe Perchese3674552014-08-06 16:10:55 -07006069 my $r1 = $a1;
6070 my $r2 = $a2;
6071 if ($a1 =~ /^sizeof\s*\S/) {
6072 $r1 = $a2;
6073 $r2 = $a1;
6074 }
6075 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6076 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
Joe Perches1b4a2ed2017-05-08 15:55:57 -07006077 my $ctx = '';
6078 my $herectx = $here . "\n";
6079 my $cnt = statement_rawlines($stat);
6080 for (my $n = 0; $n < $cnt; $n++) {
6081 $herectx .= raw_line($linenr, $n) . "\n";
6082 }
Joe Perches60a55362014-06-04 16:12:07 -07006083 if (WARN("ALLOC_WITH_MULTIPLY",
Joe Perches1b4a2ed2017-05-08 15:55:57 -07006084 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6085 $cnt == 1 &&
Joe Perches60a55362014-06-04 16:12:07 -07006086 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07006087 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
Joe Perches60a55362014-06-04 16:12:07 -07006088 }
6089 }
6090 }
6091
Joe Perches972fdea2013-04-29 16:18:12 -07006092# check for krealloc arg reuse
6093 if ($^V && $^V ge 5.10.0 &&
6094 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6095 WARN("KREALLOC_ARG_REUSE",
6096 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6097 }
6098
Joe Perches5ce59ae2013-02-21 16:44:18 -08006099# check for alloc argument mismatch
6100 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6101 WARN("ALLOC_ARRAY_ARGS",
6102 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6103 }
6104
Joe Perchescaf2a542011-01-12 16:59:56 -08006105# check for multiple semicolons
6106 if ($line =~ /;\s*;\s*$/) {
Joe Perchesd5e616f2013-09-11 14:23:54 -07006107 if (WARN("ONE_SEMICOLON",
6108 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6109 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07006110 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07006111 }
Joe Perchesd1e2ad02012-12-17 16:02:01 -08006112 }
6113
Tomas Winklercec3aaa2016-08-02 14:04:39 -07006114# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6115 if ($realfile !~ m@^include/uapi/@ &&
6116 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
Joe Perches0ab90192014-12-10 15:51:57 -08006117 my $ull = "";
6118 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6119 if (CHK("BIT_MACRO",
6120 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6121 $fix) {
6122 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6123 }
6124 }
6125
Joe Perches2d632742016-05-20 17:04:00 -07006126# check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6127 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6128 my $config = $1;
6129 if (WARN("PREFER_IS_ENABLED",
6130 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6131 $fix) {
6132 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6133 }
6134 }
6135
Joe Perchese81f2392014-08-06 16:11:25 -07006136# check for case / default statements not preceded by break/fallthrough/switch
Joe Perchesc34c09a2014-01-23 15:54:43 -08006137 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6138 my $has_break = 0;
6139 my $has_statement = 0;
6140 my $count = 0;
6141 my $prevline = $linenr;
Joe Perchese81f2392014-08-06 16:11:25 -07006142 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
Joe Perchesc34c09a2014-01-23 15:54:43 -08006143 $prevline--;
6144 my $rline = $rawlines[$prevline - 1];
6145 my $fline = $lines[$prevline - 1];
6146 last if ($fline =~ /^\@\@/);
6147 next if ($fline =~ /^\-/);
6148 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6149 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6150 next if ($fline =~ /^.[\s$;]*$/);
6151 $has_statement = 1;
6152 $count++;
Heinrich Schuchardt258f79d2017-11-17 15:28:38 -08006153 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|exit\s*\(\b|return\b|goto\b|continue\b)/);
Joe Perchesc34c09a2014-01-23 15:54:43 -08006154 }
6155 if (!$has_break && $has_statement) {
6156 WARN("MISSING_BREAK",
Andrew Morton224236d2016-12-12 16:46:26 -08006157 "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
Joe Perchesc34c09a2014-01-23 15:54:43 -08006158 }
6159 }
6160
Joe Perchesd1e2ad02012-12-17 16:02:01 -08006161# check for switch/default statements without a break;
6162 if ($^V && $^V ge 5.10.0 &&
6163 defined $stat &&
6164 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6165 my $ctx = '';
6166 my $herectx = $here . "\n";
6167 my $cnt = statement_rawlines($stat);
6168 for (my $n = 0; $n < $cnt; $n++) {
6169 $herectx .= raw_line($linenr, $n) . "\n";
6170 }
6171 WARN("DEFAULT_NO_BREAK",
6172 "switch default: should use break\n" . $herectx);
Joe Perchescaf2a542011-01-12 16:59:56 -08006173 }
6174
Andy Whitcroft13214ad2008-02-08 04:22:03 -08006175# check for gcc specific __FUNCTION__
Joe Perchesd5e616f2013-09-11 14:23:54 -07006176 if ($line =~ /\b__FUNCTION__\b/) {
6177 if (WARN("USE_FUNC",
6178 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6179 $fix) {
Joe Perches194f66f2014-08-06 16:11:03 -07006180 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
Joe Perchesd5e616f2013-09-11 14:23:54 -07006181 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08006182 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07006183
Joe Perches62ec8182015-02-13 14:38:18 -08006184# check for uses of __DATE__, __TIME__, __TIMESTAMP__
6185 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6186 ERROR("DATE_TIME",
6187 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6188 }
6189
Joe Perches2c924882012-03-23 15:02:20 -07006190# check for use of yield()
6191 if ($line =~ /\byield\s*\(\s*\)/) {
6192 WARN("YIELD",
6193 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6194 }
6195
Joe Perches179f8f42013-07-03 15:05:30 -07006196# check for comparisons against true and false
6197 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6198 my $lead = $1;
6199 my $arg = $2;
6200 my $test = $3;
6201 my $otype = $4;
6202 my $trail = $5;
6203 my $op = "!";
6204
6205 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6206
6207 my $type = lc($otype);
6208 if ($type =~ /^(?:true|false)$/) {
6209 if (("$test" eq "==" && "$type" eq "true") ||
6210 ("$test" eq "!=" && "$type" eq "false")) {
6211 $op = "";
6212 }
6213
6214 CHK("BOOL_COMPARISON",
6215 "Using comparison to $otype is error prone\n" . $herecurr);
6216
6217## maybe suggesting a correct construct would better
6218## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6219
6220 }
6221 }
6222
Thomas Gleixner4882720b2010-09-07 14:34:01 +00006223# check for semaphores initialized locked
6224 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006225 WARN("CONSIDER_COMPLETION",
6226 "consider using a completion\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07006227 }
Joe Perches6712d852012-03-23 15:02:20 -07006228
Joe Perches67d0a072011-10-31 17:13:10 -07006229# recommend kstrto* over simple_strto* and strict_strto*
6230 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006231 WARN("CONSIDER_KSTRTO",
Joe Perches67d0a072011-10-31 17:13:10 -07006232 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07006233 }
Joe Perches6712d852012-03-23 15:02:20 -07006234
Fabian Frederickae3ccc42014-06-04 16:12:10 -07006235# check for __initcall(), use device_initcall() explicitly or more appropriate function please
Michael Ellermanf3db6632008-07-23 21:28:57 -07006236 if ($line =~ /^.\s*__initcall\s*\(/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006237 WARN("USE_DEVICE_INITCALL",
Fabian Frederickae3ccc42014-06-04 16:12:10 -07006238 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
Michael Ellermanf3db6632008-07-23 21:28:57 -07006239 }
Joe Perches6712d852012-03-23 15:02:20 -07006240
Joe Perches0f3c5aa2015-02-13 14:39:05 -08006241# check for various structs that are normally const (ops, kgdb, device_tree)
Joe Perchesd9190e42017-05-08 15:55:45 -07006242# and avoid what seem like struct definitions 'struct foo {'
Andy Whitcroft6903ffb2009-01-15 13:51:07 -08006243 if ($line !~ /\bconst\b/ &&
Joe Perchesd9190e42017-05-08 15:55:45 -07006244 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006245 WARN("CONST_STRUCT",
Joe Perchesd9190e42017-05-08 15:55:45 -07006246 "struct $1 should normally be const\n" . $herecurr);
Andy Whitcroft2b6db5c2009-01-06 14:41:29 -08006247 }
Andy Whitcroft773647a2008-03-28 14:15:58 -07006248
6249# use of NR_CPUS is usually wrong
6250# ignore definitions of NR_CPUS and usage to define arrays as likely right
6251 if ($line =~ /\bNR_CPUS\b/ &&
Andy Whitcroftc45dcab2008-06-05 22:46:01 -07006252 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6253 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
Andy Whitcroft171ae1a2008-04-29 00:59:32 -07006254 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6255 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6256 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
Andy Whitcroft773647a2008-03-28 14:15:58 -07006257 {
Joe Perches000d1cc12011-07-25 17:13:25 -07006258 WARN("NR_CPUS",
6259 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
Andy Whitcroft773647a2008-03-28 14:15:58 -07006260 }
Andy Whitcroft9c9ba342008-04-29 00:59:33 -07006261
Joe Perches52ea8502013-11-12 15:10:09 -08006262# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6263 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6264 ERROR("DEFINE_ARCH_HAS",
6265 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6266 }
6267
Joe Perchesacd93622015-02-13 14:38:38 -08006268# likely/unlikely comparisons similar to "(likely(foo) > 0)"
6269 if ($^V && $^V ge 5.10.0 &&
6270 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6271 WARN("LIKELY_MISUSE",
6272 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6273 }
6274
Andy Whitcroft691d77b2009-01-06 14:41:16 -08006275# whine mightly about in_atomic
6276 if ($line =~ /\bin_atomic\s*\(/) {
6277 if ($realfile =~ m@^drivers/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006278 ERROR("IN_ATOMIC",
6279 "do not use in_atomic in drivers\n" . $herecurr);
Andy Whitcroftf4a87732009-02-27 14:03:05 -08006280 } elsif ($realfile !~ m@^kernel/@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006281 WARN("IN_ATOMIC",
6282 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
Andy Whitcroft691d77b2009-01-06 14:41:16 -08006283 }
6284 }
Peter Zijlstra1704f472010-03-19 01:37:42 +01006285
Peter Zijlstra0f5225b2016-10-07 17:43:51 +02006286# check for mutex_trylock_recursive usage
6287 if ($line =~ /mutex_trylock_recursive/) {
6288 ERROR("LOCKING",
6289 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6290 }
6291
Peter Zijlstra1704f472010-03-19 01:37:42 +01006292# check for lockdep_set_novalidate_class
6293 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6294 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6295 if ($realfile !~ m@^kernel/lockdep@ &&
6296 $realfile !~ m@^include/linux/lockdep@ &&
6297 $realfile !~ m@^drivers/base/core@) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006298 ERROR("LOCKDEP",
6299 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
Peter Zijlstra1704f472010-03-19 01:37:42 +01006300 }
6301 }
Dave Jones88f88312011-01-12 16:59:59 -08006302
Joe Perchesb392c642015-04-16 12:44:16 -07006303 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6304 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006305 WARN("EXPORTED_WORLD_WRITABLE",
6306 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
Dave Jones88f88312011-01-12 16:59:59 -08006307 }
Joe Perches24358802014-04-03 14:49:13 -07006308
Joe Perches00180462018-02-06 15:38:55 -08006309# check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
6310# and whether or not function naming is typical and if
6311# DEVICE_ATTR permissions uses are unusual too
6312 if ($^V && $^V ge 5.10.0 &&
6313 defined $stat &&
6314 $stat =~ /\bDEVICE_ATTR\s*\(\s*(\w+)\s*,\s*\(?\s*(\s*(?:${multi_mode_perms_string_search}|0[0-7]{3,3})\s*)\s*\)?\s*,\s*(\w+)\s*,\s*(\w+)\s*\)/) {
6315 my $var = $1;
6316 my $perms = $2;
6317 my $show = $3;
6318 my $store = $4;
6319 my $octal_perms = perms_to_octal($perms);
6320 if ($show =~ /^${var}_show$/ &&
6321 $store =~ /^${var}_store$/ &&
6322 $octal_perms eq "0644") {
6323 if (WARN("DEVICE_ATTR_RW",
6324 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
6325 $fix) {
6326 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
6327 }
6328 } elsif ($show =~ /^${var}_show$/ &&
6329 $store =~ /^NULL$/ &&
6330 $octal_perms eq "0444") {
6331 if (WARN("DEVICE_ATTR_RO",
6332 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
6333 $fix) {
6334 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
6335 }
6336 } elsif ($show =~ /^NULL$/ &&
6337 $store =~ /^${var}_store$/ &&
6338 $octal_perms eq "0200") {
6339 if (WARN("DEVICE_ATTR_WO",
6340 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
6341 $fix) {
6342 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
6343 }
6344 } elsif ($octal_perms eq "0644" ||
6345 $octal_perms eq "0444" ||
6346 $octal_perms eq "0200") {
6347 my $newshow = "$show";
6348 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
6349 my $newstore = $store;
6350 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
6351 my $rename = "";
6352 if ($show ne $newshow) {
6353 $rename .= " '$show' to '$newshow'";
6354 }
6355 if ($store ne $newstore) {
6356 $rename .= " '$store' to '$newstore'";
6357 }
6358 WARN("DEVICE_ATTR_FUNCTIONS",
6359 "Consider renaming function(s)$rename\n" . $herecurr);
6360 } else {
6361 WARN("DEVICE_ATTR_PERMS",
6362 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
6363 }
6364 }
6365
Joe Perches515a2352014-04-03 14:49:24 -07006366# Mode permission misuses where it seems decimal should be octal
6367# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
Joe Perches73121532018-02-06 15:38:49 -08006368# o Ignore module_param*(...) uses with a decimal 0 permission as that has a
6369# specific definition of not visible in sysfs.
6370# o Ignore proc_create*(...) uses with a decimal 0 permission as that means
6371# use the default permissions
Joe Perches515a2352014-04-03 14:49:24 -07006372 if ($^V && $^V ge 5.10.0 &&
Joe Perches459cf0a2016-10-11 13:52:19 -07006373 defined $stat &&
Joe Perches515a2352014-04-03 14:49:24 -07006374 $line =~ /$mode_perms_search/) {
6375 foreach my $entry (@mode_permission_funcs) {
6376 my $func = $entry->[0];
6377 my $arg_pos = $entry->[1];
Joe Perches24358802014-04-03 14:49:13 -07006378
Joe Perches459cf0a2016-10-11 13:52:19 -07006379 my $lc = $stat =~ tr@\n@@;
6380 $lc = $lc + $linenr;
6381 my $stat_real = raw_line($linenr, 0);
6382 for (my $count = $linenr + 1; $count <= $lc; $count++) {
6383 $stat_real = $stat_real . "\n" . raw_line($count, 0);
6384 }
6385
Joe Perches515a2352014-04-03 14:49:24 -07006386 my $skip_args = "";
6387 if ($arg_pos > 1) {
6388 $arg_pos--;
6389 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6390 }
Joe Perchesf90774e2016-10-11 13:51:47 -07006391 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
Joe Perches459cf0a2016-10-11 13:52:19 -07006392 if ($stat =~ /$test/) {
Joe Perches515a2352014-04-03 14:49:24 -07006393 my $val = $1;
6394 $val = $6 if ($skip_args ne "");
Joe Perches73121532018-02-06 15:38:49 -08006395 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
6396 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6397 ($val =~ /^$Octal$/ && length($val) ne 4))) {
Joe Perches515a2352014-04-03 14:49:24 -07006398 ERROR("NON_OCTAL_PERMISSIONS",
Joe Perches459cf0a2016-10-11 13:52:19 -07006399 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
Joe Perchesf90774e2016-10-11 13:51:47 -07006400 }
6401 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
Joe Perchesc0a5c892015-02-13 14:38:21 -08006402 ERROR("EXPORTED_WORLD_WRITABLE",
Joe Perches459cf0a2016-10-11 13:52:19 -07006403 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
Joe Perchesf90774e2016-10-11 13:51:47 -07006404 }
Joe Perches24358802014-04-03 14:49:13 -07006405 }
6406 }
6407 }
Bjorn Andersson5a6d20c2015-06-25 15:03:24 -07006408
Joe Perches459cf0a2016-10-11 13:52:19 -07006409# check for uses of S_<PERMS> that could be octal for readability
Joe Perches00180462018-02-06 15:38:55 -08006410 if ($line =~ /\b($multi_mode_perms_string_search)\b/) {
6411 my $oval = $1;
6412 my $octal = perms_to_octal($oval);
Joe Perches459cf0a2016-10-11 13:52:19 -07006413 if (WARN("SYMBOLIC_PERMS",
6414 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6415 $fix) {
Joe Perches00180462018-02-06 15:38:55 -08006416 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
Joe Perches459cf0a2016-10-11 13:52:19 -07006417 }
6418 }
6419
Bjorn Andersson5a6d20c2015-06-25 15:03:24 -07006420# validate content of MODULE_LICENSE against list from include/linux/module.h
6421 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6422 my $extracted_string = get_quoted_string($line, $rawline);
6423 my $valid_licenses = qr{
6424 GPL|
6425 GPL\ v2|
6426 GPL\ and\ additional\ rights|
6427 Dual\ BSD/GPL|
6428 Dual\ MIT/GPL|
6429 Dual\ MPL/GPL|
6430 Proprietary
6431 }x;
6432 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6433 WARN("MODULE_LICENSE",
6434 "unknown module license " . $extracted_string . "\n" . $herecurr);
6435 }
6436 }
Andy Whitcroft13214ad2008-02-08 04:22:03 -08006437 }
6438
6439 # If we have no input at all, then there is nothing to report on
6440 # so just keep quiet.
6441 if ($#rawlines == -1) {
6442 exit(0);
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07006443 }
6444
Andy Whitcroft8905a672007-11-28 16:21:06 -08006445 # In mailback mode only produce a report in the negative, for
6446 # things that appear to be patches.
6447 if ($mailback && ($clean == 1 || !$is_patch)) {
6448 exit(0);
6449 }
6450
6451 # This is not a patch, and we are are in 'no-patch' mode so
6452 # just keep quiet.
6453 if (!$chk_patch && !$is_patch) {
6454 exit(0);
6455 }
6456
Stafford Hornea08ffbe2017-10-03 16:16:51 -07006457 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006458 ERROR("NOT_UNIFIED_DIFF",
6459 "Does not appear to be a unified-diff format patch\n");
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07006460 }
Allen Hubbeed43c4e2016-08-02 14:04:45 -07006461 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
Joe Perches000d1cc12011-07-25 17:13:25 -07006462 ERROR("MISSING_SIGN_OFF",
6463 "Missing Signed-off-by: line(s)\n");
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07006464 }
6465
Andy Whitcroft8905a672007-11-28 16:21:06 -08006466 print report_dump();
Andy Whitcroft13214ad2008-02-08 04:22:03 -08006467 if ($summary && !($clean == 1 && $quiet == 1)) {
6468 print "$filename " if ($summary_file);
Andy Whitcroft8905a672007-11-28 16:21:06 -08006469 print "total: $cnt_error errors, $cnt_warn warnings, " .
6470 (($check)? "$cnt_chk checks, " : "") .
6471 "$cnt_lines lines checked\n";
Andy Whitcroftf0a594c2007-07-19 01:48:34 -07006472 }
Andy Whitcroft8905a672007-11-28 16:21:06 -08006473
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07006474 if ($quiet == 0) {
Joe Perchesef212192016-05-20 17:04:11 -07006475 # If there were any defects found and not already fixing them
6476 if (!$clean and !$fix) {
6477 print << "EOM"
6478
6479NOTE: For some of the reported defects, checkpatch may be able to
6480 mechanically convert to the typical style using --fix or --fix-inplace.
6481EOM
6482 }
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07006483 # If there were whitespace errors which cleanpatch can fix
6484 # then suggest that.
6485 if ($rpt_cleaners) {
Mike Frysingerb0781212011-03-22 16:34:43 -07006486 $rpt_cleaners = 0;
Joe Perchesd8469f12015-06-25 15:03:00 -07006487 print << "EOM"
6488
6489NOTE: Whitespace errors detected.
6490 You may wish to use scripts/cleanpatch or scripts/cleanfile
6491EOM
Andy Whitcroftd2c0a232010-10-26 14:23:12 -07006492 }
6493 }
6494
Joe Perchesd752fcc2014-08-06 16:11:05 -07006495 if ($clean == 0 && $fix &&
6496 ("@rawlines" ne "@fixed" ||
6497 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
Joe Perches9624b8d2014-01-23 15:54:44 -08006498 my $newfile = $filename;
6499 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
Joe Perches3705ce52013-07-03 15:05:31 -07006500 my $linecount = 0;
6501 my $f;
6502
Joe Perchesd752fcc2014-08-06 16:11:05 -07006503 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6504
Joe Perches3705ce52013-07-03 15:05:31 -07006505 open($f, '>', $newfile)
6506 or die "$P: Can't open $newfile for write\n";
6507 foreach my $fixed_line (@fixed) {
6508 $linecount++;
6509 if ($file) {
6510 if ($linecount > 3) {
6511 $fixed_line =~ s/^\+//;
Joe Perchesd752fcc2014-08-06 16:11:05 -07006512 print $f $fixed_line . "\n";
Joe Perches3705ce52013-07-03 15:05:31 -07006513 }
6514 } else {
6515 print $f $fixed_line . "\n";
6516 }
6517 }
6518 close($f);
6519
6520 if (!$quiet) {
6521 print << "EOM";
Joe Perchesd8469f12015-06-25 15:03:00 -07006522
Joe Perches3705ce52013-07-03 15:05:31 -07006523Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6524
6525Do _NOT_ trust the results written to this file.
6526Do _NOT_ submit these changes without inspecting them for correctness.
6527
6528This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6529No warranties, expressed or implied...
Joe Perches3705ce52013-07-03 15:05:31 -07006530EOM
6531 }
6532 }
6533
Joe Perchesd8469f12015-06-25 15:03:00 -07006534 if ($quiet == 0) {
6535 print "\n";
6536 if ($clean == 1) {
6537 print "$vname has no obvious style problems and is ready for submission.\n";
6538 } else {
6539 print "$vname has style problems, please review.\n";
6540 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07006541 }
Andy Whitcroft0a920b5b2007-06-01 00:46:48 -07006542 return $clean;
6543}