checkpatch.pl 171.7 KB
Newer Older
1
#!/usr/bin/perl -w
2
# (c) 2001, Dave Jones. (the file handling bit)
3
# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
A
Andy Whitcroft 已提交
4
# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5
# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6 7 8
# Licensed under the terms of the GNU GPL License version 2

use strict;
9
use POSIX;
10 11
use File::Basename;
use Cwd 'abs_path';
12
use Term::ANSIColor qw(:constants);
13 14

my $P = $0;
15
my $D = dirname(abs_path($P));
16

17
my $V = '0.32';
18 19 20 21 22 23 24

use Getopt::Long qw(:config no_auto_abbrev);

my $quiet = 0;
my $tree = 1;
my $chk_signoff = 1;
my $chk_patch = 1;
25
my $tst_only;
26
my $emacs = 0;
27
my $terse = 0;
28
my $showfile = 0;
29 30
my $file = 0;
my $check = 0;
31
my $check_orig = 0;
32 33
my $summary = 1;
my $mailback = 0;
34
my $summary_file = 0;
35
my $show_types = 0;
36
my $fix = 0;
37
my $fix_inplace = 0;
38
my $root;
39
my %debug;
40
my %camelcase = ();
41 42 43
my %use_type = ();
my @use = ();
my %ignore_type = ();
44
my @ignore = ();
45
my $help = 0;
46
my $configuration_file = ".checkpatch.conf";
47
my $max_line_length = 80;
48 49
my $ignore_perl_version = 0;
my $minimum_perl_version = 5.10.0;
50
my $min_conf_desc_length = 4;
51
my $spelling_file = "$D/spelling.txt";
52
my $codespell = 0;
53
my $codespellfile = "/usr/share/codespell/dictionary.txt";
54
my $color = 1;
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

sub help {
	my ($exitcode) = @_;

	print << "EOM";
Usage: $P [OPTION]... [FILE]...
Version: $V

Options:
  -q, --quiet                quiet
  --no-tree                  run without a kernel tree
  --no-signoff               do not check for 'Signed-off-by' line
  --patch                    treat FILE as patchfile (default)
  --emacs                    emacs compile window format
  --terse                    one line per report
70
  --showfile                 emit diffed file position, not input file position
71 72
  -f, --file                 treat FILE as regular source file
  --subjective, --strict     enable more subjective tests
73
  --types TYPE(,TYPE2...)    show only these comma separated message types
74
  --ignore TYPE(,TYPE2...)   ignore various comma separated message types
75
  --max-line-length=n        set the maximum line length, if exceeded, warn
76
  --min-conf-desc-length=n   set the min description length, if shorter, warn
77
  --show-types               show the message "types" in the output
78 79 80 81 82 83 84 85 86
  --root=PATH                PATH to the kernel tree root
  --no-summary               suppress the per-file summary
  --mailback                 only produce a report in case of warnings/errors
  --summary-file             include the filename in summary
  --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
                             'values', 'possible', 'type', and 'attr' (default
                             is all off)
  --test-only=WORD           report only warnings/errors containing WORD
                             literally
87 88 89 90 91
  --fix                      EXPERIMENTAL - may create horrible results
                             If correctable single-line errors exist, create
                             "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
                             with potential errors corrected to the preferred
                             checkpatch style
92 93 94
  --fix-inplace              EXPERIMENTAL - may create horrible results
                             Is the same as --fix, but overwrites the input
                             file.  It's your fault if there's no backup or git
95 96
  --ignore-perl-version      override checking of perl version.  expect
                             runtime errors.
97
  --codespell                Use the codespell dictionary for spelling/typos
98
                             (default:/usr/share/codespell/dictionary.txt)
99
  --codespellfile            Use this codespell dictionary
100
  --color                    Use colors when output is STDOUT (default: on)
101 102 103 104 105 106 107 108
  -h, --help, --version      display this help and exit

When FILE is - read standard input.
EOM

	exit($exitcode);
}

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
my $conf = which_conf($configuration_file);
if (-f $conf) {
	my @conf_args;
	open(my $conffile, '<', "$conf")
	    or warn "$P: Can't find a readable $configuration_file file $!\n";

	while (<$conffile>) {
		my $line = $_;

		$line =~ s/\s*\n?$//g;
		$line =~ s/^\s*//g;
		$line =~ s/\s+/ /g;

		next if ($line =~ m/^\s*#/);
		next if ($line =~ m/^\s*$/);

		my @words = split(" ", $line);
		foreach my $word (@words) {
			last if ($word =~ m/^#/);
			push (@conf_args, $word);
		}
	}
	close($conffile);
	unshift(@ARGV, @conf_args) if @conf_args;
}

135
GetOptions(
136
	'q|quiet+'	=> \$quiet,
137 138 139
	'tree!'		=> \$tree,
	'signoff!'	=> \$chk_signoff,
	'patch!'	=> \$chk_patch,
140
	'emacs!'	=> \$emacs,
141
	'terse!'	=> \$terse,
142
	'showfile!'	=> \$showfile,
143
	'f|file!'	=> \$file,
144 145
	'subjective!'	=> \$check,
	'strict!'	=> \$check,
146
	'ignore=s'	=> \@ignore,
147
	'types=s'	=> \@use,
148
	'show-types!'	=> \$show_types,
149
	'max-line-length=i' => \$max_line_length,
150
	'min-conf-desc-length=i' => \$min_conf_desc_length,
151
	'root=s'	=> \$root,
152 153
	'summary!'	=> \$summary,
	'mailback!'	=> \$mailback,
154
	'summary-file!'	=> \$summary_file,
155
	'fix!'		=> \$fix,
156
	'fix-inplace!'	=> \$fix_inplace,
157
	'ignore-perl-version!' => \$ignore_perl_version,
158
	'debug=s'	=> \%debug,
159
	'test-only=s'	=> \$tst_only,
160 161
	'codespell!'	=> \$codespell,
	'codespellfile=s'	=> \$codespellfile,
162
	'color!'	=> \$color,
163 164 165 166 167
	'h|help'	=> \$help,
	'version'	=> \$help
) or help(1);

help(0) if ($help);
168

169
$fix = 1 if ($fix_inplace);
170
$check_orig = $check;
171

172 173
my $exit = 0;

174 175 176 177 178 179 180
if ($^V && $^V lt $minimum_perl_version) {
	printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
	if (!$ignore_perl_version) {
		exit(1);
	}
}

181
if ($#ARGV < 0) {
182
	print "$P: no input files\n";
183 184 185
	exit(1);
}

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
sub hash_save_array_words {
	my ($hashRef, $arrayRef) = @_;

	my @array = split(/,/, join(',', @$arrayRef));
	foreach my $word (@array) {
		$word =~ s/\s*\n?$//g;
		$word =~ s/^\s*//g;
		$word =~ s/\s+/ /g;
		$word =~ tr/[a-z]/[A-Z]/;

		next if ($word =~ m/^\s*#/);
		next if ($word =~ m/^\s*$/);

		$hashRef->{$word}++;
	}
}
202

203 204
sub hash_show_words {
	my ($hashRef, $prefix) = @_;
205

206
	if (keys %$hashRef) {
207
		print "\nNOTE: $prefix message types:";
208
		foreach my $word (sort keys %$hashRef) {
209 210
			print " $word";
		}
211
		print "\n";
212
	}
213 214
}

215 216 217
hash_save_array_words(\%ignore_type, \@ignore);
hash_save_array_words(\%use_type, \@use);

218 219
my $dbg_values = 0;
my $dbg_possible = 0;
220
my $dbg_type = 0;
221
my $dbg_attr = 0;
222
for my $key (keys %debug) {
223 224 225
	## no critic
	eval "\${dbg_$key} = '$debug{$key}';";
	die "$@" if ($@);
226 227
}

228 229
my $rpt_cleaners = 0;

230 231 232 233 234
if ($terse) {
	$emacs = 1;
	$quiet++;
}

235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
if ($tree) {
	if (defined $root) {
		if (!top_of_kernel_tree($root)) {
			die "$P: $root: --root does not point at a valid tree\n";
		}
	} else {
		if (top_of_kernel_tree('.')) {
			$root = '.';
		} elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
						top_of_kernel_tree($1)) {
			$root = $1;
		}
	}

	if (!defined $root) {
		print "Must be run from the top-level dir. of a kernel tree\n";
		exit(2);
	}
253 254
}

255 256
my $emitted_corrupt = 0;

257 258 259 260
our $Ident	= qr{
			[A-Za-z_][A-Za-z\d_]*
			(?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
		}x;
261 262 263 264 265 266
our $Storage	= qr{extern|static|asmlinkage};
our $Sparse	= qr{
			__user|
			__kernel|
			__force|
			__iomem|
267
			__pmem|
268 269
			__must_check|
			__init_refok|
270
			__kprobes|
271 272
			__ref|
			__rcu
273
		}x;
274 275 276 277 278
our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
279

280 281
# Notes to $Attribute:
# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
282 283
our $Attribute	= qr{
			const|
284 285 286 287 288 289 290 291 292 293 294 295
			__percpu|
			__nocast|
			__safe|
			__bitwise__|
			__packed__|
			__packed2__|
			__naked|
			__maybe_unused|
			__always_unused|
			__noreturn|
			__used|
			__cold|
296
			__pure|
297 298
			__noclone|
			__deprecated|
299 300
			__read_mostly|
			__kprobes|
301
			$InitAttribute|
302 303
			____cacheline_aligned|
			____cacheline_aligned_in_smp|
304 305
			____cacheline_internodealigned_in_smp|
			__weak
306
		  }x;
307
our $Modifier;
308
our $Inline	= qr{inline|__always_inline|noinline|__inline|__inline__};
309 310 311
our $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
our $Lval	= qr{$Ident(?:$Member)*};

312 313 314 315
our $Int_type	= qr{(?i)llu|ull|ll|lu|ul|l|u};
our $Binary	= qr{(?i)0b[01]+$Int_type?};
our $Hex	= qr{(?i)0x[0-9a-f]+$Int_type?};
our $Int	= qr{[0-9]+$Int_type?};
316
our $Octal	= qr{0[0-7]+$Int_type?};
317
our $String	= qr{"[X\t]*"};
318 319 320
our $Float_hex	= qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
our $Float_dec	= qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
our $Float_int	= qr{(?i)[0-9]+e-?[0-9]+[fl]?};
321
our $Float	= qr{$Float_hex|$Float_dec|$Float_int};
322
our $Constant	= qr{$Float|$Binary|$Octal|$Hex|$Int};
323
our $Assignment	= qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
324
our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
325
our $Arithmetic = qr{\+|-|\*|\/|%};
326 327 328
our $Operators	= qr{
			<=|>=|==|!=|
			=>|->|<<|>>|<|>|!|~|
329
			&&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
330 331
		  }x;

332 333
our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;

334
our $BasicType;
335
our $NonptrType;
336
our $NonptrTypeMisordered;
337
our $NonptrTypeWithAttr;
338
our $Type;
339
our $TypeMisordered;
340
our $Declare;
341
our $DeclareMisordered;
342

343 344
our $NON_ASCII_UTF8	= qr{
	[\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
345 346 347 348 349 350 351 352
	|  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
	| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
	|  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
	|  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
	| [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
	|  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
}x;

353 354 355 356 357
our $UTF8	= qr{
	[\x09\x0A\x0D\x20-\x7E]              # ASCII
	| $NON_ASCII_UTF8
}x;

358
our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
359 360 361 362
our $typeOtherOSTypedefs = qr{(?x:
	u_(?:char|short|int|long) |          # bsd
	u(?:nchar|short|int|long)            # sysv
)};
363
our $typeKernelTypedefs = qr{(?x:
364
	(?:__)?(?:u|s|be|le)(?:8|16|32|64)|
365 366
	atomic_t
)};
367 368 369 370 371
our $typeTypedefs = qr{(?x:
	$typeC99Typedefs\b|
	$typeOtherOSTypedefs\b|
	$typeKernelTypedefs\b
)};
372

373 374
our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};

375
our $logFunctions = qr{(?x:
376
	printk(?:_ratelimited|_once|)|
377
	(?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
378
	WARN(?:_RATELIMIT|_ONCE|)|
379
	panic|
J
Joe Perches 已提交
380 381
	MODULE_[A-Z_]+|
	seq_vprintf|seq_printf|seq_puts
382 383
)};

384 385 386 387 388 389
our $signature_tags = qr{(?xi:
	Signed-off-by:|
	Acked-by:|
	Tested-by:|
	Reviewed-by:|
	Reported-by:|
390
	Suggested-by:|
391 392 393 394
	To:|
	Cc:
)};

395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
our @typeListMisordered = (
	qr{char\s+(?:un)?signed},
	qr{int\s+(?:(?:un)?signed\s+)?short\s},
	qr{int\s+short(?:\s+(?:un)?signed)},
	qr{short\s+int(?:\s+(?:un)?signed)},
	qr{(?:un)?signed\s+int\s+short},
	qr{short\s+(?:un)?signed},
	qr{long\s+int\s+(?:un)?signed},
	qr{int\s+long\s+(?:un)?signed},
	qr{long\s+(?:un)?signed\s+int},
	qr{int\s+(?:un)?signed\s+long},
	qr{int\s+(?:un)?signed},
	qr{int\s+long\s+long\s+(?:un)?signed},
	qr{long\s+long\s+int\s+(?:un)?signed},
	qr{long\s+long\s+(?:un)?signed\s+int},
	qr{long\s+long\s+(?:un)?signed},
	qr{long\s+(?:un)?signed},
);

414 415
our @typeList = (
	qr{void},
416 417 418 419 420 421 422 423 424
	qr{(?:(?:un)?signed\s+)?char},
	qr{(?:(?:un)?signed\s+)?short\s+int},
	qr{(?:(?:un)?signed\s+)?short},
	qr{(?:(?:un)?signed\s+)?int},
	qr{(?:(?:un)?signed\s+)?long\s+int},
	qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
	qr{(?:(?:un)?signed\s+)?long\s+long},
	qr{(?:(?:un)?signed\s+)?long},
	qr{(?:un)?signed},
425 426 427 428 429 430 431 432 433
	qr{float},
	qr{double},
	qr{bool},
	qr{struct\s+$Ident},
	qr{union\s+$Ident},
	qr{enum\s+$Ident},
	qr{${Ident}_t},
	qr{${Ident}_handler},
	qr{${Ident}_handler_fn},
434
	@typeListMisordered,
435
);
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457

our $C90_int_types = qr{(?x:
	long\s+long\s+int\s+(?:un)?signed|
	long\s+long\s+(?:un)?signed\s+int|
	long\s+long\s+(?:un)?signed|
	(?:(?:un)?signed\s+)?long\s+long\s+int|
	(?:(?:un)?signed\s+)?long\s+long|
	int\s+long\s+long\s+(?:un)?signed|
	int\s+(?:(?:un)?signed\s+)?long\s+long|

	long\s+int\s+(?:un)?signed|
	long\s+(?:un)?signed\s+int|
	long\s+(?:un)?signed|
	(?:(?:un)?signed\s+)?long\s+int|
	(?:(?:un)?signed\s+)?long|
	int\s+long\s+(?:un)?signed|
	int\s+(?:(?:un)?signed\s+)?long|

	int\s+(?:un)?signed|
	(?:(?:un)?signed\s+)?int
)};

458
our @typeListFile = ();
459 460 461 462 463 464
our @typeListWithAttr = (
	@typeList,
	qr{struct\s+$InitAttribute\s+$Ident},
	qr{union\s+$InitAttribute\s+$Ident},
);

465 466 467
our @modifierList = (
	qr{fastcall},
);
468
our @modifierListFile = ();
469

470 471 472 473 474 475 476 477 478
our @mode_permission_funcs = (
	["module_param", 3],
	["module_param_(?:array|named|string)", 4],
	["module_param_array_named", 5],
	["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
	["proc_create(?:_data|)", 2],
	["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
);

479 480 481 482 483 484 485
#Create a search pattern for all these functions to speed up a loop below
our $mode_perms_search = "";
foreach my $entry (@mode_permission_funcs) {
	$mode_perms_search .= '|' if ($mode_perms_search ne "");
	$mode_perms_search .= $entry->[0];
}

486 487 488 489 490 491 492 493
our $mode_perms_world_writable = qr{
	S_IWUGO		|
	S_IWOTH		|
	S_IRWXUGO	|
	S_IALLUGO	|
	0[0-7][0-7][2367]
}x;

494 495
our $allowed_asm_includes = qr{(?x:
	irq|
496 497 498
	memory|
	time|
	reboot
499 500 501
)};
# memory.h: ARM has a custom one

502 503 504 505
# Load common spelling mistakes and build regular expression list.
my $misspellings;
my %spelling_fix;

506 507 508
if (open(my $spelling, '<', $spelling_file)) {
	while (<$spelling>) {
		my $line = $_;
509

510 511
		$line =~ s/\s*\n?$//g;
		$line =~ s/^\s*//g;
512

513 514 515 516
		next if ($line =~ m/^\s*#/);
		next if ($line =~ m/^\s*$/);

		my ($suspect, $fix) = split(/\|\|/, $line);
517

518 519 520 521 522
		$spelling_fix{$suspect} = $fix;
	}
	close($spelling);
} else {
	warn "No typos will be found - file '$spelling_file': $!\n";
523 524
}

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
if ($codespell) {
	if (open(my $spelling, '<', $codespellfile)) {
		while (<$spelling>) {
			my $line = $_;

			$line =~ s/\s*\n?$//g;
			$line =~ s/^\s*//g;

			next if ($line =~ m/^\s*#/);
			next if ($line =~ m/^\s*$/);
			next if ($line =~ m/, disabled/i);

			$line =~ s/,.*$//;

			my ($suspect, $fix) = split(/->/, $line);

			$spelling_fix{$suspect} = $fix;
		}
		close($spelling);
	} else {
		warn "No codespell typos will be found - file '$codespellfile': $!\n";
	}
}

$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;

551
sub build_types {
552 553
	my $mods = "(?x:  \n" . join("|\n  ", (@modifierList, @modifierListFile)) . "\n)";
	my $all = "(?x:  \n" . join("|\n  ", (@typeList, @typeListFile)) . "\n)";
554
	my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
555
	my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
556
	$Modifier	= qr{(?:$Attribute|$Sparse|$mods)};
557 558 559 560
	$BasicType	= qr{
				(?:$typeTypedefs\b)|
				(?:${all}\b)
		}x;
561
	$NonptrType	= qr{
562
			(?:$Modifier\s+|const\s+)*
563
			(?:
564
				(?:typeof|__typeof__)\s*\([^\)]*\)|
565
				(?:$typeTypedefs\b)|
566
				(?:${all}\b)
567
			)
568
			(?:\s+$Modifier|\s+const)*
569
		  }x;
570 571 572 573 574 575 576
	$NonptrTypeMisordered	= qr{
			(?:$Modifier\s+|const\s+)*
			(?:
				(?:${Misordered}\b)
			)
			(?:\s+$Modifier|\s+const)*
		  }x;
577 578 579 580 581 582 583 584 585
	$NonptrTypeWithAttr	= qr{
			(?:$Modifier\s+|const\s+)*
			(?:
				(?:typeof|__typeof__)\s*\([^\)]*\)|
				(?:$typeTypedefs\b)|
				(?:${allWithAttr}\b)
			)
			(?:\s+$Modifier|\s+const)*
		  }x;
586
	$Type	= qr{
587
			$NonptrType
588
			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
589
			(?:\s+$Inline|\s+$Modifier)*
590
		  }x;
591 592 593 594 595
	$TypeMisordered	= qr{
			$NonptrTypeMisordered
			(?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
			(?:\s+$Inline|\s+$Modifier)*
		  }x;
596
	$Declare	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
597
	$DeclareMisordered	= qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
598 599
}
build_types();
600

601
our $Typecast	= qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
602 603 604 605 606 607

# Using $balanced_parens, $LvalOrFunc, or $FuncArg
# requires at least perl version v5.10.0
# Any use must be runtime checked with $^V

our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
608
our $LvalOrFunc	= qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
609
our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
610

611
our $declaration_macros = qr{(?x:
612
	(?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
613 614 615 616
	(?:$Storage\s+)?LIST_HEAD\s*\(|
	(?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
)};

617 618 619
sub deparenthesize {
	my ($string) = @_;
	return "" if (!defined($string));
620 621 622 623 624 625

	while ($string =~ /^\s*\(.*\)\s*$/) {
		$string =~ s@^\s*\(\s*@@;
		$string =~ s@\s*\)\s*$@@;
	}

626
	$string =~ s@\s+@ @g;
627

628 629 630
	return $string;
}

631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
sub seed_camelcase_file {
	my ($file) = @_;

	return if (!(-f $file));

	local $/;

	open(my $include_file, '<', "$file")
	    or warn "$P: Can't read '$file' $!\n";
	my $text = <$include_file>;
	close($include_file);

	my @lines = split('\n', $text);

	foreach my $line (@lines) {
		next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
		if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
			$camelcase{$1} = 1;
649 650 651
		} elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
			$camelcase{$1} = 1;
		} elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
652 653 654 655 656 657 658 659 660 661
			$camelcase{$1} = 1;
		}
	}
}

my $camelcase_seeded = 0;
sub seed_camelcase_includes {
	return if ($camelcase_seeded);

	my $files;
662 663 664 665
	my $camelcase_cache = "";
	my @include_files = ();

	$camelcase_seeded = 1;
666

667
	if (-e ".git") {
668 669
		my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
		chomp $git_last_include_commit;
670
		$camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
671
	} else {
672
		my $last_mod_date = 0;
673
		$files = `find $root/include -name "*.h"`;
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
		@include_files = split('\n', $files);
		foreach my $file (@include_files) {
			my $date = POSIX::strftime("%Y%m%d%H%M",
						   localtime((stat $file)[9]));
			$last_mod_date = $date if ($last_mod_date < $date);
		}
		$camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
	}

	if ($camelcase_cache ne "" && -f $camelcase_cache) {
		open(my $camelcase_file, '<', "$camelcase_cache")
		    or warn "$P: Can't read '$camelcase_cache' $!\n";
		while (<$camelcase_file>) {
			chomp;
			$camelcase{$_} = 1;
		}
		close($camelcase_file);

		return;
693
	}
694

695
	if (-e ".git") {
696 697 698 699
		$files = `git ls-files "include/*.h"`;
		@include_files = split('\n', $files);
	}

700 701 702
	foreach my $file (@include_files) {
		seed_camelcase_file($file);
	}
703

704
	if ($camelcase_cache ne "") {
705
		unlink glob ".checkpatch-camelcase.*";
706 707
		open(my $camelcase_file, '>', "$camelcase_cache")
		    or warn "$P: Can't write '$camelcase_cache' $!\n";
708 709 710 711 712
		foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
			print $camelcase_file ("$_\n");
		}
		close($camelcase_file);
	}
713 714
}

715 716 717 718 719 720 721 722 723
sub git_commit_info {
	my ($commit, $id, $desc) = @_;

	return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));

	my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
	$output =~ s/^\s*//gm;
	my @lines = split("\n", $output);

724 725
	return ($id, $desc) if ($#lines < 0);

726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
	if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
# Maybe one day convert this block of bash into something that returns
# all matching commit ids, but it's very slow...
#
#		echo "checking commits $1..."
#		git rev-list --remotes | grep -i "^$1" |
#		while read line ; do
#		    git log --format='%H %s' -1 $line |
#		    echo "commit $(cut -c 1-12,41-)"
#		done
	} elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
	} else {
		$id = substr($lines[0], 0, 12);
		$desc = substr($lines[0], 41);
	}

	return ($id, $desc);
}

745 746
$chk_signoff = 0 if ($file);

747
my @rawlines = ();
748
my @lines = ();
749
my @fixed = ();
750 751
my @fixed_inserted = ();
my @fixed_deleted = ();
752 753
my $fixlinenr = -1;

754
my $vname;
755
for my $filename (@ARGV) {
756
	my $FILE;
757
	if ($file) {
758
		open($FILE, '-|', "diff -u /dev/null $filename") ||
759
			die "$P: $filename: diff failed - $!\n";
760 761
	} elsif ($filename eq '-') {
		open($FILE, '<&STDIN');
762
	} else {
763
		open($FILE, '<', "$filename") ||
764
			die "$P: $filename: open failed - $!\n";
765
	}
766 767 768 769 770
	if ($filename eq '-') {
		$vname = 'Your patch';
	} else {
		$vname = $filename;
	}
771
	while (<$FILE>) {
772 773 774
		chomp;
		push(@rawlines, $_);
	}
775
	close($FILE);
776 777 778 779 780 781 782

	if ($#ARGV > 0 && $quiet == 0) {
		print '-' x length($vname) . "\n";
		print "$vname\n";
		print '-' x length($vname) . "\n";
	}

783
	if (!process($filename)) {
784 785 786
		$exit = 1;
	}
	@rawlines = ();
787
	@lines = ();
788
	@fixed = ();
789 790
	@fixed_inserted = ();
	@fixed_deleted = ();
791
	$fixlinenr = -1;
792 793 794
	@modifierListFile = ();
	@typeListFile = ();
	build_types();
795 796
}

797
if (!$quiet) {
798 799 800
	hash_show_words(\%use_type, "Used");
	hash_show_words(\%ignore_type, "Ignored");

801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
	if ($^V lt 5.10.0) {
		print << "EOM"

NOTE: perl $^V is not modern enough to detect all possible issues.
      An upgrade to at least perl v5.10.0 is suggested.
EOM
	}
	if ($exit) {
		print << "EOM"

NOTE: If any of the errors are false positives, please report
      them to the maintainer, see CHECKPATCH in MAINTAINERS.
EOM
	}
}

817 818 819
exit($exit);

sub top_of_kernel_tree {
820 821 822 823 824 825 826 827 828 829 830 831
	my ($root) = @_;

	my @tree_check = (
		"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
		"README", "Documentation", "arch", "include", "drivers",
		"fs", "init", "ipc", "kernel", "lib", "scripts",
	);

	foreach my $check (@tree_check) {
		if (! -e $root . '/' . $check) {
			return 0;
		}
832
	}
833
	return 1;
834
}
835

836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
sub parse_email {
	my ($formatted_email) = @_;

	my $name = "";
	my $address = "";
	my $comment = "";

	if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
		$name = $1;
		$address = $2;
		$comment = $3 if defined $3;
	} elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
		$address = $1;
		$comment = $2 if defined $2;
	} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
		$address = $1;
		$comment = $2 if defined $2;
		$formatted_email =~ s/$address.*$//;
		$name = $formatted_email;
855
		$name = trim($name);
856 857 858 859 860 861 862 863 864 865 866 867 868 869
		$name =~ s/^\"|\"$//g;
		# If there's a name left after stripping spaces and
		# leading quotes, and the address doesn't have both
		# leading and trailing angle brackets, the address
		# is invalid. ie:
		#   "joe smith joe@smith.com" bad
		#   "joe smith <joe@smith.com" bad
		if ($name ne "" && $address !~ /^<[^>]+>$/) {
			$name = "";
			$address = "";
			$comment = "";
		}
	}

870
	$name = trim($name);
871
	$name =~ s/^\"|\"$//g;
872
	$address = trim($address);
873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
	$address =~ s/^\<|\>$//g;

	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
		$name = "\"$name\"";
	}

	return ($name, $address, $comment);
}

sub format_email {
	my ($name, $address) = @_;

	my $formatted_email;

888
	$name = trim($name);
889
	$name =~ s/^\"|\"$//g;
890
	$address = trim($address);
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905

	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
		$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
		$name = "\"$name\"";
	}

	if ("$name" eq "") {
		$formatted_email = "$address";
	} else {
		$formatted_email = "$name <$address>";
	}

	return $formatted_email;
}

906
sub which {
907
	my ($bin) = @_;
908

909 910 911 912
	foreach my $path (split(/:/, $ENV{PATH})) {
		if (-e "$path/$bin") {
			return "$path/$bin";
		}
913 914
	}

915
	return "";
916 917
}

918 919 920 921 922 923 924 925 926 927 928 929
sub which_conf {
	my ($conf) = @_;

	foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
		if (-e "$path/$conf") {
			return "$path/$conf";
		}
	}

	return "";
}

930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
sub expand_tabs {
	my ($str) = @_;

	my $res = '';
	my $n = 0;
	for my $c (split(//, $str)) {
		if ($c eq "\t") {
			$res .= ' ';
			$n++;
			for (; ($n % 8) != 0; $n++) {
				$res .= ' ';
			}
			next;
		}
		$res .= $c;
		$n++;
	}

	return $res;
}
950
sub copy_spacing {
951
	(my $res = shift) =~ tr/\t/ /c;
952 953
	return $res;
}
954

955 956 957 958 959 960 961 962 963 964 965 966 967
sub line_stats {
	my ($line) = @_;

	# Drop the diff line leader and expand tabs
	$line =~ s/^.//;
	$line = expand_tabs($line);

	# Pick the indent from the front of the line.
	my ($white) = ($line =~ /^(\s*)/);

	return (length($line), length($white));
}

968 969 970 971 972 973 974 975 976 977 978
my $sanitise_quote = '';

sub sanitise_line_reset {
	my ($in_comment) = @_;

	if ($in_comment) {
		$sanitise_quote = '*/';
	} else {
		$sanitise_quote = '';
	}
}
979 980 981 982 983 984
sub sanitise_line {
	my ($line) = @_;

	my $res = '';
	my $l = '';

985
	my $qlen = 0;
986 987
	my $off = 0;
	my $c;
988

989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
	# Always copy over the diff marker.
	$res = substr($line, 0, 1);

	for ($off = 1; $off < length($line); $off++) {
		$c = substr($line, $off, 1);

		# Comments we are wacking completly including the begin
		# and end, all to $;.
		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
			$sanitise_quote = '*/';

			substr($res, $off, 2, "$;$;");
			$off++;
			next;
1003
		}
1004
		if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1005 1006 1007 1008
			$sanitise_quote = '';
			substr($res, $off, 2, "$;$;");
			$off++;
			next;
1009
		}
1010 1011 1012 1013 1014 1015 1016
		if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
			$sanitise_quote = '//';

			substr($res, $off, 2, $sanitise_quote);
			$off++;
			next;
		}
1017 1018 1019 1020 1021 1022 1023

		# A \ in a string means ignore the next character.
		if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
		    $c eq "\\") {
			substr($res, $off, 2, 'XX');
			$off++;
			next;
1024
		}
1025 1026 1027 1028
		# Regular quotes.
		if ($c eq "'" || $c eq '"') {
			if ($sanitise_quote eq '') {
				$sanitise_quote = $c;
1029

1030 1031 1032 1033 1034 1035
				substr($res, $off, 1, $c);
				next;
			} elsif ($sanitise_quote eq $c) {
				$sanitise_quote = '';
			}
		}
1036

1037
		#print "c<$c> SQ<$sanitise_quote>\n";
1038 1039
		if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
			substr($res, $off, 1, $;);
1040 1041
		} elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
			substr($res, $off, 1, $;);
1042 1043 1044 1045 1046
		} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
			substr($res, $off, 1, 'X');
		} else {
			substr($res, $off, 1, $c);
		}
1047 1048
	}

1049 1050 1051 1052
	if ($sanitise_quote eq '//') {
		$sanitise_quote = '';
	}

1053
	# The pathname on a #include may be surrounded by '<' and '>'.
1054
	if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1055 1056 1057 1058
		my $clean = 'X' x length($1);
		$res =~ s@\<.*\>@<$clean>@;

	# The whole of a #error is a string.
1059
	} elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1060
		my $clean = 'X' x length($1);
1061
		$res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1062 1063
	}

1064 1065 1066
	return $res;
}

1067 1068 1069
sub get_quoted_string {
	my ($line, $rawline) = @_;

1070
	return "" if ($line !~ m/($String)/g);
1071 1072 1073
	return substr($rawline, $-[0], $+[0] - $-[0]);
}

1074 1075 1076 1077 1078 1079
sub ctx_statement_block {
	my ($linenr, $remain, $off) = @_;
	my $line = $linenr - 1;
	my $blk = '';
	my $soff = $off;
	my $coff = $off - 1;
1080
	my $coff_set = 0;
1081

1082 1083
	my $loff = 0;

1084 1085
	my $type = '';
	my $level = 0;
1086
	my @stack = ();
1087
	my $p;
1088 1089
	my $c;
	my $len = 0;
1090 1091

	my $remainder;
1092
	while (1) {
1093 1094
		@stack = (['', 0]) if ($#stack == -1);

1095
		#warn "CSB: blk<$blk> remain<$remain>\n";
1096 1097 1098 1099
		# If we are about to drop off the end, pull in more
		# context.
		if ($off >= $len) {
			for (; $remain > 0; $line++) {
1100
				last if (!defined $lines[$line]);
1101
				next if ($lines[$line] =~ /^-/);
1102
				$remain--;
1103
				$loff = $len;
1104
				$blk .= $lines[$line] . "\n";
1105 1106 1107 1108 1109 1110
				$len = length($blk);
				$line++;
				last;
			}
			# Bail if there is no further context.
			#warn "CSB: blk<$blk> off<$off> len<$len>\n";
1111
			if ($off >= $len) {
1112 1113
				last;
			}
1114 1115 1116 1117
			if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
				$level++;
				$type = '#';
			}
1118
		}
1119
		$p = $c;
1120
		$c = substr($blk, $off, 1);
1121
		$remainder = substr($blk, $off);
1122

1123
		#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133

		# Handle nested #if/#else.
		if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
			push(@stack, [ $type, $level ]);
		} elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
			($type, $level) = @{$stack[$#stack - 1]};
		} elsif ($remainder =~ /^#\s*endif\b/) {
			($type, $level) = @{pop(@stack)};
		}

1134 1135 1136 1137 1138 1139
		# Statement ends at the ';' or a close '}' at the
		# outermost level.
		if ($level == 0 && $c eq ';') {
			last;
		}

1140
		# An else is really a conditional as long as its not else if
1141 1142 1143 1144 1145 1146 1147 1148
		if ($level == 0 && $coff_set == 0 &&
				(!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
				$remainder =~ /^(else)(?:\s|{)/ &&
				$remainder !~ /^else\s+if\b/) {
			$coff = $off + length($1) - 1;
			$coff_set = 1;
			#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
			#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1149 1150
		}

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
		if (($type eq '' || $type eq '(') && $c eq '(') {
			$level++;
			$type = '(';
		}
		if ($type eq '(' && $c eq ')') {
			$level--;
			$type = ($level != 0)? '(' : '';

			if ($level == 0 && $coff < $soff) {
				$coff = $off;
1161 1162
				$coff_set = 1;
				#warn "CSB: mark coff<$coff>\n";
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
			}
		}
		if (($type eq '' || $type eq '{') && $c eq '{') {
			$level++;
			$type = '{';
		}
		if ($type eq '{' && $c eq '}') {
			$level--;
			$type = ($level != 0)? '{' : '';

			if ($level == 0) {
1174 1175 1176
				if (substr($blk, $off + 1, 1) eq ';') {
					$off++;
				}
1177 1178 1179
				last;
			}
		}
1180 1181 1182 1183 1184 1185 1186
		# Preprocessor commands end at the newline unless escaped.
		if ($type eq '#' && $c eq "\n" && $p ne "\\") {
			$level--;
			$type = '';
			$off++;
			last;
		}
1187 1188
		$off++;
	}
1189
	# We are truly at the end, so shuffle to the next line.
1190
	if ($off == $len) {
1191
		$loff = $len + 1;
1192 1193 1194
		$line++;
		$remain--;
	}
1195 1196 1197 1198 1199 1200 1201

	my $statement = substr($blk, $soff, $off - $soff + 1);
	my $condition = substr($blk, $soff, $coff - $soff + 1);

	#warn "STATEMENT<$statement>\n";
	#warn "CONDITION<$condition>\n";

1202
	#print "coff<$coff> soff<$off> loff<$loff>\n";
1203 1204 1205 1206 1207

	return ($statement, $condition,
			$line, $remain + 1, $off - $loff + 1, $level);
}

1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
sub statement_lines {
	my ($stmt) = @_;

	# Strip the diff line prefixes and rip blank lines at start and end.
	$stmt =~ s/(^|\n)./$1/g;
	$stmt =~ s/^\s*//;
	$stmt =~ s/\s*$//;

	my @stmt_lines = ($stmt =~ /\n/g);

	return $#stmt_lines + 2;
}

sub statement_rawlines {
	my ($stmt) = @_;

	my @stmt_lines = ($stmt =~ /\n/g);

	return $#stmt_lines + 2;
}

sub statement_block_size {
	my ($stmt) = @_;

	$stmt =~ s/(^|\n)./$1/g;
	$stmt =~ s/^\s*{//;
	$stmt =~ s/}\s*$//;
	$stmt =~ s/^\s*//;
	$stmt =~ s/\s*$//;

	my @stmt_lines = ($stmt =~ /\n/g);
	my @stmt_statements = ($stmt =~ /;/g);

	my $stmt_lines = $#stmt_lines + 2;
	my $stmt_statements = $#stmt_statements + 1;

	if ($stmt_lines > $stmt_statements) {
		return $stmt_lines;
	} else {
		return $stmt_statements;
	}
}

1251 1252 1253 1254 1255 1256
sub ctx_statement_full {
	my ($linenr, $remain, $off) = @_;
	my ($statement, $condition, $level);

	my (@chunks);

1257
	# Grab the first conditional/block pair.
1258 1259
	($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
1260
	#print "F: c<$condition> s<$statement> remain<$remain>\n";
1261 1262 1263 1264 1265 1266 1267
	push(@chunks, [ $condition, $statement ]);
	if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
		return ($level, $linenr, @chunks);
	}

	# Pull in the following conditional/block pairs and see if they
	# could continue the statement.
1268 1269 1270
	for (;;) {
		($statement, $condition, $linenr, $remain, $off, $level) =
				ctx_statement_block($linenr, $remain, $off);
1271
		#print "C: c<$condition> s<$statement> remain<$remain>\n";
1272
		last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1273 1274
		#print "C: push\n";
		push(@chunks, [ $condition, $statement ]);
1275 1276 1277
	}

	return ($level, $linenr, @chunks);
1278 1279
}

1280
sub ctx_block_get {
1281
	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1282 1283 1284 1285 1286 1287 1288
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

1289
	my $level = 0;
1290
	my @stack = ($level);
1291 1292 1293 1294 1295
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
1296 1297

		# Handle nested #if/#else.
1298
		if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1299
			push(@stack, $level);
1300
		} elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1301
			$level = $stack[$#stack - 1];
1302
		} elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1303 1304 1305
			$level = pop(@stack);
		}

1306
		foreach my $c (split(//, $lines[$line])) {
1307 1308 1309 1310 1311
			##print "C<$c>L<$level><$open$close>O<$off>\n";
			if ($off > 0) {
				$off--;
				next;
			}
1312

1313 1314 1315 1316 1317 1318 1319
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
1320

1321
		if (!$outer || $level <= 1) {
1322
			push(@res, $rawlines[$line]);
1323 1324
		}

1325
		last if ($level == 0);
1326 1327
	}

1328
	return ($level, @res);
1329 1330 1331 1332
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

1333 1334
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
1335 1336 1337 1338
}
sub ctx_block {
	my ($linenr, $remain) = @_;

1339 1340
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
1341 1342
}
sub ctx_statement {
1343 1344 1345 1346 1347 1348
	my ($linenr, $remain, $off) = @_;

	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
	return @r;
}
sub ctx_block_level {
1349 1350
	my ($linenr, $remain) = @_;

1351
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1352
}
1353 1354 1355 1356 1357
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
1358 1359 1360 1361 1362

sub ctx_locate_comment {
	my ($first_line, $end_line) = @_;

	# Catch a comment on the end of the line itself.
1363
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1364 1365 1366 1367 1368 1369 1370
	return $current_comment if (defined $current_comment);

	# Look through the context and try and figure out if there is a
	# comment.
	my $in_comment = 0;
	$current_comment = '';
	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1371 1372
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
		if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
			$in_comment = 1;
		}
		if ($line =~ m@/\*@) {
			$in_comment = 1;
		}
		if (!$in_comment && $current_comment ne '') {
			$current_comment = '';
		}
		$current_comment .= $line . "\n" if ($in_comment);
		if ($line =~ m@\*/@) {
			$in_comment = 0;
		}
	}

	chomp($current_comment);
	return($current_comment);
}
sub ctx_has_comment {
	my ($first_line, $end_line) = @_;
	my $cmt = ctx_locate_comment($first_line, $end_line);

1395
	##print "LINE: $rawlines[$end_line - 1 ]\n";
1396 1397 1398 1399 1400
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
sub raw_line {
	my ($linenr, $cnt) = @_;

	my $offset = $linenr - 1;
	$cnt++;

	my $line;
	while ($cnt) {
		$line = $rawlines[$offset++];
		next if (defined($line) && $line =~ /^-/);
		$cnt--;
	}

	return $line;
}

1417 1418 1419
sub cat_vet {
	my ($vet) = @_;
	my ($res, $coded);
1420

1421 1422 1423 1424 1425 1426
	$res = '';
	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
		$res .= $1;
		if ($2 ne '') {
			$coded = sprintf("^%c", unpack('C', $2) + 64);
			$res .= $coded;
1427 1428
		}
	}
1429
	$res =~ s/$/\$/;
1430

1431
	return $res;
1432 1433
}

1434
my $av_preprocessor = 0;
1435
my $av_pending;
1436
my @av_paren_type;
1437
my $av_pend_colon;
1438 1439 1440

sub annotate_reset {
	$av_preprocessor = 0;
1441 1442
	$av_pending = '_';
	@av_paren_type = ('E');
1443
	$av_pend_colon = 'O';
1444 1445
}

1446 1447
sub annotate_values {
	my ($stream, $type) = @_;
1448

1449
	my $res;
1450
	my $var = '_' x length($stream);
1451 1452
	my $cur = $stream;

1453
	print "$stream\n" if ($dbg_values > 1);
1454 1455

	while (length($cur)) {
1456
		@av_paren_type = ('E') if ($#av_paren_type < 0);
1457
		print " <" . join('', @av_paren_type) .
1458
				"> <$type> <$av_pending>" if ($dbg_values > 1);
1459
		if ($cur =~ /^(\s+)/o) {
1460 1461
			print "WS($1)\n" if ($dbg_values > 1);
			if ($1 =~ /\n/ && $av_preprocessor) {
1462
				$type = pop(@av_paren_type);
1463
				$av_preprocessor = 0;
1464 1465
			}

1466
		} elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1467 1468
			print "CAST($1)\n" if ($dbg_values > 1);
			push(@av_paren_type, $type);
1469
			$type = 'c';
1470

1471
		} elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1472
			print "DECLARE($1)\n" if ($dbg_values > 1);
1473 1474
			$type = 'T';

1475 1476 1477 1478
		} elsif ($cur =~ /^($Modifier)\s*/) {
			print "MODIFIER($1)\n" if ($dbg_values > 1);
			$type = 'T';

1479
		} elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1480
			print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1481
			$av_preprocessor = 1;
1482 1483 1484 1485 1486 1487
			push(@av_paren_type, $type);
			if ($2 ne '') {
				$av_pending = 'N';
			}
			$type = 'E';

1488
		} elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1489 1490 1491
			print "UNDEF($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;
			push(@av_paren_type, $type);
1492

1493
		} elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1494
			print "PRE_START($1)\n" if ($dbg_values > 1);
1495
			$av_preprocessor = 1;
1496 1497 1498

			push(@av_paren_type, $type);
			push(@av_paren_type, $type);
1499
			$type = 'E';
1500

1501
		} elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1502 1503 1504 1505 1506
			print "PRE_RESTART($1)\n" if ($dbg_values > 1);
			$av_preprocessor = 1;

			push(@av_paren_type, $av_paren_type[$#av_paren_type]);

1507
			$type = 'E';
1508

1509
		} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1510 1511 1512 1513 1514 1515 1516 1517
			print "PRE_END($1)\n" if ($dbg_values > 1);

			$av_preprocessor = 1;

			# Assume all arms of the conditional end as this
			# one does, and continue as if the #endif was not here.
			pop(@av_paren_type);
			push(@av_paren_type, $type);
1518
			$type = 'E';
1519 1520

		} elsif ($cur =~ /^(\\\n)/o) {
1521
			print "PRECONT($1)\n" if ($dbg_values > 1);
1522

1523 1524 1525 1526 1527
		} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
			print "ATTR($1)\n" if ($dbg_values > 1);
			$av_pending = $type;
			$type = 'N';

1528
		} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1529
			print "SIZEOF($1)\n" if ($dbg_values > 1);
1530
			if (defined $2) {
1531
				$av_pending = 'V';
1532 1533 1534
			}
			$type = 'N';

1535
		} elsif ($cur =~ /^(if|while|for)\b/o) {
1536
			print "COND($1)\n" if ($dbg_values > 1);
1537
			$av_pending = 'E';
1538 1539
			$type = 'N';

1540 1541 1542 1543 1544
		} elsif ($cur =~/^(case)/o) {
			print "CASE($1)\n" if ($dbg_values > 1);
			$av_pend_colon = 'C';
			$type = 'N';

1545
		} elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1546
			print "KEYWORD($1)\n" if ($dbg_values > 1);
1547 1548 1549
			$type = 'N';

		} elsif ($cur =~ /^(\()/o) {
1550
			print "PAREN('$1')\n" if ($dbg_values > 1);
1551 1552
			push(@av_paren_type, $av_pending);
			$av_pending = '_';
1553 1554 1555
			$type = 'N';

		} elsif ($cur =~ /^(\))/o) {
1556 1557 1558
			my $new_type = pop(@av_paren_type);
			if ($new_type ne '_') {
				$type = $new_type;
1559 1560
				print "PAREN('$1') -> $type\n"
							if ($dbg_values > 1);
1561
			} else {
1562
				print "PAREN('$1')\n" if ($dbg_values > 1);
1563 1564
			}

1565
		} elsif ($cur =~ /^($Ident)\s*\(/o) {
1566
			print "FUNC($1)\n" if ($dbg_values > 1);
1567
			$type = 'V';
1568
			$av_pending = 'V';
1569

1570 1571
		} elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
			if (defined $2 && $type eq 'C' || $type eq 'T') {
1572
				$av_pend_colon = 'B';
1573 1574
			} elsif ($type eq 'E') {
				$av_pend_colon = 'L';
1575 1576 1577 1578
			}
			print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
			$type = 'V';

1579
		} elsif ($cur =~ /^($Ident|$Constant)/o) {
1580
			print "IDENT($1)\n" if ($dbg_values > 1);
1581 1582 1583
			$type = 'V';

		} elsif ($cur =~ /^($Assignment)/o) {
1584
			print "ASSIGN($1)\n" if ($dbg_values > 1);
1585 1586
			$type = 'N';

1587
		} elsif ($cur =~/^(;|{|})/) {
1588
			print "END($1)\n" if ($dbg_values > 1);
1589
			$type = 'E';
1590 1591
			$av_pend_colon = 'O';

1592 1593 1594 1595
		} elsif ($cur =~/^(,)/) {
			print "COMMA($1)\n" if ($dbg_values > 1);
			$type = 'C';

1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
		} elsif ($cur =~ /^(\?)/o) {
			print "QUESTION($1)\n" if ($dbg_values > 1);
			$type = 'N';

		} elsif ($cur =~ /^(:)/o) {
			print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);

			substr($var, length($res), 1, $av_pend_colon);
			if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
				$type = 'E';
			} else {
				$type = 'N';
			}
			$av_pend_colon = 'O';
1610

1611
		} elsif ($cur =~ /^(\[)/o) {
1612
			print "CLOSE($1)\n" if ($dbg_values > 1);
1613 1614
			$type = 'N';

1615
		} elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
			my $variant;

			print "OPV($1)\n" if ($dbg_values > 1);
			if ($type eq 'V') {
				$variant = 'B';
			} else {
				$variant = 'U';
			}

			substr($var, length($res), 1, $variant);
			$type = 'N';

1628
		} elsif ($cur =~ /^($Operators)/o) {
1629
			print "OP($1)\n" if ($dbg_values > 1);
1630 1631 1632 1633 1634
			if ($1 ne '++' && $1 ne '--') {
				$type = 'N';
			}

		} elsif ($cur =~ /(^.)/o) {
1635
			print "C($1)\n" if ($dbg_values > 1);
1636 1637 1638 1639 1640
		}
		if (defined $1) {
			$cur = substr($cur, length($1));
			$res .= $type x length($1);
		}
1641
	}
1642

1643
	return ($res, $var);
1644 1645
}

1646
sub possible {
1647
	my ($possible, $line) = @_;
1648
	my $notPermitted = qr{(?:
1649 1650 1651 1652
		^(?:
			$Modifier|
			$Storage|
			$Type|
1653 1654 1655
			DEFINE_\S+
		)$|
		^(?:
1656 1657 1658 1659 1660
			goto|
			return|
			case|
			else|
			asm|__asm__|
1661 1662 1663
			do|
			\#|
			\#\#|
1664
		)(?:\s|$)|
1665
		^(?:typedef|struct|enum)\b
1666 1667 1668
	    )}x;
	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
	if ($possible !~ $notPermitted) {
1669 1670 1671 1672 1673 1674 1675
		# Check for modifiers.
		$possible =~ s/\s*$Storage\s*//g;
		$possible =~ s/\s*$Sparse\s*//g;
		if ($possible =~ /^\s*$/) {

		} elsif ($possible =~ /\s/) {
			$possible =~ s/\s*$Type\s*//g;
1676
			for my $modifier (split(' ', $possible)) {
1677 1678
				if ($modifier !~ $notPermitted) {
					warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1679
					push(@modifierListFile, $modifier);
1680
				}
1681
			}
1682 1683 1684

		} else {
			warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1685
			push(@typeListFile, $possible);
1686
		}
1687
		build_types();
1688 1689
	} else {
		warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1690 1691 1692
	}
}

1693 1694
my $prefix = '';

1695
sub show_type {
1696
	my ($type) = @_;
1697

1698 1699 1700
	return defined $use_type{$type} if (scalar keys %use_type > 0);

	return !defined $ignore_type{$type};
1701 1702
}

1703
sub report {
1704 1705 1706 1707
	my ($level, $type, $msg) = @_;

	if (!show_type($type) ||
	    (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1708 1709
		return 0;
	}
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
	my $output = '';
	if (-t STDOUT && $color) {
		if ($level eq 'ERROR') {
			$output .= RED;
		} elsif ($level eq 'WARNING') {
			$output .= YELLOW;
		} else {
			$output .= GREEN;
		}
	}
	$output .= $prefix . $level . ':';
1721
	if ($show_types) {
1722 1723
		$output .= BLUE if (-t STDOUT && $color);
		$output .= "$type:";
1724
	}
1725 1726
	$output .= RESET if (-t STDOUT && $color);
	$output .= ' ' . $msg . "\n";
1727 1728 1729 1730 1731 1732

	if ($showfile) {
		my @lines = split("\n", $output, -1);
		splice(@lines, 1, 1);
		$output = join("\n", @lines);
	}
1733
	$output = (split('\n', $output))[0] . "\n" if ($terse);
1734

1735
	push(our @report, $output);
1736 1737

	return 1;
1738
}
1739

1740
sub report_dump {
1741
	our @report;
1742
}
1743

1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
sub fixup_current_range {
	my ($lineRef, $offset, $length) = @_;

	if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
		my $o = $1;
		my $l = $2;
		my $no = $o + $offset;
		my $nl = $l + $length;
		$$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
	}
}

sub fix_inserted_deleted_lines {
	my ($linesRef, $insertedRef, $deletedRef) = @_;

	my $range_last_linenr = 0;
	my $delta_offset = 0;

	my $old_linenr = 0;
	my $new_linenr = 0;

	my $next_insert = 0;
	my $next_delete = 0;

	my @lines = ();

	my $inserted = @{$insertedRef}[$next_insert++];
	my $deleted = @{$deletedRef}[$next_delete++];

	foreach my $old_line (@{$linesRef}) {
		my $save_line = 1;
		my $line = $old_line;	#don't modify the array
1776
		if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {	#new filename
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
			$delta_offset = 0;
		} elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {	#new hunk
			$range_last_linenr = $new_linenr;
			fixup_current_range(\$line, $delta_offset, 0);
		}

		while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
			$deleted = @{$deletedRef}[$next_delete++];
			$save_line = 0;
			fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
		}

		while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
			push(@lines, ${$inserted}{'LINE'});
			$inserted = @{$insertedRef}[$next_insert++];
			$new_linenr++;
			fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
		}

		if ($save_line) {
			push(@lines, $line);
			$new_linenr++;
		}

		$old_linenr++;
	}

	return @lines;
}

1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827
sub fix_insert_line {
	my ($linenr, $line) = @_;

	my $inserted = {
		LINENR => $linenr,
		LINE => $line,
	};
	push(@fixed_inserted, $inserted);
}

sub fix_delete_line {
	my ($linenr, $line) = @_;

	my $deleted = {
		LINENR => $linenr,
		LINE => $line,
	};

	push(@fixed_deleted, $deleted);
}

1828
sub ERROR {
1829 1830 1831
	my ($type, $msg) = @_;

	if (report("ERROR", $type, $msg)) {
1832 1833
		our $clean = 0;
		our $cnt_error++;
1834
		return 1;
1835
	}
1836
	return 0;
1837 1838
}
sub WARN {
1839 1840 1841
	my ($type, $msg) = @_;

	if (report("WARNING", $type, $msg)) {
1842 1843
		our $clean = 0;
		our $cnt_warn++;
1844
		return 1;
1845
	}
1846
	return 0;
1847 1848
}
sub CHK {
1849 1850 1851
	my ($type, $msg) = @_;

	if ($check && report("CHECK", $type, $msg)) {
1852 1853
		our $clean = 0;
		our $cnt_chk++;
1854
		return 1;
1855
	}
1856
	return 0;
1857 1858
}

1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881
sub check_absolute_file {
	my ($absolute, $herecurr) = @_;
	my $file = $absolute;

	##print "absolute<$absolute>\n";

	# See if any suffix of this path is a path within the tree.
	while ($file =~ s@^[^/]*/@@) {
		if (-f "$root/$file") {
			##print "file<$file>\n";
			last;
		}
	}
	if (! -f _)  {
		return 0;
	}

	# It is, so see if the prefix is acceptable.
	my $prefix = $absolute;
	substr($prefix, -length($file)) = '';

	##print "prefix<$prefix>\n";
	if ($prefix ne ".../") {
1882 1883
		WARN("USE_RELATIVE_PATH",
		     "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1884 1885 1886
	}
}

1887 1888 1889
sub trim {
	my ($string) = @_;

1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
	$string =~ s/^\s+|\s+$//g;

	return $string;
}

sub ltrim {
	my ($string) = @_;

	$string =~ s/^\s+//;

	return $string;
}

sub rtrim {
	my ($string) = @_;

	$string =~ s/\s+$//;
1907 1908 1909 1910

	return $string;
}

1911 1912 1913 1914 1915 1916 1917 1918
sub string_find_replace {
	my ($string, $find, $replace) = @_;

	$string =~ s/$find/$replace/g;

	return $string;
}

1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933
sub tabify {
	my ($leading) = @_;

	my $source_indent = 8;
	my $max_spaces_before_tab = $source_indent - 1;
	my $spaces_to_tab = " " x $source_indent;

	#convert leading spaces to tabs
	1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
	#Remove spaces before a tab
	1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;

	return "$leading";
}

1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
sub pos_last_openparen {
	my ($line) = @_;

	my $pos = 0;

	my $opens = $line =~ tr/\(/\(/;
	my $closes = $line =~ tr/\)/\)/;

	my $last_openparen = 0;

	if (($opens == 0) || ($closes >= $opens)) {
		return -1;
	}

	my $len = length($line);

	for ($pos = 0; $pos < $len; $pos++) {
		my $string = substr($line, $pos);
		if ($string =~ /^($FuncArg|$balanced_parens)/) {
			$pos += length($1) - 1;
		} elsif (substr($line, $pos, 1) eq '(') {
			$last_openparen = $pos;
		} elsif (index($string, '(') == -1) {
			last;
		}
	}

1961
	return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1962 1963
}

1964 1965 1966 1967 1968
sub process {
	my $filename = shift;

	my $linenr=0;
	my $prevline="";
1969
	my $prevrawline="";
1970
	my $stashline="";
1971
	my $stashrawline="";
1972

1973
	my $length;
1974 1975 1976 1977
	my $indent;
	my $previndent=0;
	my $stashindent=0;

1978
	our $clean = 1;
1979 1980
	my $signoff = 0;
	my $is_patch = 0;
1981
	my $in_header_lines = $file ? 0 : 1;
1982
	my $in_commit_log = 0;		#Scanning lines before patch
1983
       my $commit_log_possible_stack_dump = 0;
1984
	my $commit_log_long_line = 0;
1985
	my $commit_log_has_diff = 0;
1986
	my $reported_maintainer_file = 0;
1987 1988
	my $non_utf8_charset = 0;

1989
	my $last_blank_line = 0;
1990
	my $last_coalesced_string_linenr = -1;
1991

1992
	our @report = ();
1993 1994 1995 1996 1997
	our $cnt_lines = 0;
	our $cnt_error = 0;
	our $cnt_warn = 0;
	our $cnt_chk = 0;

1998 1999 2000 2001 2002 2003
	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
2004
	my $comment_edge = 0;
2005
	my $first_line = 0;
2006
	my $p1_prefix = '';
2007

2008 2009 2010
	my $prev_values = 'E';

	# suppression flags
2011
	my %suppress_ifbraces;
2012
	my %suppress_whiletrailers;
2013
	my %suppress_export;
2014
	my $suppress_statement = 0;
2015

2016
	my %signatures = ();
2017

2018
	# Pre-scan the patch sanitizing the lines.
2019
	# Pre-scan the patch looking for any __setup documentation.
2020
	#
2021 2022
	my @setup_docs = ();
	my $setup_docs = 0;
2023

2024 2025
	my $camelcase_file_seeded = 0;

2026
	sanitise_line_reset();
2027 2028
	my $line;
	foreach my $rawline (@rawlines) {
2029 2030
		$linenr++;
		$line = $rawline;
2031

2032 2033
		push(@fixed, $rawline) if ($fix);

2034
		if ($rawline=~/^\+\+\+\s+(\S+)/) {
2035 2036 2037 2038
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
2039 2040 2041 2042 2043 2044 2045 2046 2047
			#next;
		}
		if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
2048
			$in_comment = 0;
2049 2050 2051 2052 2053 2054

			# Guestimate if this is a continuing comment.  Run
			# the context looking for a comment "edge".  If this
			# edge is a close comment then we must be in a comment
			# at context start.
			my $edge;
2055 2056 2057 2058 2059 2060
			my $cnt = $realcnt;
			for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
				next if (defined $rawlines[$ln - 1] &&
					 $rawlines[$ln - 1] =~ /^-/);
				$cnt--;
				#print "RAW<$rawlines[$ln - 1]>\n";
2061
				last if (!defined $rawlines[$ln - 1]);
2062 2063 2064 2065 2066
				if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
				    $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
					($edge) = $1;
					last;
				}
2067 2068 2069 2070 2071 2072 2073 2074 2075
			}
			if (defined $edge && $edge eq '*/') {
				$in_comment = 1;
			}

			# Guestimate if this is a continuing comment.  If this
			# is the start of a diff block and this line starts
			# ' *' then it is very likely a comment.
			if (!defined $edge &&
2076
			    $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2077 2078 2079 2080 2081 2082 2083
			{
				$in_comment = 1;
			}

			##print "COMMENT:$in_comment edge<$edge> $rawline\n";
			sanitise_line_reset($in_comment);

2084
		} elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2085
			# Standardise the strings and chars within the input to
2086
			# simplify matching -- only bother with positive lines.
2087
			$line = sanitise_line($rawline);
2088
		}
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
		push(@lines, $line);

		if ($realcnt > 1) {
			$realcnt-- if ($line =~ /^(?:\+| |$)/);
		} else {
			$realcnt = 0;
		}

		#print "==>$rawline\n";
		#print "-->$line\n";
2099 2100 2101 2102 2103 2104

		if ($setup_docs && $line =~ /^\+/) {
			push(@setup_docs, $line);
		}
	}

2105 2106
	$prefix = '';

2107 2108
	$realcnt = 0;
	$linenr = 0;
2109
	$fixlinenr = -1;
2110 2111
	foreach my $line (@lines) {
		$linenr++;
2112
		$fixlinenr++;
2113 2114
		my $sline = $line;	#copy of $line
		$sline =~ s/$;/ /g;	#with comments as spaces
2115

2116
		my $rawline = $rawlines[$linenr - 1];
2117

2118
#extract the line range in the file after the patch is applied
2119 2120
		if (!$in_commit_log &&
		    $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2121
			$is_patch = 1;
2122
			$first_line = $linenr + 1;
2123 2124 2125 2126 2127 2128
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
2129
			annotate_reset();
2130 2131
			$prev_values = 'E';

2132
			%suppress_ifbraces = ();
2133
			%suppress_whiletrailers = ();
2134
			%suppress_export = ();
2135
			$suppress_statement = 0;
2136 2137
			next;

2138 2139 2140
# track the line number as we move through the hunk, note that
# new versions of GNU diff omit the leading space on completely
# blank context lines so we need to count that too.
2141
		} elsif ($line =~ /^( |\+|$)/) {
2142
			$realline++;
2143
			$realcnt-- if ($realcnt != 0);
2144

2145
			# Measure the line length and indent.
2146
			($length, $indent) = line_stats($rawline);
2147 2148 2149 2150

			# Track the previous line.
			($prevline, $stashline) = ($stashline, $line);
			($previndent, $stashindent) = ($stashindent, $indent);
2151 2152
			($prevrawline, $stashrawline) = ($stashrawline, $rawline);

2153
			#warn "line<$line>\n";
2154

2155 2156
		} elsif ($realcnt == 1) {
			$realcnt--;
2157 2158
		}

2159 2160
		my $hunk_line = ($realcnt != 0);

2161 2162
		$here = "#$linenr: " if (!$file);
		$here = "#$realline: " if ($file);
2163

2164
		my $found_file = 0;
2165
		# extract the filename as it passes
2166 2167
		if ($line =~ /^diff --git.*?(\S+)$/) {
			$realfile = $1;
2168
			$realfile =~ s@^([^/]*)/@@ if (!$file);
2169
			$in_commit_log = 0;
2170
			$found_file = 1;
2171
		} elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2172
			$realfile = $1;
2173
			$realfile =~ s@^([^/]*)/@@ if (!$file);
2174
			$in_commit_log = 0;
2175 2176

			$p1_prefix = $1;
2177 2178
			if (!$file && $tree && $p1_prefix ne '' &&
			    -e "$root/$p1_prefix") {
2179 2180
				WARN("PATCH_PREFIX",
				     "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2181
			}
2182

2183
			if ($realfile =~ m@^include/asm/@) {
2184 2185
				ERROR("MODIFIED_INCLUDE_ASM",
				      "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2186
			}
2187 2188 2189
			$found_file = 1;
		}

2190 2191 2192 2193
#make up the handle for any error we report on this line
		if ($showfile) {
			$prefix = "$realfile:$realline: "
		} elsif ($emacs) {
2194 2195 2196 2197 2198
			if ($file) {
				$prefix = "$filename:$realline: ";
			} else {
				$prefix = "$filename:$linenr: ";
			}
2199 2200
		}

2201
		if ($found_file) {
2202
			if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2203 2204 2205 2206
				$check = 1;
			} else {
				$check = $check_orig;
			}
2207 2208 2209
			next;
		}

2210
		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2211

2212 2213 2214
		my $hereline = "$here\n$rawline\n";
		my $herecurr = "$here\n$rawline\n";
		my $hereprev = "$here\n$prevrawline\n$rawline\n";
2215

2216 2217
		$cnt_lines++ if ($realcnt != 0);

2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
# Check if the commit log has what seems like a diff which can confuse patch
		if ($in_commit_log && !$commit_log_has_diff &&
		    (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
		      $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
		     $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
		     $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
			ERROR("DIFF_IN_COMMIT_MSG",
			      "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
			$commit_log_has_diff = 1;
		}

2229 2230 2231
# Check for incorrect file permissions
		if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
			my $permhere = $here . "FILE: $realfile\n";
2232 2233
			if ($realfile !~ m@scripts/@ &&
			    $realfile !~ /\.(py|pl|awk|sh)$/) {
2234 2235
				ERROR("EXECUTE_PERMISSIONS",
				      "do not set execute permissions for source files\n" . $permhere);
2236 2237 2238
			}
		}

2239
# Check the patch for a signoff:
2240
		if ($line =~ /^\s*signed-off-by:/i) {
2241
			$signoff++;
2242
			$in_commit_log = 0;
2243 2244
		}

2245 2246 2247 2248 2249 2250
# Check if MAINTAINERS is being updated.  If so, there's probably no need to
# emit the "does MAINTAINERS need updating?" message on file add/move/delete
		if ($line =~ /^\s*MAINTAINERS\s*\|/) {
			$reported_maintainer_file = 1;
		}

2251
# Check signature styles
2252
		if (!$in_header_lines &&
2253
		    $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2254 2255 2256 2257 2258 2259
			my $space_before = $1;
			my $sign_off = $2;
			my $space_after = $3;
			my $email = $4;
			my $ucfirst_sign_off = ucfirst(lc($sign_off));

2260 2261 2262 2263
			if ($sign_off !~ /$signature_tags/) {
				WARN("BAD_SIGN_OFF",
				     "Non-standard signature: $sign_off\n" . $herecurr);
			}
2264
			if (defined $space_before && $space_before ne "") {
2265 2266 2267
				if (WARN("BAD_SIGN_OFF",
					 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
				    $fix) {
2268
					$fixed[$fixlinenr] =
2269 2270
					    "$ucfirst_sign_off $email";
				}
2271 2272
			}
			if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2273 2274 2275
				if (WARN("BAD_SIGN_OFF",
					 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
				    $fix) {
2276
					$fixed[$fixlinenr] =
2277 2278 2279
					    "$ucfirst_sign_off $email";
				}

2280 2281
			}
			if (!defined $space_after || $space_after ne " ") {
2282 2283 2284
				if (WARN("BAD_SIGN_OFF",
					 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
				    $fix) {
2285
					$fixed[$fixlinenr] =
2286 2287
					    "$ucfirst_sign_off $email";
				}
2288
			}
2289 2290 2291 2292

			my ($email_name, $email_address, $comment) = parse_email($email);
			my $suggested_email = format_email(($email_name, $email_address));
			if ($suggested_email eq "") {
2293 2294
				ERROR("BAD_SIGN_OFF",
				      "Unrecognized email address: '$email'\n" . $herecurr);
2295 2296 2297 2298 2299 2300 2301 2302 2303
			} else {
				my $dequoted = $suggested_email;
				$dequoted =~ s/^"//;
				$dequoted =~ s/" </ </;
				# Don't force email to have quotes
				# Allow just an angle bracketed address
				if ("$dequoted$comment" ne $email &&
				    "<$email_address>$comment" ne $email &&
				    "$suggested_email$comment" ne $email) {
2304 2305
					WARN("BAD_SIGN_OFF",
					     "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2306
				}
2307
			}
2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318

# Check for duplicate signatures
			my $sig_nospace = $line;
			$sig_nospace =~ s/\s//g;
			$sig_nospace = lc($sig_nospace);
			if (defined $signatures{$sig_nospace}) {
				WARN("BAD_SIGN_OFF",
				     "Duplicate signature\n" . $herecurr);
			} else {
				$signatures{$sig_nospace} = 1;
			}
2319 2320
		}

2321 2322 2323 2324 2325 2326 2327
# Check email subject for common tools that don't need to be mentioned
		if ($in_header_lines &&
		    $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
			WARN("EMAIL_SUBJECT",
			     "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
		}

2328 2329 2330 2331 2332 2333
# Check for old stable address
		if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
			ERROR("STABLE_ADDRESS",
			      "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
		}

2334 2335 2336 2337 2338 2339
# Check for unwanted Gerrit info
		if ($in_commit_log && $line =~ /^\s*change-id:/i) {
			ERROR("GERRIT_CHANGE_ID",
			      "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
		}

2340 2341 2342 2343 2344 2345 2346 2347 2348 2349
# Check if the commit log is in a possible stack dump
		if ($in_commit_log && !$commit_log_possible_stack_dump &&
		    ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
		     $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
					# timestamp
		     $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
					# stack dump address
			$commit_log_possible_stack_dump = 1;
		}

2350 2351
# Check for line lengths > 75 in commit log, warn once
		if ($in_commit_log && !$commit_log_long_line &&
2352 2353 2354 2355 2356 2357 2358 2359
		    length($line) > 75 &&
		    !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
					# file delta changes
		      $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
					# filename then :
		      $line =~ /^\s*(?:Fixes:|Link:)/i ||
					# A Fixes: or Link: line
		      $commit_log_possible_stack_dump)) {
2360 2361 2362 2363 2364
			WARN("COMMIT_LOG_LONG_LINE",
			     "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
			$commit_log_long_line = 1;
		}

2365
# Reset possible stack dump if a blank line is found
2366 2367 2368 2369
		if ($in_commit_log && $commit_log_possible_stack_dump &&
		    $line =~ /^\s*$/) {
			$commit_log_possible_stack_dump = 0;
		}
2370

2371
# Check for git id commit length and improperly formed commit descriptions
2372
		if ($in_commit_log && !$commit_log_possible_stack_dump &&
2373
		    ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2374 2375 2376
		     ($line =~ /\b[0-9a-f]{12,40}\b/i &&
		      $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
		      $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2377 2378
			my $init_char = "c";
			my $orig_commit = "";
2379 2380 2381 2382 2383
			my $short = 1;
			my $long = 0;
			my $case = 1;
			my $space = 1;
			my $hasdesc = 0;
2384
			my $hasparens = 0;
2385 2386 2387 2388
			my $id = '0123456789ab';
			my $orig_desc = "commit description";
			my $description = "";

2389 2390 2391 2392 2393 2394 2395
			if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
				$init_char = $1;
				$orig_commit = lc($2);
			} elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
				$orig_commit = lc($1);
			}

2396 2397 2398 2399 2400 2401
			$short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
			$long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
			$space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
			$case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
			if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
				$orig_desc = $1;
2402
				$hasparens = 1;
2403 2404 2405 2406
			} elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
				 defined $rawlines[$linenr] &&
				 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
				$orig_desc = $1;
2407
				$hasparens = 1;
2408 2409 2410 2411 2412 2413 2414
			} elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
				 defined $rawlines[$linenr] &&
				 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
				$line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
				$orig_desc = $1;
				$rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
				$orig_desc .= " " . $1;
2415
				$hasparens = 1;
2416 2417 2418 2419 2420
			}

			($id, $description) = git_commit_info($orig_commit,
							      $id, $orig_desc);

2421
			if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2422 2423 2424
				ERROR("GIT_COMMIT_ID",
				      "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
			}
2425 2426
		}

2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437
# Check for added, moved or deleted files
		if (!$reported_maintainer_file && !$in_commit_log &&
		    ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
		     $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
		     ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
		      (defined($1) || defined($2))))) {
			$reported_maintainer_file = 1;
			WARN("FILE_PATH_CHANGES",
			     "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
		}

2438
# Check for wrappage within a valid hunk of the file
2439
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2440 2441
			ERROR("CORRUPTED_PATCH",
			      "patch seems to be corrupt (line wrapped?)\n" .
2442
				$herecurr) if (!$emitted_corrupt++);
2443 2444
		}

2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
# Check for absolute kernel paths.
		if ($tree) {
			while ($line =~ m{(?:^|\s)(/\S*)}g) {
				my $file = $1;

				if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
				    check_absolute_file($1, $herecurr)) {
					#
				} else {
					check_absolute_file($file, $herecurr);
				}
			}
		}

2459 2460
# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2461 2462 2463 2464 2465 2466 2467
		    $rawline !~ m/^$UTF8*$/) {
			my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);

			my $blank = copy_spacing($rawline);
			my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
			my $hereptr = "$hereline$ptr\n";

2468 2469
			CHK("INVALID_UTF8",
			    "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2470 2471
		}

2472 2473 2474
# Check if it's the start of a commit log
# (not a header line and we haven't seen the patch filename)
		if ($in_header_lines && $realfile =~ /^$/ &&
2475 2476
		    !($rawline =~ /^\s+\S/ ||
		      $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2477 2478 2479 2480
			$in_header_lines = 0;
			$in_commit_log = 1;
		}

2481 2482 2483 2484 2485 2486 2487 2488 2489
# Check if there is UTF-8 in a commit log when a mail header has explicitly
# declined it, i.e defined some charset where it is missing.
		if ($in_header_lines &&
		    $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
		    $1 !~ /utf-8/i) {
			$non_utf8_charset = 1;
		}

		if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2490
		    $rawline =~ /$NON_ASCII_UTF8/) {
2491
			WARN("UTF8_BEFORE_PATCH",
2492 2493 2494
			    "8-bit UTF-8 used in possible commit log\n" . $herecurr);
		}

2495
# Check for various typo / spelling mistakes
2496 2497
		if (defined($misspellings) &&
		    ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2498
			while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512
				my $typo = $1;
				my $typo_fix = $spelling_fix{lc($typo)};
				$typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
				$typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
				my $msg_type = \&WARN;
				$msg_type = \&CHK if ($file);
				if (&{$msg_type}("TYPO_SPELLING",
						 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
				    $fix) {
					$fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
				}
			}
		}

2513 2514
# ignore non-hunk lines and lines being removed
		next if (!$hunk_line || $line =~ /^-/);
2515 2516

#trailing whitespace
2517
		if ($line =~ /^\+.*\015/) {
2518
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2519 2520 2521
			if (ERROR("DOS_LINE_ENDINGS",
				  "DOS line endings\n" . $herevet) &&
			    $fix) {
2522
				$fixed[$fixlinenr] =~ s/[\s\015]+$//;
2523
			}
2524 2525
		} elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2526 2527 2528
			if (ERROR("TRAILING_WHITESPACE",
				  "trailing whitespace\n" . $herevet) &&
			    $fix) {
2529
				$fixed[$fixlinenr] =~ s/\s+$//;
2530 2531
			}

2532
			$rpt_cleaners = 1;
2533
		}
2534

2535
# Check for FSF mailing addresses.
2536
		if ($rawline =~ /\bwrite to the Free/i ||
2537 2538
		    $rawline =~ /\b59\s+Temple\s+Pl/i ||
		    $rawline =~ /\b51\s+Franklin\s+St/i) {
2539 2540 2541 2542
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
			my $msg_type = \&ERROR;
			$msg_type = \&CHK if ($file);
			&{$msg_type}("FSF_MAILING_ADDRESS",
2543
				     "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)
2544 2545
		}

2546
# check for Kconfig help text having a real description
2547 2548
# Only applies when adding the entry originally, after that we do not have
# sufficient context to determine whether it is indeed long enough.
2549
		if ($realfile =~ /Kconfig/ &&
2550
		    $line =~ /^\+\s*config\s+/) {
2551
			my $length = 0;
2552 2553 2554
			my $cnt = $realcnt;
			my $ln = $linenr + 1;
			my $f;
2555
			my $is_start = 0;
2556
			my $is_end = 0;
2557
			for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2558 2559 2560 2561 2562
				$f = $lines[$ln - 1];
				$cnt-- if ($lines[$ln - 1] !~ /^-/);
				$is_end = $lines[$ln - 1] =~ /^\+/;

				next if ($f =~ /^-/);
2563
				last if (!$file && $f =~ /^\@\@/);
2564

2565
				if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2566
					$is_start = 1;
2567
				} elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2568 2569 2570
					$length = -1;
				}

2571
				$f =~ s/^.//;
2572 2573 2574
				$f =~ s/#.*//;
				$f =~ s/^\s+//;
				next if ($f =~ /^$/);
2575 2576 2577 2578
				if ($f =~ /^\s*config\s/) {
					$is_end = 1;
					last;
				}
2579 2580
				$length++;
			}
2581 2582 2583 2584
			if ($is_start && $is_end && $length < $min_conf_desc_length) {
				WARN("CONFIG_DESCRIPTION",
				     "please write a paragraph that describes the config symbol fully\n" . $herecurr);
			}
2585
			#print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2586 2587
		}

2588 2589 2590 2591 2592 2593 2594
# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
		if ($realfile =~ /Kconfig/ &&
		    $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
			WARN("CONFIG_EXPERIMENTAL",
			     "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
		}

2595 2596 2597 2598 2599 2600 2601
# discourage the use of boolean for type definition attributes of Kconfig options
		if ($realfile =~ /Kconfig/ &&
		    $line =~ /^\+\s*\bboolean\b/) {
			WARN("CONFIG_TYPE_BOOLEAN",
			     "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
		}

2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615
		if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
		    ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
			my $flag = $1;
			my $replacement = {
				'EXTRA_AFLAGS' =>   'asflags-y',
				'EXTRA_CFLAGS' =>   'ccflags-y',
				'EXTRA_CPPFLAGS' => 'cppflags-y',
				'EXTRA_LDFLAGS' =>  'ldflags-y',
			};

			WARN("DEPRECATED_VARIABLE",
			     "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
		}

2616
# check for DT compatible documentation
2617 2618 2619 2620
		if (defined $root &&
			(($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
			 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {

2621 2622
			my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;

2623 2624 2625
			my $dt_path = $root . "/Documentation/devicetree/bindings/";
			my $vp_file = $dt_path . "vendor-prefixes.txt";

2626 2627
			foreach my $compat (@compats) {
				my $compat2 = $compat;
2628 2629 2630 2631
				$compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
				my $compat3 = $compat;
				$compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
				`grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2632 2633 2634 2635 2636
				if ( $? >> 8 ) {
					WARN("UNDOCUMENTED_DT_STRING",
					     "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
				}

2637 2638
				next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
				my $vendor = $1;
2639
				`grep -Eq "^$vendor\\b" $vp_file`;
2640 2641
				if ( $? >> 8 ) {
					WARN("UNDOCUMENTED_DT_STRING",
2642
					     "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2643 2644 2645 2646
				}
			}
		}

2647
# check we are in a valid source file if not then ignore this hunk
2648
		next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2649

2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664
# line length limit (with some exclusions)
#
# There are a few types of lines that may extend beyond $max_line_length:
#	logging functions like pr_info that end in a string
#	lines with a single string
#	#defines that are a single string
#
# There are 3 different line length message types:
# LONG_LINE_COMMENT	a comment starts before but extends beyond $max_linelength
# LONG_LINE_STRING	a string starts before but extends beyond $max_line_length
# LONG_LINE		all other lines longer than $max_line_length
#
# if LONG_LINE is ignored, the other 2 types are also ignored
#

2665
		if ($line =~ /^\+/ && $length > $max_line_length) {
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699
			my $msg_type = "LONG_LINE";

			# Check the allowed long line types first

			# logging functions that end in a string that starts
			# before $max_line_length
			if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
			    length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
				$msg_type = "";

			# lines with only strings (w/ possible termination)
			# #defines with only strings
			} elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
				 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
				$msg_type = "";

			# Otherwise set the alternate message types

			# a comment starts before $max_line_length
			} elsif ($line =~ /($;[\s$;]*)$/ &&
				 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
				$msg_type = "LONG_LINE_COMMENT"

			# a quoted string starts before $max_line_length
			} elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
				 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
				$msg_type = "LONG_LINE_STRING"
			}

			if ($msg_type ne "" &&
			    (show_type("LONG_LINE") || show_type($msg_type))) {
				WARN($msg_type,
				     "line over $max_line_length characters\n" . $herecurr);
			}
2700 2701
		}

2702 2703
# check for adding lines without a newline.
		if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2704 2705
			WARN("MISSING_EOF_NEWLINE",
			     "adding a line without newline at end of file\n" . $herecurr);
2706 2707
		}

2708 2709 2710 2711
# Blackfin: use hi/lo macros
		if ($realfile =~ m@arch/blackfin/.*\.S$@) {
			if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
				my $herevet = "$here\n" . cat_vet($line) . "\n";
2712 2713
				ERROR("LO_MACRO",
				      "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2714 2715 2716
			}
			if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
				my $herevet = "$here\n" . cat_vet($line) . "\n";
2717 2718
				ERROR("HI_MACRO",
				      "use the HI() macro, not (... >> 16)\n" . $herevet);
2719 2720 2721
			}
		}

2722
# check we are in a valid source file C or perl if not then ignore this hunk
2723
		next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2724 2725 2726

# at the beginning of a line any tabs must come first and anything
# more than 8 must use tabs.
2727 2728 2729
		if ($rawline =~ /^\+\s* \t\s*\S/ ||
		    $rawline =~ /^\+\s*        \s*/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2730
			$rpt_cleaners = 1;
2731 2732 2733
			if (ERROR("CODE_INDENT",
				  "code indent should use tabs where possible\n" . $herevet) &&
			    $fix) {
2734
				$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2735
			}
2736 2737
		}

2738 2739 2740
# check for space before tabs.
		if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2741 2742 2743
			if (WARN("SPACE_BEFORE_TAB",
				"please, no space before tabs\n" . $herevet) &&
			    $fix) {
2744
				while ($fixed[$fixlinenr] =~
2745
					   s/(^\+.*) {8,8}\t/$1\t\t/) {}
2746
				while ($fixed[$fixlinenr] =~
2747
					   s/(^\+.*) +\t/$1\t/) {}
2748
			}
2749 2750
		}

2751 2752 2753 2754 2755 2756 2757 2758
# check for && or || at the start of a line
		if ($rawline =~ /^\+\s*(&&|\|\|)/) {
			CHK("LOGICAL_CONTINUATIONS",
			    "Logical continuations should be on the previous line\n" . $hereprev);
		}

# check multi-line statement indentation matches previous line
		if ($^V && $^V ge 5.10.0 &&
2759
		    $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2760 2761 2762 2763 2764 2765
			$prevline =~ /^\+(\t*)(.*)$/;
			my $oldindent = $1;
			my $rest = $2;

			my $pos = pos_last_openparen($rest);
			if ($pos >= 0) {
J
Joe Perches 已提交
2766 2767
				$line =~ /^(\+| )([ \t]*)/;
				my $newindent = $2;
2768 2769 2770 2771 2772 2773 2774 2775

				my $goodtabindent = $oldindent .
					"\t" x ($pos / 8) .
					" "  x ($pos % 8);
				my $goodspaceindent = $oldindent . " "  x $pos;

				if ($newindent ne $goodtabindent &&
				    $newindent ne $goodspaceindent) {
2776 2777 2778 2779

					if (CHK("PARENTHESIS_ALIGNMENT",
						"Alignment should match open parenthesis\n" . $hereprev) &&
					    $fix && $line =~ /^\+/) {
2780
						$fixed[$fixlinenr] =~
2781 2782
						    s/^\+[ \t]*/\+$goodtabindent/;
					}
2783 2784 2785 2786
				}
			}
		}

2787 2788 2789 2790 2791 2792 2793 2794 2795
# check for space after cast like "(int) foo" or "(struct foo) bar"
# avoid checking a few false positives:
#   "sizeof(<type>)" or "__alignof__(<type>)"
#   function pointer declarations like "(*foo)(int) = bar;"
#   structure definitions like "(struct foo) { 0 };"
#   multiline macros that define functions
#   known attributes or the __attribute__ keyword
		if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
		    (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2796
			if (CHK("SPACING",
2797
				"No space is necessary after a cast\n" . $herecurr) &&
2798
			    $fix) {
2799
				$fixed[$fixlinenr] =~
2800
				    s/(\(\s*$Type\s*\))[ \t]+/$1/;
2801
			}
2802 2803
		}

2804 2805
# Block comment styles
# Networking with an initial /*
2806
		if ($realfile =~ m@^(drivers/net/|net/)@ &&
2807
		    $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2808 2809
		    $rawline =~ /^\+[ \t]*\*/ &&
		    $realline > 2) {
2810 2811 2812 2813
			WARN("NETWORKING_BLOCK_COMMENT_STYLE",
			     "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
		}

2814 2815 2816
# Block comments use * on subsequent lines
		if ($prevline =~ /$;[ \t]*$/ &&			#ends in comment
		    $prevrawline =~ /^\+.*?\/\*/ &&		#starting /*
2817
		    $prevrawline !~ /\*\/[ \t]*$/ &&		#no trailing */
2818
		    $rawline =~ /^\+/ &&			#line is new
2819
		    $rawline !~ /^\+[ \t]*\*/) {		#no leading *
2820 2821
			WARN("BLOCK_COMMENT_STYLE",
			     "Block comments use * on subsequent lines\n" . $hereprev);
2822 2823
		}

2824 2825
# Block comments use */ on trailing lines
		if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&	#trailing */
2826 2827 2828
		    $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&	#inline /*...*/
		    $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&	#trailing **/
		    $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {	#non blank */
2829 2830
			WARN("BLOCK_COMMENT_STYLE",
			     "Block comments use a trailing */ on a separate line\n" . $herecurr);
2831 2832
		}

2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
# check for missing blank lines after struct/union declarations
# with exceptions for various attributes and macros
		if ($prevline =~ /^[\+ ]};?\s*$/ &&
		    $line =~ /^\+/ &&
		    !($line =~ /^\+\s*$/ ||
		      $line =~ /^\+\s*EXPORT_SYMBOL/ ||
		      $line =~ /^\+\s*MODULE_/i ||
		      $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
		      $line =~ /^\+[a-z_]*init/ ||
		      $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
		      $line =~ /^\+\s*DECLARE/ ||
		      $line =~ /^\+\s*__setup/)) {
2845 2846 2847
			if (CHK("LINE_SPACING",
				"Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
			    $fix) {
2848
				fix_insert_line($fixlinenr, "\+");
2849
			}
2850 2851
		}

2852 2853 2854 2855
# check for multiple consecutive blank lines
		if ($prevline =~ /^[\+ ]\s*$/ &&
		    $line =~ /^\+\s*$/ &&
		    $last_blank_line != ($linenr - 1)) {
2856 2857 2858
			if (CHK("LINE_SPACING",
				"Please don't use multiple blank lines\n" . $hereprev) &&
			    $fix) {
2859
				fix_delete_line($fixlinenr, $rawline);
2860 2861
			}

2862 2863 2864
			$last_blank_line = $linenr;
		}

2865
# check for missing blank lines after declarations
2866 2867 2868
		if ($sline =~ /^\+\s+\S/ &&			#Not at char 1
			# actual declarations
		    ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2869 2870
			# function pointer declarations
		     $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882
			# foo bar; where foo is some local typedef or #define
		     $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
			# known declaration macros
		     $prevline =~ /^\+\s+$declaration_macros/) &&
			# for "else if" which can look like "$Ident $Ident"
		    !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
			# other possible extensions of declaration lines
		      $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
			# not starting a section or a macro "\" extended line
		      $prevline =~ /(?:\{\s*|\\)$/) &&
			# looks like a declaration
		    !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2883 2884
			# function pointer declarations
		      $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2885 2886 2887 2888 2889
			# foo bar; where foo is some local typedef or #define
		      $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
			# known declaration macros
		      $sline =~ /^\+\s+$declaration_macros/ ||
			# start of struct or union or enum
2890
		      $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2891 2892 2893 2894 2895 2896 2897 2898
			# start or end of block or continuation of declaration
		      $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
			# bitfield continuation
		      $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
			# other possible extensions of declaration lines
		      $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
			# indentation of previous and current line are the same
		    (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2899 2900 2901
			if (WARN("LINE_SPACING",
				 "Missing a blank line after declarations\n" . $hereprev) &&
			    $fix) {
2902
				fix_insert_line($fixlinenr, "\+");
2903
			}
2904 2905
		}

2906
# check for spaces at the beginning of a line.
2907 2908 2909 2910
# Exceptions:
#  1) within comments
#  2) indented preprocessor commands
#  3) hanging labels
2911
		if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2912
			my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2913 2914 2915
			if (WARN("LEADING_SPACE",
				 "please, no spaces at the start of a line\n" . $herevet) &&
			    $fix) {
2916
				$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2917
			}
2918 2919
		}

2920 2921 2922
# check we are in a valid C source file if not then ignore this hunk
		next if ($realfile !~ /\.(h|c)$/);

2923
# check indentation of any line with a bare else
2924
# (but not if it is a multiple line "if (foo) return bar; else return baz;")
2925 2926 2927
# if the previous line is a break or return and is indented 1 tab more...
		if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
			my $tabs = length($1) + 1;
2928 2929 2930 2931
			if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
			    ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
			     defined $lines[$linenr] &&
			     $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
2932 2933 2934 2935 2936
				WARN("UNNECESSARY_ELSE",
				     "else is not generally useful after a break or return\n" . $hereprev);
			}
		}

2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
# check indentation of a line with a break;
# if the previous line is a goto or return and is indented the same # of tabs
		if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
			my $tabs = $1;
			if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
				WARN("UNNECESSARY_BREAK",
				     "break is not useful after a goto or return\n" . $hereprev);
			}
		}

2947 2948 2949 2950 2951 2952
# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
		if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
			WARN("CONFIG_EXPERIMENTAL",
			     "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
		}

2953
# check for RCS/CVS revision markers
2954
		if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2955 2956
			WARN("CVS_KEYWORD",
			     "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2957
		}
2958

2959 2960 2961
# Blackfin: don't use __builtin_bfin_[cs]sync
		if ($line =~ /__builtin_bfin_csync/) {
			my $herevet = "$here\n" . cat_vet($line) . "\n";
2962 2963
			ERROR("CSYNC",
			      "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2964 2965 2966
		}
		if ($line =~ /__builtin_bfin_ssync/) {
			my $herevet = "$here\n" . cat_vet($line) . "\n";
2967 2968
			ERROR("SSYNC",
			      "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2969 2970
		}

2971 2972 2973 2974 2975 2976
# check for old HOTPLUG __dev<foo> section markings
		if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
			WARN("HOTPLUG_SECTION",
			     "Using $1 is unnecessary\n" . $herecurr);
		}

2977
# Check for potential 'bare' types
2978 2979
		my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
		    $realline_next);
2980 2981
#print "LINE<$line>\n";
		if ($linenr >= $suppress_statement &&
2982
		    $realcnt && $sline =~ /.\s*\S/) {
2983
			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2984
				ctx_statement_block($linenr, $realcnt, 0);
2985 2986 2987
			$stat =~ s/\n./\n /g;
			$cond =~ s/\n./\n /g;

2988 2989 2990 2991 2992 2993 2994 2995 2996
#print "linenr<$linenr> <$stat>\n";
			# If this statement has no statement boundaries within
			# it there is no point in retrying a statement scan
			# until we hit end of it.
			my $frag = $stat; $frag =~ s/;+\s*$//;
			if ($frag !~ /(?:{|;)/) {
#print "skip<$line_nr_next>\n";
				$suppress_statement = $line_nr_next;
			}
2997

2998 2999 3000 3001 3002 3003 3004 3005
			# Find the real next line.
			$realline_next = $line_nr_next;
			if (defined $realline_next &&
			    (!defined $lines[$realline_next - 1] ||
			     substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
				$realline_next++;
			}

3006 3007
			my $s = $stat;
			$s =~ s/{.*$//s;
3008

3009
			# Ignore goto labels.
3010
			if ($s =~ /$Ident:\*$/s) {
3011 3012

			# Ignore functions being called
3013
			} elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3014

3015 3016
			} elsif ($s =~ /^.\s*else\b/s) {

3017
			# declarations always start with types
3018
			} 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) {
3019 3020 3021 3022
				my $type = $1;
				$type =~ s/\s+/ /g;
				possible($type, "A:" . $s);

3023
			# definitions in global scope can only start with types
3024
			} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3025
				possible($1, "B:" . $s);
3026
			}
3027 3028

			# any (foo ... *) is a pointer cast, and foo is a type
3029
			while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3030
				possible($1, "C:" . $s);
3031 3032 3033 3034 3035
			}

			# Check for any sort of function declaration.
			# int foo(something bar, other baz);
			# void (*store_gdt)(x86_descr_ptr *);
3036
			if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3037 3038
				my ($name_len) = length($1);

3039
				my $ctx = $s;
3040
				substr($ctx, 0, $name_len + 1, '');
3041
				$ctx =~ s/\)[^\)]*$//;
3042

3043
				for my $arg (split(/\s*,\s*/, $ctx)) {
3044
					if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3045

3046
						possible($1, "D:" . $s);
3047 3048
					}
				}
3049
			}
3050

3051 3052
		}

3053 3054 3055
#
# Checks which may be anchored in the context.
#
3056

3057 3058
# Check for switch () and associated case and default
# statements should be at the same indent.
3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074
		if ($line=~/\bswitch\s*\(.*\)/) {
			my $err = '';
			my $sep = '';
			my @ctx = ctx_block_outer($linenr, $realcnt);
			shift(@ctx);
			for my $ctx (@ctx) {
				my ($clen, $cindent) = line_stats($ctx);
				if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
							$indent != $cindent) {
					$err .= "$sep$ctx\n";
					$sep = '';
				} else {
					$sep = "[...]\n";
				}
			}
			if ($err ne '') {
3075 3076
				ERROR("SWITCH_CASE_INDENT_LEVEL",
				      "switch and case should be at the same indent\n$hereline$err");
3077 3078 3079 3080 3081
			}
		}

# if/while/etc brace do not go on next line, unless defining a do while loop,
# or if that brace on the next line is for something else
3082
		if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3083 3084
			my $pre_ctx = "$1$2";

3085
			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3086 3087 3088 3089 3090 3091

			if ($line =~ /^\+\t{6,}/) {
				WARN("DEEP_INDENTATION",
				     "Too many leading tabs - consider code refactoring\n" . $herecurr);
			}

3092 3093 3094
			my $ctx_cnt = $realcnt - $#ctx - 1;
			my $ctx = join("\n", @ctx);

3095 3096
			my $ctx_ln = $linenr;
			my $ctx_skip = $realcnt;
3097

3098 3099 3100 3101 3102
			while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
					defined $lines[$ctx_ln - 1] &&
					$lines[$ctx_ln - 1] =~ /^-/)) {
				##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
				$ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3103 3104
				$ctx_ln++;
			}
3105

3106 3107
			#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
			#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3108

3109
			if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3110 3111
				ERROR("OPEN_BRACE",
				      "that open brace { should be on the previous line\n" .
3112
					"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3113
			}
3114 3115 3116 3117
			if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
			    $ctx =~ /\)\s*\;\s*$/ &&
			    defined $lines[$ctx_ln - 1])
			{
3118 3119
				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
				if ($nindent > $indent) {
3120 3121
					WARN("TRAILING_SEMICOLON",
					     "trailing semicolon indicates no statements, indent implies otherwise\n" .
3122
						"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3123 3124
				}
			}
3125 3126
		}

3127
# Check relative indent for conditionals and blocks.
3128
		if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3129 3130 3131
			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
				ctx_statement_block($linenr, $realcnt, 0)
					if (!defined $stat);
3132 3133 3134 3135
			my ($s, $c) = ($stat, $cond);

			substr($s, 0, length($c), '');

3136 3137 3138
			# remove inline comments
			$s =~ s/$;/ /g;
			$c =~ s/$;/ /g;
3139 3140

			# Find out how long the conditional actually is.
3141 3142
			my @newlines = ($c =~ /\n/gs);
			my $cond_lines = 1 + $#newlines;
3143

3144 3145 3146 3147 3148 3149 3150 3151
			# Make sure we remove the line prefixes as we have
			# none on the first line, and are going to readd them
			# where necessary.
			$s =~ s/\n./\n/gs;
			while ($s =~ /\n\s+\\\n/) {
				$cond_lines += $s =~ s/\n\s+\\\n/\n/g;
			}

3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163
			# We want to check the first line inside the block
			# starting at the end of the conditional, so remove:
			#  1) any blank line termination
			#  2) any opening brace { on end of the line
			#  3) any do (...) {
			my $continuation = 0;
			my $check = 0;
			$s =~ s/^.*\bdo\b//;
			$s =~ s/^\s*{//;
			if ($s =~ s/^\s*\\//) {
				$continuation = 1;
			}
3164
			if ($s =~ s/^\s*?\n//) {
3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
				$check = 1;
				$cond_lines++;
			}

			# Also ignore a loop construct at the end of a
			# preprocessor statement.
			if (($prevline =~ /^.\s*#\s*define\s/ ||
			    $prevline =~ /\\\s*$/) && $continuation == 0) {
				$check = 0;
			}

3176
			my $cond_ptr = -1;
3177
			$continuation = 0;
3178 3179 3180
			while ($cond_ptr != $cond_lines) {
				$cond_ptr = $cond_lines;

3181 3182 3183 3184 3185 3186
				# If we see an #else/#elif then the code
				# is not linear.
				if ($s =~ /^\s*\#\s*(?:else|elif)/) {
					$check = 0;
				}

3187 3188 3189 3190
				# Ignore:
				#  1) blank lines, they should be at 0,
				#  2) preprocessor lines, and
				#  3) labels.
3191 3192
				if ($continuation ||
				    $s =~ /^\s*?\n/ ||
3193 3194
				    $s =~ /^\s*#\s*?/ ||
				    $s =~ /^\s*$Ident\s*:/) {
3195
					$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3196 3197 3198
					if ($s =~ s/^.*?\n//) {
						$cond_lines++;
					}
3199
				}
3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214
			}

			my (undef, $sindent) = line_stats("+" . $s);
			my $stat_real = raw_line($linenr, $cond_lines);

			# Check if either of these lines are modified, else
			# this is not this patch's fault.
			if (!defined($stat_real) ||
			    $stat !~ /^\+/ && $stat_real !~ /^\+/) {
				$check = 0;
			}
			if (defined($stat_real) && $cond_lines > 1) {
				$stat_real = "[...]\n$stat_real";
			}

3215
			#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";
3216

3217 3218 3219 3220
			if ($check && $s ne '' &&
			    (($sindent % 8) != 0 ||
			     ($sindent < $indent) ||
			     ($sindent > $indent + 8))) {
3221 3222
				WARN("SUSPECT_CODE_INDENT",
				     "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3223 3224 3225
			}
		}

3226 3227
		# Track the 'values' across context and added lines.
		my $opline = $line; $opline =~ s/^./ /;
3228 3229
		my ($curr_values, $curr_vars) =
				annotate_values($opline . "\n", $prev_values);
3230
		$curr_values = $prev_values . $curr_values;
3231 3232
		if ($dbg_values) {
			my $outline = $opline; $outline =~ s/\t/ /g;
3233 3234
			print "$linenr > .$outline\n";
			print "$linenr > $curr_values\n";
3235
			print "$linenr >  $curr_vars\n";
3236
		}
3237 3238
		$prev_values = substr($curr_values, -1);

3239
#ignore lines not being added
3240
		next if ($line =~ /^[^\+]/);
3241

3242
# TEST: allow direct testing of the type matcher.
3243 3244
		if ($dbg_type) {
			if ($line =~ /^.\s*$Declare\s*$/) {
3245 3246
				ERROR("TEST_TYPE",
				      "TEST: is type\n" . $herecurr);
3247
			} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3248 3249
				ERROR("TEST_NOT_TYPE",
				      "TEST: is not type ($1 is)\n". $herecurr);
3250
			}
3251 3252
			next;
		}
3253 3254
# TEST: allow direct testing of the attribute matcher.
		if ($dbg_attr) {
3255
			if ($line =~ /^.\s*$Modifier\s*$/) {
3256 3257
				ERROR("TEST_ATTR",
				      "TEST: is attr\n" . $herecurr);
3258
			} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3259 3260
				ERROR("TEST_NOT_ATTR",
				      "TEST: is not attr ($1 is)\n". $herecurr);
3261 3262 3263
			}
			next;
		}
3264

3265
# check for initialisation to aggregates open brace on the next line
3266 3267
		if ($line =~ /^.\s*{/ &&
		    $prevline =~ /(?:^|[^=])=\s*$/) {
3268 3269
			if (ERROR("OPEN_BRACE",
				  "that open brace { should be on the previous line\n" . $hereprev) &&
3270 3271 3272
			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
				fix_delete_line($fixlinenr - 1, $prevrawline);
				fix_delete_line($fixlinenr, $rawline);
3273 3274
				my $fixedline = $prevrawline;
				$fixedline =~ s/\s*=\s*$/ = {/;
3275
				fix_insert_line($fixlinenr, $fixedline);
3276 3277
				$fixedline = $line;
				$fixedline =~ s/^(.\s*){\s*/$1/;
3278
				fix_insert_line($fixlinenr, $fixedline);
3279
			}
3280 3281
		}

3282 3283 3284 3285 3286
#
# Checks which are anchored on the added line.
#

# check for malformed paths in #include statements (uses RAW line)
3287
		if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3288 3289
			my $path = $1;
			if ($path =~ m{//}) {
3290
				ERROR("MALFORMED_INCLUDE",
3291 3292 3293 3294 3295
				      "malformed #include filename\n" . $herecurr);
			}
			if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
				ERROR("UAPI_INCLUDE",
				      "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3296 3297
			}
		}
3298

3299
# no C99 // comments
3300
		if ($line =~ m{//}) {
3301 3302 3303
			if (ERROR("C99_COMMENTS",
				  "do not use C99 // comments\n" . $herecurr) &&
			    $fix) {
3304
				my $line = $fixed[$fixlinenr];
3305 3306
				if ($line =~ /\/\/(.*)$/) {
					my $comment = trim($1);
3307
					$fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3308 3309
				}
			}
3310
		}
3311
		# Remove C99 comments.
3312
		$line =~ s@//.*@@;
3313
		$opline =~ s@//.*@@;
3314

3315 3316 3317 3318 3319 3320 3321 3322
# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
# the whole statement.
#print "APW <$lines[$realline_next - 1]>\n";
		if (defined $realline_next &&
		    exists $lines[$realline_next - 1] &&
		    !defined $suppress_export{$realline_next} &&
		    ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
		     $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3323 3324 3325 3326
			# Handle definitions which produce identifiers with
			# a prefix:
			#   XXX(foo);
			#   EXPORT_SYMBOL(something_foo);
3327
			my $name = $1;
3328
			if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3329 3330 3331 3332 3333
			    $name =~ /^${Ident}_$2/) {
#print "FOO C name<$name>\n";
				$suppress_export{$realline_next} = 1;

			} elsif ($stat !~ /(?:
3334
				\n.}\s*$|
3335 3336 3337
				^.DEFINE_$Ident\(\Q$name\E\)|
				^.DECLARE_$Ident\(\Q$name\E\)|
				^.LIST_HEAD\(\Q$name\E\)|
3338 3339
				^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
				\b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3340
			    )/x) {
3341 3342 3343 3344
#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
				$suppress_export{$realline_next} = 2;
			} else {
				$suppress_export{$realline_next} = 1;
3345 3346
			}
		}
3347 3348 3349 3350 3351 3352 3353 3354 3355
		if (!defined $suppress_export{$linenr} &&
		    $prevline =~ /^.\s*$/ &&
		    ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
		     $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
#print "FOO B <$lines[$linenr - 1]>\n";
			$suppress_export{$linenr} = 2;
		}
		if (defined $suppress_export{$linenr} &&
		    $suppress_export{$linenr} == 2) {
3356 3357
			WARN("EXPORT_SYMBOL",
			     "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3358
		}
3359

3360
# check for global initialisers.
3361
		if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3362
			if (ERROR("GLOBAL_INITIALISERS",
3363
				  "do not initialise globals to $1\n" . $herecurr) &&
3364
			    $fix) {
3365
				$fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3366
			}
3367
		}
3368
# check for static initialisers.
3369
		if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3370
			if (ERROR("INITIALISED_STATIC",
3371
				  "do not initialise statics to $1\n" .
3372 3373
				      $herecurr) &&
			    $fix) {
3374
				$fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3375
			}
3376 3377
		}

3378 3379 3380 3381 3382 3383 3384
# check for misordered declarations of char/short/int/long with signed/unsigned
		while ($sline =~ m{(\b$TypeMisordered\b)}g) {
			my $tmp = trim($1);
			WARN("MISORDERED_TYPE",
			     "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
		}

3385 3386
# check for static const char * arrays.
		if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3387 3388
			WARN("STATIC_CONST_CHAR_ARRAY",
			     "static const char * array should probably be static const char * const\n" .
3389 3390 3391 3392 3393
				$herecurr);
               }

# check for static char foo[] = "bar" declarations.
		if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3394 3395
			WARN("STATIC_CONST_CHAR_ARRAY",
			     "static char array declaration should probably be static const char\n" .
3396 3397 3398
				$herecurr);
               }

3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410
# check for const <foo> const where <foo> is not a pointer or array type
		if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
			my $found = $1;
			if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
				WARN("CONST_CONST",
				     "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
			} elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
				WARN("CONST_CONST",
				     "'const $found const' should probably be 'const $found'\n" . $herecurr);
			}
		}

3411 3412 3413 3414 3415 3416 3417
# check for non-global char *foo[] = {"bar", ...} declarations.
		if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
			WARN("STATIC_CONST_CHAR_ARRAY",
			     "char * array declaration might be better as static const\n" .
				$herecurr);
               }

3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
		if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
			my $array = $1;
			if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
				my $array_div = $1;
				if (WARN("ARRAY_SIZE",
					 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
				    $fix) {
					$fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
				}
			}
		}

3431 3432 3433 3434 3435
# check for function declarations without arguments like "int foo()"
		if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
			if (ERROR("FUNCTION_WITHOUT_ARGS",
				  "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
			    $fix) {
3436
				$fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3437 3438 3439
			}
		}

3440 3441 3442 3443 3444
# check for uses of DEFINE_PCI_DEVICE_TABLE
		if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
			if (WARN("DEFINE_PCI_DEVICE_TABLE",
				 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
			    $fix) {
3445
				$fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3446
			}
3447 3448
		}

3449 3450 3451
# check for new typedefs, only function parameters and sparse annotations
# make sense.
		if ($line =~ /\btypedef\s/ &&
3452
		    $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3453
		    $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3454
		    $line !~ /\b$typeTypedefs\b/ &&
3455
		    $line !~ /\b__bitwise(?:__|)\b/) {
3456 3457
			WARN("NEW_TYPEDEFS",
			     "do not add new typedefs\n" . $herecurr);
3458 3459 3460
		}

# * goes on variable not on type
3461
		# (char*[ const])
3462 3463
		while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
			#print "AA<$1>\n";
3464
			my ($ident, $from, $to) = ($1, $2, $2);
3465 3466 3467 3468 3469 3470

			# Should start with a space.
			$to =~ s/^(\S)/ $1/;
			# Should not end with a space.
			$to =~ s/\s+$//;
			# '*'s should not have spaces between.
3471
			while ($to =~ s/\*\s+\*/\*\*/) {
3472
			}
3473

3474
##			print "1: from<$from> to<$to> ident<$ident>\n";
3475
			if ($from ne $to) {
3476 3477 3478 3479 3480 3481
				if (ERROR("POINTER_LOCATION",
					  "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
				    $fix) {
					my $sub_from = $ident;
					my $sub_to = $ident;
					$sub_to =~ s/\Q$from\E/$to/;
3482
					$fixed[$fixlinenr] =~
3483 3484
					    s@\Q$sub_from\E@$sub_to@;
				}
3485
			}
3486 3487 3488
		}
		while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
			#print "BB<$1>\n";
3489
			my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3490 3491 3492 3493 3494 3495

			# Should start with a space.
			$to =~ s/^(\S)/ $1/;
			# Should not end with a space.
			$to =~ s/\s+$//;
			# '*'s should not have spaces between.
3496
			while ($to =~ s/\*\s+\*/\*\*/) {
3497 3498 3499
			}
			# Modifiers should have spaces.
			$to =~ s/(\b$Modifier$)/$1 /;
3500

3501
##			print "2: from<$from> to<$to> ident<$ident>\n";
3502
			if ($from ne $to && $ident !~ /^$Modifier$/) {
3503 3504 3505 3506 3507 3508 3509
				if (ERROR("POINTER_LOCATION",
					  "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
				    $fix) {

					my $sub_from = $match;
					my $sub_to = $match;
					$sub_to =~ s/\Q$from\E/$to/;
3510
					$fixed[$fixlinenr] =~
3511 3512
					    s@\Q$sub_from\E@$sub_to@;
				}
3513
			}
3514 3515
		}

3516 3517 3518 3519 3520 3521 3522
# avoid BUG() or BUG_ON()
		if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
			my $msg_type = \&WARN;
			$msg_type = \&CHK if ($file);
			&{$msg_type}("AVOID_BUG",
				     "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
		}
3523

3524
# avoid LINUX_VERSION_CODE
3525
		if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3526 3527
			WARN("LINUX_VERSION_CODE",
			     "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3528 3529
		}

3530 3531
# check for uses of printk_ratelimit
		if ($line =~ /\bprintk_ratelimit\s*\(/) {
3532
			WARN("PRINTK_RATELIMITED",
3533
			     "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3534 3535
		}

3536 3537 3538
# printk should use KERN_* levels.  Note that follow on printk's on the
# same line do not need a level, so we use the current block context
# to try and find and validate the current printk.  In summary the current
L
Lucas De Marchi 已提交
3539
# printk includes all preceding printk's which have no newline on the end.
3540
# we assume the first bad printk is the one to report.
3541
		if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3542 3543 3544
			my $ok = 0;
			for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
				#print "CHECK<$lines[$ln - 1]\n";
L
Lucas De Marchi 已提交
3545
				# we have a preceding printk if it ends
3546 3547 3548 3549 3550 3551 3552 3553 3554
				# with "\n" ignore it, else it is to blame
				if ($lines[$ln - 1] =~ m{\bprintk\(}) {
					if ($rawlines[$ln - 1] !~ m{\\n"}) {
						$ok = 1;
					}
					last;
				}
			}
			if ($ok == 0) {
3555 3556
				WARN("PRINTK_WITHOUT_KERN_LEVEL",
				     "printk() should include KERN_ facility level\n" . $herecurr);
3557
			}
3558 3559
		}

3560 3561 3562 3563
		if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
			my $orig = $1;
			my $level = lc($orig);
			$level = "warn" if ($level eq "warning");
3564 3565
			my $level2 = $level;
			$level2 = "dbg" if ($level eq "debug");
3566
			WARN("PREFER_PR_LEVEL",
3567
			     "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3568 3569 3570
		}

		if ($line =~ /\bpr_warning\s*\(/) {
3571 3572 3573
			if (WARN("PREFER_PR_LEVEL",
				 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
			    $fix) {
3574
				$fixed[$fixlinenr] =~
3575 3576
				    s/\bpr_warning\b/pr_warn/;
			}
3577 3578
		}

3579 3580 3581 3582 3583 3584 3585 3586 3587
		if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
			my $orig = $1;
			my $level = lc($orig);
			$level = "warn" if ($level eq "warning");
			$level = "dbg" if ($level eq "debug");
			WARN("PREFER_DEV_LEVEL",
			     "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
		}

3588 3589 3590 3591 3592 3593 3594 3595
# ENOSYS means "bad syscall nr" and nothing else.  This will have a small
# number of false positives, but assembly files are not checked, so at
# least the arch entry code will not trigger this warning.
		if ($line =~ /\bENOSYS\b/) {
			WARN("ENOSYS",
			     "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
		}

3596 3597
# function brace can't be on same line, except for #defines of do while,
# or if closed on same line
3598
		if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3599
		    !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613
			if (ERROR("OPEN_BRACE",
				  "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
			    $fix) {
				fix_delete_line($fixlinenr, $rawline);
				my $fixed_line = $rawline;
				$fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
				my $line1 = $1;
				my $line2 = $2;
				fix_insert_line($fixlinenr, ltrim($line1));
				fix_insert_line($fixlinenr, "\+{");
				if ($line2 !~ /^\s*$/) {
					fix_insert_line($fixlinenr, "\+\t" . trim($line2));
				}
			}
3614
		}
3615

3616 3617 3618
# open braces for enum, union and struct go on the same line.
		if ($line =~ /^.\s*{/ &&
		    $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631
			if (ERROR("OPEN_BRACE",
				  "open brace '{' following $1 go on the same line\n" . $hereprev) &&
			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
				fix_delete_line($fixlinenr - 1, $prevrawline);
				fix_delete_line($fixlinenr, $rawline);
				my $fixedline = rtrim($prevrawline) . " {";
				fix_insert_line($fixlinenr, $fixedline);
				$fixedline = $rawline;
				$fixedline =~ s/^(.\s*){\s*/$1\t/;
				if ($fixedline !~ /^\+\s*$/) {
					fix_insert_line($fixlinenr, $fixedline);
				}
			}
3632 3633
		}

3634
# missing space after union, struct or enum definition
3635 3636 3637 3638
		if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
			if (WARN("SPACING",
				 "missing space after $1 definition\n" . $herecurr) &&
			    $fix) {
3639
				$fixed[$fixlinenr] =~
3640 3641
				    s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
			}
3642 3643
		}

3644 3645 3646
# Function pointer declarations
# check spacing between type, funcptr, and args
# canonical declaration is "type (*funcptr)(args...)"
3647
		if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3648 3649 3650 3651 3652 3653 3654
			my $declare = $1;
			my $pre_pointer_space = $2;
			my $post_pointer_space = $3;
			my $funcname = $4;
			my $post_funcname_space = $5;
			my $pre_args_space = $6;

3655 3656 3657 3658 3659 3660 3661 3662 3663
# the $Declare variable will capture all spaces after the type
# so check it for a missing trailing missing space but pointer return types
# don't need a space so don't warn for those.
			my $post_declare_space = "";
			if ($declare =~ /(\s+)$/) {
				$post_declare_space = $1;
				$declare = rtrim($declare);
			}
			if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3664 3665
				WARN("SPACING",
				     "missing space after return type\n" . $herecurr);
3666
				$post_declare_space = " ";
3667 3668 3669
			}

# unnecessary space "type  (*funcptr)(args...)"
3670 3671 3672 3673 3674 3675 3676 3677 3678
# This test is not currently implemented because these declarations are
# equivalent to
#	int  foo(int bar, ...)
# and this is form shouldn't/doesn't generate a checkpatch warning.
#
#			elsif ($declare =~ /\s{2,}$/) {
#				WARN("SPACING",
#				     "Multiple spaces after return type\n" . $herecurr);
#			}
3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708

# unnecessary space "type ( *funcptr)(args...)"
			if (defined $pre_pointer_space &&
			    $pre_pointer_space =~ /^\s/) {
				WARN("SPACING",
				     "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
			}

# unnecessary space "type (* funcptr)(args...)"
			if (defined $post_pointer_space &&
			    $post_pointer_space =~ /^\s/) {
				WARN("SPACING",
				     "Unnecessary space before function pointer name\n" . $herecurr);
			}

# unnecessary space "type (*funcptr )(args...)"
			if (defined $post_funcname_space &&
			    $post_funcname_space =~ /^\s/) {
				WARN("SPACING",
				     "Unnecessary space after function pointer name\n" . $herecurr);
			}

# unnecessary space "type (*funcptr) (args...)"
			if (defined $pre_args_space &&
			    $pre_args_space =~ /^\s/) {
				WARN("SPACING",
				     "Unnecessary space before function pointer arguments\n" . $herecurr);
			}

			if (show_type("SPACING") && $fix) {
3709
				$fixed[$fixlinenr] =~
3710
				    s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3711 3712 3713
			}
		}

3714 3715
# check for spacing round square brackets; allowed:
#  1. with a type on the left -- int [] a;
3716 3717
#  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
#  3. inside a curly brace -- = { [0...10] = 5 }
3718 3719 3720
		while ($line =~ /(.*?\s)\[/g) {
			my ($where, $prefix) = ($-[1], $1);
			if ($prefix !~ /$Type\s+$/ &&
3721
			    ($where != 0 || $prefix !~ /^.\s+$/) &&
3722
			    $prefix !~ /[{,]\s+$/) {
3723 3724 3725
				if (ERROR("BRACKET_SPACE",
					  "space prohibited before open square bracket '['\n" . $herecurr) &&
				    $fix) {
3726
				    $fixed[$fixlinenr] =~
3727 3728
					s/^(\+.*?)\s+\[/$1\[/;
				}
3729 3730 3731
			}
		}

3732
# check for spaces between functions and their parentheses.
3733
		while ($line =~ /($Ident)\s+\(/g) {
3734
			my $name = $1;
3735 3736
			my $ctx_before = substr($line, 0, $-[1]);
			my $ctx = "$ctx_before$name";
3737 3738

			# Ignore those directives where spaces _are_ permitted.
3739 3740 3741 3742 3743 3744
			if ($name =~ /^(?:
				if|for|while|switch|return|case|
				volatile|__volatile__|
				__attribute__|format|__extension__|
				asm|__asm__)$/x)
			{
3745 3746 3747
			# cpp #define statements have non-optional spaces, ie
			# if there is a space between the name and the open
			# parenthesis it is simply not a parameter group.
3748
			} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3749 3750

			# cpp #elif statement condition may start with a (
3751
			} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3752 3753 3754

			# If this whole things ends with a type its most
			# likely a typedef for a function.
3755
			} elsif ($ctx =~ /$Type$/) {
3756 3757

			} else {
3758 3759 3760
				if (WARN("SPACING",
					 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
					     $fix) {
3761
					$fixed[$fixlinenr] =~
3762 3763
					    s/\b$name\s+\(/$name\(/;
				}
3764
			}
3765
		}
3766

3767
# Check operator spacing.
3768
		if (!($line=~/\#\s*include/)) {
3769 3770 3771
			my $fixed_line = "";
			my $line_fixed = 0;

3772 3773 3774 3775
			my $ops = qr{
				<<=|>>=|<=|>=|==|!=|
				\+=|-=|\*=|\/=|%=|\^=|\|=|&=|
				=>|->|<<|>>|<|>|=|!|~|
3776
				&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3777
				\?:|\?|:
3778
			}x;
3779
			my @elements = split(/($ops|;)/, $opline);
3780 3781 3782 3783 3784 3785 3786

##			print("element count: <" . $#elements . ">\n");
##			foreach my $el (@elements) {
##				print("el: <$el>\n");
##			}

			my @fix_elements = ();
3787
			my $off = 0;
3788

3789 3790 3791 3792 3793 3794 3795
			foreach my $el (@elements) {
				push(@fix_elements, substr($rawline, $off, length($el)));
				$off += length($el);
			}

			$off = 0;

3796
			my $blank = copy_spacing($opline);
3797
			my $last_after = -1;
3798

3799
			for (my $n = 0; $n < $#elements; $n += 2) {
3800 3801 3802 3803 3804

				my $good = $fix_elements[$n] . $fix_elements[$n + 1];

##				print("n: <$n> good: <$good>\n");

3805 3806
				$off += length($elements[$n]);

L
Lucas De Marchi 已提交
3807
				# Pick up the preceding and succeeding characters.
3808 3809 3810 3811 3812 3813 3814
				my $ca = substr($opline, 0, $off);
				my $cc = '';
				if (length($opline) >= ($off + length($elements[$n + 1]))) {
					$cc = substr($opline, $off + length($elements[$n + 1]));
				}
				my $cb = "$ca$;$cc";

3815 3816 3817
				my $a = '';
				$a = 'V' if ($elements[$n] ne '');
				$a = 'W' if ($elements[$n] =~ /\s$/);
3818
				$a = 'C' if ($elements[$n] =~ /$;$/);
3819 3820
				$a = 'B' if ($elements[$n] =~ /(\[|\()$/);
				$a = 'O' if ($elements[$n] eq '');
3821
				$a = 'E' if ($ca =~ /^\s*$/);
3822

3823
				my $op = $elements[$n + 1];
3824 3825

				my $c = '';
3826
				if (defined $elements[$n + 2]) {
3827 3828
					$c = 'V' if ($elements[$n + 2] ne '');
					$c = 'W' if ($elements[$n + 2] =~ /^\s/);
3829
					$c = 'C' if ($elements[$n + 2] =~ /^$;/);
3830 3831
					$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
					$c = 'O' if ($elements[$n + 2] eq '');
3832
					$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3833 3834
				} else {
					$c = 'E';
3835 3836
				}

3837 3838 3839 3840
				my $ctx = "${a}x${c}";

				my $at = "(ctx:$ctx)";

3841
				my $ptr = substr($blank, 0, $off) . "^";
3842
				my $hereptr = "$hereline$ptr\n";
3843

3844
				# Pull out the value of this operator.
3845
				my $op_type = substr($curr_values, $off + 1, 1);
3846

3847 3848 3849
				# Get the full operator variant.
				my $opv = $op . substr($curr_vars, $off, 1);

3850 3851
				# Ignore operators passed as parameters.
				if ($op_type ne 'V' &&
3852
				    $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
3853

3854 3855
#				# Ignore comments
#				} elsif ($op =~ /^$;+$/) {
3856

3857
				# ; should have either the end of line or a space or \ after it
3858
				} elsif ($op eq ';') {
3859 3860
					if ($ctx !~ /.x[WEBC]/ &&
					    $cc !~ /^\\/ && $cc !~ /^;/) {
3861 3862
						if (ERROR("SPACING",
							  "space required after that '$op' $at\n" . $hereptr)) {
3863
							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3864 3865
							$line_fixed = 1;
						}
3866 3867 3868 3869
					}

				# // is a comment
				} elsif ($op eq '//') {
3870

3871 3872 3873 3874
				#   :   when part of a bitfield
				} elsif ($opv eq ':B') {
					# skip the bitfield test for now

3875 3876
				# No spaces for:
				#   ->
3877
				} elsif ($op eq '->') {
3878
					if ($ctx =~ /Wx.|.xW/) {
3879 3880
						if (ERROR("SPACING",
							  "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3881
							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3882 3883 3884
							if (defined $fix_elements[$n + 2]) {
								$fix_elements[$n + 2] =~ s/^\s+//;
							}
3885
							$line_fixed = 1;
3886
						}
3887 3888
					}

3889
				# , must not have a space before and must have a space on the right.
3890
				} elsif ($op eq ',') {
3891 3892 3893 3894 3895 3896 3897 3898 3899
					my $rtrim_before = 0;
					my $space_after = 0;
					if ($ctx =~ /Wx./) {
						if (ERROR("SPACING",
							  "space prohibited before that '$op' $at\n" . $hereptr)) {
							$line_fixed = 1;
							$rtrim_before = 1;
						}
					}
3900
					if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3901 3902 3903
						if (ERROR("SPACING",
							  "space required after that '$op' $at\n" . $hereptr)) {
							$line_fixed = 1;
3904
							$last_after = $n;
3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915
							$space_after = 1;
						}
					}
					if ($rtrim_before || $space_after) {
						if ($rtrim_before) {
							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
						} else {
							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
						}
						if ($space_after) {
							$good .= " ";
3916
						}
3917 3918
					}

3919
				# '*' as part of a type definition -- reported already.
3920
				} elsif ($opv eq '*_') {
3921 3922 3923 3924 3925 3926
					#warn "'*' is part of type\n";

				# unary operators should have a space before and
				# none after.  May be left adjacent to another
				# unary operator, or a cast
				} elsif ($op eq '!' || $op eq '~' ||
3927
					 $opv eq '*U' || $opv eq '-U' ||
3928
					 $opv eq '&U' || $opv eq '&&U') {
3929
					if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3930 3931
						if (ERROR("SPACING",
							  "space required before that '$op' $at\n" . $hereptr)) {
3932 3933 3934 3935
							if ($n != $last_after + 2) {
								$good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
								$line_fixed = 1;
							}
3936
						}
3937
					}
3938
					if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3939 3940 3941
						# A unary '*' may be const

					} elsif ($ctx =~ /.xW/) {
3942 3943
						if (ERROR("SPACING",
							  "space prohibited after that '$op' $at\n" . $hereptr)) {
3944
							$good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3945 3946 3947
							if (defined $fix_elements[$n + 2]) {
								$fix_elements[$n + 2] =~ s/^\s+//;
							}
3948
							$line_fixed = 1;
3949
						}
3950 3951 3952 3953
					}

				# unary ++ and unary -- are allowed no space on one side.
				} elsif ($op eq '++' or $op eq '--') {
3954
					if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3955 3956
						if (ERROR("SPACING",
							  "space required one side of that '$op' $at\n" . $hereptr)) {
3957
							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3958 3959
							$line_fixed = 1;
						}
3960 3961 3962
					}
					if ($ctx =~ /Wx[BE]/ ||
					    ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3963 3964
						if (ERROR("SPACING",
							  "space prohibited before that '$op' $at\n" . $hereptr)) {
3965
							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3966 3967
							$line_fixed = 1;
						}
3968
					}
3969
					if ($ctx =~ /ExW/) {
3970 3971
						if (ERROR("SPACING",
							  "space prohibited after that '$op' $at\n" . $hereptr)) {
3972
							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3973 3974 3975
							if (defined $fix_elements[$n + 2]) {
								$fix_elements[$n + 2] =~ s/^\s+//;
							}
3976
							$line_fixed = 1;
3977
						}
3978
					}
3979 3980

				# << and >> may either have or not have spaces both sides
3981 3982 3983
				} elsif ($op eq '<<' or $op eq '>>' or
					 $op eq '&' or $op eq '^' or $op eq '|' or
					 $op eq '+' or $op eq '-' or
3984 3985
					 $op eq '*' or $op eq '/' or
					 $op eq '%')
3986
				{
3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002
					if ($check) {
						if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
							if (CHK("SPACING",
								"spaces preferred around that '$op' $at\n" . $hereptr)) {
								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
								$fix_elements[$n + 2] =~ s/^\s+//;
								$line_fixed = 1;
							}
						} elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
							if (CHK("SPACING",
								"space preferred before that '$op' $at\n" . $hereptr)) {
								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
								$line_fixed = 1;
							}
						}
					} elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4003 4004
						if (ERROR("SPACING",
							  "need consistent spacing around '$op' $at\n" . $hereptr)) {
4005 4006 4007 4008
							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
							if (defined $fix_elements[$n + 2]) {
								$fix_elements[$n + 2] =~ s/^\s+//;
							}
4009 4010
							$line_fixed = 1;
						}
4011 4012
					}

4013 4014 4015 4016
				# A colon needs no spaces before when it is
				# terminating a case value or a label.
				} elsif ($opv eq ':C' || $opv eq ':L') {
					if ($ctx =~ /Wx./) {
4017 4018
						if (ERROR("SPACING",
							  "space prohibited before that '$op' $at\n" . $hereptr)) {
4019
							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4020 4021
							$line_fixed = 1;
						}
4022 4023
					}

4024
				# All the others need spaces both sides.
4025
				} elsif ($ctx !~ /[EWC]x[CWE]/) {
4026 4027
					my $ok = 0;

4028
					# Ignore email addresses <foo@bar>
4029 4030 4031 4032 4033 4034 4035 4036
					if (($op eq '<' &&
					     $cc =~ /^\S+\@\S+>/) ||
					    ($op eq '>' &&
					     $ca =~ /<\S+\@\S+$/))
					{
					    	$ok = 1;
					}

4037 4038 4039 4040 4041 4042 4043 4044
					# for asm volatile statements
					# ignore a colon with another
					# colon immediately before or after
					if (($op eq ':') &&
					    ($ca =~ /:$/ || $cc =~ /^:/)) {
						$ok = 1;
					}

4045
					# messages are ERROR, but ?: are CHK
4046
					if ($ok == 0) {
4047 4048 4049 4050 4051
						my $msg_type = \&ERROR;
						$msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);

						if (&{$msg_type}("SPACING",
								 "spaces required around that '$op' $at\n" . $hereptr)) {
4052 4053 4054 4055
							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
							if (defined $fix_elements[$n + 2]) {
								$fix_elements[$n + 2] =~ s/^\s+//;
							}
4056 4057
							$line_fixed = 1;
						}
4058
					}
4059
				}
4060
				$off += length($elements[$n + 1]);
4061 4062 4063 4064 4065 4066 4067 4068

##				print("n: <$n> GOOD: <$good>\n");

				$fixed_line = $fixed_line . $good;
			}

			if (($#elements % 2) == 0) {
				$fixed_line = $fixed_line . $fix_elements[$#elements];
4069
			}
4070

4071 4072
			if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
				$fixed[$fixlinenr] = $fixed_line;
4073 4074 4075
			}


4076 4077
		}

4078
# check for whitespace before a non-naked semicolon
4079
		if ($line =~ /^\+.*\S\s+;\s*$/) {
4080 4081 4082
			if (WARN("SPACING",
				 "space prohibited before semicolon\n" . $herecurr) &&
			    $fix) {
4083
				1 while $fixed[$fixlinenr] =~
4084 4085 4086 4087
				    s/^(\+.*\S)\s+;/$1;/;
			}
		}

4088 4089
# check for multiple assignments
		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4090 4091
			CHK("MULTIPLE_ASSIGNMENTS",
			    "multiple assignments should be avoided\n" . $herecurr);
4092 4093
		}

4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104
## # check for multiple declarations, allowing for a function declaration
## # continuation.
## 		if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
## 		    $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
##
## 			# Remove any bracketed sections to ensure we do not
## 			# falsly report the parameters of functions.
## 			my $ln = $line;
## 			while ($ln =~ s/\([^\(\)]*\)//g) {
## 			}
## 			if ($ln =~ /,/) {
4105 4106
## 				WARN("MULTIPLE_DECLARATION",
##				     "declaring multiple variables together should be avoided\n" . $herecurr);
4107 4108
## 			}
## 		}
4109

4110
#need space before brace following if, while, etc
4111 4112
		if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\){/) ||
		    $line =~ /do\{/) {
4113 4114 4115
			if (ERROR("SPACING",
				  "space required before the open brace '{'\n" . $herecurr) &&
			    $fix) {
4116
				$fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4117
			}
4118 4119
		}

4120 4121 4122 4123 4124 4125 4126 4127
## # check for blank lines before declarations
##		if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
##		    $prevrawline =~ /^.\s*$/) {
##			WARN("SPACING",
##			     "No blank lines before declarations\n" . $hereprev);
##		}
##

4128 4129 4130
# closing brace should have a space following it when it has anything
# on the line
		if ($line =~ /}(?!(?:,|;|\)))\S/) {
4131 4132 4133
			if (ERROR("SPACING",
				  "space required after that close brace '}'\n" . $herecurr) &&
			    $fix) {
4134
				$fixed[$fixlinenr] =~
4135 4136
				    s/}((?!(?:,|;|\)))\S)/} $1/;
			}
4137 4138
		}

4139 4140
# check spacing on square brackets
		if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4141 4142 4143
			if (ERROR("SPACING",
				  "space prohibited after that open square bracket '['\n" . $herecurr) &&
			    $fix) {
4144
				$fixed[$fixlinenr] =~
4145 4146
				    s/\[\s+/\[/;
			}
4147 4148
		}
		if ($line =~ /\s\]/) {
4149 4150 4151
			if (ERROR("SPACING",
				  "space prohibited before that close square bracket ']'\n" . $herecurr) &&
			    $fix) {
4152
				$fixed[$fixlinenr] =~
4153 4154
				    s/\s+\]/\]/;
			}
4155 4156
		}

4157
# check spacing on parentheses
4158 4159
		if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
		    $line !~ /for\s*\(\s+;/) {
4160 4161 4162
			if (ERROR("SPACING",
				  "space prohibited after that open parenthesis '('\n" . $herecurr) &&
			    $fix) {
4163
				$fixed[$fixlinenr] =~
4164 4165
				    s/\(\s+/\(/;
			}
4166
		}
4167
		if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4168 4169
		    $line !~ /for\s*\(.*;\s+\)/ &&
		    $line !~ /:\s+\)/) {
4170 4171 4172
			if (ERROR("SPACING",
				  "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
			    $fix) {
4173
				$fixed[$fixlinenr] =~
4174 4175
				    s/\s+\)/\)/;
			}
4176 4177
		}

4178 4179 4180 4181
# check unnecessary parentheses around addressof/dereference single $Lvals
# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar

		while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202
			my $var = $1;
			if (CHK("UNNECESSARY_PARENTHESES",
				"Unnecessary parentheses around $var\n" . $herecurr) &&
			    $fix) {
				$fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
			}
		}

# check for unnecessary parentheses around function pointer uses
# ie: (foo->bar)(); should be foo->bar();
# but not "if (foo->bar) (" to avoid some false positives
		if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
			my $var = $2;
			if (CHK("UNNECESSARY_PARENTHESES",
				"Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
			    $fix) {
				my $var2 = deparenthesize($var);
				$var2 =~ s/\s//g;
				$fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
			}
		}
4203

4204
#goto labels aren't indented, allow a single space however
4205
		if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4206
		   !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4207 4208 4209
			if (WARN("INDENTED_LABEL",
				 "labels should not be indented\n" . $herecurr) &&
			    $fix) {
4210
				$fixed[$fixlinenr] =~
4211 4212
				    s/^(.)\s+/$1/;
			}
4213 4214
		}

4215
# return is not a function
4216
		if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4217
			my $spacing = $1;
4218
			if ($^V && $^V ge 5.10.0 &&
4219 4220 4221 4222 4223 4224 4225
			    $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
				my $value = $1;
				$value = deparenthesize($value);
				if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
					ERROR("RETURN_PARENTHESES",
					      "return is not a function, parentheses are not required\n" . $herecurr);
				}
4226
			} elsif ($spacing !~ /\s+/) {
4227 4228
				ERROR("SPACING",
				      "space required before the open parenthesis '('\n" . $herecurr);
4229 4230
			}
		}
4231

4232 4233 4234 4235 4236 4237 4238 4239
# unnecessary return in a void function
# at end-of-function, with the previous line a single leading tab, then return;
# and the line before that not a goto label target like "out:"
		if ($sline =~ /^[ \+]}\s*$/ &&
		    $prevline =~ /^\+\treturn\s*;\s*$/ &&
		    $linenr >= 3 &&
		    $lines[$linenr - 3] =~ /^[ +]/ &&
		    $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4240
			WARN("RETURN_VOID",
4241 4242
			     "void function return statements are not generally useful\n" . $hereprev);
               }
4243

4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257
# if statements using unnecessary parentheses - ie: if ((foo == bar))
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /\bif\s*((?:\(\s*){2,})/) {
			my $openparens = $1;
			my $count = $openparens =~ tr@\(@\(@;
			my $msg = "";
			if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
				my $comp = $4;	#Not $1 because of $LvalOrFunc
				$msg = " - maybe == should be = ?" if ($comp eq "==");
				WARN("UNNECESSARY_PARENTHESES",
				     "Unnecessary parentheses$msg\n" . $herecurr);
			}
		}

4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286
# comparisons with a constant or upper case identifier on the left
#	avoid cases like "foo + BAR < baz"
#	only fix matches surrounded by parentheses to avoid incorrect
#	conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
			my $lead = $1;
			my $const = $2;
			my $comp = $3;
			my $to = $4;
			my $newcomp = $comp;
			if ($lead !~ /$Operators\s*$/ &&
			    $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
			    WARN("CONSTANT_COMPARISON",
				 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
			    $fix) {
				if ($comp eq "<") {
					$newcomp = ">";
				} elsif ($comp eq "<=") {
					$newcomp = ">=";
				} elsif ($comp eq ">") {
					$newcomp = "<";
				} elsif ($comp eq ">=") {
					$newcomp = "<=";
				}
				$fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
			}
		}

4287 4288
# Return of what appears to be an errno should normally be negative
		if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4289 4290
			my $name = $1;
			if ($name ne 'EOF' && $name ne 'ERROR') {
4291
				WARN("USE_NEGATIVE_ERRNO",
4292
				     "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4293 4294
			}
		}
4295

4296
# Need a space before open parenthesis after if, while etc
4297 4298 4299 4300
		if ($line =~ /\b(if|while|for|switch)\(/) {
			if (ERROR("SPACING",
				  "space required before the open parenthesis '('\n" . $herecurr) &&
			    $fix) {
4301
				$fixed[$fixlinenr] =~
4302 4303
				    s/\b(if|while|for|switch)\(/$1 \(/;
			}
4304 4305
		}

4306 4307
# Check for illegal assignment in if conditional -- and check for trailing
# statements after the conditional.
4308
		if ($line =~ /do\s*(?!{)/) {
4309 4310 4311
			($stat, $cond, $line_nr_next, $remain_next, $off_next) =
				ctx_statement_block($linenr, $realcnt, 0)
					if (!defined $stat);
4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329
			my ($stat_next) = ctx_statement_block($line_nr_next,
						$remain_next, $off_next);
			$stat_next =~ s/\n./\n /g;
			##print "stat<$stat> stat_next<$stat_next>\n";

			if ($stat_next =~ /^\s*while\b/) {
				# If the statement carries leading newlines,
				# then count those as offsets.
				my ($whitespace) =
					($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
				my $offset =
					statement_rawlines($whitespace) - 1;

				$suppress_whiletrailers{$line_nr_next +
								$offset} = 1;
			}
		}
		if (!defined $suppress_whiletrailers{$linenr} &&
4330
		    defined($stat) && defined($cond) &&
4331
		    $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4332
			my ($s, $c) = ($stat, $cond);
4333

4334
			if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4335 4336
				ERROR("ASSIGN_IN_IF",
				      "do not use assignment in if condition\n" . $herecurr);
4337 4338 4339 4340
			}

			# Find out what is on the end of the line after the
			# conditional.
4341
			substr($s, 0, length($c), '');
4342
			$s =~ s/\n.*//g;
4343
			$s =~ s/$;//g; 	# Remove any comments
4344 4345
			if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
			    $c !~ /}\s*while\s*/)
4346
			{
4347 4348 4349
				# Find out how long the conditional actually is.
				my @newlines = ($c =~ /\n/gs);
				my $cond_lines = 1 + $#newlines;
4350
				my $stat_real = '';
4351

4352 4353
				$stat_real = raw_line($linenr, $cond_lines)
							. "\n" if ($cond_lines);
4354 4355 4356 4357
				if (defined($stat_real) && $cond_lines > 1) {
					$stat_real = "[...]\n$stat_real";
				}

4358 4359
				ERROR("TRAILING_STATEMENTS",
				      "trailing statements should be on next line\n" . $herecurr . $stat_real);
4360 4361 4362
			}
		}

4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374
# Check for bitwise tests written as boolean
		if ($line =~ /
			(?:
				(?:\[|\(|\&\&|\|\|)
				\s*0[xX][0-9]+\s*
				(?:\&\&|\|\|)
			|
				(?:\&\&|\|\|)
				\s*0[xX][0-9]+\s*
				(?:\&\&|\|\||\)|\])
			)/x)
		{
4375 4376
			WARN("HEXADECIMAL_BOOLEAN_TEST",
			     "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4377 4378
		}

4379
# if and else should not have general statements after it
4380 4381 4382 4383
		if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
			my $s = $1;
			$s =~ s/$;//g; 	# Remove any comments
			if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4384 4385
				ERROR("TRAILING_STATEMENTS",
				      "trailing statements should be on next line\n" . $herecurr);
4386
			}
4387
		}
4388 4389
# if should not continue a brace
		if ($line =~ /}\s*if\b/) {
4390
			ERROR("TRAILING_STATEMENTS",
4391
			      "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4392 4393
				$herecurr);
		}
4394 4395 4396
# case and default should not have general statements after them
		if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
		    $line !~ /\G(?:
4397
			(?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4398 4399 4400
			\s*return\s+
		    )/xg)
		{
4401 4402
			ERROR("TRAILING_STATEMENTS",
			      "trailing statements should be on next line\n" . $herecurr);
4403
		}
4404 4405 4406

		# Check for }<nl>else {, these must be at the same
		# indent level to be relevant to each other.
4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422
		if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
		    $previndent == $indent) {
			if (ERROR("ELSE_AFTER_BRACE",
				  "else should follow close brace '}'\n" . $hereprev) &&
			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
				fix_delete_line($fixlinenr - 1, $prevrawline);
				fix_delete_line($fixlinenr, $rawline);
				my $fixedline = $prevrawline;
				$fixedline =~ s/}\s*$//;
				if ($fixedline !~ /^\+\s*$/) {
					fix_insert_line($fixlinenr, $fixedline);
				}
				$fixedline = $rawline;
				$fixedline =~ s/^(.\s*)else/$1} else/;
				fix_insert_line($fixlinenr, $fixedline);
			}
4423 4424
		}

4425 4426
		if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
		    $previndent == $indent) {
4427 4428 4429 4430
			my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);

			# Find out what is on the end of the line after the
			# conditional.
4431
			substr($s, 0, length($c), '');
4432 4433 4434
			$s =~ s/\n.*//g;

			if ($s =~ /^\s*;/) {
4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446
				if (ERROR("WHILE_AFTER_BRACE",
					  "while should follow close brace '}'\n" . $hereprev) &&
				    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
					fix_delete_line($fixlinenr - 1, $prevrawline);
					fix_delete_line($fixlinenr, $rawline);
					my $fixedline = $prevrawline;
					my $trailing = $rawline;
					$trailing =~ s/^\+//;
					$trailing = trim($trailing);
					$fixedline =~ s/}\s*$/} $trailing/;
					fix_insert_line($fixlinenr, $fixedline);
				}
4447 4448 4449
			}
		}

4450
#Specific variable tests
4451 4452
		while ($line =~ m{($Constant|$Lval)}g) {
			my $var = $1;
4453 4454 4455

#gcc binary extension
			if ($var =~ /^$Binary$/) {
4456 4457 4458 4459
				if (WARN("GCC_BINARY_CONSTANT",
					 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
				    $fix) {
					my $hexval = sprintf("0x%x", oct($var));
4460
					$fixed[$fixlinenr] =~
4461 4462
					    s/\b$var\b/$hexval/;
				}
4463 4464 4465
			}

#CamelCase
4466
			if ($var !~ /^$Constant$/ &&
4467
			    $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4468
#Ignore Page<foo> variants
4469
			    $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4470
#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4471 4472 4473
			    $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
#Ignore some three character SI units explicitly, like MiB and KHz
			    $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4474 4475 4476
				while ($var =~ m{($Ident)}g) {
					my $word = $1;
					next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4477 4478 4479 4480 4481 4482 4483
					if ($check) {
						seed_camelcase_includes();
						if (!$file && !$camelcase_file_seeded) {
							seed_camelcase_file($realfile);
							$camelcase_file_seeded = 1;
						}
					}
4484 4485 4486 4487 4488
					if (!defined $camelcase{$word}) {
						$camelcase{$word} = 1;
						CHK("CAMELCASE",
						    "Avoid CamelCase: <$word>\n" . $herecurr);
					}
4489
				}
4490 4491
			}
		}
4492 4493

#no spaces allowed after \ in define
4494 4495 4496 4497
		if ($line =~ /\#\s*define.*\\\s+$/) {
			if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
				 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
			    $fix) {
4498
				$fixed[$fixlinenr] =~ s/\s+$//;
4499
			}
4500 4501
		}

4502 4503
# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
# itself <asm/foo.h> (uses RAW line)
4504
		if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4505 4506 4507 4508
			my $file = "$1.h";
			my $checkfile = "include/linux/$file";
			if (-f "$root/$checkfile" &&
			    $realfile ne $checkfile &&
4509
			    $1 !~ /$allowed_asm_includes/)
4510
			{
4511 4512 4513 4514 4515 4516 4517 4518 4519
				my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
				if ($asminclude > 0) {
					if ($realfile =~ m{^arch/}) {
						CHK("ARCH_INCLUDE_LINUX",
						    "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
					} else {
						WARN("INCLUDE_LINUX",
						     "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
					}
4520
				}
4521 4522 4523
			}
		}

4524 4525
# multi-statement macros should be enclosed in a do while loop, grab the
# first statement and ensure its the whole macro if its not enclosed
4526
# in a known good container
4527 4528
		if ($realfile !~ m@/vmlinux.lds.h$@ &&
		    $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4529 4530
			my $ln = $linenr;
			my $cnt = $realcnt;
4531 4532
			my ($off, $dstat, $dcond, $rest);
			my $ctx = '';
4533 4534
			my $has_flow_statement = 0;
			my $has_arg_concat = 0;
4535
			($dstat, $dcond, $ln, $cnt, $off) =
4536 4537
				ctx_statement_block($linenr, $realcnt, 0);
			$ctx = $dstat;
4538
			#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4539
			#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4540

4541
			$has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4542
			$has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4543

4544
			$dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4545
			$dstat =~ s/$;//g;
4546 4547 4548
			$dstat =~ s/\\\n.//g;
			$dstat =~ s/^\s*//s;
			$dstat =~ s/\s*$//s;
4549

4550
			# Flatten any parentheses and braces
4551 4552
			while ($dstat =~ s/\([^\(\)]*\)/1/ ||
			       $dstat =~ s/\{[^\{\}]*\}/1/ ||
4553
			       $dstat =~ s/.\[[^\[\]]*\]/1/)
4554
			{
4555
			}
4556

4557
			# Flatten any obvious string concatentation.
4558 4559
			while ($dstat =~ s/($String)\s*$Ident/$1/ ||
			       $dstat =~ s/$Ident\s*($String)/$1/)
4560 4561 4562
			{
			}

4563 4564 4565
			# Make asm volatile uses seem like a generic function
			$dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;

4566 4567 4568
			my $exceptions = qr{
				$Declare|
				module_param_named|
4569
				MODULE_PARM_DESC|
4570 4571
				DECLARE_PER_CPU|
				DEFINE_PER_CPU|
4572
				__typeof__\(|
4573 4574
				union|
				struct|
4575
				\.$Ident\s*=\s*|
4576 4577
				^\"|\"$|
				^\[
4578
			}x;
4579
			#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4580 4581 4582
			if ($dstat ne '' &&
			    $dstat !~ /^(?:$Ident|-?$Constant),$/ &&			# 10, // foo(),
			    $dstat !~ /^(?:$Ident|-?$Constant);$/ &&			# foo();
4583
			    $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&		# 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4584
			    $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&			# character constants
4585 4586
			    $dstat !~ /$exceptions/ &&
			    $dstat !~ /^\.$Ident\s*=/ &&				# .foo =
4587
			    $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&		# stringification #foo
4588
			    $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&	# do {...} while (...); // do {...} while (...)
4589 4590 4591
			    $dstat !~ /^for\s*$Constant$/ &&				# for (...)
			    $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&	# for (...) bar()
			    $dstat !~ /^do\s*{/ &&					# do {...
4592
			    $dstat !~ /^\(\{/ &&						# ({...
4593
			    $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4594 4595 4596 4597 4598 4599 4600
			{
				$ctx =~ s/\n*$//;
				my $herectx = $here . "\n";
				my $cnt = statement_rawlines($ctx);

				for (my $n = 0; $n < $cnt; $n++) {
					$herectx .= raw_line($linenr, $n) . "\n";
4601 4602
				}

4603 4604 4605 4606
				if ($dstat =~ /;/) {
					ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
					      "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
				} else {
4607
					ERROR("COMPLEX_MACRO",
A
Andrew Morton 已提交
4608
					      "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4609
				}
4610
			}
4611

4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624
# check for macros with flow control, but without ## concatenation
# ## concatenation is commonly a macro that defines a function so ignore those
			if ($has_flow_statement && !$has_arg_concat) {
				my $herectx = $here . "\n";
				my $cnt = statement_rawlines($ctx);

				for (my $n = 0; $n < $cnt; $n++) {
					$herectx .= raw_line($linenr, $n) . "\n";
				}
				WARN("MACRO_WITH_FLOW_CONTROL",
				     "Macros with flow control statements should be avoided\n" . "$herectx");
			}

4625
# check for line continuations outside of #defines, preprocessor #, and asm
4626 4627 4628

		} else {
			if ($prevline !~ /^..*\\$/ &&
4629 4630
			    $line !~ /^\+\s*\#.*\\$/ &&		# preprocessor
			    $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&	# asm
4631 4632 4633 4634
			    $line =~ /^\+.*\\$/) {
				WARN("LINE_CONTINUATIONS",
				     "Avoid unnecessary line continuations\n" . $herecurr);
			}
4635 4636
		}

4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651
# do {} while (0) macro tests:
# single-statement macros do not need to be enclosed in do while (0) loop,
# macro should not end with a semicolon
		if ($^V && $^V ge 5.10.0 &&
		    $realfile !~ m@/vmlinux.lds.h$@ &&
		    $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
			my $ln = $linenr;
			my $cnt = $realcnt;
			my ($off, $dstat, $dcond, $rest);
			my $ctx = '';
			($dstat, $dcond, $ln, $cnt, $off) =
				ctx_statement_block($linenr, $realcnt, 0);
			$ctx = $dstat;

			$dstat =~ s/\\\n.//g;
4652
			$dstat =~ s/$;/ /g;
4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665

			if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
				my $stmts = $2;
				my $semis = $3;

				$ctx =~ s/\n*$//;
				my $cnt = statement_rawlines($ctx);
				my $herectx = $here . "\n";

				for (my $n = 0; $n < $cnt; $n++) {
					$herectx .= raw_line($linenr, $n) . "\n";
				}

4666 4667
				if (($stmts =~ tr/;/;/) == 1 &&
				    $stmts !~ /^\s*(if|while|for|switch)\b/) {
4668 4669 4670 4671 4672 4673 4674
					WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
					     "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
				}
				if (defined $semis && $semis ne "") {
					WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
					     "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
				}
4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685
			} elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
				$ctx =~ s/\n*$//;
				my $cnt = statement_rawlines($ctx);
				my $herectx = $here . "\n";

				for (my $n = 0; $n < $cnt; $n++) {
					$herectx .= raw_line($linenr, $n) . "\n";
				}

				WARN("TRAILING_SEMICOLON",
				     "macros should not use a trailing semicolon\n" . "$herectx");
4686 4687 4688
			}
		}

4689 4690 4691 4692 4693 4694
# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
# all assignments may have only one of the following with an assignment:
#	.
#	ALIGN(...)
#	VMLINUX_SYMBOL(...)
		if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4695 4696
			WARN("MISSING_VMLINUX_SYMBOL",
			     "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4697 4698
		}

4699
# check for redundant bracing round if etc
4700 4701
		if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
			my ($level, $endln, @chunks) =
4702
				ctx_statement_full($linenr, $realcnt, 1);
4703
			#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4704 4705
			#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
			if ($#chunks > 0 && $level == 0) {
4706 4707
				my @allowed = ();
				my $allow = 0;
4708
				my $seen = 0;
4709
				my $herectx = $here . "\n";
4710
				my $ln = $linenr - 1;
4711 4712 4713
				for my $chunk (@chunks) {
					my ($cond, $block) = @{$chunk};

4714 4715 4716 4717
					# If the condition carries leading newlines, then count those as offsets.
					my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
					my $offset = statement_rawlines($whitespace) - 1;

4718
					$allowed[$allow] = 0;
4719 4720 4721 4722 4723 4724
					#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";

					# We have looked at and allowed this specific line.
					$suppress_ifbraces{$ln + $offset} = 1;

					$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4725 4726
					$ln += statement_rawlines($block) - 1;

4727
					substr($block, 0, length($cond), '');
4728 4729 4730

					$seen++ if ($block =~ /^\s*{/);

4731
					#print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4732 4733
					if (statement_lines($cond) > 1) {
						#print "APW: ALLOWED: cond<$cond>\n";
4734
						$allowed[$allow] = 1;
4735 4736
					}
					if ($block =~/\b(?:if|for|while)\b/) {
4737
						#print "APW: ALLOWED: block<$block>\n";
4738
						$allowed[$allow] = 1;
4739
					}
4740 4741
					if (statement_block_size($block) > 1) {
						#print "APW: ALLOWED: lines block<$block>\n";
4742
						$allowed[$allow] = 1;
4743
					}
4744
					$allow++;
4745
				}
4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758
				if ($seen) {
					my $sum_allowed = 0;
					foreach (@allowed) {
						$sum_allowed += $_;
					}
					if ($sum_allowed == 0) {
						WARN("BRACES",
						     "braces {} are not necessary for any arm of this statement\n" . $herectx);
					} elsif ($sum_allowed != $allow &&
						 $seen != $allow) {
						CHK("BRACES",
						    "braces {} should be used on all arms of this statement\n" . $herectx);
					}
4759 4760 4761
				}
			}
		}
4762
		if (!defined $suppress_ifbraces{$linenr - 1} &&
4763
					$line =~ /\b(if|while|for|else)\b/) {
4764 4765 4766 4767 4768 4769 4770
			my $allowed = 0;

			# Check the pre-context.
			if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
				#print "APW: ALLOWED: pre<$1>\n";
				$allowed = 1;
			}
4771 4772 4773 4774

			my ($level, $endln, @chunks) =
				ctx_statement_full($linenr, $realcnt, $-[0]);

4775 4776
			# Check the condition.
			my ($cond, $block) = @{$chunks[0]};
4777
			#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4778
			if (defined $cond) {
4779
				substr($block, 0, length($cond), '');
4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796
			}
			if (statement_lines($cond) > 1) {
				#print "APW: ALLOWED: cond<$cond>\n";
				$allowed = 1;
			}
			if ($block =~/\b(?:if|for|while)\b/) {
				#print "APW: ALLOWED: block<$block>\n";
				$allowed = 1;
			}
			if (statement_block_size($block) > 1) {
				#print "APW: ALLOWED: lines block<$block>\n";
				$allowed = 1;
			}
			# Check the post-context.
			if (defined $chunks[1]) {
				my ($cond, $block) = @{$chunks[1]};
				if (defined $cond) {
4797
					substr($block, 0, length($cond), '');
4798 4799 4800 4801 4802 4803 4804
				}
				if ($block =~ /^\s*\{/) {
					#print "APW: ALLOWED: chunk-1 block<$block>\n";
					$allowed = 1;
				}
			}
			if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4805
				my $herectx = $here . "\n";
4806
				my $cnt = statement_rawlines($block);
4807

4808
				for (my $n = 0; $n < $cnt; $n++) {
4809
					$herectx .= raw_line($linenr, $n) . "\n";
4810
				}
4811

4812 4813
				WARN("BRACES",
				     "braces {} are not necessary for single statement blocks\n" . $herectx);
4814 4815 4816
			}
		}

4817
# check for unnecessary blank lines around braces
4818
		if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4819 4820 4821 4822 4823
			if (CHK("BRACES",
				"Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
			    $fix && $prevrawline =~ /^\+/) {
				fix_delete_line($fixlinenr - 1, $prevrawline);
			}
4824
		}
4825
		if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4826 4827 4828 4829 4830
			if (CHK("BRACES",
				"Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
			    $fix) {
				fix_delete_line($fixlinenr, $rawline);
			}
4831 4832
		}

4833
# no volatiles please
4834 4835
		my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
		if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4836 4837
			WARN("VOLATILE",
			     "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4838 4839
		}

4840 4841 4842 4843
# Check for user-visible strings broken across lines, which breaks the ability
# to grep for the string.  Make exceptions when the previous string ends in a
# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4844
		if ($line =~ /^\+\s*$String/ &&
4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888
		    $prevline =~ /"\s*$/ &&
		    $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
			if (WARN("SPLIT_STRING",
				 "quoted string split across lines\n" . $hereprev) &&
				     $fix &&
				     $prevrawline =~ /^\+.*"\s*$/ &&
				     $last_coalesced_string_linenr != $linenr - 1) {
				my $extracted_string = get_quoted_string($line, $rawline);
				my $comma_close = "";
				if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
					$comma_close = $1;
				}

				fix_delete_line($fixlinenr - 1, $prevrawline);
				fix_delete_line($fixlinenr, $rawline);
				my $fixedline = $prevrawline;
				$fixedline =~ s/"\s*$//;
				$fixedline .= substr($extracted_string, 1) . trim($comma_close);
				fix_insert_line($fixlinenr - 1, $fixedline);
				$fixedline = $rawline;
				$fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
				if ($fixedline !~ /\+\s*$/) {
					fix_insert_line($fixlinenr, $fixedline);
				}
				$last_coalesced_string_linenr = $linenr;
			}
		}

# check for missing a space in a string concatenation
		if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
			WARN('MISSING_SPACE',
			     "break quoted strings at a space character\n" . $hereprev);
		}

# check for spaces before a quoted newline
		if ($rawline =~ /^.*\".*\s\\n/) {
			if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
				 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
			    $fix) {
				$fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
			}

		}

4889
# concatenated string without spaces between elements
4890
		if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
4891 4892 4893 4894
			CHK("CONCATENATED_STRING",
			    "Concatenated strings should use spaces between elements\n" . $herecurr);
		}

4895
# uncoalesced string fragments
4896
		if ($line =~ /$String\s*"/) {
4897 4898 4899 4900
			WARN("STRING_FRAGMENTS",
			     "Consecutive strings are generally better as a single string\n" . $herecurr);
		}

4901
# check for %L{u,d,i} and 0x%[udi] in strings
4902 4903 4904 4905
		my $string;
		while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
			$string = substr($rawline, $-[1], $+[1] - $-[1]);
			$string =~ s/%%/__/g;
4906
			if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
4907 4908 4909 4910
				WARN("PRINTF_L",
				     "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
				last;
			}
4911 4912 4913 4914
			if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
				ERROR("PRINTF_0xDECIMAL",
				      "Prefixing 0x with decimal output is defective\n" . $herecurr);
			}
4915 4916 4917 4918 4919 4920 4921 4922
		}

# check for line continuations in quoted strings with odd counts of "
		if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
			WARN("LINE_CONTINUATIONS",
			     "Avoid line continuations in quoted strings\n" . $herecurr);
		}

4923
# warn about #if 0
4924
		if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4925 4926
			CHK("REDUNDANT_CODE",
			    "if this code is redundant consider removing it\n" .
4927
				$herecurr);
4928 4929
		}

4930 4931
# check for needless "if (<foo>) fn(<foo>)" uses
		if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959
			my $tested = quotemeta($1);
			my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
			if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
				my $func = $1;
				if (WARN('NEEDLESS_IF',
					 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
				    $fix) {
					my $do_fix = 1;
					my $leading_tabs = "";
					my $new_leading_tabs = "";
					if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
						$leading_tabs = $1;
					} else {
						$do_fix = 0;
					}
					if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
						$new_leading_tabs = $1;
						if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
							$do_fix = 0;
						}
					} else {
						$do_fix = 0;
					}
					if ($do_fix) {
						fix_delete_line($fixlinenr - 1, $prevrawline);
						$fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
					}
				}
4960 4961
			}
		}
4962

4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979
# check for unnecessary "Out of Memory" messages
		if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
		    $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
		    (defined $1 || defined $3) &&
		    $linenr > 3) {
			my $testval = $2;
			my $testline = $lines[$linenr - 3];

			my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
#			print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");

			if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
				WARN("OOM_MESSAGE",
				     "Possible unnecessary 'out of memory' message\n" . $hereprev);
			}
		}

4980
# check for logging functions with KERN_<LEVEL>
4981
		if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
4982 4983 4984 4985 4986 4987 4988 4989 4990
		    $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
			my $level = $1;
			if (WARN("UNNECESSARY_KERN_LEVEL",
				 "Possible unnecessary $level\n" . $herecurr) &&
			    $fix) {
				$fixed[$fixlinenr] =~ s/\s*$level\s*//;
			}
		}

4991 4992 4993 4994 4995 4996 4997 4998
# check for mask then right shift without a parentheses
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
		    $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
			WARN("MASK_THEN_SHIFT",
			     "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
		}

4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012
# check for pointer comparisons to NULL
		if ($^V && $^V ge 5.10.0) {
			while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
				my $val = $1;
				my $equal = "!";
				$equal = "" if ($4 eq "!=");
				if (CHK("COMPARISON_TO_NULL",
					"Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
					    $fix) {
					$fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
				}
			}
		}

5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025
# check for bad placement of section $InitAttribute (e.g.: __initdata)
		if ($line =~ /(\b$InitAttribute\b)/) {
			my $attr = $1;
			if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
				my $ptr = $1;
				my $var = $2;
				if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
				      ERROR("MISPLACED_INIT",
					    "$attr should be placed after $var\n" . $herecurr)) ||
				     ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
				      WARN("MISPLACED_INIT",
					   "$attr should be placed after $var\n" . $herecurr))) &&
				    $fix) {
5026
					$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;
5027 5028 5029 5030
				}
			}
		}

5031 5032 5033 5034 5035 5036 5037 5038 5039
# check for $InitAttributeData (ie: __initdata) with const
		if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
			my $attr = $1;
			$attr =~ /($InitAttributePrefix)(.*)/;
			my $attr_prefix = $1;
			my $attr_type = $2;
			if (ERROR("INIT_ATTRIBUTE",
				  "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
			    $fix) {
5040
				$fixed[$fixlinenr] =~
5041 5042 5043 5044 5045 5046 5047 5048 5049 5050
				    s/$InitAttributeData/${attr_prefix}initconst/;
			}
		}

# check for $InitAttributeConst (ie: __initconst) without const
		if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
			my $attr = $1;
			if (ERROR("INIT_ATTRIBUTE",
				  "Use of $attr requires a separate use of const\n" . $herecurr) &&
			    $fix) {
5051
				my $lead = $fixed[$fixlinenr] =~
5052 5053 5054 5055
				    /(^\+\s*(?:static\s+))/;
				$lead = rtrim($1);
				$lead = "$lead " if ($lead !~ /^\+$/);
				$lead = "${lead}const ";
5056
				$fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5057 5058 5059
			}
		}

5060 5061 5062 5063 5064 5065 5066 5067 5068 5069
# check for __read_mostly with const non-pointer (should just be const)
		if ($line =~ /\b__read_mostly\b/ &&
		    $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
			if (ERROR("CONST_READ_MOSTLY",
				  "Invalid use of __read_mostly with const type\n" . $herecurr) &&
			    $fix) {
				$fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
			}
		}

5070 5071 5072 5073 5074 5075 5076 5077 5078
# don't use __constant_<foo> functions outside of include/uapi/
		if ($realfile !~ m@^include/uapi/@ &&
		    $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
			my $constant_func = $1;
			my $func = $constant_func;
			$func =~ s/^__constant_//;
			if (WARN("CONSTANT_CONVERSION",
				 "$constant_func should be $func\n" . $herecurr) &&
			    $fix) {
5079
				$fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5080 5081 5082
			}
		}

5083
# prefer usleep_range over udelay
B
Bruce Allan 已提交
5084
		if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5085
			my $delay = $1;
5086
			# ignore udelay's < 10, however
5087
			if (! ($delay < 10) ) {
5088
				CHK("USLEEP_RANGE",
5089 5090 5091 5092 5093
				    "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
			}
			if ($delay > 2000) {
				WARN("LONG_UDELAY",
				     "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5094 5095 5096
			}
		}

5097 5098 5099
# warn about unexpectedly long msleep's
		if ($line =~ /\bmsleep\s*\((\d+)\);/) {
			if ($1 < 20) {
5100
				WARN("MSLEEP",
5101
				     "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5102 5103 5104
			}
		}

5105 5106 5107 5108 5109 5110
# check for comparisons of jiffies
		if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
			WARN("JIFFIES_COMPARISON",
			     "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
		}

5111 5112 5113 5114 5115 5116
# check for comparisons of get_jiffies_64()
		if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
			WARN("JIFFIES_COMPARISON",
			     "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
		}

5117
# warn about #ifdefs in C files
5118
#		if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5119 5120 5121 5122 5123
#			print "#ifdef in C files should be avoided\n";
#			print "$herecurr";
#			$clean = 0;
#		}

5124
# warn about spacing in #ifdefs
5125
		if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5126 5127 5128
			if (ERROR("SPACING",
				  "exactly one space required after that #$1\n" . $herecurr) &&
			    $fix) {
5129
				$fixed[$fixlinenr] =~
5130 5131 5132
				    s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
			}

5133 5134
		}

5135
# check for spinlock_t definitions without a comment.
5136 5137
		if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
		    $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5138 5139
			my $which = $1;
			if (!ctx_has_comment($first_line, $linenr)) {
5140 5141
				CHK("UNCOMMENTED_DEFINITION",
				    "$1 definition without comment\n" . $herecurr);
5142 5143 5144
			}
		}
# check for memory barriers without a comment.
5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161

		my $barriers = qr{
			mb|
			rmb|
			wmb|
			read_barrier_depends
		}x;
		my $barrier_stems = qr{
			mb__before_atomic|
			mb__after_atomic|
			store_release|
			load_acquire|
			store_mb|
			(?:$barriers)
		}x;
		my $all_barriers = qr{
			(?:$barriers)|
5162 5163
			smp_(?:$barrier_stems)|
			virt_(?:$barrier_stems)
5164 5165 5166
		}x;

		if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5167
			if (!ctx_has_comment($first_line, $linenr)) {
5168 5169
				WARN("MEMORY_BARRIER",
				     "memory barrier without comment\n" . $herecurr);
5170 5171
			}
		}
5172

5173 5174 5175 5176 5177 5178 5179 5180 5181 5182
		my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;

		if ($realfile !~ m@^include/asm-generic/@ &&
		    $realfile !~ m@/barrier\.h$@ &&
		    $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
		    $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
			WARN("MEMORY_BARRIER",
			     "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
		}

5183 5184 5185 5186 5187 5188 5189
# check for waitqueue_active without a comment.
		if ($line =~ /\bwaitqueue_active\s*\(/) {
			if (!ctx_has_comment($first_line, $linenr)) {
				WARN("WAITQUEUE_ACTIVE",
				     "waitqueue_active without comment\n" . $herecurr);
			}
		}
5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207

# Check for expedited grace periods that interrupt non-idle non-nohz
# online CPUs.  These expedited can therefore degrade real-time response
# if used carelessly, and should be avoided where not absolutely
# needed.  It is always OK to use synchronize_rcu_expedited() and
# synchronize_sched_expedited() at boot time (before real-time applications
# start) and in error situations where real-time response is compromised in
# any case.  Note that synchronize_srcu_expedited() does -not- interrupt
# other CPUs, so don't warn on uses of synchronize_srcu_expedited().
# Of course, nothing comes for free, and srcu_read_lock() and
# srcu_read_unlock() do contain full memory barriers in payment for
# synchronize_srcu_expedited() non-interruption properties.
		if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
			WARN("EXPEDITED_RCU_GRACE_PERIOD",
			     "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);

		}

5208
# check of hardware specific defines
5209
		if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5210 5211
			CHK("ARCH_DEFINES",
			    "architecture specific defines should be avoided\n" .  $herecurr);
5212
		}
5213

5214 5215
# Check that the storage class is at the beginning of a declaration
		if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5216 5217
			WARN("STORAGE_CLASS",
			     "storage class should be at the beginning of the declaration\n" . $herecurr)
5218 5219
		}

5220 5221
# check the location of the inline attribute, that it is between
# storage class and type.
5222 5223
		if ($line =~ /\b$Type\s+$Inline\b/ ||
		    $line =~ /\b$Inline\s+$Storage\b/) {
5224 5225
			ERROR("INLINE_LOCATION",
			      "inline keyword should sit between storage class and type\n" . $herecurr);
5226 5227
		}

5228
# Check for __inline__ and __inline, prefer inline
5229 5230
		if ($realfile !~ m@\binclude/uapi/@ &&
		    $line =~ /\b(__inline__|__inline)\b/) {
5231 5232 5233
			if (WARN("INLINE",
				 "plain inline is preferred over $1\n" . $herecurr) &&
			    $fix) {
5234
				$fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5235 5236

			}
5237 5238
		}

5239
# Check for __attribute__ packed, prefer __packed
5240 5241
		if ($realfile !~ m@\binclude/uapi/@ &&
		    $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5242 5243
			WARN("PREFER_PACKED",
			     "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5244 5245
		}

5246
# Check for __attribute__ aligned, prefer __aligned
5247 5248
		if ($realfile !~ m@\binclude/uapi/@ &&
		    $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5249 5250
			WARN("PREFER_ALIGNED",
			     "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5251 5252
		}

5253
# Check for __attribute__ format(printf, prefer __printf
5254 5255
		if ($realfile !~ m@\binclude/uapi/@ &&
		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5256 5257 5258
			if (WARN("PREFER_PRINTF",
				 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
			    $fix) {
5259
				$fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5260 5261

			}
5262 5263
		}

5264
# Check for __attribute__ format(scanf, prefer __scanf
5265 5266
		if ($realfile !~ m@\binclude/uapi/@ &&
		    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5267 5268 5269
			if (WARN("PREFER_SCANF",
				 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
			    $fix) {
5270
				$fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5271
			}
5272 5273
		}

5274 5275 5276 5277 5278 5279 5280 5281 5282
# Check for __attribute__ weak, or __weak declarations (may have link issues)
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
		    ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
		     $line =~ /\b__weak\b/)) {
			ERROR("WEAK_DECLARATION",
			      "Using weak declarations can have unintended link defects\n" . $herecurr);
		}

5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300
# check for c99 types like uint8_t used outside of uapi/
		if ($realfile !~ m@\binclude/uapi/@ &&
		    $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
			my $type = $1;
			if ($type =~ /\b($typeC99Typedefs)\b/) {
				$type = $1;
				my $kernel_type = 'u';
				$kernel_type = 's' if ($type =~ /^_*[si]/);
				$type =~ /(\d+)/;
				$kernel_type .= $1;
				if (CHK("PREFER_KERNEL_TYPES",
					"Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
				    $fix) {
					$fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
				}
			}
		}

5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
# check for cast of C90 native int or longer types constants
		if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
			my $cast = $1;
			my $const = $2;
			if (WARN("TYPECAST_INT_CONSTANT",
				 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
			    $fix) {
				my $suffix = "";
				my $newconst = $const;
				$newconst =~ s/${Int_type}$//;
				$suffix .= 'U' if ($cast =~ /\bunsigned\b/);
				if ($cast =~ /\blong\s+long\b/) {
					$suffix .= 'LL';
				} elsif ($cast =~ /\blong\b/) {
					$suffix .= 'L';
				}
				$fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
			}
		}

5321 5322
# check for sizeof(&)
		if ($line =~ /\bsizeof\s*\(\s*\&/) {
5323 5324
			WARN("SIZEOF_ADDRESS",
			     "sizeof(& should be avoided\n" . $herecurr);
5325 5326
		}

5327 5328
# check for sizeof without parenthesis
		if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5329 5330 5331
			if (WARN("SIZEOF_PARENTHESIS",
				 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
			    $fix) {
5332
				$fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5333
			}
5334 5335
		}

5336 5337 5338 5339 5340 5341
# check for struct spinlock declarations
		if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
			WARN("USE_SPINLOCK_T",
			     "struct spinlock should be spinlock_t\n" . $herecurr);
		}

5342
# check for seq_printf uses that could be seq_puts
J
Joe Perches 已提交
5343
		if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5344
			my $fmt = get_quoted_string($line, $rawline);
5345 5346
			$fmt =~ s/%%//g;
			if ($fmt !~ /%/) {
5347 5348 5349
				if (WARN("PREFER_SEQ_PUTS",
					 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
				    $fix) {
5350
					$fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5351
				}
5352 5353 5354
			}
		}

5355
# Check for misused memsets
5356 5357
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
5358
		    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5359 5360

			my $ms_addr = $2;
5361 5362
			my $ms_val = $7;
			my $ms_size = $12;
5363 5364 5365

			if ($ms_size =~ /^(0x|)0$/i) {
				ERROR("MEMSET",
5366
				      "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5367 5368
			} elsif ($ms_size =~ /^(0x|)1$/i) {
				WARN("MEMSET",
5369 5370 5371 5372
				     "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
			}
		}

5373 5374
# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
		if ($^V && $^V ge 5.10.0 &&
5375 5376
		    defined $stat &&
		    $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5377
			if (WARN("PREFER_ETHER_ADDR_COPY",
5378
				 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5379
			    $fix) {
5380
				$fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5381 5382 5383
			}
		}

5384 5385 5386 5387 5388 5389 5390 5391
# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
		    $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
			WARN("PREFER_ETHER_ADDR_EQUAL",
			     "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
		}

5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414
# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
		    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {

			my $ms_val = $7;

			if ($ms_val =~ /^(?:0x|)0+$/i) {
				if (WARN("PREFER_ETH_ZERO_ADDR",
					 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
				    $fix) {
					$fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
				}
			} elsif ($ms_val =~ /^(?:0xff|255)$/i) {
				if (WARN("PREFER_ETH_BROADCAST_ADDR",
					 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
				    $fix) {
					$fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
				}
			}
		}

5415
# typecasts on min/max could be min_t/max_t
5416 5417
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
5418
		    $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5419
			if (defined $2 || defined $7) {
5420 5421 5422
				my $call = $1;
				my $cast1 = deparenthesize($2);
				my $arg1 = $3;
5423 5424
				my $cast2 = deparenthesize($7);
				my $arg2 = $8;
5425 5426
				my $cast;

5427
				if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5428 5429 5430 5431 5432 5433 5434 5435
					$cast = "$cast1 or $cast2";
				} elsif ($cast1 ne "") {
					$cast = $cast1;
				} else {
					$cast = $cast2;
				}
				WARN("MINMAX",
				     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5436 5437 5438
			}
		}

5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454
# check usleep_range arguments
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
		    $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
			my $min = $1;
			my $max = $7;
			if ($min eq $max) {
				WARN("USLEEP_RANGE",
				     "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
			} elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
				 $min > $max) {
				WARN("USLEEP_RANGE",
				     "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
			}
		}

5455 5456 5457
# check for naked sscanf
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
5458
		    $line =~ /\bsscanf\b/ &&
5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471
		    ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
		     $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
		     $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
			my $lc = $stat =~ tr@\n@@;
			$lc = $lc + $linenr;
			my $stat_real = raw_line($linenr, 0);
		        for (my $count = $linenr + 1; $count <= $lc; $count++) {
				$stat_real = $stat_real . "\n" . raw_line($count, 0);
			}
			WARN("NAKED_SSCANF",
			     "unchecked sscanf return value\n" . "$here\n$stat_real\n");
		}

5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492
# check for simple sscanf that should be kstrto<foo>
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
		    $line =~ /\bsscanf\b/) {
			my $lc = $stat =~ tr@\n@@;
			$lc = $lc + $linenr;
			my $stat_real = raw_line($linenr, 0);
		        for (my $count = $linenr + 1; $count <= $lc; $count++) {
				$stat_real = $stat_real . "\n" . raw_line($count, 0);
			}
			if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
				my $format = $6;
				my $count = $format =~ tr@%@%@;
				if ($count == 1 &&
				    $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
					WARN("SSCANF_TO_KSTRTO",
					     "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
				}
			}
		}

5493 5494 5495
# check for new externs in .h files.
		if ($realfile =~ /\.h$/ &&
		    $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5496 5497
			if (CHK("AVOID_EXTERNS",
				"extern prototypes should be avoided in .h files\n" . $herecurr) &&
5498
			    $fix) {
5499
				$fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5500 5501 5502
			}
		}

5503
# check for new externs in .c files.
5504
		if ($realfile =~ /\.c$/ && defined $stat &&
5505
		    $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5506
		{
5507 5508
			my $function_name = $1;
			my $paren_space = $2;
5509 5510 5511 5512 5513

			my $s = $stat;
			if (defined $cond) {
				substr($s, 0, length($cond), '');
			}
5514 5515 5516
			if ($s =~ /^\s*;/ &&
			    $function_name ne 'uninitialized_var')
			{
5517 5518
				WARN("AVOID_EXTERNS",
				     "externs should be avoided in .c files\n" .  $herecurr);
5519 5520 5521
			}

			if ($paren_space =~ /\n/) {
5522 5523
				WARN("FUNCTION_ARGUMENTS",
				     "arguments for function declarations should follow identifier\n" . $herecurr);
5524
			}
5525 5526 5527 5528

		} elsif ($realfile =~ /\.c$/ && defined $stat &&
		    $stat =~ /^.\s*extern\s+/)
		{
5529 5530
			WARN("AVOID_EXTERNS",
			     "externs should be avoided in .c files\n" .  $herecurr);
5531 5532 5533 5534 5535 5536 5537
		}

# checks for new __setup's
		if ($rawline =~ /\b__setup\("([^"]*)"/) {
			my $name = $1;

			if (!grep(/$name/, @setup_docs)) {
5538 5539
				CHK("UNDOCUMENTED_SETUP",
				    "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5540
			}
5541
		}
5542 5543

# check for pointless casting of kmalloc return
5544
		if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5545 5546
			WARN("UNNECESSARY_CASTS",
			     "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5547
		}
5548

5549 5550 5551 5552 5553 5554 5555 5556
# alloc style
# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
			CHK("ALLOC_SIZEOF_STRUCT",
			    "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
		}

5557 5558
# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
		if ($^V && $^V ge 5.10.0 &&
5559
		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5560 5561 5562 5563 5564
			my $oldfunc = $3;
			my $a1 = $4;
			my $a2 = $10;
			my $newfunc = "kmalloc_array";
			$newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5565 5566 5567 5568 5569 5570 5571 5572
			my $r1 = $a1;
			my $r2 = $a2;
			if ($a1 =~ /^sizeof\s*\S/) {
				$r1 = $a2;
				$r2 = $a1;
			}
			if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
			    !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5573 5574 5575
				if (WARN("ALLOC_WITH_MULTIPLY",
					 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
				    $fix) {
5576
					$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;
5577 5578 5579 5580 5581

				}
			}
		}

5582 5583 5584 5585 5586 5587 5588
# check for krealloc arg reuse
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
			WARN("KREALLOC_ARG_REUSE",
			     "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
		}

5589 5590 5591 5592 5593 5594
# check for alloc argument mismatch
		if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
			WARN("ALLOC_ARRAY_ARGS",
			     "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
		}

5595 5596
# check for multiple semicolons
		if ($line =~ /;\s*;\s*$/) {
5597 5598 5599
			if (WARN("ONE_SEMICOLON",
				 "Statements terminations use 1 semicolon\n" . $herecurr) &&
			    $fix) {
5600
				$fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5601
			}
5602 5603
		}

5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614
# check for #defines like: 1 << <digit> that could be BIT(digit)
		if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
			my $ull = "";
			$ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
			if (CHK("BIT_MACRO",
				"Prefer using the BIT$ull macro\n" . $herecurr) &&
			    $fix) {
				$fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
			}
		}

5615
# check for case / default statements not preceded by break/fallthrough/switch
5616 5617 5618 5619 5620
		if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
			my $has_break = 0;
			my $has_statement = 0;
			my $count = 0;
			my $prevline = $linenr;
5621
			while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639
				$prevline--;
				my $rline = $rawlines[$prevline - 1];
				my $fline = $lines[$prevline - 1];
				last if ($fline =~ /^\@\@/);
				next if ($fline =~ /^\-/);
				next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
				$has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
				next if ($fline =~ /^.[\s$;]*$/);
				$has_statement = 1;
				$count++;
				$has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
			}
			if (!$has_break && $has_statement) {
				WARN("MISSING_BREAK",
				     "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
			}
		}

5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651
# check for switch/default statements without a break;
		if ($^V && $^V ge 5.10.0 &&
		    defined $stat &&
		    $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
			my $ctx = '';
			my $herectx = $here . "\n";
			my $cnt = statement_rawlines($stat);
			for (my $n = 0; $n < $cnt; $n++) {
				$herectx .= raw_line($linenr, $n) . "\n";
			}
			WARN("DEFAULT_NO_BREAK",
			     "switch default: should use break\n" . $herectx);
5652 5653
		}

5654
# check for gcc specific __FUNCTION__
5655 5656 5657 5658
		if ($line =~ /\b__FUNCTION__\b/) {
			if (WARN("USE_FUNC",
				 "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
			    $fix) {
5659
				$fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5660
			}
5661
		}
5662

5663 5664 5665 5666 5667 5668
# check for uses of __DATE__, __TIME__, __TIMESTAMP__
		while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
			ERROR("DATE_TIME",
			      "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
		}

J
Joe Perches 已提交
5669 5670 5671 5672 5673 5674
# check for use of yield()
		if ($line =~ /\byield\s*\(\s*\)/) {
			WARN("YIELD",
			     "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
		}

5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701
# check for comparisons against true and false
		if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
			my $lead = $1;
			my $arg = $2;
			my $test = $3;
			my $otype = $4;
			my $trail = $5;
			my $op = "!";

			($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);

			my $type = lc($otype);
			if ($type =~ /^(?:true|false)$/) {
				if (("$test" eq "==" && "$type" eq "true") ||
				    ("$test" eq "!=" && "$type" eq "false")) {
					$op = "";
				}

				CHK("BOOL_COMPARISON",
				    "Using comparison to $otype is error prone\n" . $herecurr);

## maybe suggesting a correct construct would better
##				    "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);

			}
		}

5702 5703
# check for semaphores initialized locked
		if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5704 5705
			WARN("CONSIDER_COMPLETION",
			     "consider using a completion\n" . $herecurr);
5706
		}
5707

5708 5709
# recommend kstrto* over simple_strto* and strict_strto*
		if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5710
			WARN("CONSIDER_KSTRTO",
5711
			     "$1 is obsolete, use k$3 instead\n" . $herecurr);
5712
		}
5713

5714
# check for __initcall(), use device_initcall() explicitly or more appropriate function please
5715
		if ($line =~ /^.\s*__initcall\s*\(/) {
5716
			WARN("USE_DEVICE_INITCALL",
5717
			     "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5718
		}
5719

5720 5721 5722
# check for various structs that are normally const (ops, kgdb, device_tree)
		my $const_structs = qr{
				acpi_dock_ops|
5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744
				address_space_operations|
				backlight_ops|
				block_device_operations|
				dentry_operations|
				dev_pm_ops|
				dma_map_ops|
				extent_io_ops|
				file_lock_operations|
				file_operations|
				hv_ops|
				ide_dma_ops|
				intel_dvo_dev_ops|
				item_operations|
				iwl_ops|
				kgdb_arch|
				kgdb_io|
				kset_uevent_ops|
				lock_manager_operations|
				microcode_ops|
				mtrr_ops|
				neigh_ops|
				nlmsvc_binding|
5745
				of_device_id|
5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757
				pci_raw_ops|
				pipe_buf_operations|
				platform_hibernation_ops|
				platform_suspend_ops|
				proto_ops|
				rpc_pipe_ops|
				seq_operations|
				snd_ac97_build_ops|
				soc_pcmcia_socket_ops|
				stacktrace_ops|
				sysfs_ops|
				tty_operations|
5758
				uart_ops|
5759 5760
				usb_mon_operations|
				wd_ops}x;
5761
		if ($line !~ /\bconst\b/ &&
5762
		    $line =~ /\bstruct\s+($const_structs)\b/) {
5763 5764
			WARN("CONST_STRUCT",
			     "struct $1 should normally be const\n" .
5765
				$herecurr);
5766
		}
5767 5768 5769 5770

# use of NR_CPUS is usually wrong
# ignore definitions of NR_CPUS and usage to define arrays as likely right
		if ($line =~ /\bNR_CPUS\b/ &&
5771 5772
		    $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
		    $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5773 5774 5775
		    $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
		    $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
		    $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5776
		{
5777 5778
			WARN("NR_CPUS",
			     "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5779
		}
5780

5781 5782 5783 5784 5785 5786
# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
		if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
			ERROR("DEFINE_ARCH_HAS",
			      "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
		}

5787 5788 5789 5790 5791 5792 5793
# likely/unlikely comparisons similar to "(likely(foo) > 0)"
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
			WARN("LIKELY_MISUSE",
			     "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
		}

5794 5795 5796
# whine mightly about in_atomic
		if ($line =~ /\bin_atomic\s*\(/) {
			if ($realfile =~ m@^drivers/@) {
5797 5798
				ERROR("IN_ATOMIC",
				      "do not use in_atomic in drivers\n" . $herecurr);
5799
			} elsif ($realfile !~ m@^kernel/@) {
5800 5801
				WARN("IN_ATOMIC",
				     "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5802 5803
			}
		}
5804 5805 5806 5807 5808 5809 5810

# check for lockdep_set_novalidate_class
		if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
		    $line =~ /__lockdep_no_validate__\s*\)/ ) {
			if ($realfile !~ m@^kernel/lockdep@ &&
			    $realfile !~ m@^include/linux/lockdep@ &&
			    $realfile !~ m@^drivers/base/core@) {
5811 5812
				ERROR("LOCKDEP",
				      "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5813 5814
			}
		}
5815

5816 5817
		if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
		    $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5818 5819
			WARN("EXPORTED_WORLD_WRITABLE",
			     "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5820
		}
5821

5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844
# Mode permission misuses where it seems decimal should be octal
# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
		if ($^V && $^V ge 5.10.0 &&
		    $line =~ /$mode_perms_search/) {
			foreach my $entry (@mode_permission_funcs) {
				my $func = $entry->[0];
				my $arg_pos = $entry->[1];

				my $skip_args = "";
				if ($arg_pos > 1) {
					$arg_pos--;
					$skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
				}
				my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
				if ($line =~ /$test/) {
					my $val = $1;
					$val = $6 if ($skip_args ne "");

					if ($val !~ /^0$/ &&
					    (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
					     length($val) ne 4)) {
						ERROR("NON_OCTAL_PERMISSIONS",
						      "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5845 5846 5847
					} elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
						ERROR("EXPORTED_WORLD_WRITABLE",
						      "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5848
					}
5849 5850 5851
				}
			}
		}
5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869

# validate content of MODULE_LICENSE against list from include/linux/module.h
		if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
			my $extracted_string = get_quoted_string($line, $rawline);
			my $valid_licenses = qr{
						GPL|
						GPL\ v2|
						GPL\ and\ additional\ rights|
						Dual\ BSD/GPL|
						Dual\ MIT/GPL|
						Dual\ MPL/GPL|
						Proprietary
					}x;
			if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
				WARN("MODULE_LICENSE",
				     "unknown module license " . $extracted_string . "\n" . $herecurr);
			}
		}
5870 5871 5872 5873 5874 5875
	}

	# If we have no input at all, then there is nothing to report on
	# so just keep quiet.
	if ($#rawlines == -1) {
		exit(0);
5876 5877
	}

5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889
	# In mailback mode only produce a report in the negative, for
	# things that appear to be patches.
	if ($mailback && ($clean == 1 || !$is_patch)) {
		exit(0);
	}

	# This is not a patch, and we are are in 'no-patch' mode so
	# just keep quiet.
	if (!$chk_patch && !$is_patch) {
		exit(0);
	}

5890
	if (!$is_patch && $file !~ /cover-letter\.patch$/) {
5891 5892
		ERROR("NOT_UNIFIED_DIFF",
		      "Does not appear to be a unified-diff format patch\n");
5893
	}
5894
	if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
5895 5896
		ERROR("MISSING_SIGN_OFF",
		      "Missing Signed-off-by: line(s)\n");
5897 5898
	}

5899
	print report_dump();
5900 5901
	if ($summary && !($clean == 1 && $quiet == 1)) {
		print "$filename " if ($summary_file);
5902 5903 5904
		print "total: $cnt_error errors, $cnt_warn warnings, " .
			(($check)? "$cnt_chk checks, " : "") .
			"$cnt_lines lines checked\n";
5905
	}
5906

5907 5908 5909 5910
	if ($quiet == 0) {
		# If there were whitespace errors which cleanpatch can fix
		# then suggest that.
		if ($rpt_cleaners) {
5911
			$rpt_cleaners = 0;
5912 5913 5914 5915 5916
			print << "EOM"

NOTE: Whitespace errors detected.
      You may wish to use scripts/cleanpatch or scripts/cleanfile
EOM
5917 5918 5919
		}
	}

5920 5921 5922
	if ($clean == 0 && $fix &&
	    ("@rawlines" ne "@fixed" ||
	     $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
5923 5924
		my $newfile = $filename;
		$newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
5925 5926 5927
		my $linecount = 0;
		my $f;

5928 5929
		@fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);

5930 5931 5932 5933 5934 5935 5936
		open($f, '>', $newfile)
		    or die "$P: Can't open $newfile for write\n";
		foreach my $fixed_line (@fixed) {
			$linecount++;
			if ($file) {
				if ($linecount > 3) {
					$fixed_line =~ s/^\+//;
5937
					print $f $fixed_line . "\n";
5938 5939 5940 5941 5942 5943 5944 5945 5946
				}
			} else {
				print $f $fixed_line . "\n";
			}
		}
		close($f);

		if (!$quiet) {
			print << "EOM";
5947

5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958
Wrote EXPERIMENTAL --fix correction(s) to '$newfile'

Do _NOT_ trust the results written to this file.
Do _NOT_ submit these changes without inspecting them for correctness.

This EXPERIMENTAL file is simply a convenience to help rewrite patches.
No warranties, expressed or implied...
EOM
		}
	}

5959 5960 5961 5962 5963 5964 5965
	if ($quiet == 0) {
		print "\n";
		if ($clean == 1) {
			print "$vname has no obvious style problems and is ready for submission.\n";
		} else {
			print "$vname has style problems, please review.\n";
		}
5966 5967 5968
	}
	return $clean;
}