linux - scripts/checkpatch.pl

7659 lines · 228.0 KiB

1	#!/usr/bin/env perl
2	# SPDX-License-Identifier: GPL-2.0
3	#
4	# (c) 2001, Dave Jones. (the file handling bit)
5	# (c) 2005, Joel Schopp <[email protected]> (the ugly bit)
6	# (c) 2007,2008, Andy Whitcroft <[email protected]> (new conditions, test suite)
7	# (c) 2008-2010 Andy Whitcroft <[email protected]>
8	# (c) 2010-2018 Joe Perches <[email protected]>
9
10	use strict;
11	use warnings;
12	use POSIX;
13	use File::Basename;
14	use Cwd 'abs_path';
15	use Term::ANSIColor qw(:constants);
16	use Encode qw(decode encode);
17
18	my $P = $0;
19	my $D = dirname(abs_path($P));
20
21	my $V = '0.32';
22
23	use Getopt::Long qw(:config no_auto_abbrev);
24
25	my $quiet = 0;
26	my $verbose = 0;
27	my %verbose_messages = ();
28	my %verbose_emitted = ();
29	my $tree = 1;
30	my $chk_signoff = 1;
31	my $chk_patch = 1;
32	my $tst_only;
33	my $emacs = 0;
34	my $terse = 0;
35	my $showfile = 0;
36	my $file = 0;
37	my $git = 0;
38	my %git_commits = ();
39	my $check = 0;
40	my $check_orig = 0;
41	my $summary = 1;
42	my $mailback = 0;
43	my $summary_file = 0;
44	my $show_types = 0;
45	my $list_types = 0;
46	my $fix = 0;
47	my $fix_inplace = 0;
48	my $root;
49	my $gitroot = $ENV{'GIT_DIR'};
50	$gitroot = ".git" if !defined($gitroot);
51	my %debug;
52	my %camelcase = ();
53	my %use_type = ();
54	my @use = ();
55	my %ignore_type = ();
56	my @ignore = ();
57	my $help = 0;
58	my $configuration_file = ".checkpatch.conf";
59	my $max_line_length = 100;
60	my $ignore_perl_version = 0;
61	my $minimum_perl_version = 5.10.0;
62	my $min_conf_desc_length = 4;
63	my $spelling_file = "$D/spelling.txt";
64	my $codespell = 0;
65	my $codespellfile = "/usr/share/codespell/dictionary.txt";
66	my $user_codespellfile = "";
67	my $conststructsfile = "$D/const_structs.checkpatch";
68	my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";
69	my $typedefsfile;
70	my $color = "auto";
71	my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
72	# git output parsing needs US English output, so first set backtick child process LANGUAGE
73	my $git_command ='export LANGUAGE=en_US.UTF-8; git';
74	my $tabsize = 8;
75	my ${CONFIG_} = "CONFIG_";
76
77	sub help {
78	my ($exitcode) = @_;
79
80	print << "EOM";
81	Usage: $P [OPTION]... [FILE]...
82	Version: $V
83
84	Options:
85	-q, --quiet quiet
86	-v, --verbose verbose mode
87	--no-tree run without a kernel tree
88	--no-signoff do not check for 'Signed-off-by' line
89	--patch treat FILE as patchfile (default)
90	--emacs emacs compile window format
91	--terse one line per report
92	--showfile emit diffed file position, not input file position
93	-g, --git treat FILE as a single commit or git revision range
94	single git commit with:
95	<rev>
96	<rev>^
97	<rev>~n
98	multiple git commits with:
99	<rev1>..<rev2>
100	<rev1>...<rev2>
101	<rev>-<count>
102	git merges are ignored
103	-f, --file treat FILE as regular source file
104	--subjective, --strict enable more subjective tests
105	--list-types list the possible message types
106	--types TYPE(,TYPE2...) show only these comma separated message types
107	--ignore TYPE(,TYPE2...) ignore various comma separated message types
108	--show-types show the specific message type in the output
109	--max-line-length=n set the maximum line length, (default $max_line_length)
110	if exceeded, warn on patches
111	requires --strict for use with --file
112	--min-conf-desc-length=n set the min description length, if shorter, warn
113	--tab-size=n set the number of spaces for tab (default $tabsize)
114	--root=PATH PATH to the kernel tree root
115	--no-summary suppress the per-file summary
116	--mailback only produce a report in case of warnings/errors
117	--summary-file include the filename in summary
118	--debug KEY=[0\|1] turn on/off debugging of KEY, where KEY is one of
119	'values', 'possible', 'type', and 'attr' (default
120	is all off)
121	--test-only=WORD report only warnings/errors containing WORD
122	literally
123	--fix EXPERIMENTAL - may create horrible results
124	If correctable single-line errors exist, create
125	"<inputfile>.EXPERIMENTAL-checkpatch-fixes"
126	with potential errors corrected to the preferred
127	checkpatch style
128	--fix-inplace EXPERIMENTAL - may create horrible results
129	Is the same as --fix, but overwrites the input
130	file. It's your fault if there's no backup or git
131	--ignore-perl-version override checking of perl version. expect
132	runtime errors.
133	--codespell Use the codespell dictionary for spelling/typos
134	(default:$codespellfile)
135	--codespellfile Use this codespell dictionary
136	--typedefsfile Read additional types from this file
137	--color[=WHEN] Use colors 'always', 'never', or only when output
138	is a terminal ('auto'). Default is 'auto'.
139	--kconfig-prefix=WORD use WORD as a prefix for Kconfig symbols (default
140	${CONFIG_})
141	-h, --help, --version display this help and exit
142
143	When FILE is - read standard input.
144	EOM
145
146	exit($exitcode);
147	}
148
149	sub uniq {
150	my %seen;
151	return grep { !$seen{$_}++ } @_;
152	}
153
154	sub list_types {
155	my ($exitcode) = @_;
156
157	my $count = 0;
158
159	local $/ = undef;
160
161	open(my $script, '<', abs_path($P)) or
162	die "$P: Can't read '$P' $!\n";
163
164	my $text = <$script>;
165	close($script);
166
167	my %types = ();
168	# Also catch when type or level is passed through a variable
169	while ($text =~ /(?:(\bCHK\|\bWARN\|\bERROR\|&\{\$msg_level})\s\(\|\$msg_type\s=)\s*"([^"]+)"/g) {
170	if (defined($1)) {
171	if (exists($types{$2})) {
172	$types{$2} .= ",$1" if ($types{$2} ne $1);
173	} else {
174	$types{$2} = $1;
175	}
176	} else {
177	$types{$2} = "UNDETERMINED";
178	}
179	}
180
181	print("#\tMessage type\n\n");
182	if ($color) {
183	print(" ( Color coding: ");
184	print(RED . "ERROR" . RESET);
185	print(" \| ");
186	print(YELLOW . "WARNING" . RESET);
187	print(" \| ");
188	print(GREEN . "CHECK" . RESET);
189	print(" \| ");
190	print("Multiple levels / Undetermined");
191	print(" )\n\n");
192	}
193
194	foreach my $type (sort keys %types) {
195	my $orig_type = $type;
196	if ($color) {
197	my $level = $types{$type};
198	if ($level eq "ERROR") {
199	$type = RED . $type . RESET;
200	} elsif ($level eq "WARN") {
201	$type = YELLOW . $type . RESET;
202	} elsif ($level eq "CHK") {
203	$type = GREEN . $type . RESET;
204	}
205	}
206	print(++$count . "\t" . $type . "\n");
207	if ($verbose && exists($verbose_messages{$orig_type})) {
208	my $message = $verbose_messages{$orig_type};
209	$message =~ s/\n/\n\t/g;
210	print("\t" . $message . "\n\n");
211	}
212	}
213
214	exit($exitcode);
215	}
216
217	my $conf = which_conf($configuration_file);
218	if (-f $conf) {
219	my @conf_args;
220	open(my $conffile, '<', "$conf")
221	or warn "$P: Can't find a readable $configuration_file file $!\n";
222
223	while (<$conffile>) {
224	my $line = $_;
225
226	$line =~ s/\s*\n?$//g;
227	$line =~ s/^\s*//g;
228	$line =~ s/\s+/ /g;
229
230	next if ($line =~ m/^\s*#/);
231	next if ($line =~ m/^\s*$/);
232
233	my @words = split(" ", $line);
234	foreach my $word (@words) {
235	last if ($word =~ m/^#/);
236	push (@conf_args, $word);
237	}
238	}
239	close($conffile);
240	unshift(@ARGV, @conf_args) if @conf_args;
241	}
242
243	sub load_docs {
244	open(my $docs, '<', "$docsfile")
245	or warn "$P: Can't read the documentation file $docsfile $!\n";
246
247	my $type = '';
248	my $desc = '';
249	my $in_desc = 0;
250
251	while (<$docs>) {
252	chomp;
253	my $line = $_;
254	$line =~ s/\s+$//;
255
256	if ($line =~ /^\s\\(.+)\\*$/) {
257	if ($desc ne '') {
258	$verbose_messages{$type} = trim($desc);
259	}
260	$type = $1;
261	$desc = '';
262	$in_desc = 1;
263	} elsif ($in_desc) {
264	if ($line =~ /^(?:\s{4,}\|$)/) {
265	$line =~ s/^\s{4}//;
266	$desc .= $line;
267	$desc .= "\n";
268	} else {
269	$verbose_messages{$type} = trim($desc);
270	$type = '';
271	$desc = '';
272	$in_desc = 0;
273	}
274	}
275	}
276
277	if ($desc ne '') {
278	$verbose_messages{$type} = trim($desc);
279	}
280	close($docs);
281	}
282
283	# Perl's Getopt::Long allows options to take optional arguments after a space.
284	# Prevent --color by itself from consuming other arguments
285	foreach (@ARGV) {
286	if ($_ eq "--color" \|\| $_ eq "-color") {
287	$_ = "--color=$color";
288	}
289	}
290
291	GetOptions(
292	'q\|quiet+' => \$quiet,
293	'v\|verbose!' => \$verbose,
294	'tree!' => \$tree,
295	'signoff!' => \$chk_signoff,
296	'patch!' => \$chk_patch,
297	'emacs!' => \$emacs,
298	'terse!' => \$terse,
299	'showfile!' => \$showfile,
300	'f\|file!' => \$file,
301	'g\|git!' => \$git,
302	'subjective!' => \$check,
303	'strict!' => \$check,
304	'ignore=s' => \@ignore,
305	'types=s' => \@use,
306	'show-types!' => \$show_types,
307	'list-types!' => \$list_types,
308	'max-line-length=i' => \$max_line_length,
309	'min-conf-desc-length=i' => \$min_conf_desc_length,
310	'tab-size=i' => \$tabsize,
311	'root=s' => \$root,
312	'summary!' => \$summary,
313	'mailback!' => \$mailback,
314	'summary-file!' => \$summary_file,
315	'fix!' => \$fix,
316	'fix-inplace!' => \$fix_inplace,
317	'ignore-perl-version!' => \$ignore_perl_version,
318	'debug=s' => \%debug,
319	'test-only=s' => \$tst_only,
320	'codespell!' => \$codespell,
321	'codespellfile=s' => \$user_codespellfile,
322	'typedefsfile=s' => \$typedefsfile,
323	'color=s' => \$color,
324	'no-color' => \$color, #keep old behaviors of -nocolor
325	'nocolor' => \$color, #keep old behaviors of -nocolor
326	'kconfig-prefix=s' => \${CONFIG_},
327	'h\|help' => \$help,
328	'version' => \$help
329	) or $help = 2;
330
331	if ($user_codespellfile) {
332	# Use the user provided codespell file unconditionally
333	$codespellfile = $user_codespellfile;
334	} elsif (!(-f $codespellfile)) {
335	# If /usr/share/codespell/dictionary.txt is not present, try to find it
336	# under codespell's install directory: <codespell_root>/data/dictionary.txt
337	if (($codespell \|\| $help) && which("python3") ne "") {
338	my $python_codespell_dict = << "EOF";
339
340	import os.path as op
341	import codespell_lib
342	codespell_dir = op.dirname(codespell_lib.__file__)
343	codespell_file = op.join(codespell_dir, 'data', 'dictionary.txt')
344	print(codespell_file, end='')
345	EOF
346
347	my $codespell_dict = `python3 -c "$python_codespell_dict" 2> /dev/null`;
348	$codespellfile = $codespell_dict if (-f $codespell_dict);
349	}
350	}
351
352	# $help is 1 if either -h, --help or --version is passed as option - exitcode: 0
353	# $help is 2 if invalid option is passed - exitcode: 1
354	help($help - 1) if ($help);
355
356	die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file \|\| $fix));
357	die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);
358
359	if ($color =~ /^[01]$/) {
360	$color = !$color;
361	} elsif ($color =~ /^always$/i) {
362	$color = 1;
363	} elsif ($color =~ /^never$/i) {
364	$color = 0;
365	} elsif ($color =~ /^auto$/i) {
366	$color = (-t STDOUT);
367	} else {
368	die "$P: Invalid color mode: $color\n";
369	}
370
371	load_docs() if ($verbose);
372	list_types(0) if ($list_types);
373
374	$fix = 1 if ($fix_inplace);
375	$check_orig = $check;
376
377	my $exit = 0;
378
379	my $perl_version_ok = 1;
380	if ($^V && $^V lt $minimum_perl_version) {
381	$perl_version_ok = 0;
382	printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
383	exit(1) if (!$ignore_perl_version);
384	}
385
386	#if no filenames are given, push '-' to read patch from stdin
387	if ($#ARGV < 0) {
388	push(@ARGV, '-');
389	}
390
391	# skip TAB size 1 to avoid additional checks on $tabsize - 1
392	die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
393
394	sub hash_save_array_words {
395	my ($hashRef, $arrayRef) = @_;
396
397	my @array = split(/,/, join(',', @$arrayRef));
398	foreach my $word (@array) {
399	$word =~ s/\s*\n?$//g;
400	$word =~ s/^\s*//g;
401	$word =~ s/\s+/ /g;
402	$word =~ tr/[a-z]/[A-Z]/;
403
404	next if ($word =~ m/^\s*#/);
405	next if ($word =~ m/^\s*$/);
406
407	$hashRef->{$word}++;
408	}
409	}
410
411	sub hash_show_words {
412	my ($hashRef, $prefix) = @_;
413
414	if (keys %$hashRef) {
415	print "\nNOTE: $prefix message types:";
416	foreach my $word (sort keys %$hashRef) {
417	print " $word";
418	}
419	print "\n";
420	}
421	}
422
423	hash_save_array_words(\%ignore_type, \@ignore);
424	hash_save_array_words(\%use_type, \@use);
425
426	my $dbg_values = 0;
427	my $dbg_possible = 0;
428	my $dbg_type = 0;
429	my $dbg_attr = 0;
430	for my $key (keys %debug) {
431	## no critic
432	eval "\${dbg_$key} = '$debug{$key}';";
433	die "$@" if ($@);
434	}
435
436	my $rpt_cleaners = 0;
437
438	if ($terse) {
439	$emacs = 1;
440	$quiet++;
441	}
442
443	if ($tree) {
444	if (defined $root) {
445	if (!top_of_kernel_tree($root)) {
446	die "$P: $root: --root does not point at a valid tree\n";
447	}
448	} else {
449	if (top_of_kernel_tree('.')) {
450	$root = '.';
451	} elsif ($0 =~ m@(.)/scripts/[^/]$@ &&
452	top_of_kernel_tree($1)) {
453	$root = $1;
454	}
455	}
456
457	if (!defined $root) {
458	print "Must be run from the top-level dir. of a kernel tree\n";
459	exit(2);
460	}
461	}
462
463	my $emitted_corrupt = 0;
464
465	our $Ident = qr{
466	[A-Za-z_][A-Za-z\d_]*
467	(?:\s\#\#\s[A-Za-z_][A-Za-z\d_])
468	}x;
469	our $Storage = qr{extern\|static\|asmlinkage};
470	our $Sparse = qr{
471	__user\|
472	__kernel\|
473	__force\|
474	__iomem\|
475	__must_check\|
476	__kprobes\|
477	__ref\|
478	__refconst\|
479	__refdata\|
480	__rcu\|
481	__private
482	}x;
483	our $InitAttributePrefix = qr{__(?:mem\|cpu\|dev\|net_\|)};
484	our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
485	our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
486	our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
487	our $InitAttribute = qr{$InitAttributeData\|$InitAttributeConst\|$InitAttributeInit};
488
489	# Notes to $Attribute:
490	# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
491	our $Attribute = qr{
492	const\|
493	volatile\|
494	__percpu\|
495	__nocast\|
496	__safe\|
497	__bitwise\|
498	__packed__\|
499	__packed2__\|
500	__naked\|
501	__maybe_unused\|
502	__always_unused\|
503	__noreturn\|
504	__used\|
505	__cold\|
506	__pure\|
507	__noclone\|
508	__deprecated\|
509	__read_mostly\|
510	__ro_after_init\|
511	__kprobes\|
512	$InitAttribute\|
513	____cacheline_aligned\|
514	____cacheline_aligned_in_smp\|
515	____cacheline_internodealigned_in_smp\|
516	__weak\|
517	__alloc_size\s$\s\d+\s(?:,\s\d+\s*)?$
518	}x;
519	our $Modifier;
520	our $Inline = qr{inline\|__always_inline\|noinline\|__inline\|__inline__};
521	our $Member = qr{->$Ident\|\.$Ident\|\[[^]]*\]};
522	our $Lval = qr{$Ident(?:$Member)*};
523
524	our $Int_type = qr{(?i)llu\|ull\|ll\|lu\|ul\|l\|u};
525	our $Binary = qr{(?i)0b[01]+$Int_type?};
526	our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
527	our $Int = qr{[0-9]+$Int_type?};
528	our $Octal = qr{0[0-7]+$Int_type?};
529	our $String = qr{(?:\b[Lu])?"[X\t]*"};
530	our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
531	our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]\|[0-9]\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
532	our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
533	our $Float = qr{$Float_hex\|$Float_dec\|$Float_int};
534	our $Constant = qr{$Float\|$Binary\|$Octal\|$Hex\|$Int};
535	our $Assignment = qr{\*\=\|/=\|%=\|\+=\|-=\|<<=\|>>=\|&=\|\^=\|\\|=\|=};
536	our $Compare = qr{<=\|>=\|==\|!=\|<\|(?<!-)>};
537	our $Arithmetic = qr{\+\|-\|\*\|\/\|%};
538	our $Operators = qr{
539	<=\|>=\|==\|!=\|
540	=>\|->\|<<\|>>\|<\|>\|!\|~\|
541	&&\|\\|\\|\|,\|\^\|\+\+\|--\|&\|\\|\|$Arithmetic
542	}x;
543
544	our $c90_Keywords = qr{do\|for\|while\|if\|else\|return\|goto\|continue\|switch\|default\|case\|break}x;
545
546	our $BasicType;
547	our $NonptrType;
548	our $NonptrTypeMisordered;
549	our $NonptrTypeWithAttr;
550	our $Type;
551	our $TypeMisordered;
552	our $Declare;
553	our $DeclareMisordered;
554
555	our $NON_ASCII_UTF8 = qr{
556	[\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
557	\| \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
558	\| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
559	\| \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
560	\| \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
561	\| [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
562	\| \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
563	}x;
564
565	our $UTF8 = qr{
566	[\x09\x0A\x0D\x20-\x7E] # ASCII
567	\| $NON_ASCII_UTF8
568	}x;
569
570	our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8\|16\|32\|64)_t};
571	our $typeOtherOSTypedefs = qr{(?x:
572	u_(?:char\|short\|int\|long) \| # bsd
573	u(?:nchar\|short\|int\|long) # sysv
574	)};
575	our $typeKernelTypedefs = qr{(?x:
576	(?:__)?(?:u\|s\|be\|le)(?:8\|16\|32\|64)\|
577	atomic_t
578	)};
579	our $typeStdioTypedefs = qr{(?x:
580	FILE
581	)};
582	our $typeTypedefs = qr{(?x:
583	$typeC99Typedefs\b\|
584	$typeOtherOSTypedefs\b\|
585	$typeKernelTypedefs\b\|
586	$typeStdioTypedefs\b
587	)};
588
589	our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?\|NULL\|false)\b};
590
591	our $logFunctions = qr{(?x:
592	printk(?:_ratelimited\|_once\|_deferred_once\|_deferred\|)\|
593	(?:[a-z0-9]+_){1,2}(?:printk\|emerg\|alert\|crit\|err\|warning\|warn\|notice\|info\|debug\|dbg\|vdbg\|devel\|cont\|WARN)(?:_ratelimited\|_once\|)\|
594	TP_printk\|
595	WARN(?:_RATELIMIT\|_ONCE\|)\|
596	panic\|
597	MODULE_[A-Z_]+\|
598	seq_vprintf\|seq_printf\|seq_puts
599	)};
600
601	our $allocFunctions = qr{(?x:
602	(?:(?:devm_)?
603	(?:kv\|k\|v)[czm]alloc(?:_array)?(?:_node)? \|
604	kstrdup(?:_const)? \|
605	kmemdup(?:_nul)?) \|
606	(?:\w+)?alloc_skb(?:_ip_align)? \|
607	# dev_alloc_skb/netdev_alloc_skb, et al
608	dma_alloc_coherent
609	)};
610
611	our $signature_tags = qr{(?xi:
612	Signed-off-by:\|
613	Co-developed-by:\|
614	Acked-by:\|
615	Tested-by:\|
616	Reviewed-by:\|
617	Reported-by:\|
618	Suggested-by:\|
619	To:\|
620	Cc:
621	)};
622
623	our $tracing_logging_tags = qr{(?xi:
624	[=-]*> \|
625	<[=-]* \|
626	\[ \|
627	\] \|
628	start \|
629	called \|
630	entered \|
631	entry \|
632	enter \|
633	in \|
634	inside \|
635	here \|
636	begin \|
637	exit \|
638	end \|
639	done \|
640	leave \|
641	completed \|
642	out \|
643	return \|
644	[\.\!:\s]*
645	)};
646
647	sub edit_distance_min {
648	my (@arr) = @_;
649	my $len = scalar @arr;
650	if ((scalar @arr) < 1) {
651	# if underflow, return
652	return;
653	}
654	my $min = $arr[0];
655	for my $i (0 .. ($len-1)) {
656	if ($arr[$i] < $min) {
657	$min = $arr[$i];
658	}
659	}
660	return $min;
661	}
662
663	sub get_edit_distance {
664	my ($str1, $str2) = @_;
665	$str1 = lc($str1);
666	$str2 = lc($str2);
667	$str1 =~ s/-//g;
668	$str2 =~ s/-//g;
669	my $len1 = length($str1);
670	my $len2 = length($str2);
671	# two dimensional array storing minimum edit distance
672	my @distance;
673	for my $i (0 .. $len1) {
674	for my $j (0 .. $len2) {
675	if ($i == 0) {
676	$distance[$i][$j] = $j;
677	} elsif ($j == 0) {
678	$distance[$i][$j] = $i;
679	} elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
680	$distance[$i][$j] = $distance[$i - 1][$j - 1];
681	} else {
682	my $dist1 = $distance[$i][$j - 1]; #insert distance
683	my $dist2 = $distance[$i - 1][$j]; # remove
684	my $dist3 = $distance[$i - 1][$j - 1]; #replace
685	$distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);
686	}
687	}
688	}
689	return $distance[$len1][$len2];
690	}
691
692	sub find_standard_signature {
693	my ($sign_off) = @_;
694	my @standard_signature_tags = (
695	'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
696	'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
697	);
698	foreach my $signature (@standard_signature_tags) {
699	return $signature if (get_edit_distance($sign_off, $signature) <= 2);
700	}
701
702	return "";
703	}
704
705	our $obsolete_archives = qr{(?xi:
706	\Qfreedesktop.org/archives/dri-devel\E \|
707	\Qlists.infradead.org\E \|
708	\Qlkml.org\E \|
709	\Qmail-archive.com\E \|
710	\Qmailman.alsa-project.org/pipermail\E \|
711	\Qmarc.info\E \|
712	\Qozlabs.org/pipermail\E \|
713	\Qspinics.net\E
714	)};
715
716	our @typeListMisordered = (
717	qr{char\s+(?:un)?signed},
718	qr{int\s+(?:(?:un)?signed\s+)?short\s},
719	qr{int\s+short(?:\s+(?:un)?signed)},
720	qr{short\s+int(?:\s+(?:un)?signed)},
721	qr{(?:un)?signed\s+int\s+short},
722	qr{short\s+(?:un)?signed},
723	qr{long\s+int\s+(?:un)?signed},
724	qr{int\s+long\s+(?:un)?signed},
725	qr{long\s+(?:un)?signed\s+int},
726	qr{int\s+(?:un)?signed\s+long},
727	qr{int\s+(?:un)?signed},
728	qr{int\s+long\s+long\s+(?:un)?signed},
729	qr{long\s+long\s+int\s+(?:un)?signed},
730	qr{long\s+long\s+(?:un)?signed\s+int},
731	qr{long\s+long\s+(?:un)?signed},
732	qr{long\s+(?:un)?signed},
733	);
734
735	our @typeList = (
736	qr{void},
737	qr{(?:(?:un)?signed\s+)?char},
738	qr{(?:(?:un)?signed\s+)?short\s+int},
739	qr{(?:(?:un)?signed\s+)?short},
740	qr{(?:(?:un)?signed\s+)?int},
741	qr{(?:(?:un)?signed\s+)?long\s+int},
742	qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
743	qr{(?:(?:un)?signed\s+)?long\s+long},
744	qr{(?:(?:un)?signed\s+)?long},
745	qr{(?:un)?signed},
746	qr{float},
747	qr{double},
748	qr{bool},
749	qr{struct\s+$Ident},
750	qr{union\s+$Ident},
751	qr{enum\s+$Ident},
752	qr{${Ident}_t},
753	qr{${Ident}_handler},
754	qr{${Ident}_handler_fn},
755	@typeListMisordered,
756	);
757
758	our $C90_int_types = qr{(?x:
759	long\s+long\s+int\s+(?:un)?signed\|
760	long\s+long\s+(?:un)?signed\s+int\|
761	long\s+long\s+(?:un)?signed\|
762	(?:(?:un)?signed\s+)?long\s+long\s+int\|
763	(?:(?:un)?signed\s+)?long\s+long\|
764	int\s+long\s+long\s+(?:un)?signed\|
765	int\s+(?:(?:un)?signed\s+)?long\s+long\|
766
767	long\s+int\s+(?:un)?signed\|
768	long\s+(?:un)?signed\s+int\|
769	long\s+(?:un)?signed\|
770	(?:(?:un)?signed\s+)?long\s+int\|
771	(?:(?:un)?signed\s+)?long\|
772	int\s+long\s+(?:un)?signed\|
773	int\s+(?:(?:un)?signed\s+)?long\|
774
775	int\s+(?:un)?signed\|
776	(?:(?:un)?signed\s+)?int
777	)};
778
779	our @typeListFile = ();
780	our @typeListWithAttr = (
781	@typeList,
782	qr{struct\s+$InitAttribute\s+$Ident},
783	qr{union\s+$InitAttribute\s+$Ident},
784	);
785
786	our @modifierList = (
787	qr{fastcall},
788	);
789	our @modifierListFile = ();
790
791	our @mode_permission_funcs = (
792	["module_param", 3],
793	["module_param_(?:array\|named\|string)", 4],
794	["module_param_array_named", 5],
795	["debugfs_create_(?:file\|u8\|u16\|u32\|u64\|x8\|x16\|x32\|x64\|size_t\|atomic_t\|bool\|blob\|regset32\|u32_array)", 2],
796	["proc_create(?:_data\|)", 2],
797	["(?:CLASS\|DEVICE\|SENSOR\|SENSOR_DEVICE\|IIO_DEVICE)_ATTR", 2],
798	["IIO_DEV_ATTR_[A-Z_]+", 1],
799	["SENSOR_(?:DEVICE_\|)ATTR_2", 2],
800	["SENSOR_TEMPLATE(?:_2\|)", 3],
801	["__ATTR", 2],
802	);
803
804	my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
805
806	#Create a search pattern for all these functions to speed up a loop below
807	our $mode_perms_search = "";
808	foreach my $entry (@mode_permission_funcs) {
809	$mode_perms_search .= '\|' if ($mode_perms_search ne "");
810	$mode_perms_search .= $entry->[0];
811	}
812	$mode_perms_search = "(?:${mode_perms_search})";
813
814	our %deprecated_apis = (
815	"synchronize_rcu_bh" => "synchronize_rcu",
816	"synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",
817	"call_rcu_bh" => "call_rcu",
818	"rcu_barrier_bh" => "rcu_barrier",
819	"synchronize_sched" => "synchronize_rcu",
820	"synchronize_sched_expedited" => "synchronize_rcu_expedited",
821	"call_rcu_sched" => "call_rcu",
822	"rcu_barrier_sched" => "rcu_barrier",
823	"get_state_synchronize_sched" => "get_state_synchronize_rcu",
824	"cond_synchronize_sched" => "cond_synchronize_rcu",
825	"kmap" => "kmap_local_page",
826	"kmap_atomic" => "kmap_local_page",
827	);
828
829	#Create a search pattern for all these strings to speed up a loop below
830	our $deprecated_apis_search = "";
831	foreach my $entry (keys %deprecated_apis) {
832	$deprecated_apis_search .= '\|' if ($deprecated_apis_search ne "");
833	$deprecated_apis_search .= $entry;
834	}
835	$deprecated_apis_search = "(?:${deprecated_apis_search})";
836
837	our $mode_perms_world_writable = qr{
838	S_IWUGO \|
839	S_IWOTH \|
840	S_IRWXUGO \|
841	S_IALLUGO \|
842	0[0-7][0-7][2367]
843	}x;
844
845	our %mode_permission_string_types = (
846	"S_IRWXU" => 0700,
847	"S_IRUSR" => 0400,
848	"S_IWUSR" => 0200,
849	"S_IXUSR" => 0100,
850	"S_IRWXG" => 0070,
851	"S_IRGRP" => 0040,
852	"S_IWGRP" => 0020,
853	"S_IXGRP" => 0010,
854	"S_IRWXO" => 0007,
855	"S_IROTH" => 0004,
856	"S_IWOTH" => 0002,
857	"S_IXOTH" => 0001,
858	"S_IRWXUGO" => 0777,
859	"S_IRUGO" => 0444,
860	"S_IWUGO" => 0222,
861	"S_IXUGO" => 0111,
862	);
863
864	#Create a search pattern for all these strings to speed up a loop below
865	our $mode_perms_string_search = "";
866	foreach my $entry (keys %mode_permission_string_types) {
867	$mode_perms_string_search .= '\|' if ($mode_perms_string_search ne "");
868	$mode_perms_string_search .= $entry;
869	}
870	our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
871	our $multi_mode_perms_string_search = qr{
872	${single_mode_perms_string_search}
873	(?:\s\\|\s${single_mode_perms_string_search})*
874	}x;
875
876	sub perms_to_octal {
877	my ($string) = @_;
878
879	return trim($string) if ($string =~ /^\s0[0-7]{3,3}\s$/);
880
881	my $val = "";
882	my $oval = "";
883	my $to = 0;
884	my $curpos = 0;
885	my $lastpos = 0;
886	while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s\\|\s)?\s*)/g) {
887	$curpos = pos($string);
888	my $match = $2;
889	my $omatch = $1;
890	last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
891	$lastpos = $curpos;
892	$to \|= $mode_permission_string_types{$match};
893	$val .= '\s\\|\s' if ($val ne "");
894	$val .= $match;
895	$oval .= $omatch;
896	}
897	$oval =~ s/^\s\\|\s//;
898	$oval =~ s/\s\\|\s$//;
899	return sprintf("%04o", $to);
900	}
901
902	our $allowed_asm_includes = qr{(?x:
903	irq\|
904	memory\|
905	time\|
906	reboot
907	)};
908	# memory.h: ARM has a custom one
909
910	# Load common spelling mistakes and build regular expression list.
911	my $misspellings;
912	my %spelling_fix;
913
914	if (open(my $spelling, '<', $spelling_file)) {
915	while (<$spelling>) {
916	my $line = $_;
917
918	$line =~ s/\s*\n?$//g;
919	$line =~ s/^\s*//g;
920
921	next if ($line =~ m/^\s*#/);
922	next if ($line =~ m/^\s*$/);
923
924	my ($suspect, $fix) = split(/\\|\\|/, $line);
925
926	$spelling_fix{$suspect} = $fix;
927	}
928	close($spelling);
929	} else {
930	warn "No typos will be found - file '$spelling_file': $!\n";
931	}
932
933	if ($codespell) {
934	if (open(my $spelling, '<', $codespellfile)) {
935	while (<$spelling>) {
936	my $line = $_;
937
938	$line =~ s/\s*\n?$//g;
939	$line =~ s/^\s*//g;
940
941	next if ($line =~ m/^\s*#/);
942	next if ($line =~ m/^\s*$/);
943	next if ($line =~ m/, disabled/i);
944
945	$line =~ s/,.*$//;
946
947	my ($suspect, $fix) = split(/->/, $line);
948
949	$spelling_fix{$suspect} = $fix;
950	}
951	close($spelling);
952	} else {
953	warn "No codespell typos will be found - file '$codespellfile': $!\n";
954	}
955	}
956
957	$misspellings = join("\|", sort keys %spelling_fix) if keys %spelling_fix;
958
959	sub read_words {
960	my ($wordsRef, $file) = @_;
961
962	if (open(my $words, '<', $file)) {
963	while (<$words>) {
964	my $line = $_;
965
966	$line =~ s/\s*\n?$//g;
967	$line =~ s/^\s*//g;
968
969	next if ($line =~ m/^\s*#/);
970	next if ($line =~ m/^\s*$/);
971	if ($line =~ /\s/) {
972	print("$file: '$line' invalid - ignored\n");
973	next;
974	}
975
976	$$wordsRef .= '\|' if (defined $$wordsRef);
977	$$wordsRef .= $line;
978	}
979	close($file);
980	return 1;
981	}
982
983	return 0;
984	}
985
986	my $const_structs;
987	if (show_type("CONST_STRUCT")) {
988	read_words(\$const_structs, $conststructsfile)
989	or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
990	}
991
992	if (defined($typedefsfile)) {
993	my $typeOtherTypedefs;
994	read_words(\$typeOtherTypedefs, $typedefsfile)
995	or warn "No additional types will be considered - file '$typedefsfile': $!\n";
996	$typeTypedefs .= '\|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
997	}
998
999	sub build_types {
1000	my $mods = "(?x: \n" . join("\|\n ", (@modifierList, @modifierListFile)) . "\n)";
1001	my $all = "(?x: \n" . join("\|\n ", (@typeList, @typeListFile)) . "\n)";
1002	my $Misordered = "(?x: \n" . join("\|\n ", @typeListMisordered) . "\n)";
1003	my $allWithAttr = "(?x: \n" . join("\|\n ", @typeListWithAttr) . "\n)";
1004	$Modifier = qr{(?:$Attribute\|$Sparse\|$mods)};
1005	$BasicType = qr{
1006	(?:$typeTypedefs\b)\|
1007	(?:${all}\b)
1008	}x;
1009	$NonptrType = qr{
1010	(?:$Modifier\s+\|const\s+)*
1011	(?:
1012	(?:typeof\|__typeof__)\s$[^$]\)\|
1013	(?:$typeTypedefs\b)\|
1014	(?:${all}\b)
1015	)
1016	(?:\s+$Modifier\|\s+const)*
1017	}x;
1018	$NonptrTypeMisordered = qr{
1019	(?:$Modifier\s+\|const\s+)*
1020	(?:
1021	(?:${Misordered}\b)
1022	)
1023	(?:\s+$Modifier\|\s+const)*
1024	}x;
1025	$NonptrTypeWithAttr = qr{
1026	(?:$Modifier\s+\|const\s+)*
1027	(?:
1028	(?:typeof\|__typeof__)\s$[^$]\)\|
1029	(?:$typeTypedefs\b)\|
1030	(?:${allWithAttr}\b)
1031	)
1032	(?:\s+$Modifier\|\s+const)*
1033	}x;
1034	$Type = qr{
1035	$NonptrType
1036	(?:(?:\s\|\\|\[\])+\sconst\|(?:\s\|\\s(?:const\s)?\|\[\])+\|(?:\s\[\s*\])+){0,4}
1037	(?:\s+$Inline\|\s+$Modifier)*
1038	}x;
1039	$TypeMisordered = qr{
1040	$NonptrTypeMisordered
1041	(?:(?:\s\|\\|\[\])+\sconst\|(?:\s\|\\s(?:const\s)?\|\[\])+\|(?:\s\[\s*\])+){0,4}
1042	(?:\s+$Inline\|\s+$Modifier)*
1043	}x;
1044	$Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
1045	$DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
1046	}
1047	build_types();
1048
1049	our $Typecast = qr{\s($\s$NonptrType\s$){0,1}\s};
1050
1051	# Using $balanced_parens, $LvalOrFunc, or $FuncArg
1052	# requires at least perl version v5.10.0
1053	# Any use must be runtime checked with $^V
1054
1055	our $balanced_parens = qr/($(?:[^\($]++\|(?-1))*\))/;
1056	our $LvalOrFunc = qr{((?:[\&\]\s)?$Lval)\s($balanced_parens{0,1})\s};
1057	our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc\|$Constant\|$String)};
1058
1059	our $declaration_macros = qr{(?x:
1060	(?:$Storage\s+)?(?:[A-Z_][A-Z0-9]_){0,2}(?:DEFINE\|DECLARE)(?:_[A-Z0-9]+){1,6}\s\(\|
1061	(?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(\|
1062	(?:SKCIPHER_REQUEST\|SHASH_DESC\|AHASH_REQUEST)_ON_STACK\s*\(\|
1063	(?:$Storage\s+)?(?:XA_STATE\|XA_STATE_ORDER)\s*\(
1064	)};
1065
1066	our %allow_repeated_words = (
1067	add => '',
1068	added => '',
1069	bad => '',
1070	be => '',
1071	);
1072
1073	sub deparenthesize {
1074	my ($string) = @_;
1075	return "" if (!defined($string));
1076
1077	while ($string =~ /^\s$.$\s*$/) {
1078	$string =~ s@^\s\(\s@@;
1079	$string =~ s@\s\)\s$@@;
1080	}
1081
1082	$string =~ s@\s+@ @g;
1083
1084	return $string;
1085	}
1086
1087	sub seed_camelcase_file {
1088	my ($file) = @_;
1089
1090	return if (!(-f $file));
1091
1092	local $/;
1093
1094	open(my $include_file, '<', "$file")
1095	or warn "$P: Can't read '$file' $!\n";
1096	my $text = <$include_file>;
1097	close($include_file);
1098
1099	my @lines = split('\n', $text);
1100
1101	foreach my $line (@lines) {
1102	next if ($line !~ /(?:[A-Z][a-z]\|[a-z][A-Z])/);
1103	if ($line =~ /^[ \t](?:#[ \t]define\|typedef\s+$Type)\s+(\w(?:[A-Z][a-z]\|[a-z][A-Z])\w)/) {
1104	$camelcase{$1} = 1;
1105	} elsif ($line =~ /^\s$Declare\s+(\w(?:[A-Z][a-z]\|[a-z][A-Z])\w)\s[\(\[,;]/) {
1106	$camelcase{$1} = 1;
1107	} elsif ($line =~ /^\s(?:union\|struct\|enum)\s+(\w(?:[A-Z][a-z]\|[a-z][A-Z])\w)\s[;\{]/) {
1108	$camelcase{$1} = 1;
1109	}
1110	}
1111	}
1112
1113	our %maintained_status = ();
1114
1115	sub is_maintained_obsolete {
1116	my ($filename) = @_;
1117
1118	return 0 if (!$tree \|\| !(-e "$root/scripts/get_maintainer.pl"));
1119
1120	if (!exists($maintained_status{$filename})) {
1121	$maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
1122	}
1123
1124	return $maintained_status{$filename} =~ /obsolete/i;
1125	}
1126
1127	sub is_SPDX_License_valid {
1128	my ($license) = @_;
1129
1130	return 1 if (!$tree \|\| which("python3") eq "" \|\| !(-x "$root/scripts/spdxcheck.py") \|\| !(-e "$gitroot"));
1131
1132	my $root_path = abs_path($root);
1133	my $status = `cd "$root_path"; echo "$license" \| scripts/spdxcheck.py -`;
1134	return 0 if ($status ne "");
1135	return 1;
1136	}
1137
1138	my $camelcase_seeded = 0;
1139	sub seed_camelcase_includes {
1140	return if ($camelcase_seeded);
1141
1142	my $files;
1143	my $camelcase_cache = "";
1144	my @include_files = ();
1145
1146	$camelcase_seeded = 1;
1147
1148	if (-e "$gitroot") {
1149	my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
1150	chomp $git_last_include_commit;
1151	$camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
1152	} else {
1153	my $last_mod_date = 0;
1154	$files = `find $root/include -name "*.h"`;
1155	@include_files = split('\n', $files);
1156	foreach my $file (@include_files) {
1157	my $date = POSIX::strftime("%Y%m%d%H%M",
1158	localtime((stat $file)[9]));
1159	$last_mod_date = $date if ($last_mod_date < $date);
1160	}
1161	$camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
1162	}
1163
1164	if ($camelcase_cache ne "" && -f $camelcase_cache) {
1165	open(my $camelcase_file, '<', "$camelcase_cache")
1166	or warn "$P: Can't read '$camelcase_cache' $!\n";
1167	while (<$camelcase_file>) {
1168	chomp;
1169	$camelcase{$_} = 1;
1170	}
1171	close($camelcase_file);
1172
1173	return;
1174	}
1175
1176	if (-e "$gitroot") {
1177	$files = `${git_command} ls-files "include/*.h"`;
1178	@include_files = split('\n', $files);
1179	}
1180
1181	foreach my $file (@include_files) {
1182	seed_camelcase_file($file);
1183	}
1184
1185	if ($camelcase_cache ne "") {
1186	unlink glob ".checkpatch-camelcase.*";
1187	open(my $camelcase_file, '>', "$camelcase_cache")
1188	or warn "$P: Can't write '$camelcase_cache' $!\n";
1189	foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
1190	print $camelcase_file ("$_\n");
1191	}
1192	close($camelcase_file);
1193	}
1194	}
1195
1196	sub git_is_single_file {
1197	my ($filename) = @_;
1198
1199	return 0 if ((which("git") eq "") \|\| !(-e "$gitroot"));
1200
1201	my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
1202	my $count = $output =~ tr/\n//;
1203	return $count eq 1 && $output =~ m{^${filename}$};
1204	}
1205
1206	sub git_commit_info {
1207	my ($commit, $id, $desc) = @_;
1208
1209	return ($id, $desc) if ((which("git") eq "") \|\| !(-e "$gitroot"));
1210
1211	my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
1212	$output =~ s/^\s*//gm;
1213	my @lines = split("\n", $output);
1214
1215	return ($id, $desc) if ($#lines < 0);
1216
1217	if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
1218	# Maybe one day convert this block of bash into something that returns
1219	# all matching commit ids, but it's very slow...
1220	#
1221	# echo "checking commits $1..."
1222	# git rev-list --remotes \| grep -i "^$1" \|
1223	# while read line ; do
1224	# git log --format='%H %s' -1 $line \|
1225	# echo "commit $(cut -c 1-12,41-)"
1226	# done
1227	} elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./ \|\|
1228	$lines[0] =~ /^fatal: bad object $commit/) {
1229	$id = undef;
1230	} else {
1231	$id = substr($lines[0], 0, 12);
1232	$desc = substr($lines[0], 41);
1233	}
1234
1235	return ($id, $desc);
1236	}
1237
1238	$chk_signoff = 0 if ($file);
1239
1240	my @rawlines = ();
1241	my @lines = ();
1242	my @fixed = ();
1243	my @fixed_inserted = ();
1244	my @fixed_deleted = ();
1245	my $fixlinenr = -1;
1246
1247	# If input is git commits, extract all commits from the commit expressions.
1248	# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1249	die "$P: No git repository found\n" if ($git && !-e "$gitroot");
1250
1251	if ($git) {
1252	my @commits = ();
1253	foreach my $commit_expr (@ARGV) {
1254	my $git_range;
1255	if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1256	$git_range = "-$2 $1";
1257	} elsif ($commit_expr =~ m/\.\./) {
1258	$git_range = "$commit_expr";
1259	} else {
1260	$git_range = "-1 $commit_expr";
1261	}
1262	my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1263	foreach my $line (split(/\n/, $lines)) {
1264	$line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1265	next if (!defined($1) \|\| !defined($2));
1266	my $sha1 = $1;
1267	my $subject = $2;
1268	unshift(@commits, $sha1);
1269	$git_commits{$sha1} = $subject;
1270	}
1271	}
1272	die "$P: no git commits after extraction!\n" if (@commits == 0);
1273	@ARGV = @commits;
1274	}
1275
1276	my $vname;
1277	$allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1278	for my $filename (@ARGV) {
1279	my $FILE;
1280	my $is_git_file = git_is_single_file($filename);
1281	my $oldfile = $file;
1282	$file = 1 if ($is_git_file);
1283	if ($git) {
1284	open($FILE, '-\|', "git format-patch -M --stdout -1 $filename") \|\|
1285	die "$P: $filename: git format-patch failed - $!\n";
1286	} elsif ($file) {
1287	open($FILE, '-\|', "diff -u /dev/null $filename") \|\|
1288	die "$P: $filename: diff failed - $!\n";
1289	} elsif ($filename eq '-') {
1290	open($FILE, '<&STDIN');
1291	} else {
1292	open($FILE, '<', "$filename") \|\|
1293	die "$P: $filename: open failed - $!\n";
1294	}
1295	if ($filename eq '-') {
1296	$vname = 'Your patch';
1297	} elsif ($git) {
1298	$vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1299	} else {
1300	$vname = $filename;
1301	}
1302	while (<$FILE>) {
1303	chomp;
1304	push(@rawlines, $_);
1305	$vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1306	}
1307	close($FILE);
1308
1309	if ($#ARGV > 0 && $quiet == 0) {
1310	print '-' x length($vname) . "\n";
1311	print "$vname\n";
1312	print '-' x length($vname) . "\n";
1313	}
1314
1315	if (!process($filename)) {
1316	$exit = 1;
1317	}
1318	@rawlines = ();
1319	@lines = ();
1320	@fixed = ();
1321	@fixed_inserted = ();
1322	@fixed_deleted = ();
1323	$fixlinenr = -1;
1324	@modifierListFile = ();
1325	@typeListFile = ();
1326	build_types();
1327	$file = $oldfile if ($is_git_file);
1328	}
1329
1330	if (!$quiet) {
1331	hash_show_words(\%use_type, "Used");
1332	hash_show_words(\%ignore_type, "Ignored");
1333
1334	if (!$perl_version_ok) {
1335	print << "EOM"
1336
1337	NOTE: perl $^V is not modern enough to detect all possible issues.
1338	An upgrade to at least perl $minimum_perl_version is suggested.
1339	EOM
1340	}
1341	if ($exit) {
1342	print << "EOM"
1343
1344	NOTE: If any of the errors are false positives, please report
1345	them to the maintainer, see CHECKPATCH in MAINTAINERS.
1346	EOM
1347	}
1348	}
1349
1350	exit($exit);
1351
1352	sub top_of_kernel_tree {
1353	my ($root) = @_;
1354
1355	my @tree_check = (
1356	"COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1357	"README", "Documentation", "arch", "include", "drivers",
1358	"fs", "init", "ipc", "kernel", "lib", "scripts",
1359	);
1360
1361	foreach my $check (@tree_check) {
1362	if (! -e $root . '/' . $check) {
1363	return 0;
1364	}
1365	}
1366	return 1;
1367	}
1368
1369	sub parse_email {
1370	my ($formatted_email) = @_;
1371
1372	my $name = "";
1373	my $quoted = "";
1374	my $name_comment = "";
1375	my $address = "";
1376	my $comment = "";
1377
1378	if ($formatted_email =~ /^(.)<(\S+\@\S+)>(.)$/) {
1379	$name = $1;
1380	$address = $2;
1381	$comment = $3 if defined $3;
1382	} elsif ($formatted_email =~ /^\s<(\S+\@\S+)>(.)$/) {
1383	$address = $1;
1384	$comment = $2 if defined $2;
1385	} elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1386	$address = $1;
1387	$comment = $2 if defined $2;
1388	$formatted_email =~ s/\Q$address\E.*$//;
1389	$name = $formatted_email;
1390	$name = trim($name);
1391	$name =~ s/^\"\|\"$//g;
1392	# If there's a name left after stripping spaces and
1393	# leading quotes, and the address doesn't have both
1394	# leading and trailing angle brackets, the address
1395	# is invalid. ie:
1396	# "joe smith [email protected]" bad
1397	# "joe smith <[email protected]" bad
1398	if ($name ne "" && $address !~ /^<[^>]+>$/) {
1399	$name = "";
1400	$address = "";
1401	$comment = "";
1402	}
1403	}
1404
1405	# Extract comments from names excluding quoted parts
1406	# "John D. (Doe)" - Do not extract
1407	if ($name =~ s/\"(.+)\"//) {
1408	$quoted = $1;
1409	}
1410	while ($name =~ s/\s($balanced_parens)\s/ /) {
1411	$name_comment .= trim($1);
1412	}
1413	$name =~ s/^[ \"]+\|[ \"]+$//g;
1414	$name = trim("$quoted $name");
1415
1416	$address = trim($address);
1417	$address =~ s/^\<\|\>$//g;
1418	$comment = trim($comment);
1419
1420	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1421	$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1422	$name = "\"$name\"";
1423	}
1424
1425	return ($name, $name_comment, $address, $comment);
1426	}
1427
1428	sub format_email {
1429	my ($name, $name_comment, $address, $comment) = @_;
1430
1431	my $formatted_email;
1432
1433	$name =~ s/^[ \"]+\|[ \"]+$//g;
1434	$address = trim($address);
1435	$address =~ s/(?:\.\|\,\|\")+$//; ##trailing commas, dots or quotes
1436
1437	if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1438	$name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1439	$name = "\"$name\"";
1440	}
1441
1442	$name_comment = trim($name_comment);
1443	$name_comment = " $name_comment" if ($name_comment ne "");
1444	$comment = trim($comment);
1445	$comment = " $comment" if ($comment ne "");
1446
1447	if ("$name" eq "") {
1448	$formatted_email = "$address";
1449	} else {
1450	$formatted_email = "$name$name_comment <$address>";
1451	}
1452	$formatted_email .= "$comment";
1453	return $formatted_email;
1454	}
1455
1456	sub reformat_email {
1457	my ($email) = @_;
1458
1459	my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
1460	return format_email($email_name, $name_comment, $email_address, $comment);
1461	}
1462
1463	sub same_email_addresses {
1464	my ($email1, $email2) = @_;
1465
1466	my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
1467	my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);
1468
1469	return $email1_name eq $email2_name &&
1470	$email1_address eq $email2_address &&
1471	$name1_comment eq $name2_comment &&
1472	$comment1 eq $comment2;
1473	}
1474
1475	sub which {
1476	my ($bin) = @_;
1477
1478	foreach my $path (split(/:/, $ENV{PATH})) {
1479	if (-e "$path/$bin") {
1480	return "$path/$bin";
1481	}
1482	}
1483
1484	return "";
1485	}
1486
1487	sub which_conf {
1488	my ($conf) = @_;
1489
1490	foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1491	if (-e "$path/$conf") {
1492	return "$path/$conf";
1493	}
1494	}
1495
1496	return "";
1497	}
1498
1499	sub expand_tabs {
1500	my ($str) = @_;
1501
1502	my $res = '';
1503	my $n = 0;
1504	for my $c (split(//, $str)) {
1505	if ($c eq "\t") {
1506	$res .= ' ';
1507	$n++;
1508	for (; ($n % $tabsize) != 0; $n++) {
1509	$res .= ' ';
1510	}
1511	next;
1512	}
1513	$res .= $c;
1514	$n++;
1515	}
1516
1517	return $res;
1518	}
1519	sub copy_spacing {
1520	(my $res = shift) =~ tr/\t/ /c;
1521	return $res;
1522	}
1523
1524	sub line_stats {
1525	my ($line) = @_;
1526
1527	# Drop the diff line leader and expand tabs
1528	$line =~ s/^.//;
1529	$line = expand_tabs($line);
1530
1531	# Pick the indent from the front of the line.
1532	my ($white) = ($line =~ /^(\s*)/);
1533
1534	return (length($line), length($white));
1535	}
1536
1537	my $sanitise_quote = '';
1538
1539	sub sanitise_line_reset {
1540	my ($in_comment) = @_;
1541
1542	if ($in_comment) {
1543	$sanitise_quote = '*/';
1544	} else {
1545	$sanitise_quote = '';
1546	}
1547	}
1548	sub sanitise_line {
1549	my ($line) = @_;
1550
1551	my $res = '';
1552	my $l = '';
1553
1554	my $qlen = 0;
1555	my $off = 0;
1556	my $c;
1557
1558	# Always copy over the diff marker.
1559	$res = substr($line, 0, 1);
1560
1561	for ($off = 1; $off < length($line); $off++) {
1562	$c = substr($line, $off, 1);
1563
1564	# Comments we are whacking completely including the begin
1565	# and end, all to $;.
1566	if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1567	$sanitise_quote = '*/';
1568
1569	substr($res, $off, 2, "$;$;");
1570	$off++;
1571	next;
1572	}
1573	if ($sanitise_quote eq '/' && substr($line, $off, 2) eq '/') {
1574	$sanitise_quote = '';
1575	substr($res, $off, 2, "$;$;");
1576	$off++;
1577	next;
1578	}
1579	if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1580	$sanitise_quote = '//';
1581
1582	substr($res, $off, 2, $sanitise_quote);
1583	$off++;
1584	next;
1585	}
1586
1587	# A \ in a string means ignore the next character.
1588	if (($sanitise_quote eq "'" \|\| $sanitise_quote eq '"') &&
1589	$c eq "\\") {
1590	substr($res, $off, 2, 'XX');
1591	$off++;
1592	next;
1593	}
1594	# Regular quotes.
1595	if ($c eq "'" \|\| $c eq '"') {
1596	if ($sanitise_quote eq '') {
1597	$sanitise_quote = $c;
1598
1599	substr($res, $off, 1, $c);
1600	next;
1601	} elsif ($sanitise_quote eq $c) {
1602	$sanitise_quote = '';
1603	}
1604	}
1605
1606	#print "c<$c> SQ<$sanitise_quote>\n";
1607	if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1608	substr($res, $off, 1, $;);
1609	} elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1610	substr($res, $off, 1, $;);
1611	} elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1612	substr($res, $off, 1, 'X');
1613	} else {
1614	substr($res, $off, 1, $c);
1615	}
1616	}
1617
1618	if ($sanitise_quote eq '//') {
1619	$sanitise_quote = '';
1620	}
1621
1622	# The pathname on a #include may be surrounded by '<' and '>'.
1623	if ($res =~ /^.\s\#\sinclude\s+\<(.*)\>/) {
1624	my $clean = 'X' x length($1);
1625	$res =~ s@\<.*\>@<$clean>@;
1626
1627	# The whole of a #error is a string.
1628	} elsif ($res =~ /^.\s\#\s(?:error\|warning)\s+(.*)\b/) {
1629	my $clean = 'X' x length($1);
1630	$res =~ s@(\#\s(?:error\|warning)\s+).@$1$clean@;
1631	}
1632
1633	if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1634	my $match = $1;
1635	$res =~ s/\Q$match\E/"$;" x length($match)/e;
1636	}
1637
1638	return $res;
1639	}
1640
1641	sub get_quoted_string {
1642	my ($line, $rawline) = @_;
1643
1644	return "" if (!defined($line) \|\| !defined($rawline));
1645	return "" if ($line !~ m/($String)/g);
1646	return substr($rawline, $-[0], $+[0] - $-[0]);
1647	}
1648
1649	sub ctx_statement_block {
1650	my ($linenr, $remain, $off) = @_;
1651	my $line = $linenr - 1;
1652	my $blk = '';
1653	my $soff = $off;
1654	my $coff = $off - 1;
1655	my $coff_set = 0;
1656
1657	my $loff = 0;
1658
1659	my $type = '';
1660	my $level = 0;
1661	my @stack = ();
1662	my $p;
1663	my $c;
1664	my $len = 0;
1665
1666	my $remainder;
1667	while (1) {
1668	@stack = (['', 0]) if ($#stack == -1);
1669
1670	#warn "CSB: blk<$blk> remain<$remain>\n";
1671	# If we are about to drop off the end, pull in more
1672	# context.
1673	if ($off >= $len) {
1674	for (; $remain > 0; $line++) {
1675	last if (!defined $lines[$line]);
1676	next if ($lines[$line] =~ /^-/);
1677	$remain--;
1678	$loff = $len;
1679	$blk .= $lines[$line] . "\n";
1680	$len = length($blk);
1681	$line++;
1682	last;
1683	}
1684	# Bail if there is no further context.
1685	#warn "CSB: blk<$blk> off<$off> len<$len>\n";
1686	if ($off >= $len) {
1687	last;
1688	}
1689	if ($level == 0 && substr($blk, $off) =~ /^.\s#\sdefine/) {
1690	$level++;
1691	$type = '#';
1692	}
1693	}
1694	$p = $c;
1695	$c = substr($blk, $off, 1);
1696	$remainder = substr($blk, $off);
1697
1698	#warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1699
1700	# Handle nested #if/#else.
1701	if ($remainder =~ /^#\s*(?:ifndef\|ifdef\|if)\s/) {
1702	push(@stack, [ $type, $level ]);
1703	} elsif ($remainder =~ /^#\s*(?:else\|elif)\b/) {
1704	($type, $level) = @{$stack[$#stack - 1]};
1705	} elsif ($remainder =~ /^#\s*endif\b/) {
1706	($type, $level) = @{pop(@stack)};
1707	}
1708
1709	# Statement ends at the ';' or a close '}' at the
1710	# outermost level.
1711	if ($level == 0 && $c eq ';') {
1712	last;
1713	}
1714
1715	# An else is really a conditional as long as its not else if
1716	if ($level == 0 && $coff_set == 0 &&
1717	(!defined($p) \|\| $p =~ /(?:\s\|\}\|\+)/) &&
1718	$remainder =~ /^(else)(?:\s\|{)/ &&
1719	$remainder !~ /^else\s+if\b/) {
1720	$coff = $off + length($1) - 1;
1721	$coff_set = 1;
1722	#warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1723	#warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1724	}
1725
1726	if (($type eq '' \|\| $type eq '(') && $c eq '(') {
1727	$level++;
1728	$type = '(';
1729	}
1730	if ($type eq '(' && $c eq ')') {
1731	$level--;
1732	$type = ($level != 0)? '(' : '';
1733
1734	if ($level == 0 && $coff < $soff) {
1735	$coff = $off;
1736	$coff_set = 1;
1737	#warn "CSB: mark coff<$coff>\n";
1738	}
1739	}
1740	if (($type eq '' \|\| $type eq '{') && $c eq '{') {
1741	$level++;
1742	$type = '{';
1743	}
1744	if ($type eq '{' && $c eq '}') {
1745	$level--;
1746	$type = ($level != 0)? '{' : '';
1747
1748	if ($level == 0) {
1749	if (substr($blk, $off + 1, 1) eq ';') {
1750	$off++;
1751	}
1752	last;
1753	}
1754	}
1755	# Preprocessor commands end at the newline unless escaped.
1756	if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1757	$level--;
1758	$type = '';
1759	$off++;
1760	last;
1761	}
1762	$off++;
1763	}
1764	# We are truly at the end, so shuffle to the next line.
1765	if ($off == $len) {
1766	$loff = $len + 1;
1767	$line++;
1768	$remain--;
1769	}
1770
1771	my $statement = substr($blk, $soff, $off - $soff + 1);
1772	my $condition = substr($blk, $soff, $coff - $soff + 1);
1773
1774	#warn "STATEMENT<$statement>\n";
1775	#warn "CONDITION<$condition>\n";
1776
1777	#print "coff<$coff> soff<$off> loff<$loff>\n";
1778
1779	return ($statement, $condition,
1780	$line, $remain + 1, $off - $loff + 1, $level);
1781	}
1782
1783	sub statement_lines {
1784	my ($stmt) = @_;
1785
1786	# Strip the diff line prefixes and rip blank lines at start and end.
1787	$stmt =~ s/(^\|\n)./$1/g;
1788	$stmt =~ s/^\s*//;
1789	$stmt =~ s/\s*$//;
1790
1791	my @stmt_lines = ($stmt =~ /\n/g);
1792
1793	return $#stmt_lines + 2;
1794	}
1795
1796	sub statement_rawlines {
1797	my ($stmt) = @_;
1798
1799	my @stmt_lines = ($stmt =~ /\n/g);
1800
1801	return $#stmt_lines + 2;
1802	}
1803
1804	sub statement_block_size {
1805	my ($stmt) = @_;
1806
1807	$stmt =~ s/(^\|\n)./$1/g;
1808	$stmt =~ s/^\s*{//;
1809	$stmt =~ s/}\s*$//;
1810	$stmt =~ s/^\s*//;
1811	$stmt =~ s/\s*$//;
1812
1813	my @stmt_lines = ($stmt =~ /\n/g);
1814	my @stmt_statements = ($stmt =~ /;/g);
1815
1816	my $stmt_lines = $#stmt_lines + 2;
1817	my $stmt_statements = $#stmt_statements + 1;
1818
1819	if ($stmt_lines > $stmt_statements) {
1820	return $stmt_lines;
1821	} else {
1822	return $stmt_statements;
1823	}
1824	}
1825
1826	sub ctx_statement_full {
1827	my ($linenr, $remain, $off) = @_;
1828	my ($statement, $condition, $level);
1829
1830	my (@chunks);
1831
1832	# Grab the first conditional/block pair.
1833	($statement, $condition, $linenr, $remain, $off, $level) =
1834	ctx_statement_block($linenr, $remain, $off);
1835	#print "F: c<$condition> s<$statement> remain<$remain>\n";
1836	push(@chunks, [ $condition, $statement ]);
1837	if (!($remain > 0 && $condition =~ /^\s(?:\n[+-])?\s(?:if\|else\|do)\b/s)) {
1838	return ($level, $linenr, @chunks);
1839	}
1840
1841	# Pull in the following conditional/block pairs and see if they
1842	# could continue the statement.
1843	for (;;) {
1844	($statement, $condition, $linenr, $remain, $off, $level) =
1845	ctx_statement_block($linenr, $remain, $off);
1846	#print "C: c<$condition> s<$statement> remain<$remain>\n";
1847	last if (!($remain > 0 && $condition =~ /^(?:\s\n[+-])\s*(?:else\|do)\b/s));
1848	#print "C: push\n";
1849	push(@chunks, [ $condition, $statement ]);
1850	}
1851
1852	return ($level, $linenr, @chunks);
1853	}
1854
1855	sub ctx_block_get {
1856	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1857	my $line;
1858	my $start = $linenr - 1;
1859	my $blk = '';
1860	my @o;
1861	my @c;
1862	my @res = ();
1863
1864	my $level = 0;
1865	my @stack = ($level);
1866	for ($line = $start; $remain > 0; $line++) {
1867	next if ($rawlines[$line] =~ /^-/);
1868	$remain--;
1869
1870	$blk .= $rawlines[$line];
1871
1872	# Handle nested #if/#else.
1873	if ($lines[$line] =~ /^.\s#\s(?:ifndef\|ifdef\|if)\s/) {
1874	push(@stack, $level);
1875	} elsif ($lines[$line] =~ /^.\s#\s(?:else\|elif)\b/) {
1876	$level = $stack[$#stack - 1];
1877	} elsif ($lines[$line] =~ /^.\s#\sendif\b/) {
1878	$level = pop(@stack);
1879	}
1880
1881	foreach my $c (split(//, $lines[$line])) {
1882	##print "C<$c>L<$level><$open$close>O<$off>\n";
1883	if ($off > 0) {
1884	$off--;
1885	next;
1886	}
1887
1888	if ($c eq $close && $level > 0) {
1889	$level--;
1890	last if ($level == 0);
1891	} elsif ($c eq $open) {
1892	$level++;
1893	}
1894	}
1895
1896	if (!$outer \|\| $level <= 1) {
1897	push(@res, $rawlines[$line]);
1898	}
1899
1900	last if ($level == 0);
1901	}
1902
1903	return ($level, @res);
1904	}
1905	sub ctx_block_outer {
1906	my ($linenr, $remain) = @_;
1907
1908	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1909	return @r;
1910	}
1911	sub ctx_block {
1912	my ($linenr, $remain) = @_;
1913
1914	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1915	return @r;
1916	}
1917	sub ctx_statement {
1918	my ($linenr, $remain, $off) = @_;
1919
1920	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1921	return @r;
1922	}
1923	sub ctx_block_level {
1924	my ($linenr, $remain) = @_;
1925
1926	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1927	}
1928	sub ctx_statement_level {
1929	my ($linenr, $remain, $off) = @_;
1930
1931	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1932	}
1933
1934	sub ctx_locate_comment {
1935	my ($first_line, $end_line) = @_;
1936
1937	# If c99 comment on the current line, or the line before or after
1938	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.(//.$)@);
1939	return $current_comment if (defined $current_comment);
1940	($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].(//.$)@);
1941	return $current_comment if (defined $current_comment);
1942	($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].(//.$)@);
1943	return $current_comment if (defined $current_comment);
1944
1945	# Catch a comment on the end of the line itself.
1946	($current_comment) = ($rawlines[$end_line - 1] =~ m@.(/\.\/)\s(?:\\\s)?$@);
1947	return $current_comment if (defined $current_comment);
1948
1949	# Look through the context and try and figure out if there is a
1950	# comment.
1951	my $in_comment = 0;
1952	$current_comment = '';
1953	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1954	my $line = $rawlines[$linenr - 1];
1955	#warn " $line\n";
1956	if ($linenr == $first_line and $line =~ m@^.\s\@) {
1957	$in_comment = 1;
1958	}
1959	if ($line =~ m@/\*@) {
1960	$in_comment = 1;
1961	}
1962	if (!$in_comment && $current_comment ne '') {
1963	$current_comment = '';
1964	}
1965	$current_comment .= $line . "\n" if ($in_comment);
1966	if ($line =~ m@\*/@) {
1967	$in_comment = 0;
1968	}
1969	}
1970
1971	chomp($current_comment);
1972	return($current_comment);
1973	}
1974	sub ctx_has_comment {
1975	my ($first_line, $end_line) = @_;
1976	my $cmt = ctx_locate_comment($first_line, $end_line);
1977
1978	##print "LINE: $rawlines[$end_line - 1 ]\n";
1979	##print "CMMT: $cmt\n";
1980
1981	return ($cmt ne '');
1982	}
1983
1984	sub raw_line {
1985	my ($linenr, $cnt) = @_;
1986
1987	my $offset = $linenr - 1;
1988	$cnt++;
1989
1990	my $line;
1991	while ($cnt) {
1992	$line = $rawlines[$offset++];
1993	next if (defined($line) && $line =~ /^-/);
1994	$cnt--;
1995	}
1996
1997	return $line;
1998	}
1999
2000	sub get_stat_real {
2001	my ($linenr, $lc) = @_;
2002
2003	my $stat_real = raw_line($linenr, 0);
2004	for (my $count = $linenr + 1; $count <= $lc; $count++) {
2005	$stat_real = $stat_real . "\n" . raw_line($count, 0);
2006	}
2007
2008	return $stat_real;
2009	}
2010
2011	sub get_stat_here {
2012	my ($linenr, $cnt, $here) = @_;
2013
2014	my $herectx = $here . "\n";
2015	for (my $n = 0; $n < $cnt; $n++) {
2016	$herectx .= raw_line($linenr, $n) . "\n";
2017	}
2018
2019	return $herectx;
2020	}
2021
2022	sub cat_vet {
2023	my ($vet) = @_;
2024	my ($res, $coded);
2025
2026	$res = '';
2027	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]\|$)/g) {
2028	$res .= $1;
2029	if ($2 ne '') {
2030	$coded = sprintf("^%c", unpack('C', $2) + 64);
2031	$res .= $coded;
2032	}
2033	}
2034	$res =~ s/$/\$/;
2035
2036	return $res;
2037	}
2038
2039	my $av_preprocessor = 0;
2040	my $av_pending;
2041	my @av_paren_type;
2042	my $av_pend_colon;
2043
2044	sub annotate_reset {
2045	$av_preprocessor = 0;
2046	$av_pending = '_';
2047	@av_paren_type = ('E');
2048	$av_pend_colon = 'O';
2049	}
2050
2051	sub annotate_values {
2052	my ($stream, $type) = @_;
2053
2054	my $res;
2055	my $var = '_' x length($stream);
2056	my $cur = $stream;
2057
2058	print "$stream\n" if ($dbg_values > 1);
2059
2060	while (length($cur)) {
2061	@av_paren_type = ('E') if ($#av_paren_type < 0);
2062	print " <" . join('', @av_paren_type) .
2063	"> <$type> <$av_pending>" if ($dbg_values > 1);
2064	if ($cur =~ /^(\s+)/o) {
2065	print "WS($1)\n" if ($dbg_values > 1);
2066	if ($1 =~ /\n/ && $av_preprocessor) {
2067	$type = pop(@av_paren_type);
2068	$av_preprocessor = 0;
2069	}
2070
2071	} elsif ($cur =~ /^($\s$Type\s)$/ && $av_pending eq '_') {
2072	print "CAST($1)\n" if ($dbg_values > 1);
2073	push(@av_paren_type, $type);
2074	$type = 'c';
2075
2076	} elsif ($cur =~ /^($Type)\s(?:$Ident\|,\|\)\|\(\|\s$)/) {
2077	print "DECLARE($1)\n" if ($dbg_values > 1);
2078	$type = 'T';
2079
2080	} elsif ($cur =~ /^($Modifier)\s*/) {
2081	print "MODIFIER($1)\n" if ($dbg_values > 1);
2082	$type = 'T';
2083
2084	} elsif ($cur =~ /^(\#\sdefine\s$Ident)(\(?)/o) {
2085	print "DEFINE($1,$2)\n" if ($dbg_values > 1);
2086	$av_preprocessor = 1;
2087	push(@av_paren_type, $type);
2088	if ($2 ne '') {
2089	$av_pending = 'N';
2090	}
2091	$type = 'E';
2092
2093	} elsif ($cur =~ /^(\#\s(?:undef\s$Ident\|include\b))/o) {
2094	print "UNDEF($1)\n" if ($dbg_values > 1);
2095	$av_preprocessor = 1;
2096	push(@av_paren_type, $type);
2097
2098	} elsif ($cur =~ /^(\#\s*(?:ifdef\|ifndef\|if))/o) {
2099	print "PRE_START($1)\n" if ($dbg_values > 1);
2100	$av_preprocessor = 1;
2101
2102	push(@av_paren_type, $type);
2103	push(@av_paren_type, $type);
2104	$type = 'E';
2105
2106	} elsif ($cur =~ /^(\#\s*(?:else\|elif))/o) {
2107	print "PRE_RESTART($1)\n" if ($dbg_values > 1);
2108	$av_preprocessor = 1;
2109
2110	push(@av_paren_type, $av_paren_type[$#av_paren_type]);
2111
2112	$type = 'E';
2113
2114	} elsif ($cur =~ /^(\#\s*(?:endif))/o) {
2115	print "PRE_END($1)\n" if ($dbg_values > 1);
2116
2117	$av_preprocessor = 1;
2118
2119	# Assume all arms of the conditional end as this
2120	# one does, and continue as if the #endif was not here.
2121	pop(@av_paren_type);
2122	push(@av_paren_type, $type);
2123	$type = 'E';
2124
2125	} elsif ($cur =~ /^(\\\n)/o) {
2126	print "PRECONT($1)\n" if ($dbg_values > 1);
2127
2128	} elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
2129	print "ATTR($1)\n" if ($dbg_values > 1);
2130	$av_pending = $type;
2131	$type = 'N';
2132
2133	} elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
2134	print "SIZEOF($1)\n" if ($dbg_values > 1);
2135	if (defined $2) {
2136	$av_pending = 'V';
2137	}
2138	$type = 'N';
2139
2140	} elsif ($cur =~ /^(if\|while\|for)\b/o) {
2141	print "COND($1)\n" if ($dbg_values > 1);
2142	$av_pending = 'E';
2143	$type = 'N';
2144
2145	} elsif ($cur =~/^(case)/o) {
2146	print "CASE($1)\n" if ($dbg_values > 1);
2147	$av_pend_colon = 'C';
2148	$type = 'N';
2149
2150	} elsif ($cur =~/^(return\|else\|goto\|typeof\|__typeof__)\b/o) {
2151	print "KEYWORD($1)\n" if ($dbg_values > 1);
2152	$type = 'N';
2153
2154	} elsif ($cur =~ /^(\()/o) {
2155	print "PAREN('$1')\n" if ($dbg_values > 1);
2156	push(@av_paren_type, $av_pending);
2157	$av_pending = '_';
2158	$type = 'N';
2159
2160	} elsif ($cur =~ /^(\))/o) {
2161	my $new_type = pop(@av_paren_type);
2162	if ($new_type ne '_') {
2163	$type = $new_type;
2164	print "PAREN('$1') -> $type\n"
2165	if ($dbg_values > 1);
2166	} else {
2167	print "PAREN('$1')\n" if ($dbg_values > 1);
2168	}
2169
2170	} elsif ($cur =~ /^($Ident)\s*\(/o) {
2171	print "FUNC($1)\n" if ($dbg_values > 1);
2172	$type = 'V';
2173	$av_pending = 'V';
2174
2175	} elsif ($cur =~ /^($Ident\s):(?:\s\d+\s*(,\|=\|;))?/) {
2176	if (defined $2 && $type eq 'C' \|\| $type eq 'T') {
2177	$av_pend_colon = 'B';
2178	} elsif ($type eq 'E') {
2179	$av_pend_colon = 'L';
2180	}
2181	print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
2182	$type = 'V';
2183
2184	} elsif ($cur =~ /^($Ident\|$Constant)/o) {
2185	print "IDENT($1)\n" if ($dbg_values > 1);
2186	$type = 'V';
2187
2188	} elsif ($cur =~ /^($Assignment)/o) {
2189	print "ASSIGN($1)\n" if ($dbg_values > 1);
2190	$type = 'N';
2191
2192	} elsif ($cur =~/^(;\|{\|})/) {
2193	print "END($1)\n" if ($dbg_values > 1);
2194	$type = 'E';
2195	$av_pend_colon = 'O';
2196
2197	} elsif ($cur =~/^(,)/) {
2198	print "COMMA($1)\n" if ($dbg_values > 1);
2199	$type = 'C';
2200
2201	} elsif ($cur =~ /^(\?)/o) {
2202	print "QUESTION($1)\n" if ($dbg_values > 1);
2203	$type = 'N';
2204
2205	} elsif ($cur =~ /^(:)/o) {
2206	print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
2207
2208	substr($var, length($res), 1, $av_pend_colon);
2209	if ($av_pend_colon eq 'C' \|\| $av_pend_colon eq 'L') {
2210	$type = 'E';
2211	} else {
2212	$type = 'N';
2213	}
2214	$av_pend_colon = 'O';
2215
2216	} elsif ($cur =~ /^(\[)/o) {
2217	print "CLOSE($1)\n" if ($dbg_values > 1);
2218	$type = 'N';
2219
2220	} elsif ($cur =~ /^(-(?![->])\|\+(?!\+)\|\*\|\&\&\|\&)/o) {
2221	my $variant;
2222
2223	print "OPV($1)\n" if ($dbg_values > 1);
2224	if ($type eq 'V') {
2225	$variant = 'B';
2226	} else {
2227	$variant = 'U';
2228	}
2229
2230	substr($var, length($res), 1, $variant);
2231	$type = 'N';
2232
2233	} elsif ($cur =~ /^($Operators)/o) {
2234	print "OP($1)\n" if ($dbg_values > 1);
2235	if ($1 ne '++' && $1 ne '--') {
2236	$type = 'N';
2237	}
2238
2239	} elsif ($cur =~ /(^.)/o) {
2240	print "C($1)\n" if ($dbg_values > 1);
2241	}
2242	if (defined $1) {
2243	$cur = substr($cur, length($1));
2244	$res .= $type x length($1);
2245	}
2246	}
2247
2248	return ($res, $var);
2249	}
2250
2251	sub possible {
2252	my ($possible, $line) = @_;
2253	my $notPermitted = qr{(?:
2254	^(?:
2255	$Modifier\|
2256	$Storage\|
2257	$Type\|
2258	DEFINE_\S+
2259	)$\|
2260	^(?:
2261	goto\|
2262	return\|
2263	case\|
2264	else\|
2265	asm\|__asm__\|
2266	do\|
2267	\#\|
2268	\#\#\|
2269	)(?:\s\|$)\|
2270	^(?:typedef\|struct\|enum)\b
2271	)}x;
2272	warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2273	if ($possible !~ $notPermitted) {
2274	# Check for modifiers.
2275	$possible =~ s/\s$Storage\s//g;
2276	$possible =~ s/\s$Sparse\s//g;
2277	if ($possible =~ /^\s*$/) {
2278
2279	} elsif ($possible =~ /\s/) {
2280	$possible =~ s/\s$Type\s//g;
2281	for my $modifier (split(' ', $possible)) {
2282	if ($modifier !~ $notPermitted) {
2283	warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2284	push(@modifierListFile, $modifier);
2285	}
2286	}
2287
2288	} else {
2289	warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2290	push(@typeListFile, $possible);
2291	}
2292	build_types();
2293	} else {
2294	warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2295	}
2296	}
2297
2298	my $prefix = '';
2299
2300	sub show_type {
2301	my ($type) = @_;
2302
2303	$type =~ tr/[a-z]/[A-Z]/;
2304
2305	return defined $use_type{$type} if (scalar keys %use_type > 0);
2306
2307	return !defined $ignore_type{$type};
2308	}
2309
2310	sub report {
2311	my ($level, $type, $msg) = @_;
2312
2313	if (!show_type($type) \|\|
2314	(defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2315	return 0;
2316	}
2317	my $output = '';
2318	if ($color) {
2319	if ($level eq 'ERROR') {
2320	$output .= RED;
2321	} elsif ($level eq 'WARNING') {
2322	$output .= YELLOW;
2323	} else {
2324	$output .= GREEN;
2325	}
2326	}
2327	$output .= $prefix . $level . ':';
2328	if ($show_types) {
2329	$output .= BLUE if ($color);
2330	$output .= "$type:";
2331	}
2332	$output .= RESET if ($color);
2333	$output .= ' ' . $msg . "\n";
2334
2335	if ($showfile) {
2336	my @lines = split("\n", $output, -1);
2337	splice(@lines, 1, 1);
2338	$output = join("\n", @lines);
2339	}
2340
2341	if ($terse) {
2342	$output = (split('\n', $output))[0] . "\n";
2343	}
2344
2345	if ($verbose && exists($verbose_messages{$type}) &&
2346	!exists($verbose_emitted{$type})) {
2347	$output .= $verbose_messages{$type} . "\n\n";
2348	$verbose_emitted{$type} = 1;
2349	}
2350
2351	push(our @report, $output);
2352
2353	return 1;
2354	}
2355
2356	sub report_dump {
2357	our @report;
2358	}
2359
2360	sub fixup_current_range {
2361	my ($lineRef, $offset, $length) = @_;
2362
2363	if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2364	my $o = $1;
2365	my $l = $2;
2366	my $no = $o + $offset;
2367	my $nl = $l + $length;
2368	$$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2369	}
2370	}
2371
2372	sub fix_inserted_deleted_lines {
2373	my ($linesRef, $insertedRef, $deletedRef) = @_;
2374
2375	my $range_last_linenr = 0;
2376	my $delta_offset = 0;
2377
2378	my $old_linenr = 0;
2379	my $new_linenr = 0;
2380
2381	my $next_insert = 0;
2382	my $next_delete = 0;
2383
2384	my @lines = ();
2385
2386	my $inserted = @{$insertedRef}[$next_insert++];
2387	my $deleted = @{$deletedRef}[$next_delete++];
2388
2389	foreach my $old_line (@{$linesRef}) {
2390	my $save_line = 1;
2391	my $line = $old_line; #don't modify the array
2392	if ($line =~ /^(?:\+\+\+\|\-\-\-)\s+\S+/) { #new filename
2393	$delta_offset = 0;
2394	} elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2395	$range_last_linenr = $new_linenr;
2396	fixup_current_range(\$line, $delta_offset, 0);
2397	}
2398
2399	while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2400	$deleted = @{$deletedRef}[$next_delete++];
2401	$save_line = 0;
2402	fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2403	}
2404
2405	while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2406	push(@lines, ${$inserted}{'LINE'});
2407	$inserted = @{$insertedRef}[$next_insert++];
2408	$new_linenr++;
2409	fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2410	}
2411
2412	if ($save_line) {
2413	push(@lines, $line);
2414	$new_linenr++;
2415	}
2416
2417	$old_linenr++;
2418	}
2419
2420	return @lines;
2421	}
2422
2423	sub fix_insert_line {
2424	my ($linenr, $line) = @_;
2425
2426	my $inserted = {
2427	LINENR => $linenr,
2428	LINE => $line,
2429	};
2430	push(@fixed_inserted, $inserted);
2431	}
2432
2433	sub fix_delete_line {
2434	my ($linenr, $line) = @_;
2435
2436	my $deleted = {
2437	LINENR => $linenr,
2438	LINE => $line,
2439	};
2440
2441	push(@fixed_deleted, $deleted);
2442	}
2443
2444	sub ERROR {
2445	my ($type, $msg) = @_;
2446
2447	if (report("ERROR", $type, $msg)) {
2448	our $clean = 0;
2449	our $cnt_error++;
2450	return 1;
2451	}
2452	return 0;
2453	}
2454	sub WARN {
2455	my ($type, $msg) = @_;
2456
2457	if (report("WARNING", $type, $msg)) {
2458	our $clean = 0;
2459	our $cnt_warn++;
2460	return 1;
2461	}
2462	return 0;
2463	}
2464	sub CHK {
2465	my ($type, $msg) = @_;
2466
2467	if ($check && report("CHECK", $type, $msg)) {
2468	our $clean = 0;
2469	our $cnt_chk++;
2470	return 1;
2471	}
2472	return 0;
2473	}
2474
2475	sub check_absolute_file {
2476	my ($absolute, $herecurr) = @_;
2477	my $file = $absolute;
2478
2479	##print "absolute<$absolute>\n";
2480
2481	# See if any suffix of this path is a path within the tree.
2482	while ($file =~ s@^[^/]*/@@) {
2483	if (-f "$root/$file") {
2484	##print "file<$file>\n";
2485	last;
2486	}
2487	}
2488	if (! -f _) {
2489	return 0;
2490	}
2491
2492	# It is, so see if the prefix is acceptable.
2493	my $prefix = $absolute;
2494	substr($prefix, -length($file)) = '';
2495
2496	##print "prefix<$prefix>\n";
2497	if ($prefix ne ".../") {
2498	WARN("USE_RELATIVE_PATH",
2499	"use relative pathname instead of absolute in changelog text\n" . $herecurr);
2500	}
2501	}
2502
2503	sub trim {
2504	my ($string) = @_;
2505
2506	$string =~ s/^\s+\|\s+$//g;
2507
2508	return $string;
2509	}
2510
2511	sub ltrim {
2512	my ($string) = @_;
2513
2514	$string =~ s/^\s+//;
2515
2516	return $string;
2517	}
2518
2519	sub rtrim {
2520	my ($string) = @_;
2521
2522	$string =~ s/\s+$//;
2523
2524	return $string;
2525	}
2526
2527	sub string_find_replace {
2528	my ($string, $find, $replace) = @_;
2529
2530	$string =~ s/$find/$replace/g;
2531
2532	return $string;
2533	}
2534
2535	sub tabify {
2536	my ($leading) = @_;
2537
2538	my $source_indent = $tabsize;
2539	my $max_spaces_before_tab = $source_indent - 1;
2540	my $spaces_to_tab = " " x $source_indent;
2541
2542	#convert leading spaces to tabs
2543	1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2544	#Remove spaces before a tab
2545	1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2546
2547	return "$leading";
2548	}
2549
2550	sub pos_last_openparen {
2551	my ($line) = @_;
2552
2553	my $pos = 0;
2554
2555	my $opens = $line =~ tr/\(/\(/;
2556	my $closes = $line =~ tr/\)/\)/;
2557
2558	my $last_openparen = 0;
2559
2560	if (($opens == 0) \|\| ($closes >= $opens)) {
2561	return -1;
2562	}
2563
2564	my $len = length($line);
2565
2566	for ($pos = 0; $pos < $len; $pos++) {
2567	my $string = substr($line, $pos);
2568	if ($string =~ /^($FuncArg\|$balanced_parens)/) {
2569	$pos += length($1) - 1;
2570	} elsif (substr($line, $pos, 1) eq '(') {
2571	$last_openparen = $pos;
2572	} elsif (index($string, '(') == -1) {
2573	last;
2574	}
2575	}
2576
2577	return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2578	}
2579
2580	sub get_raw_comment {
2581	my ($line, $rawline) = @_;
2582	my $comment = '';
2583
2584	for my $i (0 .. (length($line) - 1)) {
2585	if (substr($line, $i, 1) eq "$;") {
2586	$comment .= substr($rawline, $i, 1);
2587	}
2588	}
2589
2590	return $comment;
2591	}
2592
2593	sub exclude_global_initialisers {
2594	my ($realfile) = @_;
2595
2596	# Do not check for BPF programs (tools/testing/selftests/bpf/progs/.c, samples/bpf/_kern.c, *.bpf.c).
2597	return $realfile =~ m@^tools/testing/selftests/bpf/progs/.*\.c$@ \|\|
2598	$realfile =~ m@^samples/bpf/.*_kern\.c$@ \|\|
2599	$realfile =~ m@/bpf/.*\.bpf\.c$@;
2600	}
2601
2602	sub process {
2603	my $filename = shift;
2604
2605	my $linenr=0;
2606	my $prevline="";
2607	my $prevrawline="";
2608	my $stashline="";
2609	my $stashrawline="";
2610
2611	my $length;
2612	my $indent;
2613	my $previndent=0;
2614	my $stashindent=0;
2615
2616	our $clean = 1;
2617	my $signoff = 0;
2618	my $author = '';
2619	my $authorsignoff = 0;
2620	my $author_sob = '';
2621	my $is_patch = 0;
2622	my $is_binding_patch = -1;
2623	my $in_header_lines = $file ? 0 : 1;
2624	my $in_commit_log = 0; #Scanning lines before patch
2625	my $has_patch_separator = 0; #Found a --- line
2626	my $has_commit_log = 0; #Encountered lines before patch
2627	my $commit_log_lines = 0; #Number of commit log lines
2628	my $commit_log_possible_stack_dump = 0;
2629	my $commit_log_long_line = 0;
2630	my $commit_log_has_diff = 0;
2631	my $reported_maintainer_file = 0;
2632	my $non_utf8_charset = 0;
2633
2634	my $last_git_commit_id_linenr = -1;
2635
2636	my $last_blank_line = 0;
2637	my $last_coalesced_string_linenr = -1;
2638
2639	our @report = ();
2640	our $cnt_lines = 0;
2641	our $cnt_error = 0;
2642	our $cnt_warn = 0;
2643	our $cnt_chk = 0;
2644
2645	# Trace the real file/line as we go.
2646	my $realfile = '';
2647	my $realline = 0;
2648	my $realcnt = 0;
2649	my $here = '';
2650	my $context_function; #undef'd unless there's a known function
2651	my $in_comment = 0;
2652	my $comment_edge = 0;
2653	my $first_line = 0;
2654	my $p1_prefix = '';
2655
2656	my $prev_values = 'E';
2657
2658	# suppression flags
2659	my %suppress_ifbraces;
2660	my %suppress_whiletrailers;
2661	my %suppress_export;
2662	my $suppress_statement = 0;
2663
2664	my %signatures = ();
2665
2666	# Pre-scan the patch sanitizing the lines.
2667	# Pre-scan the patch looking for any __setup documentation.
2668	#
2669	my @setup_docs = ();
2670	my $setup_docs = 0;
2671
2672	my $camelcase_file_seeded = 0;
2673
2674	my $checklicenseline = 1;
2675
2676	sanitise_line_reset();
2677	my $line;
2678	foreach my $rawline (@rawlines) {
2679	$linenr++;
2680	$line = $rawline;
2681
2682	push(@fixed, $rawline) if ($fix);
2683
2684	if ($rawline=~/^\+\+\+\s+(\S+)/) {
2685	$setup_docs = 0;
2686	if ($1 =~ m@Documentation/admin-guide/kernel-parameters.txt$@) {
2687	$setup_docs = 1;
2688	}
2689	#next;
2690	}
2691	if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2692	$realline=$1-1;
2693	if (defined $2) {
2694	$realcnt=$3+1;
2695	} else {
2696	$realcnt=1+1;
2697	}
2698	$in_comment = 0;
2699
2700	# Guestimate if this is a continuing comment. Run
2701	# the context looking for a comment "edge". If this
2702	# edge is a close comment then we must be in a comment
2703	# at context start.
2704	my $edge;
2705	my $cnt = $realcnt;
2706	for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2707	next if (defined $rawlines[$ln - 1] &&
2708	$rawlines[$ln - 1] =~ /^-/);
2709	$cnt--;
2710	#print "RAW<$rawlines[$ln - 1]>\n";
2711	last if (!defined $rawlines[$ln - 1]);
2712	if ($rawlines[$ln - 1] =~ m@(/\\|\/)@ &&
2713	$rawlines[$ln - 1] !~ m@"[^"](?:/\\|\/)[^"]"@) {
2714	($edge) = $1;
2715	last;
2716	}
2717	}
2718	if (defined $edge && $edge eq '*/') {
2719	$in_comment = 1;
2720	}
2721
2722	# Guestimate if this is a continuing comment. If this
2723	# is the start of a diff block and this line starts
2724	# ' *' then it is very likely a comment.
2725	if (!defined $edge &&
2726	$rawlines[$linenr] =~ m@^.\s(?:\\+\| \)(?:\s\|$)@)
2727	{
2728	$in_comment = 1;
2729	}
2730
2731	##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2732	sanitise_line_reset($in_comment);
2733
2734	} elsif ($realcnt && $rawline =~ /^(?:\+\| \|$)/) {
2735	# Standardise the strings and chars within the input to
2736	# simplify matching -- only bother with positive lines.
2737	$line = sanitise_line($rawline);
2738	}
2739	push(@lines, $line);
2740
2741	if ($realcnt > 1) {
2742	$realcnt-- if ($line =~ /^(?:\+\| \|$)/);
2743	} else {
2744	$realcnt = 0;
2745	}
2746
2747	#print "==>$rawline\n";
2748	#print "-->$line\n";
2749
2750	if ($setup_docs && $line =~ /^\+/) {
2751	push(@setup_docs, $line);
2752	}
2753	}
2754
2755	$prefix = '';
2756
2757	$realcnt = 0;
2758	$linenr = 0;
2759	$fixlinenr = -1;
2760	foreach my $line (@lines) {
2761	$linenr++;
2762	$fixlinenr++;
2763	my $sline = $line; #copy of $line
2764	$sline =~ s/$;/ /g; #with comments as spaces
2765
2766	my $rawline = $rawlines[$linenr - 1];
2767	my $raw_comment = get_raw_comment($line, $rawline);
2768
2769	# check if it's a mode change, rename or start of a patch
2770	if (!$in_commit_log &&
2771	($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ \|\|
2772	($line =~ /^rename (?:from\|to) \S+\s*$/ \|\|
2773	$line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2774	$is_patch = 1;
2775	}
2776
2777	#extract the line range in the file after the patch is applied
2778	if (!$in_commit_log &&
2779	$line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2780	my $context = $4;
2781	$is_patch = 1;
2782	$first_line = $linenr + 1;
2783	$realline=$1-1;
2784	if (defined $2) {
2785	$realcnt=$3+1;
2786	} else {
2787	$realcnt=1+1;
2788	}
2789	annotate_reset();
2790	$prev_values = 'E';
2791
2792	%suppress_ifbraces = ();
2793	%suppress_whiletrailers = ();
2794	%suppress_export = ();
2795	$suppress_statement = 0;
2796	if ($context =~ /\b(\w+)\s*\(/) {
2797	$context_function = $1;
2798	} else {
2799	undef $context_function;
2800	}
2801	next;
2802
2803	# track the line number as we move through the hunk, note that
2804	# new versions of GNU diff omit the leading space on completely
2805	# blank context lines so we need to count that too.
2806	} elsif ($line =~ /^( \|\+\|$)/) {
2807	$realline++;
2808	$realcnt-- if ($realcnt != 0);
2809
2810	# Measure the line length and indent.
2811	($length, $indent) = line_stats($rawline);
2812
2813	# Track the previous line.
2814	($prevline, $stashline) = ($stashline, $line);
2815	($previndent, $stashindent) = ($stashindent, $indent);
2816	($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2817
2818	#warn "line<$line>\n";
2819
2820	} elsif ($realcnt == 1) {
2821	$realcnt--;
2822	}
2823
2824	my $hunk_line = ($realcnt != 0);
2825
2826	$here = "#$linenr: " if (!$file);
2827	$here = "#$realline: " if ($file);
2828
2829	my $found_file = 0;
2830	# extract the filename as it passes
2831	if ($line =~ /^diff --git.*?(\S+)$/) {
2832	$realfile = $1;
2833	$realfile =~ s@^([^/]*)/@@ if (!$file);
2834	$in_commit_log = 0;
2835	$found_file = 1;
2836	} elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2837	$realfile = $1;
2838	$realfile =~ s@^([^/]*)/@@ if (!$file);
2839	$in_commit_log = 0;
2840
2841	$p1_prefix = $1;
2842	if (!$file && $tree && $p1_prefix ne '' &&
2843	-e "$root/$p1_prefix") {
2844	WARN("PATCH_PREFIX",
2845	"patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2846	}
2847
2848	if ($realfile =~ m@^include/asm/@) {
2849	ERROR("MODIFIED_INCLUDE_ASM",
2850	"do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2851	}
2852	$found_file = 1;
2853	}
2854
2855	#make up the handle for any error we report on this line
2856	if ($showfile) {
2857	$prefix = "$realfile:$realline: "
2858	} elsif ($emacs) {
2859	if ($file) {
2860	$prefix = "$filename:$realline: ";
2861	} else {
2862	$prefix = "$filename:$linenr: ";
2863	}
2864	}
2865
2866	if ($found_file) {
2867	if (is_maintained_obsolete($realfile)) {
2868	WARN("OBSOLETE",
2869	"$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2870	}
2871	if ($realfile =~ m@^(?:drivers/net/\|net/\|drivers/staging/)@) {
2872	$check = 1;
2873	} else {
2874	$check = $check_orig;
2875	}
2876	$checklicenseline = 1;
2877
2878	if ($realfile !~ /^MAINTAINERS/) {
2879	my $last_binding_patch = $is_binding_patch;
2880
2881	$is_binding_patch = () = $realfile =~ m@^(?:Documentation/devicetree/\|include/dt-bindings/)@;
2882
2883	if (($last_binding_patch != -1) &&
2884	($last_binding_patch ^ $is_binding_patch)) {
2885	WARN("DT_SPLIT_BINDING_PATCH",
2886	"DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2887	}
2888	}
2889
2890	next;
2891	}
2892
2893	$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2894
2895	my $hereline = "$here\n$rawline\n";
2896	my $herecurr = "$here\n$rawline\n";
2897	my $hereprev = "$here\n$prevrawline\n$rawline\n";
2898
2899	$cnt_lines++ if ($realcnt != 0);
2900
2901	# Verify the existence of a commit log if appropriate
2902	# 2 is used because a $signature is counted in $commit_log_lines
2903	if ($in_commit_log) {
2904	if ($line !~ /^\s*$/) {
2905	$commit_log_lines++; #could be a $signature
2906	}
2907	} elsif ($has_commit_log && $commit_log_lines < 2) {
2908	WARN("COMMIT_MESSAGE",
2909	"Missing commit description - Add an appropriate one\n");
2910	$commit_log_lines = 2; #warn only once
2911	}
2912
2913	# Check if the commit log has what seems like a diff which can confuse patch
2914	if ($in_commit_log && !$commit_log_has_diff &&
2915	(($line =~ m@^\s+diff\b.*a/([\w/]+)@ &&
2916	$line =~ m@^\s+diff\b.*a/[\w/]+\s+b/$1\b@) \|\|
2917	$line =~ m@^\s*(?:\-\-\-\s+a/\|\+\+\+\s+b/)@ \|\|
2918	$line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2919	ERROR("DIFF_IN_COMMIT_MSG",
2920	"Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2921	$commit_log_has_diff = 1;
2922	}
2923
2924	# Check for incorrect file permissions
2925	if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2926	my $permhere = $here . "FILE: $realfile\n";
2927	if ($realfile !~ m@scripts/@ &&
2928	$realfile !~ /\.(py\|pl\|awk\|sh)$/) {
2929	ERROR("EXECUTE_PERMISSIONS",
2930	"do not set execute permissions for source files\n" . $permhere);
2931	}
2932	}
2933
2934	# Check the patch for a From:
2935	if (decode("MIME-Header", $line) =~ /^From:\s(.)/) {
2936	$author = $1;
2937	my $curline = $linenr;
2938	while(defined($rawlines[$curline]) && ($rawlines[$curline++] =~ /^[ \t]\s(.)/)) {
2939	$author .= $1;
2940	}
2941	$author = encode("utf8", $author) if ($line =~ /=\?utf-8\?/i);
2942	$author =~ s/"//g;
2943	$author = reformat_email($author);
2944	}
2945
2946	# Check the patch for a signoff:
2947	if ($line =~ /^\ssigned-off-by:\s(.*)/i) {
2948	$signoff++;
2949	$in_commit_log = 0;
2950	if ($author ne '' && $authorsignoff != 1) {
2951	if (same_email_addresses($1, $author)) {
2952	$authorsignoff = 1;
2953	} else {
2954	my $ctx = $1;
2955	my ($email_name, $email_comment, $email_address, $comment1) = parse_email($ctx);
2956	my ($author_name, $author_comment, $author_address, $comment2) = parse_email($author);
2957
2958	if (lc $email_address eq lc $author_address && $email_name eq $author_name) {
2959	$author_sob = $ctx;
2960	$authorsignoff = 2;
2961	} elsif (lc $email_address eq lc $author_address) {
2962	$author_sob = $ctx;
2963	$authorsignoff = 3;
2964	} elsif ($email_name eq $author_name) {
2965	$author_sob = $ctx;
2966	$authorsignoff = 4;
2967
2968	my $address1 = $email_address;
2969	my $address2 = $author_address;
2970
2971	if ($address1 =~ /(\S+)\+\S+(\@.*)/) {
2972	$address1 = "$1$2";
2973	}
2974	if ($address2 =~ /(\S+)\+\S+(\@.*)/) {
2975	$address2 = "$1$2";
2976	}
2977	if ($address1 eq $address2) {
2978	$authorsignoff = 5;
2979	}
2980	}
2981	}
2982	}
2983	}
2984
2985	# Check for patch separator
2986	if ($line =~ /^---$/) {
2987	$has_patch_separator = 1;
2988	$in_commit_log = 0;
2989	}
2990
2991	# Check if MAINTAINERS is being updated. If so, there's probably no need to
2992	# emit the "does MAINTAINERS need updating?" message on file add/move/delete
2993	if ($line =~ /^\sMAINTAINERS\s\\|/) {
2994	$reported_maintainer_file = 1;
2995	}
2996
2997	# Check signature styles
2998	if (!$in_header_lines &&
2999	$line =~ /^(\s)([a-z0-9_-]+by:\|$signature_tags)(\s)(.*)/i) {
3000	my $space_before = $1;
3001	my $sign_off = $2;
3002	my $space_after = $3;
3003	my $email = $4;
3004	my $ucfirst_sign_off = ucfirst(lc($sign_off));
3005
3006	if ($sign_off !~ /$signature_tags/) {
3007	my $suggested_signature = find_standard_signature($sign_off);
3008	if ($suggested_signature eq "") {
3009	WARN("BAD_SIGN_OFF",
3010	"Non-standard signature: $sign_off\n" . $herecurr);
3011	} else {
3012	if (WARN("BAD_SIGN_OFF",
3013	"Non-standard signature: '$sign_off' - perhaps '$suggested_signature'?\n" . $herecurr) &&
3014	$fix) {
3015	$fixed[$fixlinenr] =~ s/$sign_off/$suggested_signature/;
3016	}
3017	}
3018	}
3019	if (defined $space_before && $space_before ne "") {
3020	if (WARN("BAD_SIGN_OFF",
3021	"Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
3022	$fix) {
3023	$fixed[$fixlinenr] =
3024	"$ucfirst_sign_off $email";
3025	}
3026	}
3027	if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
3028	if (WARN("BAD_SIGN_OFF",
3029	"'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
3030	$fix) {
3031	$fixed[$fixlinenr] =
3032	"$ucfirst_sign_off $email";
3033	}
3034
3035	}
3036	if (!defined $space_after \|\| $space_after ne " ") {
3037	if (WARN("BAD_SIGN_OFF",
3038	"Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
3039	$fix) {
3040	$fixed[$fixlinenr] =
3041	"$ucfirst_sign_off $email";
3042	}
3043	}
3044
3045	my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
3046	my $suggested_email = format_email(($email_name, $name_comment, $email_address, $comment));
3047	if ($suggested_email eq "") {
3048	ERROR("BAD_SIGN_OFF",
3049	"Unrecognized email address: '$email'\n" . $herecurr);
3050	} else {
3051	my $dequoted = $suggested_email;
3052	$dequoted =~ s/^"//;
3053	$dequoted =~ s/" </ </;
3054	# Don't force email to have quotes
3055	# Allow just an angle bracketed address
3056	if (!same_email_addresses($email, $suggested_email)) {
3057	if (WARN("BAD_SIGN_OFF",
3058	"email address '$email' might be better as '$suggested_email'\n" . $herecurr) &&
3059	$fix) {
3060	$fixed[$fixlinenr] =~ s/\Q$email\E/$suggested_email/;
3061	}
3062	}
3063
3064	# Address part shouldn't have comments
3065	my $stripped_address = $email_address;
3066	$stripped_address =~ s/$[^\($]*\)//g;
3067	if ($email_address ne $stripped_address) {
3068	if (WARN("BAD_SIGN_OFF",
3069	"address part of email should not have comments: '$email_address'\n" . $herecurr) &&
3070	$fix) {
3071	$fixed[$fixlinenr] =~ s/\Q$email_address\E/$stripped_address/;
3072	}
3073	}
3074
3075	# Only one name comment should be allowed
3076	my $comment_count = () = $name_comment =~ /$[^$]+\)/g;
3077	if ($comment_count > 1) {
3078	WARN("BAD_SIGN_OFF",
3079	"Use a single name comment in email: '$email'\n" . $herecurr);
3080	}
3081
3082
3083	# [email protected] or [email protected] shouldn't
3084	# have an email name. In addition comments should strictly
3085	# begin with a #
3086	if ($email =~ /^.*stable\@(?:vger\.)?kernel\.org/i) {
3087	if (($comment ne "" && $comment !~ /^#.+/) \|\|
3088	($email_name ne "")) {
3089	my $cur_name = $email_name;
3090	my $new_comment = $comment;
3091	$cur_name =~ s/[a-zA-Z\s\-\"]+//g;
3092
3093	# Remove brackets enclosing comment text
3094	# and # from start of comments to get comment text
3095	$new_comment =~ s/^$(.*)$$/$1/;
3096	$new_comment =~ s/^\[(.*)\]$/$1/;
3097	$new_comment =~ s/^[\s\#]+\|\s+$//g;
3098
3099	$new_comment = trim("$new_comment $cur_name") if ($cur_name ne $new_comment);
3100	$new_comment = " # $new_comment" if ($new_comment ne "");
3101	my $new_email = "$email_address$new_comment";
3102
3103	if (WARN("BAD_STABLE_ADDRESS_STYLE",
3104	"Invalid email format for stable: '$email', prefer '$new_email'\n" . $herecurr) &&
3105	$fix) {
3106	$fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3107	}
3108	}
3109	} elsif ($comment ne "" && $comment !~ /^(?:#.+\|$.+$)$/) {
3110	my $new_comment = $comment;
3111
3112	# Extract comment text from within brackets or
3113	# c89 style /.../ comments
3114	$new_comment =~ s/^\[(.*)\]$/$1/;
3115	$new_comment =~ s/^\/\(.)\*\/$/$1/;
3116
3117	$new_comment = trim($new_comment);
3118	$new_comment =~ s/^[^\w]$//; # Single lettered comment with non word character is usually a typo
3119	$new_comment = "($new_comment)" if ($new_comment ne "");
3120	my $new_email = format_email($email_name, $name_comment, $email_address, $new_comment);
3121
3122	if (WARN("BAD_SIGN_OFF",
3123	"Unexpected content after email: '$email', should be: '$new_email'\n" . $herecurr) &&
3124	$fix) {
3125	$fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3126	}
3127	}
3128	}
3129
3130	# Check for duplicate signatures
3131	my $sig_nospace = $line;
3132	$sig_nospace =~ s/\s//g;
3133	$sig_nospace = lc($sig_nospace);
3134	if (defined $signatures{$sig_nospace}) {
3135	WARN("BAD_SIGN_OFF",
3136	"Duplicate signature\n" . $herecurr);
3137	} else {
3138	$signatures{$sig_nospace} = 1;
3139	}
3140
3141	# Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
3142	if ($sign_off =~ /^co-developed-by:$/i) {
3143	if ($email eq $author) {
3144	WARN("BAD_SIGN_OFF",
3145	"Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . "$here\n" . $rawline);
3146	}
3147	if (!defined $lines[$linenr]) {
3148	WARN("BAD_SIGN_OFF",
3149	"Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline);
3150	} elsif ($rawlines[$linenr] !~ /^\ssigned-off-by:\s(.*)/i) {
3151	WARN("BAD_SIGN_OFF",
3152	"Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3153	} elsif ($1 ne $email) {
3154	WARN("BAD_SIGN_OFF",
3155	"Co-developed-by and Signed-off-by: name/email do not match \n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3156	}
3157	}
3158	}
3159
3160	# Check Fixes: styles is correct
3161	if (!$in_header_lines &&
3162	$line =~ /^\sfixes:?\s(?:commit\s*)?[0-9a-f]{5,}\b/i) {
3163	my $orig_commit = "";
3164	my $id = "0123456789ab";
3165	my $title = "commit title";
3166	my $tag_case = 1;
3167	my $tag_space = 1;
3168	my $id_length = 1;
3169	my $id_case = 1;
3170	my $title_has_quotes = 0;
3171
3172	if ($line =~ /(\s*fixes:?)\s+([0-9a-f]{5,})\s+($balanced_parens)/i) {
3173	my $tag = $1;
3174	$orig_commit = $2;
3175	$title = $3;
3176
3177	$tag_case = 0 if $tag eq "Fixes:";
3178	$tag_space = 0 if ($line =~ /^fixes:? [0-9a-f]{5,} ($balanced_parens)/i);
3179
3180	$id_length = 0 if ($orig_commit =~ /^[0-9a-f]{12}$/i);
3181	$id_case = 0 if ($orig_commit !~ /[A-F]/);
3182
3183	# Always strip leading/trailing parens then double quotes if existing
3184	$title = substr($title, 1, -1);
3185	if ($title =~ /^".*"$/) {
3186	$title = substr($title, 1, -1);
3187	$title_has_quotes = 1;
3188	}
3189	}
3190
3191	my ($cid, $ctitle) = git_commit_info($orig_commit, $id,
3192	$title);
3193
3194	if ($ctitle ne $title \|\| $tag_case \|\| $tag_space \|\|
3195	$id_length \|\| $id_case \|\| !$title_has_quotes) {
3196	if (WARN("BAD_FIXES_TAG",
3197	"Please use correct Fixes: style 'Fixes: <12 chars of sha1> (\"<title line>\")' - ie: 'Fixes: $cid (\"$ctitle\")'\n" . $herecurr) &&
3198	$fix) {
3199	$fixed[$fixlinenr] = "Fixes: $cid (\"$ctitle\")";
3200	}
3201	}
3202	}
3203
3204	# Check email subject for common tools that don't need to be mentioned
3205	if ($in_header_lines &&
3206	$line =~ /^Subject:.*\b(?:checkpatch\|sparse\|smatch)\b[^:]/i) {
3207	WARN("EMAIL_SUBJECT",
3208	"A patch subject line should describe the change not the tool that found it\n" . $herecurr);
3209	}
3210
3211	# Check for Gerrit Change-Ids not in any patch context
3212	if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
3213	if (ERROR("GERRIT_CHANGE_ID",
3214	"Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr) &&
3215	$fix) {
3216	fix_delete_line($fixlinenr, $rawline);
3217	}
3218	}
3219
3220	# Check if the commit log is in a possible stack dump
3221	if ($in_commit_log && !$commit_log_possible_stack_dump &&
3222	($line =~ /^\s*(?:WARNING:\|BUG:)/ \|\|
3223	$line =~ /^\s\[\s\d+\.\d{6,6}\s*\]/ \|\|
3224	# timestamp
3225	$line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) \|\|
3226	$line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ \|\|
3227	$line =~ /^\s\#\d+\s\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
3228	# stack dump address styles
3229	$commit_log_possible_stack_dump = 1;
3230	}
3231
3232	# Check for line lengths > 75 in commit log, warn once
3233	if ($in_commit_log && !$commit_log_long_line &&
3234	length($line) > 75 &&
3235	!($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\\|\s+\d+/ \|\|
3236	# file delta changes
3237	$line =~ /^\s(?:[\w\.\-\+]\/)++[\w\.\-\+]+:/ \|\|
3238	# filename then :
3239	$line =~ /^\s*(?:Fixes:\|Link:\|$signature_tags)/i \|\|
3240	# A Fixes: or Link: line or signature tag line
3241	$commit_log_possible_stack_dump)) {
3242	WARN("COMMIT_LOG_LONG_LINE",
3243	"Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
3244	$commit_log_long_line = 1;
3245	}
3246
3247	# Reset possible stack dump if a blank line is found
3248	if ($in_commit_log && $commit_log_possible_stack_dump &&
3249	$line =~ /^\s*$/) {
3250	$commit_log_possible_stack_dump = 0;
3251	}
3252
3253	# Check for lines starting with a #
3254	if ($in_commit_log && $line =~ /^#/) {
3255	if (WARN("COMMIT_COMMENT_SYMBOL",
3256	"Commit log lines starting with '#' are dropped by git as comments\n" . $herecurr) &&
3257	$fix) {
3258	$fixed[$fixlinenr] =~ s/^/ /;
3259	}
3260	}
3261
3262	# Check for git id commit length and improperly formed commit descriptions
3263	# A correctly formed commit description is:
3264	# commit <SHA-1 hash length 12+ chars> ("Complete commit subject")
3265	# with the commit subject '("' prefix and '")' suffix
3266	# This is a fairly compilicated block as it tests for what appears to be
3267	# bare SHA-1 hash with minimum length of 5. It also avoids several types of
3268	# possible SHA-1 matches.
3269	# A commit match can span multiple lines so this block attempts to find a
3270	# complete typical commit on a maximum of 3 lines
3271	if ($perl_version_ok &&
3272	$in_commit_log && !$commit_log_possible_stack_dump &&
3273	$line !~ /^\s*(?:Link\|Patchwork\|http\|https\|BugLink\|base-commit):/i &&
3274	$line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
3275	(($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i \|\|
3276	($line =~ /\bcommit\s$/i && defined($rawlines[$linenr]) && $rawlines[$linenr] =~ /^\s[0-9a-f]{5,}\b/i)) \|\|
3277	($line =~ /(?:\s\|^)[0-9a-f]{12,40}(?:[\s"'\(\[]\|$)/i &&
3278	$line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
3279	$line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
3280	my $init_char = "c";
3281	my $orig_commit = "";
3282	my $short = 1;
3283	my $long = 0;
3284	my $case = 1;
3285	my $space = 1;
3286	my $id = '0123456789ab';
3287	my $orig_desc = "commit description";
3288	my $description = "";
3289	my $herectx = $herecurr;
3290	my $has_parens = 0;
3291	my $has_quotes = 0;
3292
3293	my $input = $line;
3294	if ($line =~ /(?:\bcommit\s+[0-9a-f]{5,}\|\bcommit\s*$)/i) {
3295	for (my $n = 0; $n < 2; $n++) {
3296	if ($input =~ /\bcommit\s+[0-9a-f]{5,}\s*($balanced_parens)/i) {
3297	$orig_desc = $1;
3298	$has_parens = 1;
3299	# Always strip leading/trailing parens then double quotes if existing
3300	$orig_desc = substr($orig_desc, 1, -1);
3301	if ($orig_desc =~ /^".*"$/) {
3302	$orig_desc = substr($orig_desc, 1, -1);
3303	$has_quotes = 1;
3304	}
3305	last;
3306	}
3307	last if ($#lines < $linenr + $n);
3308	$input .= " " . trim($rawlines[$linenr + $n]);
3309	$herectx .= "$rawlines[$linenr + $n]\n";
3310	}
3311	$herectx = $herecurr if (!$has_parens);
3312	}
3313
3314	if ($input =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
3315	$init_char = $1;
3316	$orig_commit = lc($2);
3317	$short = 0 if ($input =~ /\bcommit\s+[0-9a-f]{12,40}/i);
3318	$long = 1 if ($input =~ /\bcommit\s+[0-9a-f]{41,}/i);
3319	$space = 0 if ($input =~ /\bcommit [0-9a-f]/i);
3320	$case = 0 if ($input =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
3321	} elsif ($input =~ /\b([0-9a-f]{12,40})\b/i) {
3322	$orig_commit = lc($1);
3323	}
3324
3325	($id, $description) = git_commit_info($orig_commit,
3326	$id, $orig_desc);
3327
3328	if (defined($id) &&
3329	($short \|\| $long \|\| $space \|\| $case \|\| ($orig_desc ne $description) \|\| !$has_quotes) &&
3330	$last_git_commit_id_linenr != $linenr - 1) {
3331	ERROR("GIT_COMMIT_ID",
3332	"Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herectx);
3333	}
3334	#don't report the next line if this line ends in commit and the sha1 hash is the next line
3335	$last_git_commit_id_linenr = $linenr if ($line =~ /\bcommit\s*$/i);
3336	}
3337
3338	# Check for mailing list archives other than lore.kernel.org
3339	if ($rawline =~ m{http.*\b$obsolete_archives}) {
3340	WARN("PREFER_LORE_ARCHIVE",
3341	"Use lore.kernel.org archive links when possible - see https://lore.kernel.org/lists.html\n" . $herecurr);
3342	}
3343
3344	# Check for added, moved or deleted files
3345	if (!$reported_maintainer_file && !$in_commit_log &&
3346	($line =~ /^(?:new\|deleted) file mode\s\d+\s$/ \|\|
3347	$line =~ /^rename (?:from\|to) [\w\/\.\-]+\s*$/ \|\|
3348	($line =~ /\{\s([\w\/\.\-])\s\=\>\s([\w\/\.\-])\s\}/ &&
3349	(defined($1) \|\| defined($2))))) {
3350	$is_patch = 1;
3351	$reported_maintainer_file = 1;
3352	WARN("FILE_PATH_CHANGES",
3353	"added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
3354	}
3355
3356	# Check for adding new DT bindings not in schema format
3357	if (!$in_commit_log &&
3358	($line =~ /^new file mode\s\d+\s$/) &&
3359	($realfile =~ m@^Documentation/devicetree/bindings/.*\.txt$@)) {
3360	WARN("DT_SCHEMA_BINDING_PATCH",
3361	"DT bindings should be in DT schema format. See: Documentation/devicetree/bindings/writing-schema.rst\n");
3362	}
3363
3364	# Check for wrappage within a valid hunk of the file
3365	if ($realcnt != 0 && $line !~ m{^(?:\+\|-\| \|\\ No newline\|$)}) {
3366	ERROR("CORRUPTED_PATCH",
3367	"patch seems to be corrupt (line wrapped?)\n" .
3368	$herecurr) if (!$emitted_corrupt++);
3369	}
3370
3371	# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
3372	if (($realfile =~ /^$/ \|\| $line =~ /^\+/) &&
3373	$rawline !~ m/^$UTF8*$/) {
3374	my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
3375
3376	my $blank = copy_spacing($rawline);
3377	my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
3378	my $hereptr = "$hereline$ptr\n";
3379
3380	CHK("INVALID_UTF8",
3381	"Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
3382	}
3383
3384	# Check if it's the start of a commit log
3385	# (not a header line and we haven't seen the patch filename)
3386	if ($in_header_lines && $realfile =~ /^$/ &&
3387	!($rawline =~ /^\s+(?:\S\|$)/ \|\|
3388	$rawline =~ /^(?:commit\b\|from\b\|[\w-]+:)/i)) {
3389	$in_header_lines = 0;
3390	$in_commit_log = 1;
3391	$has_commit_log = 1;
3392	}
3393
3394	# Check if there is UTF-8 in a commit log when a mail header has explicitly
3395	# declined it, i.e defined some charset where it is missing.
3396	if ($in_header_lines &&
3397	$rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
3398	$1 !~ /utf-8/i) {
3399	$non_utf8_charset = 1;
3400	}
3401
3402	if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
3403	$rawline =~ /$NON_ASCII_UTF8/) {
3404	WARN("UTF8_BEFORE_PATCH",
3405	"8-bit UTF-8 used in possible commit log\n" . $herecurr);
3406	}
3407
3408	# Check for absolute kernel paths in commit message
3409	if ($tree && $in_commit_log) {
3410	while ($line =~ m{(?:^\|\s)(/\S*)}g) {
3411	my $file = $1;
3412
3413	if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
3414	check_absolute_file($1, $herecurr)) {
3415	#
3416	} else {
3417	check_absolute_file($file, $herecurr);
3418	}
3419	}
3420	}
3421
3422	# Check for various typo / spelling mistakes
3423	if (defined($misspellings) &&
3424	($in_commit_log \|\| $line =~ /^(?:\+\|Subject:)/i)) {
3425	while ($rawline =~ /(?:^\|[^\w\-'`])($misspellings)(?:[^\w\-'`]\|$)/gi) {
3426	my $typo = $1;
3427	my $blank = copy_spacing($rawline);
3428	my $ptr = substr($blank, 0, $-[1]) . "^" x length($typo);
3429	my $hereptr = "$hereline$ptr\n";
3430	my $typo_fix = $spelling_fix{lc($typo)};
3431	$typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
3432	$typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
3433	my $msg_level = \&WARN;
3434	$msg_level = \&CHK if ($file);
3435	if (&{$msg_level}("TYPO_SPELLING",
3436	"'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr) &&
3437	$fix) {
3438	$fixed[$fixlinenr] =~ s/(^\|[^A-Za-z@])($typo)($\|[^A-Za-z@])/$1$typo_fix$3/;
3439	}
3440	}
3441	}
3442
3443	# check for invalid commit id
3444	if ($in_commit_log && $line =~ /(^fixes:\|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
3445	my $id;
3446	my $description;
3447	($id, $description) = git_commit_info($2, undef, undef);
3448	if (!defined($id)) {
3449	WARN("UNKNOWN_COMMIT_ID",
3450	"Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
3451	}
3452	}
3453
3454	# check for repeated words separated by a single space
3455	# avoid false positive from list command eg, '-rw-r--r-- 1 root root'
3456	if (($rawline =~ /^\+/ \|\| $in_commit_log) &&
3457	$rawline !~ /[bcCdDlMnpPs\?-][rwxsStT-]{9}/) {
3458	pos($rawline) = 1 if (!$in_commit_log);
3459	while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3460
3461	my $first = $1;
3462	my $second = $2;
3463	my $start_pos = $-[1];
3464	my $end_pos = $+[2];
3465	if ($first =~ /(?:struct\|union\|enum)/) {
3466	pos($rawline) += length($first) + length($second) + 1;
3467	next;
3468	}
3469
3470	next if (lc($first) ne lc($second));
3471	next if ($first eq 'long');
3472
3473	# check for character before and after the word matches
3474	my $start_char = '';
3475	my $end_char = '';
3476	$start_char = substr($rawline, $start_pos - 1, 1) if ($start_pos > ($in_commit_log ? 0 : 1));
3477	$end_char = substr($rawline, $end_pos, 1) if ($end_pos < length($rawline));
3478
3479	next if ($start_char =~ /^\S$/);
3480	next if (index(" \t.,;?!", $end_char) == -1);
3481
3482	# avoid repeating hex occurrences like 'ff ff fe 09 ...'
3483	if ($first =~ /\b[0-9a-f]{2,}\b/i) {
3484	next if (!exists($allow_repeated_words{lc($first)}));
3485	}
3486
3487	if (WARN("REPEATED_WORD",
3488	"Possible repeated word: '$first'\n" . $herecurr) &&
3489	$fix) {
3490	$fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3491	}
3492	}
3493
3494	# if it's a repeated word on consecutive lines in a comment block
3495	if ($prevline =~ /$;+\s*$/ &&
3496	$prevrawline =~ /($word_pattern)\s*$/) {
3497	my $last_word = $1;
3498	if ($rawline =~ /^\+\s\\s*$last_word /) {
3499	if (WARN("REPEATED_WORD",
3500	"Possible repeated word: '$last_word'\n" . $hereprev) &&
3501	$fix) {
3502	$fixed[$fixlinenr] =~ s/(\+\s\\s*)$last_word /$1/;
3503	}
3504	}
3505	}
3506	}
3507
3508	# ignore non-hunk lines and lines being removed
3509	next if (!$hunk_line \|\| $line =~ /^-/);
3510
3511	#trailing whitespace
3512	if ($line =~ /^\+.*\015/) {
3513	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3514	if (ERROR("DOS_LINE_ENDINGS",
3515	"DOS line endings\n" . $herevet) &&
3516	$fix) {
3517	$fixed[$fixlinenr] =~ s/[\s\015]+$//;
3518	}
3519	} elsif ($rawline =~ /^\+.*\S\s+$/ \|\| $rawline =~ /^\+\s+$/) {
3520	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3521	if (ERROR("TRAILING_WHITESPACE",
3522	"trailing whitespace\n" . $herevet) &&
3523	$fix) {
3524	$fixed[$fixlinenr] =~ s/\s+$//;
3525	}
3526
3527	$rpt_cleaners = 1;
3528	}
3529
3530	# Check for FSF mailing addresses.
3531	if ($rawline =~ /\bwrite to the Free/i \|\|
3532	$rawline =~ /\b675\s+Mass\s+Ave/i \|\|
3533	$rawline =~ /\b59\s+Temple\s+Pl/i \|\|
3534	$rawline =~ /\b51\s+Franklin\s+St/i) {
3535	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3536	my $msg_level = \&ERROR;
3537	$msg_level = \&CHK if ($file);
3538	&{$msg_level}("FSF_MAILING_ADDRESS",
3539	"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)
3540	}
3541
3542	# check for Kconfig help text having a real description
3543	# Only applies when adding the entry originally, after that we do not have
3544	# sufficient context to determine whether it is indeed long enough.
3545	if ($realfile =~ /Kconfig/ &&
3546	# 'choice' is usually the last thing on the line (though
3547	# Kconfig supports named choices), so use a word boundary
3548	# (\b) rather than a whitespace character (\s)
3549	$line =~ /^\+\s*(?:config\|menuconfig\|choice)\b/) {
3550	my $ln = $linenr;
3551	my $needs_help = 0;
3552	my $has_help = 0;
3553	my $help_length = 0;
3554	while (defined $lines[$ln]) {
3555	my $f = $lines[$ln++];
3556
3557	next if ($f =~ /^-/);
3558	last if ($f !~ /^[\+ ]/); # !patch context
3559
3560	if ($f =~ /^\+\s(?:bool\|tristate\|prompt)\s["']/) {
3561	$needs_help = 1;
3562	next;
3563	}
3564	if ($f =~ /^\+\shelp\s$/) {
3565	$has_help = 1;
3566	next;
3567	}
3568
3569	$f =~ s/^.//; # strip patch context [+ ]
3570	$f =~ s/#.*//; # strip # directives
3571	$f =~ s/^\s+//; # strip leading blanks
3572	next if ($f =~ /^$/); # skip blank lines
3573
3574	# At the end of this Kconfig block:
3575	# This only checks context lines in the patch
3576	# and so hopefully shouldn't trigger false
3577	# positives, even though some of these are
3578	# common words in help texts
3579	if ($f =~ /^(?:config\|menuconfig\|choice\|endchoice\|
3580	if\|endif\|menu\|endmenu\|source)\b/x) {
3581	last;
3582	}
3583	$help_length++ if ($has_help);
3584	}
3585	if ($needs_help &&
3586	$help_length < $min_conf_desc_length) {
3587	my $stat_real = get_stat_real($linenr, $ln - 1);
3588	WARN("CONFIG_DESCRIPTION",
3589	"please write a help paragraph that fully describes the config symbol\n" . "$here\n$stat_real\n");
3590	}
3591	}
3592
3593	# check MAINTAINERS entries
3594	if ($realfile =~ /^MAINTAINERS$/) {
3595	# check MAINTAINERS entries for the right form
3596	if ($rawline =~ /^\+[A-Z]:/ &&
3597	$rawline !~ /^\+[A-Z]:\t\S/) {
3598	if (WARN("MAINTAINERS_STYLE",
3599	"MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3600	$fix) {
3601	$fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3602	}
3603	}
3604	# check MAINTAINERS entries for the right ordering too
3605	my $preferred_order = 'MRLSWQBCPTFXNK';
3606	if ($rawline =~ /^\+[A-Z]:/ &&
3607	$prevrawline =~ /^[\+ ][A-Z]:/) {
3608	$rawline =~ /^\+([A-Z]):\s(.)/;
3609	my $cur = $1;
3610	my $curval = $2;
3611	$prevrawline =~ /^[\+ ]([A-Z]):\s(.)/;
3612	my $prev = $1;
3613	my $prevval = $2;
3614	my $curindex = index($preferred_order, $cur);
3615	my $previndex = index($preferred_order, $prev);
3616	if ($curindex < 0) {
3617	WARN("MAINTAINERS_STYLE",
3618	"Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3619	} else {
3620	if ($previndex >= 0 && $curindex < $previndex) {
3621	WARN("MAINTAINERS_STYLE",
3622	"Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3623	} elsif ((($prev eq 'F' && $cur eq 'F') \|\|
3624	($prev eq 'X' && $cur eq 'X')) &&
3625	($prevval cmp $curval) > 0) {
3626	WARN("MAINTAINERS_STYLE",
3627	"Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3628	}
3629	}
3630	}
3631	}
3632
3633	if (($realfile =~ /Makefile./ \|\| $realfile =~ /Kbuild./) &&
3634	($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3635	my $flag = $1;
3636	my $replacement = {
3637	'EXTRA_AFLAGS' => 'asflags-y',
3638	'EXTRA_CFLAGS' => 'ccflags-y',
3639	'EXTRA_CPPFLAGS' => 'cppflags-y',
3640	'EXTRA_LDFLAGS' => 'ldflags-y',
3641	};
3642
3643	WARN("DEPRECATED_VARIABLE",
3644	"Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3645	}
3646
3647	# check for DT compatible documentation
3648	if (defined $root &&
3649	(($realfile =~ /\.dtsi?$/ && $line =~ /^\+\scompatible\s=\s*\"/) \|\|
3650	($realfile =~ /\.[ch]$/ && $line =~ /^\+.\.compatible\s=\s*\"/))) {
3651
3652	my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3653
3654	my $dt_path = $root . "/Documentation/devicetree/bindings/";
3655	my $vp_file = $dt_path . "vendor-prefixes.yaml";
3656
3657	foreach my $compat (@compats) {
3658	my $compat2 = $compat;
3659	$compat2 =~ s/\,[a-zA-Z0-9]\-/\,<\.\>\-/;
3660	my $compat3 = $compat;
3661	$compat3 =~ s/\,([a-z])[0-9]\-/\,$1<\.\*>\-/;
3662	`grep -Erq "$compat\|$compat2\|$compat3" $dt_path`;
3663	if ( $? >> 8 ) {
3664	WARN("UNDOCUMENTED_DT_STRING",
3665	"DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3666	}
3667
3668	next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3669	my $vendor = $1;
3670	`grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3671	if ( $? >> 8 ) {
3672	WARN("UNDOCUMENTED_DT_STRING",
3673	"DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3674	}
3675	}
3676	}
3677
3678	# check for using SPDX license tag at beginning of files
3679	if ($realline == $checklicenseline) {
3680	if ($rawline =~ /^[ \+]\s\#\!\s\//) {
3681	$checklicenseline = 2;
3682	} elsif ($rawline =~ /^\+/) {
3683	my $comment = "";
3684	if ($realfile =~ /\.(h\|s\|S)$/) {
3685	$comment = '/*';
3686	} elsif ($realfile =~ /\.(c\|rs\|dts\|dtsi)$/) {
3687	$comment = '//';
3688	} elsif (($checklicenseline == 2) \|\| $realfile =~ /\.(sh\|pl\|py\|awk\|tc\|yaml)$/) {
3689	$comment = '#';
3690	} elsif ($realfile =~ /\.rst$/) {
3691	$comment = '..';
3692	}
3693
3694	# check SPDX comment style for .[chsS] files
3695	if ($realfile =~ /\.[chsS]$/ &&
3696	$rawline =~ /SPDX-License-Identifier:/ &&
3697	$rawline !~ m@^\+\s\Q$comment\E\s@) {
3698	WARN("SPDX_LICENSE_TAG",
3699	"Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3700	}
3701
3702	if ($comment !~ /^$/ &&
3703	$rawline !~ m@^\+\Q$comment\E SPDX-License-Identifier: @) {
3704	WARN("SPDX_LICENSE_TAG",
3705	"Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3706	} elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3707	my $spdx_license = $1;
3708	if (!is_SPDX_License_valid($spdx_license)) {
3709	WARN("SPDX_LICENSE_TAG",
3710	"'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3711	}
3712	if ($realfile =~ m@^Documentation/devicetree/bindings/@ &&
3713	not $spdx_license =~ /GPL-2\.0.*BSD-2-Clause/) {
3714	my $msg_level = \&WARN;
3715	$msg_level = \&CHK if ($file);
3716	if (&{$msg_level}("SPDX_LICENSE_TAG",
3717
3718	"DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3719	$fix) {
3720	$fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3721	}
3722	}
3723	}
3724	}
3725	}
3726
3727	# check for embedded filenames
3728	if ($rawline =~ /^\+.*\Q$realfile\E/) {
3729	WARN("EMBEDDED_FILENAME",
3730	"It's generally not useful to have the filename in the file\n" . $herecurr);
3731	}
3732
3733	# check we are in a valid source file if not then ignore this hunk
3734	next if ($realfile !~ /\.(h\|c\|rs\|s\|S\|sh\|dtsi\|dts)$/);
3735
3736	# check for using SPDX-License-Identifier on the wrong line number
3737	if ($realline != $checklicenseline &&
3738	$rawline =~ /\bSPDX-License-Identifier:/ &&
3739	substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
3740	WARN("SPDX_LICENSE_TAG",
3741	"Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3742	}
3743
3744	# line length limit (with some exclusions)
3745	#
3746	# There are a few types of lines that may extend beyond $max_line_length:
3747	# logging functions like pr_info that end in a string
3748	# lines with a single string
3749	# #defines that are a single string
3750	# lines with an RFC3986 like URL
3751	#
3752	# There are 3 different line length message types:
3753	# LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
3754	# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
3755	# LONG_LINE all other lines longer than $max_line_length
3756	#
3757	# if LONG_LINE is ignored, the other 2 types are also ignored
3758	#
3759
3760	if ($line =~ /^\+/ && $length > $max_line_length) {
3761	my $msg_type = "LONG_LINE";
3762
3763	# Check the allowed long line types first
3764
3765	# logging functions that end in a string that starts
3766	# before $max_line_length
3767	if ($line =~ /^\+\s$logFunctions\s$\s(?:(?:KERN_\S+\s\|[^"]))?($String\s(?:\|,\|$\s;)\s)$/ &&
3768	length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3769	$msg_type = "";
3770
3771	# lines with only strings (w/ possible termination)
3772	# #defines with only strings
3773	} elsif ($line =~ /^\+\s$String\s(?:\s\|,\|\)\s;)\s*$/ \|\|
3774	$line =~ /^\+\s#\sdefine\s+\w+\s+$String$/) {
3775	$msg_type = "";
3776
3777	# More special cases
3778	} elsif ($line =~ /^\+.\bEFI_GUID\s\(/ \|\|
3779	$line =~ /^\+\s(?:\w+)?\sDEFINE_PER_CPU/) {
3780	$msg_type = "";
3781
3782	# URL ($rawline is used in case the URL is in a comment)
3783	} elsif ($rawline =~ /^\+.\b[a-z][\w\.\+\-]:\/\/\S+/i) {
3784	$msg_type = "";
3785
3786	# Otherwise set the alternate message types
3787
3788	# a comment starts before $max_line_length
3789	} elsif ($line =~ /($;[\s$;]*)$/ &&
3790	length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3791	$msg_type = "LONG_LINE_COMMENT"
3792
3793	# a quoted string starts before $max_line_length
3794	} elsif ($sline =~ /\s($String(?:\s(?:\\\|,\s\|\)\s;\s*))?)$/ &&
3795	length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3796	$msg_type = "LONG_LINE_STRING"
3797	}
3798
3799	if ($msg_type ne "" &&
3800	(show_type("LONG_LINE") \|\| show_type($msg_type))) {
3801	my $msg_level = \&WARN;
3802	$msg_level = \&CHK if ($file);
3803	&{$msg_level}($msg_type,
3804	"line length of $length exceeds $max_line_length columns\n" . $herecurr);
3805	}
3806	}
3807
3808	# check for adding lines without a newline.
3809	if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3810	if (WARN("MISSING_EOF_NEWLINE",
3811	"adding a line without newline at end of file\n" . $herecurr) &&
3812	$fix) {
3813	fix_delete_line($fixlinenr+1, "No newline at end of file");
3814	}
3815	}
3816
3817	# check for .L prefix local symbols in .S files
3818	if ($realfile =~ /\.S$/ &&
3819	$line =~ /^\+\s(?:[A-Z]+_)?SYM_[A-Z]+_(?:START\|END)(?:_[A-Z_]+)?\s\(\s*\.L/) {
3820	WARN("AVOID_L_PREFIX",
3821	"Avoid using '.L' prefixed local symbol names for denoting a range of code via 'SYM_*_START/END' annotations; see Documentation/core-api/asm-annotations.rst\n" . $herecurr);
3822	}
3823
3824	# check we are in a valid source file C or perl if not then ignore this hunk
3825	next if ($realfile !~ /\.(h\|c\|pl\|dtsi\|dts)$/);
3826
3827	# at the beginning of a line any tabs must come first and anything
3828	# more than $tabsize must use tabs.
3829	if ($rawline =~ /^\+\s* \t\s*\S/ \|\|
3830	$rawline =~ /^\+\s* \s*/) {
3831	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3832	$rpt_cleaners = 1;
3833	if (ERROR("CODE_INDENT",
3834	"code indent should use tabs where possible\n" . $herevet) &&
3835	$fix) {
3836	$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3837	}
3838	}
3839
3840	# check for space before tabs.
3841	if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3842	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3843	if (WARN("SPACE_BEFORE_TAB",
3844	"please, no space before tabs\n" . $herevet) &&
3845	$fix) {
3846	while ($fixed[$fixlinenr] =~
3847	s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3848	while ($fixed[$fixlinenr] =~
3849	s/(^\+.*) +\t/$1\t/) {}
3850	}
3851	}
3852
3853	# check for assignments on the start of a line
3854	if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3855	my $operator = $1;
3856	if (CHK("ASSIGNMENT_CONTINUATIONS",
3857	"Assignment operator '$1' should be on the previous line\n" . $hereprev) &&
3858	$fix && $prevrawline =~ /^\+/) {
3859	# add assignment operator to the previous line, remove from current line
3860	$fixed[$fixlinenr - 1] .= " $operator";
3861	$fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3862	}
3863	}
3864
3865	# check for && or \|\| at the start of a line
3866	if ($rawline =~ /^\+\s*(&&\|\\|\\|)/) {
3867	my $operator = $1;
3868	if (CHK("LOGICAL_CONTINUATIONS",
3869	"Logical continuations should be on the previous line\n" . $hereprev) &&
3870	$fix && $prevrawline =~ /^\+/) {
3871	# insert logical operator at last non-comment, non-whitepsace char on previous line
3872	$prevline =~ /[\s$;]*$/;
3873	my $line_end = substr($prevrawline, $-[0]);
3874	$fixed[$fixlinenr - 1] =~ s/\Q$line_end\E$/ $operator$line_end/;
3875	$fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3876	}
3877	}
3878
3879	# check indentation starts on a tab stop
3880	if ($perl_version_ok &&
3881	$sline =~ /^\+\t+( +)(?:$c90_Keywords\b\|\{\s$\|\}\s(?:else\b\|while\b\|\s$)\|$Declare\s$Ident\s*[;=])/) {
3882	my $indent = length($1);
3883	if ($indent % $tabsize) {
3884	if (WARN("TABSTOP",
3885	"Statements should start on a tabstop\n" . $herecurr) &&
3886	$fix) {
3887	$fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/$tabsize)@e;
3888	}
3889	}
3890	}
3891
3892	# check multi-line statement indentation matches previous line
3893	if ($perl_version_ok &&
3894	$prevline =~ /^\+([ \t])((?:$c90_Keywords(?:\s+if)\s)\|(?:$Declare\s)?(?:$Ident\|$\s\\s$Ident\s$)\s\|(?:\\s)$Lval\s=\s$Ident\s)\(.(\&\&\|\\|\\|\|,)\s$/) {
3895	$prevline =~ /^\+(\t)(.)$/;
3896	my $oldindent = $1;
3897	my $rest = $2;
3898
3899	my $pos = pos_last_openparen($rest);
3900	if ($pos >= 0) {
3901	$line =~ /^(\+\| )([ \t]*)/;
3902	my $newindent = $2;
3903
3904	my $goodtabindent = $oldindent .
3905	"\t" x ($pos / $tabsize) .
3906	" " x ($pos % $tabsize);
3907	my $goodspaceindent = $oldindent . " " x $pos;
3908
3909	if ($newindent ne $goodtabindent &&
3910	$newindent ne $goodspaceindent) {
3911
3912	if (CHK("PARENTHESIS_ALIGNMENT",
3913	"Alignment should match open parenthesis\n" . $hereprev) &&
3914	$fix && $line =~ /^\+/) {
3915	$fixed[$fixlinenr] =~
3916	s/^\+[ \t]*/\+$goodtabindent/;
3917	}
3918	}
3919	}
3920	}
3921
3922	# check for space after cast like "(int) foo" or "(struct foo) bar"
3923	# avoid checking a few false positives:
3924	# "sizeof(<type>)" or "__alignof__(<type>)"
3925	# function pointer declarations like "(*foo)(int) = bar;"
3926	# structure definitions like "(struct foo) { 0 };"
3927	# multiline macros that define functions
3928	# known attributes or the __attribute__ keyword
3929	if ($line =~ /^\+(.)$\s$Type\s*$([ \t]++)((?![={]\|\\$\|$Attribute\|__attribute__))/ &&
3930	(!defined($1) \|\| $1 !~ /\b(?:sizeof\|__alignof__)\s*$/)) {
3931	if (CHK("SPACING",
3932	"No space is necessary after a cast\n" . $herecurr) &&
3933	$fix) {
3934	$fixed[$fixlinenr] =~
3935	s/($\s$Type\s$)[ \t]+/$1/;
3936	}
3937	}
3938
3939	# Block comment styles
3940	# Networking with an initial /*
3941	if ($realfile =~ m@^(drivers/net/\|net/)@ &&
3942	$prevrawline =~ /^\+[ \t]\/\[ \t]*$/ &&
3943	$rawline =~ /^\+[ \t]\/ &&
3944	$realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
3945	WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3946	"networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3947	}
3948
3949	# Block comments use * on subsequent lines
3950	if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3951	$prevrawline =~ /^\+.?\/\/ && #starting /*
3952	$prevrawline !~ /\\/[ \t]$/ && #no trailing */
3953	$rawline =~ /^\+/ && #line is new
3954	$rawline !~ /^\+[ \t]\/) { #no leading *
3955	WARN("BLOCK_COMMENT_STYLE",
3956	"Block comments use * on subsequent lines\n" . $hereprev);
3957	}
3958
3959	# Block comments use */ on trailing lines
3960	if ($rawline !~ m@^\+[ \t]\/[ \t]$@ && #trailing /
3961	$rawline !~ m@^\+./\.\/[ \t]$@ && #inline /...*/
3962	$rawline !~ m@^\+.\{2,}/[ \t]$@ && #trailing */
3963	$rawline =~ m@^\+[ \t].+\\/[ \t]$@) { #non blank /
3964	WARN("BLOCK_COMMENT_STYLE",
3965	"Block comments use a trailing */ on a separate line\n" . $herecurr);
3966	}
3967
3968	# Block comment * alignment
3969	if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3970	$line =~ /^\+[ \t]*$;/ && #leading comment
3971	$rawline =~ /^\+[ \t]\/ && #leading *
3972	(($prevrawline =~ /^\+.?\/\/ && #leading /*
3973	$prevrawline !~ /\\/[ \t]$/) \|\| #no trailing */
3974	$prevrawline =~ /^\+[ \t]\/)) { #leading *
3975	my $oldindent;
3976	$prevrawline =~ m@^\+([ \t]/?)\@;
3977	if (defined($1)) {
3978	$oldindent = expand_tabs($1);
3979	} else {
3980	$prevrawline =~ m@^\+(./?)\@;
3981	$oldindent = expand_tabs($1);
3982	}
3983	$rawline =~ m@^\+([ \t])\@;
3984	my $newindent = $1;
3985	$newindent = expand_tabs($newindent);
3986	if (length($oldindent) ne length($newindent)) {
3987	WARN("BLOCK_COMMENT_STYLE",
3988	"Block comments should align the * on each line\n" . $hereprev);
3989	}
3990	}
3991
3992	# check for missing blank lines after struct/union declarations
3993	# with exceptions for various attributes and macros
3994	if ($prevline =~ /^[\+ ]};?\s*$/ &&
3995	$line =~ /^\+/ &&
3996	!($line =~ /^\+\s*$/ \|\|
3997	$line =~ /^\+\s*(?:EXPORT_SYMBOL\|early_param)/ \|\|
3998	$line =~ /^\+\s*MODULE_/i \|\|
3999	$line =~ /^\+\s\#\s(?:end\|elif\|else)/ \|\|
4000	$line =~ /^\+[a-z_]*init/ \|\|
4001	$line =~ /^\+\s(?:static\s+)?[A-Z_]ATTR/ \|\|
4002	$line =~ /^\+\s*DECLARE/ \|\|
4003	$line =~ /^\+\sbuiltin_[\w_]driver/ \|\|
4004	$line =~ /^\+\s*__setup/)) {
4005	if (CHK("LINE_SPACING",
4006	"Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
4007	$fix) {
4008	fix_insert_line($fixlinenr, "\+");
4009	}
4010	}
4011
4012	# check for multiple consecutive blank lines
4013	if ($prevline =~ /^[\+ ]\s*$/ &&
4014	$line =~ /^\+\s*$/ &&
4015	$last_blank_line != ($linenr - 1)) {
4016	if (CHK("LINE_SPACING",
4017	"Please don't use multiple blank lines\n" . $hereprev) &&
4018	$fix) {
4019	fix_delete_line($fixlinenr, $rawline);
4020	}
4021
4022	$last_blank_line = $linenr;
4023	}
4024
4025	# check for missing blank lines after declarations
4026	# (declarations must have the same indentation and not be at the start of line)
4027	if (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/) {
4028	# use temporaries
4029	my $sl = $sline;
4030	my $pl = $prevline;
4031	# remove $Attribute/$Sparse uses to simplify comparisons
4032	$sl =~ s/\b(?:$Attribute\|$Sparse)\b//g;
4033	$pl =~ s/\b(?:$Attribute\|$Sparse)\b//g;
4034	if (($pl =~ /^\+\s+$Declare\s$Ident\s[=,;:\[]/ \|\|
4035	# function pointer declarations
4036	$pl =~ /^\+\s+$Declare\s$\s\\s$Ident\s$\s[=,;:\[\(]/ \|\|
4037	# foo bar; where foo is some local typedef or #define
4038	$pl =~ /^\+\s+$Ident(?:\s+\|\s\\s)$Ident\s[=,;\[]/ \|\|
4039	# known declaration macros
4040	$pl =~ /^\+\s+$declaration_macros/) &&
4041	# for "else if" which can look like "$Ident $Ident"
4042	!($pl =~ /^\+\s+$c90_Keywords\b/ \|\|
4043	# other possible extensions of declaration lines
4044	$pl =~ /(?:$Compare\|$Assignment\|$Operators)\s*$/ \|\|
4045	# not starting a section or a macro "\" extended line
4046	$pl =~ /(?:\{\s*\|\\)$/) &&
4047	# looks like a declaration
4048	!($sl =~ /^\+\s+$Declare\s$Ident\s[=,;:\[]/ \|\|
4049	# function pointer declarations
4050	$sl =~ /^\+\s+$Declare\s$\s\\s$Ident\s$\s[=,;:\[\(]/ \|\|
4051	# foo bar; where foo is some local typedef or #define
4052	$sl =~ /^\+\s+$Ident(?:\s+\|\s\\s)$Ident\s[=,;\[]/ \|\|
4053	# known declaration macros
4054	$sl =~ /^\+\s+$declaration_macros/ \|\|
4055	# start of struct or union or enum
4056	$sl =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union\|struct\|enum\|typedef)\b/ \|\|
4057	# start or end of block or continuation of declaration
4058	$sl =~ /^\+\s+(?:$\|[\{\}\.\#\"\?\:\(\[])/ \|\|
4059	# bitfield continuation
4060	$sl =~ /^\+\s+$Ident\s:\s\d+\s*[,;]/ \|\|
4061	# other possible extensions of declaration lines
4062	$sl =~ /^\+\s+\(?\s*(?:$Compare\|$Assignment\|$Operators)/)) {
4063	if (WARN("LINE_SPACING",
4064	"Missing a blank line after declarations\n" . $hereprev) &&
4065	$fix) {
4066	fix_insert_line($fixlinenr, "\+");
4067	}
4068	}
4069	}
4070
4071	# check for spaces at the beginning of a line.
4072	# Exceptions:
4073	# 1) within comments
4074	# 2) indented preprocessor commands
4075	# 3) hanging labels
4076	if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;\|#\|$Ident:)/) {
4077	my $herevet = "$here\n" . cat_vet($rawline) . "\n";
4078	if (WARN("LEADING_SPACE",
4079	"please, no spaces at the start of a line\n" . $herevet) &&
4080	$fix) {
4081	$fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
4082	}
4083	}
4084
4085	# check we are in a valid C source file if not then ignore this hunk
4086	next if ($realfile !~ /\.(h\|c)$/);
4087
4088	# check for unusual line ending [ or (
4089	if ($line =~ /^\+.([\[\(])\s$/) {
4090	CHK("OPEN_ENDED_LINE",
4091	"Lines should not end with a '$1'\n" . $herecurr);
4092	}
4093
4094	# check if this appears to be the start function declaration, save the name
4095	if ($sline =~ /^\+\{\s*$/ &&
4096	$prevline =~ /^\+(?:(?:(?:$Storage\|$Inline)\s)\s$Type\s)?($Ident)\(/) {
4097	$context_function = $1;
4098	}
4099
4100	# check if this appears to be the end of function declaration
4101	if ($sline =~ /^\+\}\s*$/) {
4102	undef $context_function;
4103	}
4104
4105	# check indentation of any line with a bare else
4106	# (but not if it is a multiple line "if (foo) return bar; else return baz;")
4107	# if the previous line is a break or return and is indented 1 tab more...
4108	if ($sline =~ /^\+([\t]+)(?:}[ \t])?else(?:[ \t]{)?\s*$/) {
4109	my $tabs = length($1) + 1;
4110	if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ \|\|
4111	($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
4112	defined $lines[$linenr] &&
4113	$lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
4114	WARN("UNNECESSARY_ELSE",
4115	"else is not generally useful after a break or return\n" . $hereprev);
4116	}
4117	}
4118
4119	# check indentation of a line with a break;
4120	# if the previous line is a goto, return or break
4121	# and is indented the same # of tabs
4122	if ($sline =~ /^\+([\t]+)break\s;\s$/) {
4123	my $tabs = $1;
4124	if ($prevline =~ /^\+$tabs(goto\|return\|break)\b/) {
4125	if (WARN("UNNECESSARY_BREAK",
4126	"break is not useful after a $1\n" . $hereprev) &&
4127	$fix) {
4128	fix_delete_line($fixlinenr, $rawline);
4129	}
4130	}
4131	}
4132
4133	# check for RCS/CVS revision markers
4134	if ($rawline =~ /^\+.*\$(Revision\|Log\|Id)(?:\$\|)/) {
4135	WARN("CVS_KEYWORD",
4136	"CVS style keyword markers, these will _not_ be updated\n". $herecurr);
4137	}
4138
4139	# check for old HOTPLUG __dev<foo> section markings
4140	if ($line =~ /\b(__dev(init\|exit)(data\|const\|))\b/) {
4141	WARN("HOTPLUG_SECTION",
4142	"Using $1 is unnecessary\n" . $herecurr);
4143	}
4144
4145	# Check for potential 'bare' types
4146	my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
4147	$realline_next);
4148	#print "LINE<$line>\n";
4149	if ($linenr > $suppress_statement &&
4150	$realcnt && $sline =~ /.\s*\S/) {
4151	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4152	ctx_statement_block($linenr, $realcnt, 0);
4153	$stat =~ s/\n./\n /g;
4154	$cond =~ s/\n./\n /g;
4155
4156	#print "linenr<$linenr> <$stat>\n";
4157	# If this statement has no statement boundaries within
4158	# it there is no point in retrying a statement scan
4159	# until we hit end of it.
4160	my $frag = $stat; $frag =~ s/;+\s*$//;
4161	if ($frag !~ /(?:{\|;)/) {
4162	#print "skip<$line_nr_next>\n";
4163	$suppress_statement = $line_nr_next;
4164	}
4165
4166	# Find the real next line.
4167	$realline_next = $line_nr_next;
4168	if (defined $realline_next &&
4169	(!defined $lines[$realline_next - 1] \|\|
4170	substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
4171	$realline_next++;
4172	}
4173
4174	my $s = $stat;
4175	$s =~ s/{.*$//s;
4176
4177	# Ignore goto labels.
4178	if ($s =~ /$Ident:\*$/s) {
4179
4180	# Ignore functions being called
4181	} elsif ($s =~ /^.\s$Ident\s\(/s) {
4182
4183	} elsif ($s =~ /^.\s*else\b/s) {
4184
4185	# declarations always start with types
4186	} 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) {
4187	my $type = $1;
4188	$type =~ s/\s+/ /g;
4189	possible($type, "A:" . $s);
4190
4191	# definitions in global scope can only start with types
4192	} elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
4193	possible($1, "B:" . $s);
4194	}
4195
4196	# any (foo ... *) is a pointer cast, and foo is a type
4197	while ($s =~ /$($Ident)(?:\s+$Sparse)[\s\]+\s*$/sg) {
4198	possible($1, "C:" . $s);
4199	}
4200
4201	# Check for any sort of function declaration.
4202	# int foo(something bar, other baz);
4203	# void (store_gdt)(x86_descr_ptr );
4204	if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s)?(?:(?:$Storage\|$Inline)\s)\s$Type\s(?:\b$Ident\|$\\s$Ident$)\s)\(/s) {
4205	my ($name_len) = length($1);
4206
4207	my $ctx = $s;
4208	substr($ctx, 0, $name_len + 1, '');
4209	$ctx =~ s/\)[^\)]*$//;
4210
4211	for my $arg (split(/\s,\s/, $ctx)) {
4212	if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)\s\*\s(:?\b$Ident)?$/s \|\| $arg =~ /^($Ident)$/s) {
4213
4214	possible($1, "D:" . $s);
4215	}
4216	}
4217	}
4218
4219	}
4220
4221	#
4222	# Checks which may be anchored in the context.
4223	#
4224
4225	# Check for switch () and associated case and default
4226	# statements should be at the same indent.
4227	if ($line=~/\bswitch\s$.$/) {
4228	my $err = '';
4229	my $sep = '';
4230	my @ctx = ctx_block_outer($linenr, $realcnt);
4231	shift(@ctx);
4232	for my $ctx (@ctx) {
4233	my ($clen, $cindent) = line_stats($ctx);
4234	if ($ctx =~ /^\+\s*(case\s+\|default:)/ &&
4235	$indent != $cindent) {
4236	$err .= "$sep$ctx\n";
4237	$sep = '';
4238	} else {
4239	$sep = "[...]\n";
4240	}
4241	}
4242	if ($err ne '') {
4243	ERROR("SWITCH_CASE_INDENT_LEVEL",
4244	"switch and case should be at the same indent\n$hereline$err");
4245	}
4246	}
4247
4248	# if/while/etc brace do not go on next line, unless defining a do while loop,
4249	# or if that brace on the next line is for something else
4250	if ($line =~ /(.)\b((?:if\|while\|for\|switch\|(?:[a-z_]+\|)for_each[a-z_]+)\s\(\|do\b\|else\b)/ && $line !~ /^.\s*\#/) {
4251	my $pre_ctx = "$1$2";
4252
4253	my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
4254
4255	if ($line =~ /^\+\t{6,}/) {
4256	WARN("DEEP_INDENTATION",
4257	"Too many leading tabs - consider code refactoring\n" . $herecurr);
4258	}
4259
4260	my $ctx_cnt = $realcnt - $#ctx - 1;
4261	my $ctx = join("\n", @ctx);
4262
4263	my $ctx_ln = $linenr;
4264	my $ctx_skip = $realcnt;
4265
4266	while ($ctx_skip > $ctx_cnt \|\| ($ctx_skip == $ctx_cnt &&
4267	defined $lines[$ctx_ln - 1] &&
4268	$lines[$ctx_ln - 1] =~ /^-/)) {
4269	##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4270	$ctx_skip-- if (!defined $lines[$ctx_ln - 1] \|\| $lines[$ctx_ln - 1] !~ /^-/);
4271	$ctx_ln++;
4272	}
4273
4274	#print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4275	#print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4276
4277	if ($ctx !~ /{\s/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s{/) {
4278	ERROR("OPEN_BRACE",
4279	"that open brace { should be on the previous line\n" .
4280	"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4281	}
4282	if ($level == 0 && $pre_ctx !~ /}\swhile\s\($/ &&
4283	$ctx =~ /\)\s\;\s$/ &&
4284	defined $lines[$ctx_ln - 1])
4285	{
4286	my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
4287	if ($nindent > $indent) {
4288	WARN("TRAILING_SEMICOLON",
4289	"trailing semicolon indicates no statements, indent implies otherwise\n" .
4290	"$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4291	}
4292	}
4293	}
4294
4295	# Check relative indent for conditionals and blocks.
4296	if ($line =~ /\b(?:(?:if\|while\|for\|(?:[a-z_]+\|)for_each[a-z_]+)\s\(\|(?:do\|else)\b)/ && $line !~ /^.\s#/ && $line !~ /\}\swhile\s/) {
4297	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4298	ctx_statement_block($linenr, $realcnt, 0)
4299	if (!defined $stat);
4300	my ($s, $c) = ($stat, $cond);
4301
4302	substr($s, 0, length($c), '');
4303
4304	# remove inline comments
4305	$s =~ s/$;/ /g;
4306	$c =~ s/$;/ /g;
4307
4308	# Find out how long the conditional actually is.
4309	my @newlines = ($c =~ /\n/gs);
4310	my $cond_lines = 1 + $#newlines;
4311
4312	# Make sure we remove the line prefixes as we have
4313	# none on the first line, and are going to readd them
4314	# where necessary.
4315	$s =~ s/\n./\n/gs;
4316	while ($s =~ /\n\s+\\\n/) {
4317	$cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4318	}
4319
4320	# We want to check the first line inside the block
4321	# starting at the end of the conditional, so remove:
4322	# 1) any blank line termination
4323	# 2) any opening brace { on end of the line
4324	# 3) any do (...) {
4325	my $continuation = 0;
4326	my $check = 0;
4327	$s =~ s/^.*\bdo\b//;
4328	$s =~ s/^\s*{//;
4329	if ($s =~ s/^\s*\\//) {
4330	$continuation = 1;
4331	}
4332	if ($s =~ s/^\s*?\n//) {
4333	$check = 1;
4334	$cond_lines++;
4335	}
4336
4337	# Also ignore a loop construct at the end of a
4338	# preprocessor statement.
4339	if (($prevline =~ /^.\s#\sdefine\s/ \|\|
4340	$prevline =~ /\\\s*$/) && $continuation == 0) {
4341	$check = 0;
4342	}
4343
4344	my $cond_ptr = -1;
4345	$continuation = 0;
4346	while ($cond_ptr != $cond_lines) {
4347	$cond_ptr = $cond_lines;
4348
4349	# If we see an #else/#elif then the code
4350	# is not linear.
4351	if ($s =~ /^\s\#\s(?:else\|elif)/) {
4352	$check = 0;
4353	}
4354
4355	# Ignore:
4356	# 1) blank lines, they should be at 0,
4357	# 2) preprocessor lines, and
4358	# 3) labels.
4359	if ($continuation \|\|
4360	$s =~ /^\s*?\n/ \|\|
4361	$s =~ /^\s#\s?/ \|\|
4362	$s =~ /^\s$Ident\s:/) {
4363	$continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
4364	if ($s =~ s/^.*?\n//) {
4365	$cond_lines++;
4366	}
4367	}
4368	}
4369
4370	my (undef, $sindent) = line_stats("+" . $s);
4371	my $stat_real = raw_line($linenr, $cond_lines);
4372
4373	# Check if either of these lines are modified, else
4374	# this is not this patch's fault.
4375	if (!defined($stat_real) \|\|
4376	$stat !~ /^\+/ && $stat_real !~ /^\+/) {
4377	$check = 0;
4378	}
4379	if (defined($stat_real) && $cond_lines > 1) {
4380	$stat_real = "[...]\n$stat_real";
4381	}
4382
4383	#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";
4384
4385	if ($check && $s ne '' &&
4386	(($sindent % $tabsize) != 0 \|\|
4387	($sindent < $indent) \|\|
4388	($sindent == $indent &&
4389	($s !~ /^\s*(?:\}\|\{\|else\b)/)) \|\|
4390	($sindent > $indent + $tabsize))) {
4391	WARN("SUSPECT_CODE_INDENT",
4392	"suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4393	}
4394	}
4395
4396	# Track the 'values' across context and added lines.
4397	my $opline = $line; $opline =~ s/^./ /;
4398	my ($curr_values, $curr_vars) =
4399	annotate_values($opline . "\n", $prev_values);
4400	$curr_values = $prev_values . $curr_values;
4401	if ($dbg_values) {
4402	my $outline = $opline; $outline =~ s/\t/ /g;
4403	print "$linenr > .$outline\n";
4404	print "$linenr > $curr_values\n";
4405	print "$linenr > $curr_vars\n";
4406	}
4407	$prev_values = substr($curr_values, -1);
4408
4409	#ignore lines not being added
4410	next if ($line =~ /^[^\+]/);
4411
4412	# check for self assignments used to avoid compiler warnings
4413	# e.g.: int foo = foo, *bar = NULL;
4414	# struct foo bar = *(&(bar));
4415	if ($line =~ /^\+\s(?:$Declare)?([A-Za-z_][A-Za-z\d_])\s*=/) {
4416	my $var = $1;
4417	if ($line =~ /^\+\s(?:$Declare)?$var\s=\s(?:$var\|\\s$?\s&\s\(?\s$var\s$?\s\)?)\s*[;,]/) {
4418	WARN("SELF_ASSIGNMENT",
4419	"Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4420	}
4421	}
4422
4423	# check for dereferences that span multiple lines
4424	if ($prevline =~ /^\+.$Lval\s(?:\.\|->)\s*$/ &&
4425	$line =~ /^\+\s(?!\#\s(?!define\s+\|if))\s*$Lval/) {
4426	$prevline =~ /($Lval\s(?:\.\|->))\s$/;
4427	my $ref = $1;
4428	$line =~ /^.\s*($Lval)/;
4429	$ref .= $1;
4430	$ref =~ s/\s//g;
4431	WARN("MULTILINE_DEREFERENCE",
4432	"Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4433	}
4434
4435	# check for declarations of signed or unsigned without int
4436	while ($line =~ m{\b($Declare)\s(?!char\b\|short\b\|int\b\|long\b)\s($Ident)?\s*[=,;\[\)\(]}g) {
4437	my $type = $1;
4438	my $var = $2;
4439	$var = "" if (!defined $var);
4440	if ($type =~ /^(?:(?:$Storage\|$Inline\|$Attribute)\s+)((?:un)?signed)((?:\s\))\s*$/) {
4441	my $sign = $1;
4442	my $pointer = $2;
4443
4444	$pointer = "" if (!defined $pointer);
4445
4446	if (WARN("UNSPECIFIED_INT",
4447	"Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
4448	$fix) {
4449	my $decl = trim($sign) . " int ";
4450	my $comp_pointer = $pointer;
4451	$comp_pointer =~ s/\s//g;
4452	$decl .= $comp_pointer;
4453	$decl = rtrim($decl) if ($var eq "");
4454	$fixed[$fixlinenr] =~ s@\b$sign\s\Q$pointer\E\s$var\b@$decl$var@;
4455	}
4456	}
4457	}
4458
4459	# TEST: allow direct testing of the type matcher.
4460	if ($dbg_type) {
4461	if ($line =~ /^.\s$Declare\s$/) {
4462	ERROR("TEST_TYPE",
4463	"TEST: is type\n" . $herecurr);
4464	} elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4465	ERROR("TEST_NOT_TYPE",
4466	"TEST: is not type ($1 is)\n". $herecurr);
4467	}
4468	next;
4469	}
4470	# TEST: allow direct testing of the attribute matcher.
4471	if ($dbg_attr) {
4472	if ($line =~ /^.\s$Modifier\s$/) {
4473	ERROR("TEST_ATTR",
4474	"TEST: is attr\n" . $herecurr);
4475	} elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4476	ERROR("TEST_NOT_ATTR",
4477	"TEST: is not attr ($1 is)\n". $herecurr);
4478	}
4479	next;
4480	}
4481
4482	# check for initialisation to aggregates open brace on the next line
4483	if ($line =~ /^.\s*{/ &&
4484	$prevline =~ /(?:^\|[^=])=\s*$/) {
4485	if (ERROR("OPEN_BRACE",
4486	"that open brace { should be on the previous line\n" . $hereprev) &&
4487	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4488	fix_delete_line($fixlinenr - 1, $prevrawline);
4489	fix_delete_line($fixlinenr, $rawline);
4490	my $fixedline = $prevrawline;
4491	$fixedline =~ s/\s=\s$/ = {/;
4492	fix_insert_line($fixlinenr, $fixedline);
4493	$fixedline = $line;
4494	$fixedline =~ s/^(.\s)\{\s/$1/;
4495	fix_insert_line($fixlinenr, $fixedline);
4496	}
4497	}
4498
4499	#
4500	# Checks which are anchored on the added line.
4501	#
4502
4503	# check for malformed paths in #include statements (uses RAW line)
4504	if ($rawline =~ m{^.\s\#\sinclude\s+[<"](.*)[">]}) {
4505	my $path = $1;
4506	if ($path =~ m{//}) {
4507	ERROR("MALFORMED_INCLUDE",
4508	"malformed #include filename\n" . $herecurr);
4509	}
4510	if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
4511	ERROR("UAPI_INCLUDE",
4512	"No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4513	}
4514	}
4515
4516	# no C99 // comments
4517	if ($line =~ m{//}) {
4518	if (ERROR("C99_COMMENTS",
4519	"do not use C99 // comments\n" . $herecurr) &&
4520	$fix) {
4521	my $line = $fixed[$fixlinenr];
4522	if ($line =~ /\/\/(.*)$/) {
4523	my $comment = trim($1);
4524	$fixed[$fixlinenr] =~ s@\/\/(.)$@/\ $comment \*/@;
4525	}
4526	}
4527	}
4528	# Remove C99 comments.
4529	$line =~ s@//.*@@;
4530	$opline =~ s@//.*@@;
4531
4532	# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4533	# the whole statement.
4534	#print "APW <$lines[$realline_next - 1]>\n";
4535	if (defined $realline_next &&
4536	exists $lines[$realline_next - 1] &&
4537	!defined $suppress_export{$realline_next} &&
4538	($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.$(.)$/)) {
4539	# Handle definitions which produce identifiers with
4540	# a prefix:
4541	# XXX(foo);
4542	# EXPORT_SYMBOL(something_foo);
4543	my $name = $1;
4544	$name =~ s/^\s($Ident)./$1/;
4545	if ($stat =~ /^(?:.\s}\s\n)?.([A-Z_]+)\s\(\s($Ident)/ &&
4546	$name =~ /^${Ident}_$2/) {
4547	#print "FOO C name<$name>\n";
4548	$suppress_export{$realline_next} = 1;
4549
4550	} elsif ($stat !~ /(?:
4551	\n.}\s*$\|
4552	^.DEFINE_$Ident$\Q$name\E$\|
4553	^.DECLARE_$Ident$\Q$name\E$\|
4554	^.LIST_HEAD$\Q$name\E$\|
4555	^.(?:$Storage\s+)?$Type\s$\s\\s\Q$name\E\s$\s\(\|
4556	\b\Q$name\E(?:\s+$Attribute)\s(?:;\|=\|\[\|\()
4557	)/x) {
4558	#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4559	$suppress_export{$realline_next} = 2;
4560	} else {
4561	$suppress_export{$realline_next} = 1;
4562	}
4563	}
4564	if (!defined $suppress_export{$linenr} &&
4565	$prevline =~ /^.\s*$/ &&
4566	($line =~ /EXPORT_SYMBOL.$(.)$/)) {
4567	#print "FOO B <$lines[$linenr - 1]>\n";
4568	$suppress_export{$linenr} = 2;
4569	}
4570	if (defined $suppress_export{$linenr} &&
4571	$suppress_export{$linenr} == 2) {
4572	WARN("EXPORT_SYMBOL",
4573	"EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4574	}
4575
4576	# check for global initialisers.
4577	if ($line =~ /^\+$Type\s$Ident(?:\s+$Modifier)\s=\s($zero_initializer)\s*;/ &&
4578	!exclude_global_initialisers($realfile)) {
4579	if (ERROR("GLOBAL_INITIALISERS",
4580	"do not initialise globals to $1\n" . $herecurr) &&
4581	$fix) {
4582	$fixed[$fixlinenr] =~ s/(^.$Type\s$Ident(?:\s+$Modifier))\s=\s$zero_initializer\s*;/$1;/;
4583	}
4584	}
4585	# check for static initialisers.
4586	if ($line =~ /^\+.\bstatic\s.=\s($zero_initializer)\s;/) {
4587	if (ERROR("INITIALISED_STATIC",
4588	"do not initialise statics to $1\n" .
4589	$herecurr) &&
4590	$fix) {
4591	$fixed[$fixlinenr] =~ s/(\bstatic\s.?)\s=\s$zero_initializer\s;/$1;/;
4592	}
4593	}
4594
4595	# check for misordered declarations of char/short/int/long with signed/unsigned
4596	while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4597	my $tmp = trim($1);
4598	WARN("MISORDERED_TYPE",
4599	"type '$tmp' should be specified in [[un]signed] [short\|int\|long\|long long] order\n" . $herecurr);
4600	}
4601
4602	# check for unnecessary <signed> int declarations of short/long/long long
4603	while ($sline =~ m{\b($TypeMisordered(\s\)*\|$C90_int_types)\b}g) {
4604	my $type = trim($1);
4605	next if ($type !~ /\bint\b/);
4606	next if ($type !~ /\b(?:short\|long\s+long\|long)\b/);
4607	my $new_type = $type;
4608	$new_type =~ s/\b\sint\s\b/ /;
4609	$new_type =~ s/\b\s(?:un)?signed\b\s/ /;
4610	$new_type =~ s/^const\s+//;
4611	$new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4612	$new_type = "const $new_type" if ($type =~ /^const\b/);
4613	$new_type =~ s/\s+/ /g;
4614	$new_type = trim($new_type);
4615	if (WARN("UNNECESSARY_INT",
4616	"Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4617	$fix) {
4618	$fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4619	}
4620	}
4621
4622	# check for static const char * arrays.
4623	if ($line =~ /\bstatic\s+const\s+char\s\\s(\w+)\s\[\s\]\s=\s*/) {
4624	WARN("STATIC_CONST_CHAR_ARRAY",
4625	"static const char * array should probably be static const char * const\n" .
4626	$herecurr);
4627	}
4628
4629	# check for initialized const char arrays that should be static const
4630	if ($line =~ /^\+\sconst\s+(char\|unsigned\s+char\|_u8\|(?:[us]_)?int8_t)\s+\w+\s\[\s(?:\w+\s)?\]\s=\s*"/) {
4631	if (WARN("STATIC_CONST_CHAR_ARRAY",
4632	"const array should probably be static const\n" . $herecurr) &&
4633	$fix) {
4634	$fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4635	}
4636	}
4637
4638	# check for static char foo[] = "bar" declarations.
4639	if ($line =~ /\bstatic\s+char\s+(\w+)\s\[\s\]\s=\s"/) {
4640	WARN("STATIC_CONST_CHAR_ARRAY",
4641	"static char array declaration should probably be static const char\n" .
4642	$herecurr);
4643	}
4644
4645	# check for const <foo> const where <foo> is not a pointer or array type
4646	if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4647	my $found = $1;
4648	if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s\/) {
4649	WARN("CONST_CONST",
4650	"'const $found const ' should probably be 'const $found const'\n" . $herecurr);
4651	} elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4652	WARN("CONST_CONST",
4653	"'const $found const' should probably be 'const $found'\n" . $herecurr);
4654	}
4655	}
4656
4657	# check for const static or static <non ptr type> const declarations
4658	# prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4659	if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ \|\|
4660	$sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4661	if (WARN("STATIC_CONST",
4662	"Move const after static - use 'static const $1'\n" . $herecurr) &&
4663	$fix) {
4664	$fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4665	$fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4666	}
4667	}
4668
4669	# check for non-global char *foo[] = {"bar", ...} declarations.
4670	if ($line =~ /^.\s+(?:static\s+\|const\s+)?char\s+\\s\w+\s\[\s\]\s=\s\{/) {
4671	WARN("STATIC_CONST_CHAR_ARRAY",
4672	"char * array declaration might be better as static const\n" .
4673	$herecurr);
4674	}
4675
4676	# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4677	if ($line =~ m@\bsizeof\s$\s($Lval)\s*$@) {
4678	my $array = $1;
4679	if ($line =~ m@\b(sizeof\s$\s\Q$array\E\s$\s/\ssizeof\s$\s\Q$array\E\s\[\s0\s\]\s*$)@) {
4680	my $array_div = $1;
4681	if (WARN("ARRAY_SIZE",
4682	"Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4683	$fix) {
4684	$fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4685	}
4686	}
4687	}
4688
4689	# check for function declarations without arguments like "int foo()"
4690	if ($line =~ /(\b$Type\s$Ident)\s$\s*$/) {
4691	if (ERROR("FUNCTION_WITHOUT_ARGS",
4692	"Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4693	$fix) {
4694	$fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s$\s$/$2 $3(void)/;
4695	}
4696	}
4697
4698	# check for new typedefs, only function parameters and sparse annotations
4699	# make sense.
4700	if ($line =~ /\btypedef\s/ &&
4701	$line !~ /\btypedef\s+$Type\s$\s\?$Ident\s$\s*\(/ &&
4702	$line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4703	$line !~ /\b$typeTypedefs\b/ &&
4704	$line !~ /\b__bitwise\b/) {
4705	WARN("NEW_TYPEDEFS",
4706	"do not add new typedefs\n" . $herecurr);
4707	}
4708
4709	# * goes on variable not on type
4710	# (char*[ const])
4711	while ($line =~ m{($$NonptrType(\s(?:$Modifier\b\s\|\\s)+)$)}g) {
4712	#print "AA<$1>\n";
4713	my ($ident, $from, $to) = ($1, $2, $2);
4714
4715	# Should start with a space.
4716	$to =~ s/^(\S)/ $1/;
4717	# Should not end with a space.
4718	$to =~ s/\s+$//;
4719	# '*'s should not have spaces between.
4720	while ($to =~ s/\\s+\/\\/) {
4721	}
4722
4723	## print "1: from<$from> to<$to> ident<$ident>\n";
4724	if ($from ne $to) {
4725	if (ERROR("POINTER_LOCATION",
4726	"\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4727	$fix) {
4728	my $sub_from = $ident;
4729	my $sub_to = $ident;
4730	$sub_to =~ s/\Q$from\E/$to/;
4731	$fixed[$fixlinenr] =~
4732	s@\Q$sub_from\E@$sub_to@;
4733	}
4734	}
4735	}
4736	while ($line =~ m{(\b$NonptrType(\s(?:$Modifier\b\s\|\\s)+)($Ident))}g) {
4737	#print "BB<$1>\n";
4738	my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4739
4740	# Should start with a space.
4741	$to =~ s/^(\S)/ $1/;
4742	# Should not end with a space.
4743	$to =~ s/\s+$//;
4744	# '*'s should not have spaces between.
4745	while ($to =~ s/\\s+\/\\/) {
4746	}
4747	# Modifiers should have spaces.
4748	$to =~ s/(\b$Modifier$)/$1 /;
4749
4750	## print "2: from<$from> to<$to> ident<$ident>\n";
4751	if ($from ne $to && $ident !~ /^$Modifier$/) {
4752	if (ERROR("POINTER_LOCATION",
4753	"\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4754	$fix) {
4755
4756	my $sub_from = $match;
4757	my $sub_to = $match;
4758	$sub_to =~ s/\Q$from\E/$to/;
4759	$fixed[$fixlinenr] =~
4760	s@\Q$sub_from\E@$sub_to@;
4761	}
4762	}
4763	}
4764
4765	# do not use BUG() or variants
4766	if ($line =~ /\b(?!AA_\|BUILD_\|DCCP_\|IDA_\|KVM_\|RWLOCK_\|snd_\|SPIN_)(?:[a-zA-Z_]_)?BUG(?:_ON)?(?:_[A-Z_]+)?\s\(/) {
4767	my $msg_level = \&WARN;
4768	$msg_level = \&CHK if ($file);
4769	&{$msg_level}("AVOID_BUG",
4770	"Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants\n" . $herecurr);
4771	}
4772
4773	# avoid LINUX_VERSION_CODE
4774	if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4775	WARN("LINUX_VERSION_CODE",
4776	"LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4777	}
4778
4779	# check for uses of printk_ratelimit
4780	if ($line =~ /\bprintk_ratelimit\s*\(/) {
4781	WARN("PRINTK_RATELIMITED",
4782	"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4783	}
4784
4785	# printk should use KERN_* levels
4786	if ($line =~ /\bprintk\s\(\s(?!KERN_[A-Z]+\b)/) {
4787	WARN("PRINTK_WITHOUT_KERN_LEVEL",
4788	"printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4789	}
4790
4791	# prefer variants of (subsystem\|netdev\|dev\|pr)_<level> to printk(KERN_<LEVEL>
4792	if ($line =~ /\b(printk(_once\|_ratelimited)?)\s\(\sKERN_([A-Z]+)/) {
4793	my $printk = $1;
4794	my $modifier = $2;
4795	my $orig = $3;
4796	$modifier = "" if (!defined($modifier));
4797	my $level = lc($orig);
4798	$level = "warn" if ($level eq "warning");
4799	my $level2 = $level;
4800	$level2 = "dbg" if ($level eq "debug");
4801	$level .= $modifier;
4802	$level2 .= $modifier;
4803	WARN("PREFER_PR_LEVEL",
4804	"Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to $printk(KERN_$orig ...\n" . $herecurr);
4805	}
4806
4807	# prefer dev_<level> to dev_printk(KERN_<LEVEL>
4808	if ($line =~ /\bdev_printk\s\(\sKERN_([A-Z]+)/) {
4809	my $orig = $1;
4810	my $level = lc($orig);
4811	$level = "warn" if ($level eq "warning");
4812	$level = "dbg" if ($level eq "debug");
4813	WARN("PREFER_DEV_LEVEL",
4814	"Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4815	}
4816
4817	# trace_printk should not be used in production code.
4818	if ($line =~ /\b(trace_printk\|trace_puts\|ftrace_vprintk)\s*\(/) {
4819	WARN("TRACE_PRINTK",
4820	"Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4821	}
4822
4823	# ENOSYS means "bad syscall nr" and nothing else. This will have a small
4824	# number of false positives, but assembly files are not checked, so at
4825	# least the arch entry code will not trigger this warning.
4826	if ($line =~ /\bENOSYS\b/) {
4827	WARN("ENOSYS",
4828	"ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4829	}
4830
4831	# ENOTSUPP is not a standard error code and should be avoided in new patches.
4832	# Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4833	# Similarly to ENOSYS warning a small number of false positives is expected.
4834	if (!$file && $line =~ /\bENOTSUPP\b/) {
4835	if (WARN("ENOTSUPP",
4836	"ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4837	$fix) {
4838	$fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4839	}
4840	}
4841
4842	# function brace can't be on same line, except for #defines of do while,
4843	# or if closed on same line
4844	if ($perl_version_ok &&
4845	$sline =~ /$Type\s$Ident\s$balanced_parens\s*\{/ &&
4846	$sline !~ /\#\sdefine\b.do\s*\{/ &&
4847	$sline !~ /}/) {
4848	if (ERROR("OPEN_BRACE",
4849	"open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4850	$fix) {
4851	fix_delete_line($fixlinenr, $rawline);
4852	my $fixed_line = $rawline;
4853	$fixed_line =~ /(^..$Type\s$Ident$.$\s)\{(.*)$/;
4854	my $line1 = $1;
4855	my $line2 = $2;
4856	fix_insert_line($fixlinenr, ltrim($line1));
4857	fix_insert_line($fixlinenr, "\+{");
4858	if ($line2 !~ /^\s*$/) {
4859	fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4860	}
4861	}
4862	}
4863
4864	# open braces for enum, union and struct go on the same line.
4865	if ($line =~ /^.\s*{/ &&
4866	$prevline =~ /^.\s(?:typedef\s+)?(enum\|union\|struct)(?:\s+$Ident)?\s$/) {
4867	if (ERROR("OPEN_BRACE",
4868	"open brace '{' following $1 go on the same line\n" . $hereprev) &&
4869	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4870	fix_delete_line($fixlinenr - 1, $prevrawline);
4871	fix_delete_line($fixlinenr, $rawline);
4872	my $fixedline = rtrim($prevrawline) . " {";
4873	fix_insert_line($fixlinenr, $fixedline);
4874	$fixedline = $rawline;
4875	$fixedline =~ s/^(.\s)\{\s/$1\t/;
4876	if ($fixedline !~ /^\+\s*$/) {
4877	fix_insert_line($fixlinenr, $fixedline);
4878	}
4879	}
4880	}
4881
4882	# missing space after union, struct or enum definition
4883	if ($line =~ /^.\s*(?:typedef\s+)?(enum\|union\|struct)(?:\s+$Ident){1,2}[=\{]/) {
4884	if (WARN("SPACING",
4885	"missing space after $1 definition\n" . $herecurr) &&
4886	$fix) {
4887	$fixed[$fixlinenr] =~
4888	s/^(.\s*(?:typedef\s+)?(?:enum\|union\|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4889	}
4890	}
4891
4892	# Function pointer declarations
4893	# check spacing between type, funcptr, and args
4894	# canonical declaration is "type (*funcptr)(args...)"
4895	if ($line =~ /^.\s($Declare)$(\s)\(\s)($Ident)(\s)$(\s)\(/) {
4896	my $declare = $1;
4897	my $pre_pointer_space = $2;
4898	my $post_pointer_space = $3;
4899	my $funcname = $4;
4900	my $post_funcname_space = $5;
4901	my $pre_args_space = $6;
4902
4903	# the $Declare variable will capture all spaces after the type
4904	# so check it for a missing trailing missing space but pointer return types
4905	# don't need a space so don't warn for those.
4906	my $post_declare_space = "";
4907	if ($declare =~ /(\s+)$/) {
4908	$post_declare_space = $1;
4909	$declare = rtrim($declare);
4910	}
4911	if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4912	WARN("SPACING",
4913	"missing space after return type\n" . $herecurr);
4914	$post_declare_space = " ";
4915	}
4916
4917	# unnecessary space "type (*funcptr)(args...)"
4918	# This test is not currently implemented because these declarations are
4919	# equivalent to
4920	# int foo(int bar, ...)
4921	# and this is form shouldn't/doesn't generate a checkpatch warning.
4922	#
4923	# elsif ($declare =~ /\s{2,}$/) {
4924	# WARN("SPACING",
4925	# "Multiple spaces after return type\n" . $herecurr);
4926	# }
4927
4928	# unnecessary space "type ( *funcptr)(args...)"
4929	if (defined $pre_pointer_space &&
4930	$pre_pointer_space =~ /^\s/) {
4931	WARN("SPACING",
4932	"Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4933	}
4934
4935	# unnecessary space "type (* funcptr)(args...)"
4936	if (defined $post_pointer_space &&
4937	$post_pointer_space =~ /^\s/) {
4938	WARN("SPACING",
4939	"Unnecessary space before function pointer name\n" . $herecurr);
4940	}
4941
4942	# unnecessary space "type (*funcptr )(args...)"
4943	if (defined $post_funcname_space &&
4944	$post_funcname_space =~ /^\s/) {
4945	WARN("SPACING",
4946	"Unnecessary space after function pointer name\n" . $herecurr);
4947	}
4948
4949	# unnecessary space "type (*funcptr) (args...)"
4950	if (defined $pre_args_space &&
4951	$pre_args_space =~ /^\s/) {
4952	WARN("SPACING",
4953	"Unnecessary space before function pointer arguments\n" . $herecurr);
4954	}
4955
4956	if (show_type("SPACING") && $fix) {
4957	$fixed[$fixlinenr] =~
4958	s/^(.\s)$Declare\s$\s\\s$Ident\s$\s\(/$1 . $declare . $post_declare_space . '(' . $funcname . ')('/ex;
4959	}
4960	}
4961
4962	# check for spacing round square brackets; allowed:
4963	# 1. with a type on the left -- int [] a;
4964	# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4965	# 3. inside a curly brace -- = { [0...10] = 5 }
4966	while ($line =~ /(.*?\s)\[/g) {
4967	my ($where, $prefix) = ($-[1], $1);
4968	if ($prefix !~ /$Type\s+$/ &&
4969	($where != 0 \|\| $prefix !~ /^.\s+$/) &&
4970	$prefix !~ /[{,:]\s+$/) {
4971	if (ERROR("BRACKET_SPACE",
4972	"space prohibited before open square bracket '['\n" . $herecurr) &&
4973	$fix) {
4974	$fixed[$fixlinenr] =~
4975	s/^(\+.*?)\s+\[/$1\[/;
4976	}
4977	}
4978	}
4979
4980	# check for spaces between functions and their parentheses.
4981	while ($line =~ /($Ident)\s+\(/g) {
4982	my $name = $1;
4983	my $ctx_before = substr($line, 0, $-[1]);
4984	my $ctx = "$ctx_before$name";
4985
4986	# Ignore those directives where spaces _are_ permitted.
4987	if ($name =~ /^(?:
4988	if\|for\|while\|switch\|return\|case\|
4989	volatile\|__volatile__\|
4990	__attribute__\|format\|__extension__\|
4991	asm\|__asm__)$/x)
4992	{
4993	# cpp #define statements have non-optional spaces, ie
4994	# if there is a space between the name and the open
4995	# parenthesis it is simply not a parameter group.
4996	} elsif ($ctx_before =~ /^.\s\#\sdefine\s*$/) {
4997
4998	# cpp #elif statement condition may start with a (
4999	} elsif ($ctx =~ /^.\s\#\selif\s*$/) {
5000
5001	# If this whole things ends with a type its most
5002	# likely a typedef for a function.
5003	} elsif ($ctx =~ /$Type$/) {
5004
5005	} else {
5006	if (WARN("SPACING",
5007	"space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
5008	$fix) {
5009	$fixed[$fixlinenr] =~
5010	s/\b$name\s+\(/$name\(/;
5011	}
5012	}
5013	}
5014
5015	# Check operator spacing.
5016	if (!($line=~/\#\s*include/)) {
5017	my $fixed_line = "";
5018	my $line_fixed = 0;
5019
5020	my $ops = qr{
5021	<<=\|>>=\|<=\|>=\|==\|!=\|
5022	\+=\|-=\|\*=\|\/=\|%=\|\^=\|\\|=\|&=\|
5023	=>\|->\|<<\|>>\|<\|>\|=\|!\|~\|
5024	&&\|\\|\\|\|,\|\^\|\+\+\|--\|&\|\\|\|\+\|-\|\*\|\/\|%\|
5025	\?:\|\?\|:
5026	}x;
5027	my @elements = split(/($ops\|;)/, $opline);
5028
5029	## print("element count: <" . $#elements . ">\n");
5030	## foreach my $el (@elements) {
5031	## print("el: <$el>\n");
5032	## }
5033
5034	my @fix_elements = ();
5035	my $off = 0;
5036
5037	foreach my $el (@elements) {
5038	push(@fix_elements, substr($rawline, $off, length($el)));
5039	$off += length($el);
5040	}
5041
5042	$off = 0;
5043
5044	my $blank = copy_spacing($opline);
5045	my $last_after = -1;
5046
5047	for (my $n = 0; $n < $#elements; $n += 2) {
5048
5049	my $good = $fix_elements[$n] . $fix_elements[$n + 1];
5050
5051	## print("n: <$n> good: <$good>\n");
5052
5053	$off += length($elements[$n]);
5054
5055	# Pick up the preceding and succeeding characters.
5056	my $ca = substr($opline, 0, $off);
5057	my $cc = '';
5058	if (length($opline) >= ($off + length($elements[$n + 1]))) {
5059	$cc = substr($opline, $off + length($elements[$n + 1]));
5060	}
5061	my $cb = "$ca$;$cc";
5062
5063	my $a = '';
5064	$a = 'V' if ($elements[$n] ne '');
5065	$a = 'W' if ($elements[$n] =~ /\s$/);
5066	$a = 'C' if ($elements[$n] =~ /$;$/);
5067	$a = 'B' if ($elements[$n] =~ /(\[\|\()$/);
5068	$a = 'O' if ($elements[$n] eq '');
5069	$a = 'E' if ($ca =~ /^\s*$/);
5070
5071	my $op = $elements[$n + 1];
5072
5073	my $c = '';
5074	if (defined $elements[$n + 2]) {
5075	$c = 'V' if ($elements[$n + 2] ne '');
5076	$c = 'W' if ($elements[$n + 2] =~ /^\s/);
5077	$c = 'C' if ($elements[$n + 2] =~ /^$;/);
5078	$c = 'B' if ($elements[$n + 2] =~ /^(\)\|\]\|;)/);
5079	$c = 'O' if ($elements[$n + 2] eq '');
5080	$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
5081	} else {
5082	$c = 'E';
5083	}
5084
5085	my $ctx = "${a}x${c}";
5086
5087	my $at = "(ctx:$ctx)";
5088
5089	my $ptr = substr($blank, 0, $off) . "^";
5090	my $hereptr = "$hereline$ptr\n";
5091
5092	# Pull out the value of this operator.
5093	my $op_type = substr($curr_values, $off + 1, 1);
5094
5095	# Get the full operator variant.
5096	my $opv = $op . substr($curr_vars, $off, 1);
5097
5098	# Ignore operators passed as parameters.
5099	if ($op_type ne 'V' &&
5100	$ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
5101
5102	# # Ignore comments
5103	# } elsif ($op =~ /^$;+$/) {
5104
5105	# ; should have either the end of line or a space or \ after it
5106	} elsif ($op eq ';') {
5107	if ($ctx !~ /.x[WEBC]/ &&
5108	$cc !~ /^\\/ && $cc !~ /^;/) {
5109	if (ERROR("SPACING",
5110	"space required after that '$op' $at\n" . $hereptr)) {
5111	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5112	$line_fixed = 1;
5113	}
5114	}
5115
5116	# // is a comment
5117	} elsif ($op eq '//') {
5118
5119	# : when part of a bitfield
5120	} elsif ($opv eq ':B') {
5121	# skip the bitfield test for now
5122
5123	# No spaces for:
5124	# ->
5125	} elsif ($op eq '->') {
5126	if ($ctx =~ /Wx.\|.xW/) {
5127	if (ERROR("SPACING",
5128	"spaces prohibited around that '$op' $at\n" . $hereptr)) {
5129	$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5130	if (defined $fix_elements[$n + 2]) {
5131	$fix_elements[$n + 2] =~ s/^\s+//;
5132	}
5133	$line_fixed = 1;
5134	}
5135	}
5136
5137	# , must not have a space before and must have a space on the right.
5138	} elsif ($op eq ',') {
5139	my $rtrim_before = 0;
5140	my $space_after = 0;
5141	if ($ctx =~ /Wx./) {
5142	if (ERROR("SPACING",
5143	"space prohibited before that '$op' $at\n" . $hereptr)) {
5144	$line_fixed = 1;
5145	$rtrim_before = 1;
5146	}
5147	}
5148	if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
5149	if (ERROR("SPACING",
5150	"space required after that '$op' $at\n" . $hereptr)) {
5151	$line_fixed = 1;
5152	$last_after = $n;
5153	$space_after = 1;
5154	}
5155	}
5156	if ($rtrim_before \|\| $space_after) {
5157	if ($rtrim_before) {
5158	$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5159	} else {
5160	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5161	}
5162	if ($space_after) {
5163	$good .= " ";
5164	}
5165	}
5166
5167	# '*' as part of a type definition -- reported already.
5168	} elsif ($opv eq '*_') {
5169	#warn "'*' is part of type\n";
5170
5171	# unary operators should have a space before and
5172	# none after. May be left adjacent to another
5173	# unary operator, or a cast
5174	} elsif ($op eq '!' \|\| $op eq '~' \|\|
5175	$opv eq '*U' \|\| $opv eq '-U' \|\|
5176	$opv eq '&U' \|\| $opv eq '&&U') {
5177	if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)\|!\|~\|\*\|-\|\&\|\\|\|\+\+\|\-\-\|\{)$/) {
5178	if (ERROR("SPACING",
5179	"space required before that '$op' $at\n" . $hereptr)) {
5180	if ($n != $last_after + 2) {
5181	$good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
5182	$line_fixed = 1;
5183	}
5184	}
5185	}
5186	if ($op eq '' && $cc =~/\s$Modifier\b/) {
5187	# A unary '*' may be const
5188
5189	} elsif ($ctx =~ /.xW/) {
5190	if (ERROR("SPACING",
5191	"space prohibited after that '$op' $at\n" . $hereptr)) {
5192	$good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
5193	if (defined $fix_elements[$n + 2]) {
5194	$fix_elements[$n + 2] =~ s/^\s+//;
5195	}
5196	$line_fixed = 1;
5197	}
5198	}
5199
5200	# unary ++ and unary -- are allowed no space on one side.
5201	} elsif ($op eq '++' or $op eq '--') {
5202	if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
5203	if (ERROR("SPACING",
5204	"space required one side of that '$op' $at\n" . $hereptr)) {
5205	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5206	$line_fixed = 1;
5207	}
5208	}
5209	if ($ctx =~ /Wx[BE]/ \|\|
5210	($ctx =~ /Wx./ && $cc =~ /^;/)) {
5211	if (ERROR("SPACING",
5212	"space prohibited before that '$op' $at\n" . $hereptr)) {
5213	$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5214	$line_fixed = 1;
5215	}
5216	}
5217	if ($ctx =~ /ExW/) {
5218	if (ERROR("SPACING",
5219	"space prohibited after that '$op' $at\n" . $hereptr)) {
5220	$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5221	if (defined $fix_elements[$n + 2]) {
5222	$fix_elements[$n + 2] =~ s/^\s+//;
5223	}
5224	$line_fixed = 1;
5225	}
5226	}
5227
5228	# << and >> may either have or not have spaces both sides
5229	} elsif ($op eq '<<' or $op eq '>>' or
5230	$op eq '&' or $op eq '^' or $op eq '\|' or
5231	$op eq '+' or $op eq '-' or
5232	$op eq '*' or $op eq '/' or
5233	$op eq '%')
5234	{
5235	if ($check) {
5236	if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
5237	if (CHK("SPACING",
5238	"spaces preferred around that '$op' $at\n" . $hereptr)) {
5239	$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5240	$fix_elements[$n + 2] =~ s/^\s+//;
5241	$line_fixed = 1;
5242	}
5243	} elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
5244	if (CHK("SPACING",
5245	"space preferred before that '$op' $at\n" . $hereptr)) {
5246	$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
5247	$line_fixed = 1;
5248	}
5249	}
5250	} elsif ($ctx =~ /Wx[^WCE]\|[^WCE]xW/) {
5251	if (ERROR("SPACING",
5252	"need consistent spacing around '$op' $at\n" . $hereptr)) {
5253	$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5254	if (defined $fix_elements[$n + 2]) {
5255	$fix_elements[$n + 2] =~ s/^\s+//;
5256	}
5257	$line_fixed = 1;
5258	}
5259	}
5260
5261	# A colon needs no spaces before when it is
5262	# terminating a case value or a label.
5263	} elsif ($opv eq ':C' \|\| $opv eq ':L') {
5264	if ($ctx =~ /Wx./ and $realfile !~ m@.*\.lds\.h$@) {
5265	if (ERROR("SPACING",
5266	"space prohibited before that '$op' $at\n" . $hereptr)) {
5267	$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5268	$line_fixed = 1;
5269	}
5270	}
5271
5272	# All the others need spaces both sides.
5273	} elsif ($ctx !~ /[EWC]x[CWE]/) {
5274	my $ok = 0;
5275
5276	# Ignore email addresses <foo@bar>
5277	if (($op eq '<' &&
5278	$cc =~ /^\S+\@\S+>/) \|\|
5279	($op eq '>' &&
5280	$ca =~ /<\S+\@\S+$/))
5281	{
5282	$ok = 1;
5283	}
5284
5285	# for asm volatile statements
5286	# ignore a colon with another
5287	# colon immediately before or after
5288	if (($op eq ':') &&
5289	($ca =~ /:$/ \|\| $cc =~ /^:/)) {
5290	$ok = 1;
5291	}
5292
5293	# messages are ERROR, but ?: are CHK
5294	if ($ok == 0) {
5295	my $msg_level = \&ERROR;
5296	$msg_level = \&CHK if (($op eq '?:' \|\| $op eq '?' \|\| $op eq ':') && $ctx =~ /VxV/);
5297
5298	if (&{$msg_level}("SPACING",
5299	"spaces required around that '$op' $at\n" . $hereptr)) {
5300	$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5301	if (defined $fix_elements[$n + 2]) {
5302	$fix_elements[$n + 2] =~ s/^\s+//;
5303	}
5304	$line_fixed = 1;
5305	}
5306	}
5307	}
5308	$off += length($elements[$n + 1]);
5309
5310	## print("n: <$n> GOOD: <$good>\n");
5311
5312	$fixed_line = $fixed_line . $good;
5313	}
5314
5315	if (($#elements % 2) == 0) {
5316	$fixed_line = $fixed_line . $fix_elements[$#elements];
5317	}
5318
5319	if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5320	$fixed[$fixlinenr] = $fixed_line;
5321	}
5322
5323
5324	}
5325
5326	# check for whitespace before a non-naked semicolon
5327	if ($line =~ /^\+.\S\s+;\s$/) {
5328	if (WARN("SPACING",
5329	"space prohibited before semicolon\n" . $herecurr) &&
5330	$fix) {
5331	1 while $fixed[$fixlinenr] =~
5332	s/^(\+.*\S)\s+;/$1;/;
5333	}
5334	}
5335
5336	# check for multiple assignments
5337	if ($line =~ /^.\s$Lval\s=\s$Lval\s=(?!=)/) {
5338	CHK("MULTIPLE_ASSIGNMENTS",
5339	"multiple assignments should be avoided\n" . $herecurr);
5340	}
5341
5342	## # check for multiple declarations, allowing for a function declaration
5343	## # continuation.
5344	## if ($line =~ /^.\s$Type\s+$Ident(?:\s=[^,{])?\s,\s$Ident./ &&
5345	## $line !~ /^.\s$Type\s+$Ident(?:\s=[^,{])?\s,\s$Type\s$Ident.*/) {
5346	##
5347	## # Remove any bracketed sections to ensure we do not
5348	## # falsely report the parameters of functions.
5349	## my $ln = $line;
5350	## while ($ln =~ s/$[^\($]*\)//g) {
5351	## }
5352	## if ($ln =~ /,/) {
5353	## WARN("MULTIPLE_DECLARATION",
5354	## "declaring multiple variables together should be avoided\n" . $herecurr);
5355	## }
5356	## }
5357
5358	#need space before brace following if, while, etc
5359	if (($line =~ /$.*$\{/ && $line !~ /$$Type$\{/) \|\|
5360	$line =~ /\b(?:else\|do)\{/) {
5361	if (ERROR("SPACING",
5362	"space required before the open brace '{'\n" . $herecurr) &&
5363	$fix) {
5364	$fixed[$fixlinenr] =~ s/^(\+.*(?:do\|else\|\)))\{/$1 {/;
5365	}
5366	}
5367
5368	## # check for blank lines before declarations
5369	## if ($line =~ /^.\t+$Type\s+$Ident(?:\s=.)?;/ &&
5370	## $prevrawline =~ /^.\s*$/) {
5371	## WARN("SPACING",
5372	## "No blank lines before declarations\n" . $hereprev);
5373	## }
5374	##
5375
5376	# closing brace should have a space following it when it has anything
5377	# on the line
5378	if ($line =~ /}(?!(?:,\|;\|\)\|\}))\S/) {
5379	if (ERROR("SPACING",
5380	"space required after that close brace '}'\n" . $herecurr) &&
5381	$fix) {
5382	$fixed[$fixlinenr] =~
5383	s/}((?!(?:,\|;\|\)))\S)/} $1/;
5384	}
5385	}
5386
5387	# check spacing on square brackets
5388	if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5389	if (ERROR("SPACING",
5390	"space prohibited after that open square bracket '['\n" . $herecurr) &&
5391	$fix) {
5392	$fixed[$fixlinenr] =~
5393	s/\[\s+/\[/;
5394	}
5395	}
5396	if ($line =~ /\s\]/) {
5397	if (ERROR("SPACING",
5398	"space prohibited before that close square bracket ']'\n" . $herecurr) &&
5399	$fix) {
5400	$fixed[$fixlinenr] =~
5401	s/\s+\]/\]/;
5402	}
5403	}
5404
5405	# check spacing on parentheses
5406	if ($line =~ /$\s/ && $line !~ /\(\s*(?:\$?$/ &&
5407	$line !~ /for\s*\(\s+;/) {
5408	if (ERROR("SPACING",
5409	"space prohibited after that open parenthesis '('\n" . $herecurr) &&
5410	$fix) {
5411	$fixed[$fixlinenr] =~
5412	s/\(\s+/\(/;
5413	}
5414	}
5415	if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5416	$line !~ /for\s$.;\s+$/ &&
5417	$line !~ /:\s+\)/) {
5418	if (ERROR("SPACING",
5419	"space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5420	$fix) {
5421	$fixed[$fixlinenr] =~
5422	s/\s+\)/\)/;
5423	}
5424	}
5425
5426	# check unnecessary parentheses around addressof/dereference single $Lvals
5427	# ie: &(foo->bar) should be &foo->bar and (foo->bar) should be foo->bar
5428
5429	while ($line =~ /(?:[^&]&\s\|\)$\s($Ident\s(?:$Member\s)+)\s$/g) {
5430	my $var = $1;
5431	if (CHK("UNNECESSARY_PARENTHESES",
5432	"Unnecessary parentheses around $var\n" . $herecurr) &&
5433	$fix) {
5434	$fixed[$fixlinenr] =~ s/$\s\Q$var\E\s$/$var/;
5435	}
5436	}
5437
5438	# check for unnecessary parentheses around function pointer uses
5439	# ie: (foo->bar)(); should be foo->bar();
5440	# but not "if (foo->bar) (" to avoid some false positives
5441	if ($line =~ /(\bif\s\|)($\s$Ident\s(?:$Member\s)+$)[ \t]*\(/ && $1 !~ /^if/) {
5442	my $var = $2;
5443	if (CHK("UNNECESSARY_PARENTHESES",
5444	"Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5445	$fix) {
5446	my $var2 = deparenthesize($var);
5447	$var2 =~ s/\s//g;
5448	$fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5449	}
5450	}
5451
5452	# check for unnecessary parentheses around comparisons in if uses
5453	# when !drivers/staging or command-line uses --strict
5454	if (($realfile !~ m@^(?:drivers/staging/)@ \|\| $check_orig) &&
5455	$perl_version_ok && defined($stat) &&
5456	$stat =~ /(^.\sif\s($balanced_parens))/) {
5457	my $if_stat = $1;
5458	my $test = substr($2, 1, -1);
5459	my $herectx;
5460	while ($test =~ /(?:^\|[^\w\&\!\~])+\s$\s([\&\!\~]?\s$Lval\s(?:$Compare\s$FuncArg)?)\s$/g) {
5461	my $match = $1;
5462	# avoid parentheses around potential macro args
5463	next if ($match =~ /^\s\w+\s$/);
5464	if (!defined($herectx)) {
5465	$herectx = $here . "\n";
5466	my $cnt = statement_rawlines($if_stat);
5467	for (my $n = 0; $n < $cnt; $n++) {
5468	my $rl = raw_line($linenr, $n);
5469	$herectx .= $rl . "\n";
5470	last if $rl =~ /^[ \+].*\{/;
5471	}
5472	}
5473	CHK("UNNECESSARY_PARENTHESES",
5474	"Unnecessary parentheses around '$match'\n" . $herectx);
5475	}
5476	}
5477
5478	# check that goto labels aren't indented (allow a single space indentation)
5479	# and ignore bitfield definitions like foo:1
5480	# Strictly, labels can have whitespace after the identifier and before the :
5481	# but this is not allowed here as many ?: uses would appear to be labels
5482	if ($sline =~ /^.\s+[A-Za-z_][A-Za-z\d_]:(?!\s\d+)/ &&
5483	$sline !~ /^. [A-Za-z\d_][A-Za-z\d_]*:/ &&
5484	$sline !~ /^.\s+default:/) {
5485	if (WARN("INDENTED_LABEL",
5486	"labels should not be indented\n" . $herecurr) &&
5487	$fix) {
5488	$fixed[$fixlinenr] =~
5489	s/^(.)\s+/$1/;
5490	}
5491	}
5492
5493	# check if a statement with a comma should be two statements like:
5494	# foo = bar(), /* comma should be semicolon */
5495	# bar = baz();
5496	if (defined($stat) &&
5497	$stat =~ /^\+\s(?:$Lval\s$Assignment\s)?$FuncArg\s,\s(?:$Lval\s$Assignment\s)?$FuncArg\s;\s*$/) {
5498	my $cnt = statement_rawlines($stat);
5499	my $herectx = get_stat_here($linenr, $cnt, $here);
5500	WARN("SUSPECT_COMMA_SEMICOLON",
5501	"Possible comma where semicolon could be used\n" . $herectx);
5502	}
5503
5504	# return is not a function
5505	if (defined($stat) && $stat =~ /^.\sreturn(\s)\(/s) {
5506	my $spacing = $1;
5507	if ($perl_version_ok &&
5508	$stat =~ /^.\sreturn\s($balanced_parens)\s;\s$/) {
5509	my $value = $1;
5510	$value = deparenthesize($value);
5511	if ($value =~ m/^\s$FuncArg\s(?:\?\|$)/) {
5512	ERROR("RETURN_PARENTHESES",
5513	"return is not a function, parentheses are not required\n" . $herecurr);
5514	}
5515	} elsif ($spacing !~ /\s+/) {
5516	ERROR("SPACING",
5517	"space required before the open parenthesis '('\n" . $herecurr);
5518	}
5519	}
5520
5521	# unnecessary return in a void function
5522	# at end-of-function, with the previous line a single leading tab, then return;
5523	# and the line before that not a goto label target like "out:"
5524	if ($sline =~ /^[ \+]}\s*$/ &&
5525	$prevline =~ /^\+\treturn\s;\s$/ &&
5526	$linenr >= 3 &&
5527	$lines[$linenr - 3] =~ /^[ +]/ &&
5528	$lines[$linenr - 3] !~ /^[ +]\s$Ident\s:/) {
5529	WARN("RETURN_VOID",
5530	"void function return statements are not generally useful\n" . $hereprev);
5531	}
5532
5533	# if statements using unnecessary parentheses - ie: if ((foo == bar))
5534	if ($perl_version_ok &&
5535	$line =~ /\bif\s((?:\(\s){2,})/) {
5536	my $openparens = $1;
5537	my $count = $openparens =~ tr@\(@\(@;
5538	my $msg = "";
5539	if ($line =~ /\bif\s(?:$\s){$count,$count}$LvalOrFunc\s($Compare)\s$LvalOrFunc(?:\s*$){$count,$count}/) {
5540	my $comp = $4; #Not $1 because of $LvalOrFunc
5541	$msg = " - maybe == should be = ?" if ($comp eq "==");
5542	WARN("UNNECESSARY_PARENTHESES",
5543	"Unnecessary parentheses$msg\n" . $herecurr);
5544	}
5545	}
5546
5547	# comparisons with a constant or upper case identifier on the left
5548	# avoid cases like "foo + BAR < baz"
5549	# only fix matches surrounded by parentheses to avoid incorrect
5550	# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5551	if ($perl_version_ok &&
5552	$line =~ /^\+(.)\b($Constant\|[A-Z_][A-Z0-9_])\s($Compare)\s($LvalOrFunc)/) {
5553	my $lead = $1;
5554	my $const = $2;
5555	my $comp = $3;
5556	my $to = $4;
5557	my $newcomp = $comp;
5558	if ($lead !~ /(?:$Operators\|\.)\s*$/ &&
5559	$to !~ /^(?:Constant\|[A-Z_][A-Z0-9_]*)$/ &&
5560	WARN("CONSTANT_COMPARISON",
5561	"Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5562	$fix) {
5563	if ($comp eq "<") {
5564	$newcomp = ">";
5565	} elsif ($comp eq "<=") {
5566	$newcomp = ">=";
5567	} elsif ($comp eq ">") {
5568	$newcomp = "<";
5569	} elsif ($comp eq ">=") {
5570	$newcomp = "<=";
5571	}
5572	$fixed[$fixlinenr] =~ s/$\s\Q$const\E\s$Compare\s\Q$to\E\s$/($to $newcomp $const)/;
5573	}
5574	}
5575
5576	# Return of what appears to be an errno should normally be negative
5577	if ($sline =~ /\breturn(?:\s$+\s\|\s+)(E[A-Z]+)(?:\s$+\s\|\s*)[;:,]/) {
5578	my $name = $1;
5579	if ($name ne 'EOF' && $name ne 'ERROR' && $name !~ /^EPOLL/) {
5580	WARN("USE_NEGATIVE_ERRNO",
5581	"return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5582	}
5583	}
5584
5585	# Need a space before open parenthesis after if, while etc
5586	if ($line =~ /\b(if\|while\|for\|switch)\(/) {
5587	if (ERROR("SPACING",
5588	"space required before the open parenthesis '('\n" . $herecurr) &&
5589	$fix) {
5590	$fixed[$fixlinenr] =~
5591	s/\b(if\|while\|for\|switch)\(/$1 \(/;
5592	}
5593	}
5594
5595	# Check for illegal assignment in if conditional -- and check for trailing
5596	# statements after the conditional.
5597	if ($line =~ /do\s*(?!{)/) {
5598	($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5599	ctx_statement_block($linenr, $realcnt, 0)
5600	if (!defined $stat);
5601	my ($stat_next) = ctx_statement_block($line_nr_next,
5602	$remain_next, $off_next);
5603	$stat_next =~ s/\n./\n /g;
5604	##print "stat<$stat> stat_next<$stat_next>\n";
5605
5606	if ($stat_next =~ /^\s*while\b/) {
5607	# If the statement carries leading newlines,
5608	# then count those as offsets.
5609	my ($whitespace) =
5610	($stat_next =~ /^((?:\s\n[+-])\s*)/s);
5611	my $offset =
5612	statement_rawlines($whitespace) - 1;
5613
5614	$suppress_whiletrailers{$line_nr_next +
5615	$offset} = 1;
5616	}
5617	}
5618	if (!defined $suppress_whiletrailers{$linenr} &&
5619	defined($stat) && defined($cond) &&
5620	$line =~ /\b(?:if\|while\|for)\s\(/ && $line !~ /^.\s#/) {
5621	my ($s, $c) = ($stat, $cond);
5622	my $fixed_assign_in_if = 0;
5623
5624	if ($c =~ /\bif\s\(.[^<>!=]=[^=].*/s) {
5625	if (ERROR("ASSIGN_IN_IF",
5626	"do not use assignment in if condition\n" . $herecurr) &&
5627	$fix && $perl_version_ok) {
5628	if ($rawline =~ /^\+(\s+)if\s$\s(\!)?\s\(\s(($Lval)\s=\s$LvalOrFunc)\s$\s(?:($Compare)\s($FuncArg))?\s\)\s(\{)?\s$/) {
5629	my $space = $1;
5630	my $not = $2;
5631	my $statement = $3;
5632	my $assigned = $4;
5633	my $test = $8;
5634	my $against = $9;
5635	my $brace = $15;
5636	fix_delete_line($fixlinenr, $rawline);
5637	fix_insert_line($fixlinenr, "$space$statement;");
5638	my $newline = "${space}if (";
5639	$newline .= '!' if defined($not);
5640	$newline .= '(' if (defined $not && defined($test) && defined($against));
5641	$newline .= "$assigned";
5642	$newline .= " $test $against" if (defined($test) && defined($against));
5643	$newline .= ')' if (defined $not && defined($test) && defined($against));
5644	$newline .= ')';
5645	$newline .= " {" if (defined($brace));
5646	fix_insert_line($fixlinenr + 1, $newline);
5647	$fixed_assign_in_if = 1;
5648	}
5649	}
5650	}
5651
5652	# Find out what is on the end of the line after the
5653	# conditional.
5654	substr($s, 0, length($c), '');
5655	$s =~ s/\n.*//g;
5656	$s =~ s/$;//g; # Remove any comments
5657	if (length($c) && $s !~ /^\s{?\s\\\s$/ &&
5658	$c !~ /}\swhile\s/)
5659	{
5660	# Find out how long the conditional actually is.
5661	my @newlines = ($c =~ /\n/gs);
5662	my $cond_lines = 1 + $#newlines;
5663	my $stat_real = '';
5664
5665	$stat_real = raw_line($linenr, $cond_lines)
5666	. "\n" if ($cond_lines);
5667	if (defined($stat_real) && $cond_lines > 1) {
5668	$stat_real = "[...]\n$stat_real";
5669	}
5670
5671	if (ERROR("TRAILING_STATEMENTS",
5672	"trailing statements should be on next line\n" . $herecurr . $stat_real) &&
5673	!$fixed_assign_in_if &&
5674	$cond_lines == 0 &&
5675	$fix && $perl_version_ok &&
5676	$fixed[$fixlinenr] =~ /^\+(\s)((?:if\|while\|for)\s$balanced_parens)\s(.)$/) {
5677	my $indent = $1;
5678	my $test = $2;
5679	my $rest = rtrim($4);
5680	if ($rest =~ /;$/) {
5681	$fixed[$fixlinenr] = "\+$indent$test";
5682	fix_insert_line($fixlinenr + 1, "$indent\t$rest");
5683	}
5684	}
5685	}
5686	}
5687
5688	# Check for bitwise tests written as boolean
5689	if ($line =~ /
5690	(?:
5691	(?:\[\|\(\|\&\&\|\\|\\|)
5692	\s0[xX][0-9]+\s
5693	(?:\&\&\|\\|\\|)
5694	\|
5695	(?:\&\&\|\\|\\|)
5696	\s0[xX][0-9]+\s
5697	(?:\&\&\|\\|\\|\|\)\|\])
5698	)/x)
5699	{
5700	WARN("HEXADECIMAL_BOOLEAN_TEST",
5701	"boolean test with hexadecimal, perhaps just 1 \& or \\|?\n" . $herecurr);
5702	}
5703
5704	# if and else should not have general statements after it
5705	if ($line =~ /^.\s(?:}\s)?else\b(.*)/) {
5706	my $s = $1;
5707	$s =~ s/$;//g; # Remove any comments
5708	if ($s !~ /^\s(?:\sif\|(?:{\|)\s\\?\s*$)/) {
5709	ERROR("TRAILING_STATEMENTS",
5710	"trailing statements should be on next line\n" . $herecurr);
5711	}
5712	}
5713	# if should not continue a brace
5714	if ($line =~ /}\s*if\b/) {
5715	ERROR("TRAILING_STATEMENTS",
5716	"trailing statements should be on next line (or did you mean 'else if'?)\n" .
5717	$herecurr);
5718	}
5719	# case and default should not have general statements after them
5720	if ($line =~ /^.\s(?:case\s.\|default\s):/g &&
5721	$line !~ /\G(?:
5722	(?:\s$;)(?:\s{)?(?:\s$;)(?:\s\\)?\s*$\|
5723	\s*return\s+
5724	)/xg)
5725	{
5726	ERROR("TRAILING_STATEMENTS",
5727	"trailing statements should be on next line\n" . $herecurr);
5728	}
5729
5730	# Check for }<nl>else {, these must be at the same
5731	# indent level to be relevant to each other.
5732	if ($prevline=~/}\s$/ and $line=~/^.\selse\s*/ &&
5733	$previndent == $indent) {
5734	if (ERROR("ELSE_AFTER_BRACE",
5735	"else should follow close brace '}'\n" . $hereprev) &&
5736	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5737	fix_delete_line($fixlinenr - 1, $prevrawline);
5738	fix_delete_line($fixlinenr, $rawline);
5739	my $fixedline = $prevrawline;
5740	$fixedline =~ s/}\s*$//;
5741	if ($fixedline !~ /^\+\s*$/) {
5742	fix_insert_line($fixlinenr, $fixedline);
5743	}
5744	$fixedline = $rawline;
5745	$fixedline =~ s/^(.\s*)else/$1} else/;
5746	fix_insert_line($fixlinenr, $fixedline);
5747	}
5748	}
5749
5750	if ($prevline=~/}\s$/ and $line=~/^.\swhile\s*/ &&
5751	$previndent == $indent) {
5752	my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5753
5754	# Find out what is on the end of the line after the
5755	# conditional.
5756	substr($s, 0, length($c), '');
5757	$s =~ s/\n.*//g;
5758
5759	if ($s =~ /^\s*;/) {
5760	if (ERROR("WHILE_AFTER_BRACE",
5761	"while should follow close brace '}'\n" . $hereprev) &&
5762	$fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5763	fix_delete_line($fixlinenr - 1, $prevrawline);
5764	fix_delete_line($fixlinenr, $rawline);
5765	my $fixedline = $prevrawline;
5766	my $trailing = $rawline;
5767	$trailing =~ s/^\+//;
5768	$trailing = trim($trailing);
5769	$fixedline =~ s/}\s*$/} $trailing/;
5770	fix_insert_line($fixlinenr, $fixedline);
5771	}
5772	}
5773	}
5774
5775	#Specific variable tests
5776	while ($line =~ m{($Constant\|$Lval)}g) {
5777	my $var = $1;
5778
5779	#CamelCase
5780	if ($var !~ /^$Constant$/ &&
5781	$var =~ /[A-Z][a-z]\|[a-z][A-Z]/ &&
5782	#Ignore some autogenerated defines and enum values
5783	$var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5784	#Ignore Page<foo> variants
5785	$var !~ /^(?:Clear\|Set\|TestClear\|TestSet\|)Page[A-Z]/ &&
5786	#Ignore SI style variants like nS, mV and dB
5787	#(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5788	$var !~ /^(?:[a-z0-9_]\|[A-Z0-9_])?_?[a-z][A-Z](?:_[a-z0-9_]+\|_[A-Z0-9_]+)?$/ &&
5789	#Ignore some three character SI units explicitly, like MiB and KHz
5790	$var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB\|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5791	while ($var =~ m{\b($Ident)}g) {
5792	my $word = $1;
5793	next if ($word !~ /[A-Z][a-z]\|[a-z][A-Z]/);
5794	if ($check) {
5795	seed_camelcase_includes();
5796	if (!$file && !$camelcase_file_seeded) {
5797	seed_camelcase_file($realfile);
5798	$camelcase_file_seeded = 1;
5799	}
5800	}
5801	if (!defined $camelcase{$word}) {
5802	$camelcase{$word} = 1;
5803	CHK("CAMELCASE",
5804	"Avoid CamelCase: <$word>\n" . $herecurr);
5805	}
5806	}
5807	}
5808	}
5809
5810	#no spaces allowed after \ in define
5811	if ($line =~ /\#\sdefine.\\\s+$/) {
5812	if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5813	"Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5814	$fix) {
5815	$fixed[$fixlinenr] =~ s/\s+$//;
5816	}
5817	}
5818
5819	# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5820	# itself <asm/foo.h> (uses RAW line)
5821	if ($tree && $rawline =~ m{^.\s\#\sinclude\s\<asm\/(.)\.h\>}) {
5822	my $file = "$1.h";
5823	my $checkfile = "include/linux/$file";
5824	if (-f "$root/$checkfile" &&
5825	$realfile ne $checkfile &&
5826	$1 !~ /$allowed_asm_includes/)
5827	{
5828	my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5829	if ($asminclude > 0) {
5830	if ($realfile =~ m{^arch/}) {
5831	CHK("ARCH_INCLUDE_LINUX",
5832	"Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5833	} else {
5834	WARN("INCLUDE_LINUX",
5835	"Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5836	}
5837	}
5838	}
5839	}
5840
5841	# multi-statement macros should be enclosed in a do while loop, grab the
5842	# first statement and ensure its the whole macro if its not enclosed
5843	# in a known good container
5844	if ($realfile !~ m@/vmlinux.lds.h$@ &&
5845	$line =~ /^.\s\#\sdefine\s*$Ident(\()?/) {
5846	my $ln = $linenr;
5847	my $cnt = $realcnt;
5848	my ($off, $dstat, $dcond, $rest);
5849	my $ctx = '';
5850	my $has_flow_statement = 0;
5851	my $has_arg_concat = 0;
5852	($dstat, $dcond, $ln, $cnt, $off) =
5853	ctx_statement_block($linenr, $realcnt, 0);
5854	$ctx = $dstat;
5855	#print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5856	#print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5857
5858	$has_flow_statement = 1 if ($ctx =~ /\b(goto\|return)\b/);
5859	$has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__\|args)\b/);
5860
5861	$dstat =~ s/^.\s\#\sdefine\s+$Ident($[^$]\))?\s//;
5862	my $define_args = $1;
5863	my $define_stmt = $dstat;
5864	my @def_args = ();
5865
5866	if (defined $define_args && $define_args ne "") {
5867	$define_args = substr($define_args, 1, length($define_args) - 2);
5868	$define_args =~ s/\s*//g;
5869	$define_args =~ s/\\\+?//g;
5870	@def_args = split(",", $define_args);
5871	}
5872
5873	$dstat =~ s/$;//g;
5874	$dstat =~ s/\\\n.//g;
5875	$dstat =~ s/^\s*//s;
5876	$dstat =~ s/\s*$//s;
5877
5878	# Flatten any parentheses and braces
5879	while ($dstat =~ s/$[^\($]*\)/1u/ \|\|
5880	$dstat =~ s/\{[^\{\}]*\}/1u/ \|\|
5881	$dstat =~ s/.\[[^\[\]]*\]/1u/)
5882	{
5883	}
5884
5885	# Flatten any obvious string concatenation.
5886	while ($dstat =~ s/($String)\s*$Ident/$1/ \|\|
5887	$dstat =~ s/$Ident\s*($String)/$1/)
5888	{
5889	}
5890
5891	# Make asm volatile uses seem like a generic function
5892	$dstat =~ s/\b_asm_\s+_volatile_\b/asm_volatile/g;
5893
5894	my $exceptions = qr{
5895	$Declare\|
5896	module_param_named\|
5897	MODULE_PARM_DESC\|
5898	DECLARE_PER_CPU\|
5899	DEFINE_PER_CPU\|
5900	__typeof__\(\|
5901	union\|
5902	struct\|
5903	\.$Ident\s=\s\|
5904	^\"\|\"$\|
5905	^\[
5906	}x;
5907	#print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5908
5909	$ctx =~ s/\n*$//;
5910	my $stmt_cnt = statement_rawlines($ctx);
5911	my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5912
5913	if ($dstat ne '' &&
5914	$dstat !~ /^(?:$Ident\|-?$Constant),$/ && # 10, // foo(),
5915	$dstat !~ /^(?:$Ident\|-?$Constant);$/ && # foo();
5916	$dstat !~ /^[!~-]?(?:$Lval\|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5917	$dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5918	$dstat !~ /$exceptions/ &&
5919	$dstat !~ /^\.$Ident\s*=/ && # .foo =
5920	$dstat !~ /^(?:\#\s$Ident\|\#\s$Constant)\s*$/ && # stringification #foo
5921	$dstat !~ /^case\b/ && # case ...
5922	$dstat !~ /^do\s$Constant\swhile\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5923	$dstat !~ /^while\s$Constant\s$Constant\s*$/ && # while (...) {...}
5924	$dstat !~ /^for\s*$Constant$/ && # for (...)
5925	$dstat !~ /^for\s*$Constant\s+(?:$Ident\|-?$Constant)$/ && # for (...) bar()
5926	$dstat !~ /^do\s*{/ && # do {...
5927	$dstat !~ /^\(\{/ && # ({...
5928	$ctx !~ /^.\s#\sdefine\s+TRACE_(?:SYSTEM\|INCLUDE_FILE\|INCLUDE_PATH)\b/)
5929	{
5930	if ($dstat =~ /^\s*if\b/) {
5931	ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5932	"Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5933	} elsif ($dstat =~ /;/) {
5934	ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5935	"Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5936	} else {
5937	ERROR("COMPLEX_MACRO",
5938	"Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5939	}
5940
5941	}
5942
5943	# Make $define_stmt single line, comment-free, etc
5944	my @stmt_array = split('\n', $define_stmt);
5945	my $first = 1;
5946	$define_stmt = "";
5947	foreach my $l (@stmt_array) {
5948	$l =~ s/\\$//;
5949	if ($first) {
5950	$define_stmt = $l;
5951	$first = 0;
5952	} elsif ($l =~ /^[\+ ]/) {
5953	$define_stmt .= substr($l, 1);
5954	}
5955	}
5956	$define_stmt =~ s/$;//g;
5957	$define_stmt =~ s/\s+/ /g;
5958	$define_stmt = trim($define_stmt);
5959
5960	# check if any macro arguments are reused (ignore '...' and 'type')
5961	foreach my $arg (@def_args) {
5962	next if ($arg =~ /\.\.\./);
5963	next if ($arg =~ /^type$/i);
5964	my $tmp_stmt = $define_stmt;
5965	$tmp_stmt =~ s/\b(__must_be_array\|offsetof\|sizeof\|sizeof_field\|__stringify\|typeof\|__typeof__\|__builtin\w+\|typecheck\s$\s$Type\s,\|\#+)\s\(\s$arg\s$\b//g;
5966	$tmp_stmt =~ s/\#+\s*$arg\b//g;
5967	$tmp_stmt =~ s/\b$arg\s*\#\#//g;
5968	my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
5969	if ($use_cnt > 1) {
5970	CHK("MACRO_ARG_REUSE",
5971	"Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5972	}
5973	# check if any macro arguments may have other precedence issues
5974	if ($tmp_stmt =~ m/($Operators)?\s\b$arg\b\s($Operators)?/m &&
5975	((defined($1) && $1 ne ',') \|\|
5976	(defined($2) && $2 ne ','))) {
5977	CHK("MACRO_ARG_PRECEDENCE",
5978	"Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5979	}
5980	}
5981
5982	# check for macros with flow control, but without ## concatenation
5983	# ## concatenation is commonly a macro that defines a function so ignore those
5984	if ($has_flow_statement && !$has_arg_concat) {
5985	my $cnt = statement_rawlines($ctx);
5986	my $herectx = get_stat_here($linenr, $cnt, $here);
5987
5988	WARN("MACRO_WITH_FLOW_CONTROL",
5989	"Macros with flow control statements should be avoided\n" . "$herectx");
5990	}
5991
5992	# check for line continuations outside of #defines, preprocessor #, and asm
5993
5994	} else {
5995	if ($prevline !~ /^..*\\$/ &&
5996	$line !~ /^\+\s\#.\\$/ && # preprocessor
5997	$line !~ /^\+.\b(__asm__\|asm)\b.\\$/ && # asm
5998	$line =~ /^\+.*\\$/) {
5999	WARN("LINE_CONTINUATIONS",
6000	"Avoid unnecessary line continuations\n" . $herecurr);
6001	}
6002	}
6003
6004	# do {} while (0) macro tests:
6005	# single-statement macros do not need to be enclosed in do while (0) loop,
6006	# macro should not end with a semicolon
6007	if ($perl_version_ok &&
6008	$realfile !~ m@/vmlinux.lds.h$@ &&
6009	$line =~ /^.\s\#\sdefine\s+$Ident(\()?/) {
6010	my $ln = $linenr;
6011	my $cnt = $realcnt;
6012	my ($off, $dstat, $dcond, $rest);
6013	my $ctx = '';
6014	($dstat, $dcond, $ln, $cnt, $off) =
6015	ctx_statement_block($linenr, $realcnt, 0);
6016	$ctx = $dstat;
6017
6018	$dstat =~ s/\\\n.//g;
6019	$dstat =~ s/$;/ /g;
6020
6021	if ($dstat =~ /^\+\s#\sdefine\s+$Ident\s${balanced_parens}\sdo\s{(.)\s}\swhile\s$\s0\s$\s([;\s])\s$/) {
6022	my $stmts = $2;
6023	my $semis = $3;
6024
6025	$ctx =~ s/\n*$//;
6026	my $cnt = statement_rawlines($ctx);
6027	my $herectx = get_stat_here($linenr, $cnt, $here);
6028
6029	if (($stmts =~ tr/;/;/) == 1 &&
6030	$stmts !~ /^\s*(if\|while\|for\|switch)\b/) {
6031	WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
6032	"Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
6033	}
6034	if (defined $semis && $semis ne "") {
6035	WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
6036	"do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
6037	}
6038	} elsif ($dstat =~ /^\+\s#\sdefine\s+$Ident.;\s$/) {
6039	$ctx =~ s/\n*$//;
6040	my $cnt = statement_rawlines($ctx);
6041	my $herectx = get_stat_here($linenr, $cnt, $here);
6042
6043	WARN("TRAILING_SEMICOLON",
6044	"macros should not use a trailing semicolon\n" . "$herectx");
6045	}
6046	}
6047
6048	# check for redundant bracing round if etc
6049	if ($line =~ /(^.)\bif\b/ && $1 !~ /else\s$/) {
6050	my ($level, $endln, @chunks) =
6051	ctx_statement_full($linenr, $realcnt, 1);
6052	#print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
6053	#print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
6054	if ($#chunks > 0 && $level == 0) {
6055	my @allowed = ();
6056	my $allow = 0;
6057	my $seen = 0;
6058	my $herectx = $here . "\n";
6059	my $ln = $linenr - 1;
6060	for my $chunk (@chunks) {
6061	my ($cond, $block) = @{$chunk};
6062
6063	# If the condition carries leading newlines, then count those as offsets.
6064	my ($whitespace) = ($cond =~ /^((?:\s\n[+-])\s*)/s);
6065	my $offset = statement_rawlines($whitespace) - 1;
6066
6067	$allowed[$allow] = 0;
6068	#print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
6069
6070	# We have looked at and allowed this specific line.
6071	$suppress_ifbraces{$ln + $offset} = 1;
6072
6073	$herectx .= "$rawlines[$ln + $offset]\n[...]\n";
6074	$ln += statement_rawlines($block) - 1;
6075
6076	substr($block, 0, length($cond), '');
6077
6078	$seen++ if ($block =~ /^\s*{/);
6079
6080	#print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
6081	if (statement_lines($cond) > 1) {
6082	#print "APW: ALLOWED: cond<$cond>\n";
6083	$allowed[$allow] = 1;
6084	}
6085	if ($block =~/\b(?:if\|for\|while)\b/) {
6086	#print "APW: ALLOWED: block<$block>\n";
6087	$allowed[$allow] = 1;
6088	}
6089	if (statement_block_size($block) > 1) {
6090	#print "APW: ALLOWED: lines block<$block>\n";
6091	$allowed[$allow] = 1;
6092	}
6093	$allow++;
6094	}
6095	if ($seen) {
6096	my $sum_allowed = 0;
6097	foreach (@allowed) {
6098	$sum_allowed += $_;
6099	}
6100	if ($sum_allowed == 0) {
6101	WARN("BRACES",
6102	"braces {} are not necessary for any arm of this statement\n" . $herectx);
6103	} elsif ($sum_allowed != $allow &&
6104	$seen != $allow) {
6105	CHK("BRACES",
6106	"braces {} should be used on all arms of this statement\n" . $herectx);
6107	}
6108	}
6109	}
6110	}
6111	if (!defined $suppress_ifbraces{$linenr - 1} &&
6112	$line =~ /\b(if\|while\|for\|else)\b/) {
6113	my $allowed = 0;
6114
6115	# Check the pre-context.
6116	if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
6117	#print "APW: ALLOWED: pre<$1>\n";
6118	$allowed = 1;
6119	}
6120
6121	my ($level, $endln, @chunks) =
6122	ctx_statement_full($linenr, $realcnt, $-[0]);
6123
6124	# Check the condition.
6125	my ($cond, $block) = @{$chunks[0]};
6126	#print "CHECKING<$linenr> cond<$cond> block<$block>\n";
6127	if (defined $cond) {
6128	substr($block, 0, length($cond), '');
6129	}
6130	if (statement_lines($cond) > 1) {
6131	#print "APW: ALLOWED: cond<$cond>\n";
6132	$allowed = 1;
6133	}
6134	if ($block =~/\b(?:if\|for\|while)\b/) {
6135	#print "APW: ALLOWED: block<$block>\n";
6136	$allowed = 1;
6137	}
6138	if (statement_block_size($block) > 1) {
6139	#print "APW: ALLOWED: lines block<$block>\n";
6140	$allowed = 1;
6141	}
6142	# Check the post-context.
6143	if (defined $chunks[1]) {
6144	my ($cond, $block) = @{$chunks[1]};
6145	if (defined $cond) {
6146	substr($block, 0, length($cond), '');
6147	}
6148	if ($block =~ /^\s*\{/) {
6149	#print "APW: ALLOWED: chunk-1 block<$block>\n";
6150	$allowed = 1;
6151	}
6152	}
6153	if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6154	my $cnt = statement_rawlines($block);
6155	my $herectx = get_stat_here($linenr, $cnt, $here);
6156
6157	WARN("BRACES",
6158	"braces {} are not necessary for single statement blocks\n" . $herectx);
6159	}
6160	}
6161
6162	# check for single line unbalanced braces
6163	if ($sline =~ /^.\s\}\selse\s*$/ \|\|
6164	$sline =~ /^.\selse\s\{\s*$/) {
6165	CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6166	}
6167
6168	# check for unnecessary blank lines around braces
6169	if (($line =~ /^.\s}\s$/ && $prevrawline =~ /^.\s*$/)) {
6170	if (CHK("BRACES",
6171	"Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6172	$fix && $prevrawline =~ /^\+/) {
6173	fix_delete_line($fixlinenr - 1, $prevrawline);
6174	}
6175	}
6176	if (($rawline =~ /^.\s$/ && $prevline =~ /^..{\s*$/)) {
6177	if (CHK("BRACES",
6178	"Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6179	$fix) {
6180	fix_delete_line($fixlinenr, $rawline);
6181	}
6182	}
6183
6184	# no volatiles please
6185	my $asm_volatile = qr{\b(__asm__\|asm)\s+(__volatile__\|volatile)\b};
6186	if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6187	WARN("VOLATILE",
6188	"Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6189	}
6190
6191	# Check for user-visible strings broken across lines, which breaks the ability
6192	# to grep for the string. Make exceptions when the previous string ends in a
6193	# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6194	# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6195	if ($line =~ /^\+\s*$String/ &&
6196	$prevline =~ /"\s*$/ &&
6197	$prevrawline !~ /(?:\\(?:[ntr]\|[0-7]{1,3}\|x[0-9a-fA-F]{1,2})\|;\s\|\{\s)"\s*$/) {
6198	if (WARN("SPLIT_STRING",
6199	"quoted string split across lines\n" . $hereprev) &&
6200	$fix &&
6201	$prevrawline =~ /^\+."\s$/ &&
6202	$last_coalesced_string_linenr != $linenr - 1) {
6203	my $extracted_string = get_quoted_string($line, $rawline);
6204	my $comma_close = "";
6205	if ($rawline =~ /\Q$extracted_string\E(\s\)\s;\s$\|\s,\s*)/) {
6206	$comma_close = $1;
6207	}
6208
6209	fix_delete_line($fixlinenr - 1, $prevrawline);
6210	fix_delete_line($fixlinenr, $rawline);
6211	my $fixedline = $prevrawline;
6212	$fixedline =~ s/"\s*$//;
6213	$fixedline .= substr($extracted_string, 1) . trim($comma_close);
6214	fix_insert_line($fixlinenr - 1, $fixedline);
6215	$fixedline = $rawline;
6216	$fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6217	if ($fixedline !~ /\+\s*$/) {
6218	fix_insert_line($fixlinenr, $fixedline);
6219	}
6220	$last_coalesced_string_linenr = $linenr;
6221	}
6222	}
6223
6224	# check for missing a space in a string concatenation
6225	if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6226	WARN('MISSING_SPACE',
6227	"break quoted strings at a space character\n" . $hereprev);
6228	}
6229
6230	# check for an embedded function name in a string when the function is known
6231	# This does not work very well for -f --file checking as it depends on patch
6232	# context providing the function name or a single line form for in-file
6233	# function declarations
6234	if ($line =~ /^\+.*$String/ &&
6235	defined($context_function) &&
6236	get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
6237	length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
6238	WARN("EMBEDDED_FUNCTION_NAME",
6239	"Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6240	}
6241
6242	# check for unnecessary function tracing like uses
6243	# This does not use $logFunctions because there are many instances like
6244	# 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6245	if ($rawline =~ /^\+.$[^"]"$tracing_logging_tags{0,3}%s(?:\s\(\s$\s)?$tracing_logging_tags{0,3}(?:\\n)?"\s,\s__func__\s\)\s*;/) {
6246	if (WARN("TRACING_LOGGING",
6247	"Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6248	$fix) {
6249	fix_delete_line($fixlinenr, $rawline);
6250	}
6251	}
6252
6253	# check for spaces before a quoted newline
6254	if ($rawline =~ /^.\".\s\\n/) {
6255	if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6256	"unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6257	$fix) {
6258	$fixed[$fixlinenr] =~ s/^(\+.\".)\s+\\n/$1\\n/;
6259	}
6260
6261	}
6262
6263	# concatenated string without spaces between elements
6264	if ($line =~ /$String[A-Z_]/ \|\|
6265	($line =~ /([A-Za-z0-9_]+)$String/ && $1 !~ /^[Lu]$/)) {
6266	if (CHK("CONCATENATED_STRING",
6267	"Concatenated strings should use spaces between elements\n" . $herecurr) &&
6268	$fix) {
6269	while ($line =~ /($String)/g) {
6270	my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6271	$fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6272	$fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6273	}
6274	}
6275	}
6276
6277	# uncoalesced string fragments
6278	if ($line =~ /$String\s*[Lu]?"/) {
6279	if (WARN("STRING_FRAGMENTS",
6280	"Consecutive strings are generally better as a single string\n" . $herecurr) &&
6281	$fix) {
6282	while ($line =~ /($String)(?=\s*")/g) {
6283	my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6284	$fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6285	}
6286	}
6287	}
6288
6289	# check for non-standard and hex prefixed decimal printf formats
6290	my $show_L = 1; #don't show the same defect twice
6291	my $show_Z = 1;
6292	while ($line =~ /(?:^\|")([X\t]*)(?:"\|$)/g) {
6293	my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6294	$string =~ s/%%/__/g;
6295	# check for %L
6296	if ($show_L && $string =~ /%[\\d\.\$]L([diouxX])/) {
6297	WARN("PRINTF_L",
6298	"\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6299	$show_L = 0;
6300	}
6301	# check for %Z
6302	if ($show_Z && $string =~ /%[\\d\.\$]Z([diouxX])/) {
6303	WARN("PRINTF_Z",
6304	"%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6305	$show_Z = 0;
6306	}
6307	# check for 0x<decimal>
6308	if ($string =~ /0x%[\\d\.\$\Llzth][diou]/) {
6309	ERROR("PRINTF_0XDECIMAL",
6310	"Prefixing 0x with decimal output is defective\n" . $herecurr);
6311	}
6312	}
6313
6314	# check for line continuations in quoted strings with odd counts of "
6315	if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6316	WARN("LINE_CONTINUATIONS",
6317	"Avoid line continuations in quoted strings\n" . $herecurr);
6318	}
6319
6320	# warn about #if 0
6321	if ($line =~ /^.\s\#\sif\s+0\b/) {
6322	WARN("IF_0",
6323	"Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6324	}
6325
6326	# warn about #if 1
6327	if ($line =~ /^.\s\#\sif\s+1\b/) {
6328	WARN("IF_1",
6329	"Consider removing the #if 1 and its #endif\n" . $herecurr);
6330	}
6331
6332	# check for needless "if (<foo>) fn(<foo>)" uses
6333	if ($prevline =~ /\bif\s$\s($Lval)\s*$/) {
6334	my $tested = quotemeta($1);
6335	my $expr = '\s$\s' . $tested . '\s$\s;';
6336	if ($line =~ /\b(kfree\|usb_free_urb\|debugfs_remove(?:_recursive)?\|(?:kmem_cache\|mempool\|dma_pool)_destroy)$expr/) {
6337	my $func = $1;
6338	if (WARN('NEEDLESS_IF',
6339	"$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6340	$fix) {
6341	my $do_fix = 1;
6342	my $leading_tabs = "";
6343	my $new_leading_tabs = "";
6344	if ($lines[$linenr - 2] =~ /^\+(\t)if\s$\s$tested\s$\s*$/) {
6345	$leading_tabs = $1;
6346	} else {
6347	$do_fix = 0;
6348	}
6349	if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s$\s$tested\s$\s;\s*$/) {
6350	$new_leading_tabs = $1;
6351	if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6352	$do_fix = 0;
6353	}
6354	} else {
6355	$do_fix = 0;
6356	}
6357	if ($do_fix) {
6358	fix_delete_line($fixlinenr - 1, $prevrawline);
6359	$fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6360	}
6361	}
6362	}
6363	}
6364
6365	# check for unnecessary "Out of Memory" messages
6366	if ($line =~ /^\+.\b$logFunctions\s\(/ &&
6367	$prevline =~ /^[ \+]\sif\s$\s(\!\s\|NULL\s==\s)?($Lval)(\s==\sNULL\s)?\s$/ &&
6368	(defined $1 \|\| defined $3) &&
6369	$linenr > 3) {
6370	my $testval = $2;
6371	my $testline = $lines[$linenr - 3];
6372
6373	my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6374	# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6375
6376	if ($s =~ /(?:^\|\n)[ \+]\s(?:$Type\s)?\Q$testval\E\s=\s(?:$[^$]\)\s)?\s$allocFunctions\s\(/ &&
6377	$s !~ /\b__GFP_NOWARN\b/ ) {
6378	WARN("OOM_MESSAGE",
6379	"Possible unnecessary 'out of memory' message\n" . $hereprev);
6380	}
6381	}
6382
6383	# check for logging functions with KERN_<LEVEL>
6384	if ($line !~ /printk(?:_ratelimited\|_once)?\s*\(/ &&
6385	$line =~ /\b$logFunctions\s\(.\b(KERN_[A-Z]+)\b/) {
6386	my $level = $1;
6387	if (WARN("UNNECESSARY_KERN_LEVEL",
6388	"Possible unnecessary $level\n" . $herecurr) &&
6389	$fix) {
6390	$fixed[$fixlinenr] =~ s/\s$level\s//;
6391	}
6392	}
6393
6394	# check for logging continuations
6395	if ($line =~ /\bprintk\s\(\sKERN_CONT\b\|\bpr_cont\s*\(/) {
6396	WARN("LOGGING_CONTINUATION",
6397	"Avoid logging continuation uses where feasible\n" . $herecurr);
6398	}
6399
6400	# check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6401	if (defined $stat &&
6402	$line =~ /\b$logFunctions\s*\(/ &&
6403	index($stat, '"') >= 0) {
6404	my $lc = $stat =~ tr@\n@@;
6405	$lc = $lc + $linenr;
6406	my $stat_real = get_stat_real($linenr, $lc);
6407	pos($stat_real) = index($stat_real, '"');
6408	while ($stat_real =~ /[^\"%](%[\#\d\.\\-]*(h+)[idux])/g) {
6409	my $pspec = $1;
6410	my $h = $2;
6411	my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6412	if (WARN("UNNECESSARY_MODIFIER",
6413	"Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6414	$fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6415	my $nspec = $pspec;
6416	$nspec =~ s/h//g;
6417	$fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6418	}
6419	}
6420	}
6421
6422	# check for mask then right shift without a parentheses
6423	if ($perl_version_ok &&
6424	$line =~ /$LvalOrFunc\s\&\s($LvalOrFunc)\s*>>/ &&
6425	$4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6426	WARN("MASK_THEN_SHIFT",
6427	"Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6428	}
6429
6430	# check for pointer comparisons to NULL
6431	if ($perl_version_ok) {
6432	while ($line =~ /\b$LvalOrFunc\s(==\|\!=)\sNULL\b/g) {
6433	my $val = $1;
6434	my $equal = "!";
6435	$equal = "" if ($4 eq "!=");
6436	if (CHK("COMPARISON_TO_NULL",
6437	"Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6438	$fix) {
6439	$fixed[$fixlinenr] =~ s/\b\Q$val\E\s(?:==\|\!=)\sNULL\b/$equal$val/;
6440	}
6441	}
6442	}
6443
6444	# check for bad placement of section $InitAttribute (e.g.: __initdata)
6445	if ($line =~ /(\b$InitAttribute\b)/) {
6446	my $attr = $1;
6447	if ($line =~ /^\+\sstatic\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]\])?)\s*[=;]/) {
6448	my $ptr = $1;
6449	my $var = $2;
6450	if ((($ptr =~ /\b(union\|struct)\s+$attr\b/ &&
6451	ERROR("MISPLACED_INIT",
6452	"$attr should be placed after $var\n" . $herecurr)) \|\|
6453	($ptr !~ /\b(union\|struct)\s+$attr\b/ &&
6454	WARN("MISPLACED_INIT",
6455	"$attr should be placed after $var\n" . $herecurr))) &&
6456	$fix) {
6457	$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;
6458	}
6459	}
6460	}
6461
6462	# check for $InitAttributeData (ie: __initdata) with const
6463	if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6464	my $attr = $1;
6465	$attr =~ /($InitAttributePrefix)(.*)/;
6466	my $attr_prefix = $1;
6467	my $attr_type = $2;
6468	if (ERROR("INIT_ATTRIBUTE",
6469	"Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6470	$fix) {
6471	$fixed[$fixlinenr] =~
6472	s/$InitAttributeData/${attr_prefix}initconst/;
6473	}
6474	}
6475
6476	# check for $InitAttributeConst (ie: __initconst) without const
6477	if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6478	my $attr = $1;
6479	if (ERROR("INIT_ATTRIBUTE",
6480	"Use of $attr requires a separate use of const\n" . $herecurr) &&
6481	$fix) {
6482	my $lead = $fixed[$fixlinenr] =~
6483	/(^\+\s*(?:static\s+))/;
6484	$lead = rtrim($1);
6485	$lead = "$lead " if ($lead !~ /^\+$/);
6486	$lead = "${lead}const ";
6487	$fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6488	}
6489	}
6490
6491	# check for __read_mostly with const non-pointer (should just be const)
6492	if ($line =~ /\b__read_mostly\b/ &&
6493	$line =~ /($Type)\s$Ident/ && $1 !~ /\\s*$/ && $1 =~ /\bconst\b/) {
6494	if (ERROR("CONST_READ_MOSTLY",
6495	"Invalid use of __read_mostly with const type\n" . $herecurr) &&
6496	$fix) {
6497	$fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6498	}
6499	}
6500
6501	# don't use __constant_<foo> functions outside of include/uapi/
6502	if ($realfile !~ m@^include/uapi/@ &&
6503	$line =~ /(__constant_(?:htons\|ntohs\|[bl]e(?:16\|32\|64)_to_cpu\|cpu_to_[bl]e(?:16\|32\|64)))\s*\(/) {
6504	my $constant_func = $1;
6505	my $func = $constant_func;
6506	$func =~ s/^__constant_//;
6507	if (WARN("CONSTANT_CONVERSION",
6508	"$constant_func should be $func\n" . $herecurr) &&
6509	$fix) {
6510	$fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6511	}
6512	}
6513
6514	# prefer usleep_range over udelay
6515	if ($line =~ /\budelay\s$\s(\d+)\s*$/) {
6516	my $delay = $1;
6517	# ignore udelay's < 10, however
6518	if (! ($delay < 10) ) {
6519	CHK("USLEEP_RANGE",
6520	"usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6521	}
6522	if ($delay > 2000) {
6523	WARN("LONG_UDELAY",
6524	"long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6525	}
6526	}
6527
6528	# warn about unexpectedly long msleep's
6529	if ($line =~ /\bmsleep\s*$(\d+)$;/) {
6530	if ($1 < 20) {
6531	WARN("MSLEEP",
6532	"msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6533	}
6534	}
6535
6536	# check for comparisons of jiffies
6537	if ($line =~ /\bjiffies\s$Compare\|$Compare\sjiffies\b/) {
6538	WARN("JIFFIES_COMPARISON",
6539	"Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6540	}
6541
6542	# check for comparisons of get_jiffies_64()
6543	if ($line =~ /\bget_jiffies_64\s$\s$\s$Compare\|$Compare\sget_jiffies_64\s$\s$/) {
6544	WARN("JIFFIES_COMPARISON",
6545	"Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6546	}
6547
6548	# warn about #ifdefs in C files
6549	# if ($line =~ /^.\s\#\sif(\|n)def/ && ($realfile =~ /\.c$/)) {
6550	# print "#ifdef in C files should be avoided\n";
6551	# print "$herecurr";
6552	# $clean = 0;
6553	# }
6554
6555	# warn about spacing in #ifdefs
6556	if ($line =~ /^.\s\#\s(ifdef\|ifndef\|elif)\s\s+/) {
6557	if (ERROR("SPACING",
6558	"exactly one space required after that #$1\n" . $herecurr) &&
6559	$fix) {
6560	$fixed[$fixlinenr] =~
6561	s/^(.\s\#\s(ifdef\|ifndef\|elif))\s{2,}/$1 /;
6562	}
6563
6564	}
6565
6566	# check for spinlock_t definitions without a comment.
6567	if ($line =~ /^.\s*(struct\s+mutex\|spinlock_t)\s+\S+;/ \|\|
6568	$line =~ /^.\s(DEFINE_MUTEX)\s\(/) {
6569	my $which = $1;
6570	if (!ctx_has_comment($first_line, $linenr)) {
6571	CHK("UNCOMMENTED_DEFINITION",
6572	"$1 definition without comment\n" . $herecurr);
6573	}
6574	}
6575	# check for memory barriers without a comment.
6576
6577	my $barriers = qr{
6578	mb\|
6579	rmb\|
6580	wmb
6581	}x;
6582	my $barrier_stems = qr{
6583	mb__before_atomic\|
6584	mb__after_atomic\|
6585	store_release\|
6586	load_acquire\|
6587	store_mb\|
6588	(?:$barriers)
6589	}x;
6590	my $all_barriers = qr{
6591	(?:$barriers)\|
6592	smp_(?:$barrier_stems)\|
6593	virt_(?:$barrier_stems)
6594	}x;
6595
6596	if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6597	if (!ctx_has_comment($first_line, $linenr)) {
6598	WARN("MEMORY_BARRIER",
6599	"memory barrier without comment\n" . $herecurr);
6600	}
6601	}
6602
6603	my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6604
6605	if ($realfile !~ m@^include/asm-generic/@ &&
6606	$realfile !~ m@/barrier\.h$@ &&
6607	$line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6608	$line !~ m/^.\s\#\sdefine\s+(?:$underscore_smp_barriers)\s*\(/) {
6609	WARN("MEMORY_BARRIER",
6610	"__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6611	}
6612
6613	# check for waitqueue_active without a comment.
6614	if ($line =~ /\bwaitqueue_active\s*\(/) {
6615	if (!ctx_has_comment($first_line, $linenr)) {
6616	WARN("WAITQUEUE_ACTIVE",
6617	"waitqueue_active without comment\n" . $herecurr);
6618	}
6619	}
6620
6621	# check for data_race without a comment.
6622	if ($line =~ /\bdata_race\s*\(/) {
6623	if (!ctx_has_comment($first_line, $linenr)) {
6624	WARN("DATA_RACE",
6625	"data_race without comment\n" . $herecurr);
6626	}
6627	}
6628
6629	# check of hardware specific defines
6630	if ($line =~ m@^.\s\#\sif.*\b(__i386__\|__powerpc64__\|__sun__\|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6631	CHK("ARCH_DEFINES",
6632	"architecture specific defines should be avoided\n" . $herecurr);
6633	}
6634
6635	# check that the storage class is not after a type
6636	if ($line =~ /\b($Type)\s+($Storage)\b/) {
6637	WARN("STORAGE_CLASS",
6638	"storage class '$2' should be located before type '$1'\n" . $herecurr);
6639	}
6640	# Check that the storage class is at the beginning of a declaration
6641	if ($line =~ /\b$Storage\b/ &&
6642	$line !~ /^.\s*$Storage/ &&
6643	$line =~ /^.\s*(.+?)\$Storage\s/ &&
6644	$1 !~ /[\,\)]\s*$/) {
6645	WARN("STORAGE_CLASS",
6646	"storage class should be at the beginning of the declaration\n" . $herecurr);
6647	}
6648
6649	# check the location of the inline attribute, that it is between
6650	# storage class and type.
6651	if ($line =~ /\b$Type\s+$Inline\b/ \|\|
6652	$line =~ /\b$Inline\s+$Storage\b/) {
6653	ERROR("INLINE_LOCATION",
6654	"inline keyword should sit between storage class and type\n" . $herecurr);
6655	}
6656
6657	# Check for __inline__ and __inline, prefer inline
6658	if ($realfile !~ m@\binclude/uapi/@ &&
6659	$line =~ /\b(__inline__\|__inline)\b/) {
6660	if (WARN("INLINE",
6661	"plain inline is preferred over $1\n" . $herecurr) &&
6662	$fix) {
6663	$fixed[$fixlinenr] =~ s/\b(__inline__\|__inline)\b/inline/;
6664
6665	}
6666	}
6667
6668	# Check for compiler attributes
6669	if ($realfile !~ m@\binclude/uapi/@ &&
6670	$rawline =~ /\b__attribute__\s$\s($balanced_parens)\s*$/) {
6671	my $attr = $1;
6672	$attr =~ s/\s$\s(.)$\s/$1/;
6673
6674	my %attr_list = (
6675	"alias" => "__alias",
6676	"aligned" => "__aligned",
6677	"always_inline" => "__always_inline",
6678	"assume_aligned" => "__assume_aligned",
6679	"cold" => "__cold",
6680	"const" => "__attribute_const__",
6681	"copy" => "__copy",
6682	"designated_init" => "__designated_init",
6683	"externally_visible" => "__visible",
6684	"format" => "printf\|scanf",
6685	"gnu_inline" => "__gnu_inline",
6686	"malloc" => "__malloc",
6687	"mode" => "__mode",
6688	"no_caller_saved_registers" => "__no_caller_saved_registers",
6689	"noclone" => "__noclone",
6690	"noinline" => "noinline",
6691	"nonstring" => "__nonstring",
6692	"noreturn" => "__noreturn",
6693	"packed" => "__packed",
6694	"pure" => "__pure",
6695	"section" => "__section",
6696	"used" => "__used",
6697	"weak" => "__weak"
6698	);
6699
6700	while ($attr =~ /\s(\w+)\s(${balanced_parens})?/g) {
6701	my $orig_attr = $1;
6702	my $params = '';
6703	$params = $2 if defined($2);
6704	my $curr_attr = $orig_attr;
6705	$curr_attr =~ s/^[\s_]+\|[\s_]+$//g;
6706	if (exists($attr_list{$curr_attr})) {
6707	my $new = $attr_list{$curr_attr};
6708	if ($curr_attr eq "format" && $params) {
6709	$params =~ /^\s\(\s(\w+)\s,\s(.*)/;
6710	$new = "__$1\($2";
6711	} else {
6712	$new = "$new$params";
6713	}
6714	if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6715	"Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6716	$fix) {
6717	my $remove = "\Q$orig_attr\E" . '\s' . "\Q$params\E" . '(?:\s,\s*)?';
6718	$fixed[$fixlinenr] =~ s/$remove//;
6719	$fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6720	$fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6721	$fixed[$fixlinenr] =~ s/ __attribute__\s$\s\(\s$\s\)//;
6722	}
6723	}
6724	}
6725
6726	# Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6727	if ($attr =~ /^_*unused/) {
6728	WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6729	"__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6730	}
6731	}
6732
6733	# Check for __attribute__ weak, or __weak declarations (may have link issues)
6734	if ($perl_version_ok &&
6735	$line =~ /(?:$Declare\|$DeclareMisordered)\s$Ident\s$balanced_parens\s(?:$Attribute)?\s;/ &&
6736	($line =~ /\b__attribute__\s\(\s\(.*\bweak\b/ \|\|
6737	$line =~ /\b__weak\b/)) {
6738	ERROR("WEAK_DECLARATION",
6739	"Using weak declarations can have unintended link defects\n" . $herecurr);
6740	}
6741
6742	# check for c99 types like uint8_t used outside of uapi/ and tools/
6743	if ($realfile !~ m@\binclude/uapi/@ &&
6744	$realfile !~ m@\btools/@ &&
6745	$line =~ /\b($Declare)\s$Ident\s[=;,\[]/) {
6746	my $type = $1;
6747	if ($type =~ /\b($typeC99Typedefs)\b/) {
6748	$type = $1;
6749	my $kernel_type = 'u';
6750	$kernel_type = 's' if ($type =~ /^_*[si]/);
6751	$type =~ /(\d+)/;
6752	$kernel_type .= $1;
6753	if (CHK("PREFER_KERNEL_TYPES",
6754	"Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6755	$fix) {
6756	$fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6757	}
6758	}
6759	}
6760
6761	# check for cast of C90 native int or longer types constants
6762	if ($line =~ /($\s$C90_int_types\s$\s*)($Constant)\b/) {
6763	my $cast = $1;
6764	my $const = $2;
6765	my $suffix = "";
6766	my $newconst = $const;
6767	$newconst =~ s/${Int_type}$//;
6768	$suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6769	if ($cast =~ /\blong\s+long\b/) {
6770	$suffix .= 'LL';
6771	} elsif ($cast =~ /\blong\b/) {
6772	$suffix .= 'L';
6773	}
6774	if (WARN("TYPECAST_INT_CONSTANT",
6775	"Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6776	$fix) {
6777	$fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6778	}
6779	}
6780
6781	# check for sizeof(&)
6782	if ($line =~ /\bsizeof\s\(\s\&/) {
6783	WARN("SIZEOF_ADDRESS",
6784	"sizeof(& should be avoided\n" . $herecurr);
6785	}
6786
6787	# check for sizeof without parenthesis
6788	if ($line =~ /\bsizeof\s+((?:\\s\|)$Lval\|$Type(?:\s+$Lval\|))/) {
6789	if (WARN("SIZEOF_PARENTHESIS",
6790	"sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6791	$fix) {
6792	$fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\\s\|)$Lval\|$Type(?:\s+$Lval\|))/"sizeof(" . trim($1) . ")"/ex;
6793	}
6794	}
6795
6796	# check for struct spinlock declarations
6797	if ($line =~ /^.\s\bstruct\s+spinlock\s+\w+\s;/) {
6798	WARN("USE_SPINLOCK_T",
6799	"struct spinlock should be spinlock_t\n" . $herecurr);
6800	}
6801
6802	# check for seq_printf uses that could be seq_puts
6803	if ($sline =~ /\bseq_printf\s$."\s$\s;\s*$/) {
6804	my $fmt = get_quoted_string($line, $rawline);
6805	$fmt =~ s/%%//g;
6806	if ($fmt !~ /%/) {
6807	if (WARN("PREFER_SEQ_PUTS",
6808	"Prefer seq_puts to seq_printf\n" . $herecurr) &&
6809	$fix) {
6810	$fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6811	}
6812	}
6813	}
6814
6815	# check for vsprintf extension %p<foo> misuses
6816	if ($perl_version_ok &&
6817	defined $stat &&
6818	$stat =~ /^\+(?![^\{]\{\s).\b(\w+)\s\(.$String\s,/s &&
6819	$1 !~ /^_volatile_$/) {
6820	my $stat_real;
6821
6822	my $lc = $stat =~ tr@\n@@;
6823	$lc = $lc + $linenr;
6824	for (my $count = $linenr; $count <= $lc; $count++) {
6825	my $specifier;
6826	my $extension;
6827	my $qualifier;
6828	my $bad_specifier = "";
6829	my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6830	$fmt =~ s/%%//g;
6831
6832	while ($fmt =~ /(\%[\\d\.]p(\w)(\w*))/g) {
6833	$specifier = $1;
6834	$extension = $2;
6835	$qualifier = $3;
6836	if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ \|\|
6837	($extension eq "f" &&
6838	defined $qualifier && $qualifier !~ /^w/) \|\|
6839	($extension eq "4" &&
6840	defined $qualifier && $qualifier !~ /^cc/)) {
6841	$bad_specifier = $specifier;
6842	last;
6843	}
6844	if ($extension eq "x" && !defined($stat_real)) {
6845	if (!defined($stat_real)) {
6846	$stat_real = get_stat_real($linenr, $lc);
6847	}
6848	WARN("VSPRINTF_SPECIFIER_PX",
6849	"Using vsprintf specifier '\%px' potentially exposes the kernel memory layout, if you don't really need the address please consider using '\%p'.\n" . "$here\n$stat_real\n");
6850	}
6851	}
6852	if ($bad_specifier ne "") {
6853	my $stat_real = get_stat_real($linenr, $lc);
6854	my $msg_level = \&WARN;
6855	my $ext_type = "Invalid";
6856	my $use = "";
6857	if ($bad_specifier =~ /p[Ff]/) {
6858	$use = " - use %pS instead";
6859	$use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6860	} elsif ($bad_specifier =~ /pA/) {
6861	$use = " - '%pA' is only intended to be used from Rust code";
6862	$msg_level = \&ERROR;
6863	}
6864
6865	&{$msg_level}("VSPRINTF_POINTER_EXTENSION",
6866	"$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6867	}
6868	}
6869	}
6870
6871	# Check for misused memsets
6872	if ($perl_version_ok &&
6873	defined $stat &&
6874	$stat =~ /^\+(?:.?)\bmemset\s$\s$FuncArg\s,\s$FuncArg\s\,\s$FuncArg\s$/) {
6875
6876	my $ms_addr = $2;
6877	my $ms_val = $7;
6878	my $ms_size = $12;
6879
6880	if ($ms_size =~ /^(0x\|)0$/i) {
6881	ERROR("MEMSET",
6882	"memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6883	} elsif ($ms_size =~ /^(0x\|)1$/i) {
6884	WARN("MEMSET",
6885	"single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6886	}
6887	}
6888
6889	# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6890	# if ($perl_version_ok &&
6891	# defined $stat &&
6892	# $stat =~ /^\+(?:.?)\bmemcpy\s$\s$FuncArg\s,\s$FuncArg\s\,\sETH_ALEN\s$/) {
6893	# if (WARN("PREFER_ETHER_ADDR_COPY",
6894	# "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6895	# $fix) {
6896	# $fixed[$fixlinenr] =~ s/\bmemcpy\s$\s$FuncArg\s,\s$FuncArg\s\,\sETH_ALEN\s*$/ether_addr_copy($2, $7)/;
6897	# }
6898	# }
6899
6900	# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6901	# if ($perl_version_ok &&
6902	# defined $stat &&
6903	# $stat =~ /^\+(?:.?)\bmemcmp\s$\s$FuncArg\s,\s$FuncArg\s\,\sETH_ALEN\s$/) {
6904	# WARN("PREFER_ETHER_ADDR_EQUAL",
6905	# "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6906	# }
6907
6908	# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6909	# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6910	# if ($perl_version_ok &&
6911	# defined $stat &&
6912	# $stat =~ /^\+(?:.?)\bmemset\s$\s$FuncArg\s,\s$FuncArg\s\,\sETH_ALEN\s$/) {
6913	#
6914	# my $ms_val = $7;
6915	#
6916	# if ($ms_val =~ /^(?:0x\|)0+$/i) {
6917	# if (WARN("PREFER_ETH_ZERO_ADDR",
6918	# "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6919	# $fix) {
6920	# $fixed[$fixlinenr] =~ s/\bmemset\s$\s$FuncArg\s,\s$FuncArg\s,\sETH_ALEN\s*$/eth_zero_addr($2)/;
6921	# }
6922	# } elsif ($ms_val =~ /^(?:0xff\|255)$/i) {
6923	# if (WARN("PREFER_ETH_BROADCAST_ADDR",
6924	# "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6925	# $fix) {
6926	# $fixed[$fixlinenr] =~ s/\bmemset\s$\s$FuncArg\s,\s$FuncArg\s,\sETH_ALEN\s*$/eth_broadcast_addr($2)/;
6927	# }
6928	# }
6929	# }
6930
6931	# strlcpy uses that should likely be strscpy
6932	if ($line =~ /\bstrlcpy\s*\(/) {
6933	WARN("STRLCPY",
6934	"Prefer strscpy over strlcpy - see: https://lore.kernel.org/r/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw\@mail.gmail.com/\n" . $herecurr);
6935	}
6936
6937	# typecasts on min/max could be min_t/max_t
6938	if ($perl_version_ok &&
6939	defined $stat &&
6940	$stat =~ /^\+(?:.?)\b(min\|max)\s$\s$FuncArg\s,\s$FuncArg\s$/) {
6941	if (defined $2 \|\| defined $7) {
6942	my $call = $1;
6943	my $cast1 = deparenthesize($2);
6944	my $arg1 = $3;
6945	my $cast2 = deparenthesize($7);
6946	my $arg2 = $8;
6947	my $cast;
6948
6949	if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
6950	$cast = "$cast1 or $cast2";
6951	} elsif ($cast1 ne "") {
6952	$cast = $cast1;
6953	} else {
6954	$cast = $cast2;
6955	}
6956	WARN("MINMAX",
6957	"$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
6958	}
6959	}
6960
6961	# check usleep_range arguments
6962	if ($perl_version_ok &&
6963	defined $stat &&
6964	$stat =~ /^\+(?:.?)\busleep_range\s$\s($FuncArg)\s,\s($FuncArg)\s$/) {
6965	my $min = $1;
6966	my $max = $7;
6967	if ($min eq $max) {
6968	WARN("USLEEP_RANGE",
6969	"usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6970	} elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
6971	$min > $max) {
6972	WARN("USLEEP_RANGE",
6973	"usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6974	}
6975	}
6976
6977	# check for naked sscanf
6978	if ($perl_version_ok &&
6979	defined $stat &&
6980	$line =~ /\bsscanf\b/ &&
6981	($stat !~ /$Ident\s=\ssscanf\s*$balanced_parens/ &&
6982	$stat !~ /\bsscanf\s$balanced_parens\s(?:$Compare)/ &&
6983	$stat !~ /(?:$Compare)\s\bsscanf\s$balanced_parens/)) {
6984	my $lc = $stat =~ tr@\n@@;
6985	$lc = $lc + $linenr;
6986	my $stat_real = get_stat_real($linenr, $lc);
6987	WARN("NAKED_SSCANF",
6988	"unchecked sscanf return value\n" . "$here\n$stat_real\n");
6989	}
6990
6991	# check for simple sscanf that should be kstrto<foo>
6992	if ($perl_version_ok &&
6993	defined $stat &&
6994	$line =~ /\bsscanf\b/) {
6995	my $lc = $stat =~ tr@\n@@;
6996	$lc = $lc + $linenr;
6997	my $stat_real = get_stat_real($linenr, $lc);
6998	if ($stat_real =~ /\bsscanf\b\s\(\s$FuncArg\s,\s("[^"]+")/) {
6999	my $format = $6;
7000	my $count = $format =~ tr@%@%@;
7001	if ($count == 1 &&
7002	$format =~ /^"\%(?i:ll[udxi]\|[udxi]ll\|ll\|[hl]h?[udxi]\|[udxi][hl]h?\|[hl]h?\|[udxi])"$/) {
7003	WARN("SSCANF_TO_KSTRTO",
7004	"Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
7005	}
7006	}
7007	}
7008
7009	# check for new externs in .h files.
7010	if ($realfile =~ /\.h$/ &&
7011	$line =~ /^\+\s(extern\s+)$Type\s$Ident\s*\(/s) {
7012	if (CHK("AVOID_EXTERNS",
7013	"extern prototypes should be avoided in .h files\n" . $herecurr) &&
7014	$fix) {
7015	$fixed[$fixlinenr] =~ s/(.)\bextern\b\s(.*)/$1$2/;
7016	}
7017	}
7018
7019	# check for new externs in .c files.
7020	if ($realfile =~ /\.c$/ && defined $stat &&
7021	$stat =~ /^.\s(?:extern\s+)?$Type\s+($Ident)(\s)\(/s)
7022	{
7023	my $function_name = $1;
7024	my $paren_space = $2;
7025
7026	my $s = $stat;
7027	if (defined $cond) {
7028	substr($s, 0, length($cond), '');
7029	}
7030	if ($s =~ /^\s*;/)
7031	{
7032	WARN("AVOID_EXTERNS",
7033	"externs should be avoided in .c files\n" . $herecurr);
7034	}
7035
7036	if ($paren_space =~ /\n/) {
7037	WARN("FUNCTION_ARGUMENTS",
7038	"arguments for function declarations should follow identifier\n" . $herecurr);
7039	}
7040
7041	} elsif ($realfile =~ /\.c$/ && defined $stat &&
7042	$stat =~ /^.\s*extern\s+/)
7043	{
7044	WARN("AVOID_EXTERNS",
7045	"externs should be avoided in .c files\n" . $herecurr);
7046	}
7047
7048	# check for function declarations that have arguments without identifier names
7049	if (defined $stat &&
7050	$stat =~ /^.\s(?:extern\s+)?$Type\s(?:$Ident\|$\s\\s$Ident\s$)\s$\s([^{]+)\s$\s;/s &&
7051	$1 ne "void") {
7052	my $args = trim($1);
7053	while ($args =~ m/\s($Type\s(?:$Ident\|$\s\\s$Ident?\s$\s*$balanced_parens)?)/g) {
7054	my $arg = trim($1);
7055	if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
7056	WARN("FUNCTION_ARGUMENTS",
7057	"function definition argument '$arg' should also have an identifier name\n" . $herecurr);
7058	}
7059	}
7060	}
7061
7062	# check for function definitions
7063	if ($perl_version_ok &&
7064	defined $stat &&
7065	$stat =~ /^.\s(?:$Storage\s+)?$Type\s($Ident)\s$balanced_parens\s{/s) {
7066	$context_function = $1;
7067
7068	# check for multiline function definition with misplaced open brace
7069	my $ok = 0;
7070	my $cnt = statement_rawlines($stat);
7071	my $herectx = $here . "\n";
7072	for (my $n = 0; $n < $cnt; $n++) {
7073	my $rl = raw_line($linenr, $n);
7074	$herectx .= $rl . "\n";
7075	$ok = 1 if ($rl =~ /^[ \+]\{/);
7076	$ok = 1 if ($rl =~ /\{/ && $n == 0);
7077	last if $rl =~ /^[ \+].*\{/;
7078	}
7079	if (!$ok) {
7080	ERROR("OPEN_BRACE",
7081	"open brace '{' following function definitions go on the next line\n" . $herectx);
7082	}
7083	}
7084
7085	# checks for new __setup's
7086	if ($rawline =~ /\b__setup\("([^"]*)"/) {
7087	my $name = $1;
7088
7089	if (!grep(/$name/, @setup_docs)) {
7090	CHK("UNDOCUMENTED_SETUP",
7091	"__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
7092	}
7093	}
7094
7095	# check for pointless casting of alloc functions
7096	if ($line =~ /\\s\)\s*$allocFunctions\b/) {
7097	WARN("UNNECESSARY_CASTS",
7098	"unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
7099	}
7100
7101	# alloc style
7102	# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
7103	if ($perl_version_ok &&
7104	$line =~ /\b($Lval)\s\=\s(?:$balanced_parens)?\s((?:kv\|k\|v)[mz]alloc(?:_node)?)\s$\s(sizeof\s\(\sstruct\s+$Lval\s$)/) {
7105	CHK("ALLOC_SIZEOF_STRUCT",
7106	"Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
7107	}
7108
7109	# check for (kv\|k)[mz]alloc with multiplies that could be kmalloc_array/kvmalloc_array/kvcalloc/kcalloc
7110	if ($perl_version_ok &&
7111	defined $stat &&
7112	$stat =~ /^\+\s($Lval)\s\=\s(?:$balanced_parens)?\s((?:kv\|k)[mz]alloc)\s\(\s($FuncArg)\s\\s($FuncArg)\s,/) {
7113	my $oldfunc = $3;
7114	my $a1 = $4;
7115	my $a2 = $10;
7116	my $newfunc = "kmalloc_array";
7117	$newfunc = "kvmalloc_array" if ($oldfunc eq "kvmalloc");
7118	$newfunc = "kvcalloc" if ($oldfunc eq "kvzalloc");
7119	$newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
7120	my $r1 = $a1;
7121	my $r2 = $a2;
7122	if ($a1 =~ /^sizeof\s*\S/) {
7123	$r1 = $a2;
7124	$r2 = $a1;
7125	}
7126	if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
7127	!($r1 =~ /^$Constant$/ \|\| $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
7128	my $cnt = statement_rawlines($stat);
7129	my $herectx = get_stat_here($linenr, $cnt, $here);
7130
7131	if (WARN("ALLOC_WITH_MULTIPLY",
7132	"Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
7133	$cnt == 1 &&
7134	$fix) {
7135	$fixed[$fixlinenr] =~ s/\b($Lval)\s\=\s(?:$balanced_parens)?\s((?:kv\|k)[mz]alloc)\s\(\s($FuncArg)\s\\s($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
7136	}
7137	}
7138	}
7139
7140	# check for krealloc arg reuse
7141	if ($perl_version_ok &&
7142	$line =~ /\b($Lval)\s\=\s(?:$balanced_parens)?\skrealloc\s\(\s($Lval)\s,/ &&
7143	$1 eq $3) {
7144	WARN("KREALLOC_ARG_REUSE",
7145	"Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7146	}
7147
7148	# check for alloc argument mismatch
7149	if ($line =~ /\b((?:devm_)?((?:k\|kv)?(calloc\|malloc_array)(?:_node)?))\s\(\ssizeof\b/) {
7150	WARN("ALLOC_ARRAY_ARGS",
7151	"$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7152	}
7153
7154	# check for multiple semicolons
7155	if ($line =~ /;\s;\s$/) {
7156	if (WARN("ONE_SEMICOLON",
7157	"Statements terminations use 1 semicolon\n" . $herecurr) &&
7158	$fix) {
7159	$fixed[$fixlinenr] =~ s/(\s;\s){2,}$/;/g;
7160	}
7161	}
7162
7163	# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7164	if ($realfile !~ m@^include/uapi/@ &&
7165	$line =~ /#\sdefine\s+\w+\s+$?\s1\s([ulUL])\s\<\<\s(?:\d+\|$Ident)\s*$?/) {
7166	my $ull = "";
7167	$ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7168	if (CHK("BIT_MACRO",
7169	"Prefer using the BIT$ull macro\n" . $herecurr) &&
7170	$fix) {
7171	$fixed[$fixlinenr] =~ s/$?\s1\s[ulUL]\s<<\s(\d+\|$Ident)\s$?/BIT${ull}($1)/;
7172	}
7173	}
7174
7175	# check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7176	if ($rawline =~ /\bIS_ENABLED\s$\s(\w+)\s*$/ && $1 !~ /^${CONFIG_}/) {
7177	WARN("IS_ENABLED_CONFIG",
7178	"IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7179	}
7180
7181	# check for #if defined CONFIG_<FOO> \|\| defined CONFIG_<FOO>_MODULE
7182	if ($line =~ /^\+\s#\sif\s+defined(?:\s$?\s\|\s+)(${CONFIG_}[A-Z_]+)\s$?\s\\|\\|\sdefined(?:\s$?\s\|\s+)\1_MODULE\s$?\s*$/) {
7183	my $config = $1;
7184	if (WARN("PREFER_IS_ENABLED",
7185	"Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> \|\| ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7186	$fix) {
7187	$fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7188	}
7189	}
7190
7191	# check for /* fallthrough */ like comment, prefer fallthrough;
7192	my @fallthroughs = (
7193	'fallthrough',
7194	'@fallthrough@',
7195	'lint -fallthrough[ \t]*',
7196	'intentional(?:ly)?[ \t]*fall(?:(?:s \| \|-)[Tt]\|t)hr(?:ough\|u\|ew)',
7197	'(?:else,?\s)?FALL(?:S \| \|-)?THR(?:OUGH\|U\|EW)[ \t.!](?:-[^\n\r]*)?',
7198	'Fall(?:(?:s \| \|-)[Tt]\|t)hr(?:ough\|u\|ew)[ \t.!](?:-[^\n\r])?',
7199	'fall(?:s \| \|-)?thr(?:ough\|u\|ew)[ \t.!](?:-[^\n\r])?',
7200	);
7201	if ($raw_comment ne '') {
7202	foreach my $ft (@fallthroughs) {
7203	if ($raw_comment =~ /$ft/) {
7204	my $msg_level = \&WARN;
7205	$msg_level = \&CHK if ($file);
7206	&{$msg_level}("PREFER_FALLTHROUGH",
7207	"Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7208	last;
7209	}
7210	}
7211	}
7212
7213	# check for switch/default statements without a break;
7214	if ($perl_version_ok &&
7215	defined $stat &&
7216	$stat =~ /^\+[$;\s](?:case[$;\s]+\w+[$;\s]:[$;\s]\|)[$;\s]\bdefault[$;\s]:[$;\s]*;/g) {
7217	my $cnt = statement_rawlines($stat);
7218	my $herectx = get_stat_here($linenr, $cnt, $here);
7219
7220	WARN("DEFAULT_NO_BREAK",
7221	"switch default: should use break\n" . $herectx);
7222	}
7223
7224	# check for gcc specific __FUNCTION__
7225	if ($line =~ /\b__FUNCTION__\b/) {
7226	if (WARN("USE_FUNC",
7227	"__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
7228	$fix) {
7229	$fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7230	}
7231	}
7232
7233	# check for uses of __DATE__, __TIME__, __TIMESTAMP__
7234	while ($line =~ /\b(__(?:DATE\|TIME\|TIMESTAMP)__)\b/g) {
7235	ERROR("DATE_TIME",
7236	"Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7237	}
7238
7239	# check for use of yield()
7240	if ($line =~ /\byield\s$\s$/) {
7241	WARN("YIELD",
7242	"Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
7243	}
7244
7245	# check for comparisons against true and false
7246	if ($line =~ /\+\s(.?)\b(true\|false\|$Lval)\s(==\|\!=)\s(true\|false\|$Lval)\b(.*)$/i) {
7247	my $lead = $1;
7248	my $arg = $2;
7249	my $test = $3;
7250	my $otype = $4;
7251	my $trail = $5;
7252	my $op = "!";
7253
7254	($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true\|false)$/i);
7255
7256	my $type = lc($otype);
7257	if ($type =~ /^(?:true\|false)$/) {
7258	if (("$test" eq "==" && "$type" eq "true") \|\|
7259	("$test" eq "!=" && "$type" eq "false")) {
7260	$op = "";
7261	}
7262
7263	CHK("BOOL_COMPARISON",
7264	"Using comparison to $otype is error prone\n" . $herecurr);
7265
7266	## maybe suggesting a correct construct would better
7267	## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7268
7269	}
7270	}
7271
7272	# check for semaphores initialized locked
7273	if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7274	WARN("CONSIDER_COMPLETION",
7275	"consider using a completion\n" . $herecurr);
7276	}
7277
7278	# recommend kstrto* over simple_strto* and strict_strto*
7279	if ($line =~ /\b((simple\|strict)_(strto(l\|ll\|ul\|ull)))\s*\(/) {
7280	WARN("CONSIDER_KSTRTO",
7281	"$1 is obsolete, use k$3 instead\n" . $herecurr);
7282	}
7283
7284	# check for __initcall(), use device_initcall() explicitly or more appropriate function please
7285	if ($line =~ /^.\s__initcall\s\(/) {
7286	WARN("USE_DEVICE_INITCALL",
7287	"please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7288	}
7289
7290	# check for spin_is_locked(), suggest lockdep instead
7291	if ($line =~ /\bspin_is_locked\(/) {
7292	WARN("USE_LOCKDEP",
7293	"Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7294	}
7295
7296	# check for deprecated apis
7297	if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7298	my $deprecated_api = $1;
7299	my $new_api = $deprecated_apis{$deprecated_api};
7300	WARN("DEPRECATED_API",
7301	"Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7302	}
7303
7304	# check for various structs that are normally const (ops, kgdb, device_tree)
7305	# and avoid what seem like struct definitions 'struct foo {'
7306	if (defined($const_structs) &&
7307	$line !~ /\bconst\b/ &&
7308	$line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7309	WARN("CONST_STRUCT",
7310	"struct $1 should normally be const\n" . $herecurr);
7311	}
7312
7313	# use of NR_CPUS is usually wrong
7314	# ignore definitions of NR_CPUS and usage to define arrays as likely right
7315	# ignore designated initializers using NR_CPUS
7316	if ($line =~ /\bNR_CPUS\b/ &&
7317	$line !~ /^.\s\s#\sif\b.\bNR_CPUS\b/ &&
7318	$line !~ /^.\s\s#\sdefine\b.\bNR_CPUS\b/ &&
7319	$line !~ /^.\s$Declare\s.\[[^\]]NR_CPUS[^\]]\]/ &&
7320	$line !~ /\[[^\]]\.\.\.[^\]]NR_CPUS[^\]]*\]/ &&
7321	$line !~ /\[[^\]]NR_CPUS[^\]]\.\.\.[^\]]*\]/ &&
7322	$line !~ /^.\s\.\w+\s=\s.\bNR_CPUS\b/)
7323	{
7324	WARN("NR_CPUS",
7325	"usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7326	}
7327
7328	# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7329	if ($line =~ /\+\s#\sdefine\s+((?:__)?ARCH_(?:HAS\|HAVE)\w*)\b/) {
7330	ERROR("DEFINE_ARCH_HAS",
7331	"#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7332	}
7333
7334	# likely/unlikely comparisons similar to "(likely(foo) > 0)"
7335	if ($perl_version_ok &&
7336	$line =~ /\b((?:un)?likely)\s$\s$FuncArg\s$\s$Compare/) {
7337	WARN("LIKELY_MISUSE",
7338	"Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7339	}
7340
7341	# return sysfs_emit(foo, fmt, ...) fmt without newline
7342	if ($line =~ /\breturn\s+sysfs_emit\s\(\s$FuncArg\s,\s($String)/ &&
7343	substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7344	my $offset = $+[6] - 1;
7345	if (WARN("SYSFS_EMIT",
7346	"return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7347	$fix) {
7348	substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7349	}
7350	}
7351
7352	# nested likely/unlikely calls
7353	if ($line =~ /\b(?:(?:un)?likely)\s\(\s!?\s*(IS_ERR(?:_OR_NULL\|_VALUE)?\|WARN)/) {
7354	WARN("LIKELY_MISUSE",
7355	"nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7356	}
7357
7358	# whine mightly about in_atomic
7359	if ($line =~ /\bin_atomic\s*\(/) {
7360	if ($realfile =~ m@^drivers/@) {
7361	ERROR("IN_ATOMIC",
7362	"do not use in_atomic in drivers\n" . $herecurr);
7363	} elsif ($realfile !~ m@^kernel/@) {
7364	WARN("IN_ATOMIC",
7365	"use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7366	}
7367	}
7368
7369	# check for lockdep_set_novalidate_class
7370	if ($line =~ /^.\slockdep_set_novalidate_class\s\(/ \|\|
7371	$line =~ /__lockdep_no_validate__\s*\)/ ) {
7372	if ($realfile !~ m@^kernel/lockdep@ &&
7373	$realfile !~ m@^include/linux/lockdep@ &&
7374	$realfile !~ m@^drivers/base/core@) {
7375	ERROR("LOCKDEP",
7376	"lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7377	}
7378	}
7379
7380	if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ \|\|
7381	$line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7382	WARN("EXPORTED_WORLD_WRITABLE",
7383	"Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7384	}
7385
7386	# check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7387	# and whether or not function naming is typical and if
7388	# DEVICE_ATTR permissions uses are unusual too
7389	if ($perl_version_ok &&
7390	defined $stat &&
7391	$stat =~ /\bDEVICE_ATTR\s$\s(\w+)\s,\s\(?\s(\s(?:${multi_mode_perms_string_search}\|0[0-7]{3,3})\s)\s$?\s,\s(\w+)\s,\s(\w+)\s*\)/) {
7392	my $var = $1;
7393	my $perms = $2;
7394	my $show = $3;
7395	my $store = $4;
7396	my $octal_perms = perms_to_octal($perms);
7397	if ($show =~ /^${var}_show$/ &&
7398	$store =~ /^${var}_store$/ &&
7399	$octal_perms eq "0644") {
7400	if (WARN("DEVICE_ATTR_RW",
7401	"Use DEVICE_ATTR_RW\n" . $herecurr) &&
7402	$fix) {
7403	$fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s$\s$var\s,\s\Q$perms\E\s,\s$show\s,\s$store\s*$/DEVICE_ATTR_RW(${var})/;
7404	}
7405	} elsif ($show =~ /^${var}_show$/ &&
7406	$store =~ /^NULL$/ &&
7407	$octal_perms eq "0444") {
7408	if (WARN("DEVICE_ATTR_RO",
7409	"Use DEVICE_ATTR_RO\n" . $herecurr) &&
7410	$fix) {
7411	$fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s$\s$var\s,\s\Q$perms\E\s,\s$show\s,\sNULL\s*$/DEVICE_ATTR_RO(${var})/;
7412	}
7413	} elsif ($show =~ /^NULL$/ &&
7414	$store =~ /^${var}_store$/ &&
7415	$octal_perms eq "0200") {
7416	if (WARN("DEVICE_ATTR_WO",
7417	"Use DEVICE_ATTR_WO\n" . $herecurr) &&
7418	$fix) {
7419	$fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s$\s$var\s,\s\Q$perms\E\s,\sNULL\s,\s$store\s*$/DEVICE_ATTR_WO(${var})/;
7420	}
7421	} elsif ($octal_perms eq "0644" \|\|
7422	$octal_perms eq "0444" \|\|
7423	$octal_perms eq "0200") {
7424	my $newshow = "$show";
7425	$newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7426	my $newstore = $store;
7427	$newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7428	my $rename = "";
7429	if ($show ne $newshow) {
7430	$rename .= " '$show' to '$newshow'";
7431	}
7432	if ($store ne $newstore) {
7433	$rename .= " '$store' to '$newstore'";
7434	}
7435	WARN("DEVICE_ATTR_FUNCTIONS",
7436	"Consider renaming function(s)$rename\n" . $herecurr);
7437	} else {
7438	WARN("DEVICE_ATTR_PERMS",
7439	"DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7440	}
7441	}
7442
7443	# Mode permission misuses where it seems decimal should be octal
7444	# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7445	# o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7446	# specific definition of not visible in sysfs.
7447	# o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7448	# use the default permissions
7449	if ($perl_version_ok &&
7450	defined $stat &&
7451	$line =~ /$mode_perms_search/) {
7452	foreach my $entry (@mode_permission_funcs) {
7453	my $func = $entry->[0];
7454	my $arg_pos = $entry->[1];
7455
7456	my $lc = $stat =~ tr@\n@@;
7457	$lc = $lc + $linenr;
7458	my $stat_real = get_stat_real($linenr, $lc);
7459
7460	my $skip_args = "";
7461	if ($arg_pos > 1) {
7462	$arg_pos--;
7463	$skip_args = "(?:\\s$FuncArg\\s,\\s*){$arg_pos,$arg_pos}";
7464	}
7465	my $test = "\\b$func\\s\$${skip_args}($FuncArg(?:\\\|\\s$FuncArg))\\s[,\$]";
7466	if ($stat =~ /$test/) {
7467	my $val = $1;
7468	$val = $6 if ($skip_args ne "");
7469	if (!($func =~ /^(?:module_param\|proc_create)/ && $val eq "0") &&
7470	(($val =~ /^$Int$/ && $val !~ /^$Octal$/) \|\|
7471	($val =~ /^$Octal$/ && length($val) ne 4))) {
7472	ERROR("NON_OCTAL_PERMISSIONS",
7473	"Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7474	}
7475	if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7476	ERROR("EXPORTED_WORLD_WRITABLE",
7477	"Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7478	}
7479	}
7480	}
7481	}
7482
7483	# check for uses of S_<PERMS> that could be octal for readability
7484	while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7485	my $oval = $1;
7486	my $octal = perms_to_octal($oval);
7487	if (WARN("SYMBOLIC_PERMS",
7488	"Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7489	$fix) {
7490	$fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7491	}
7492	}
7493
7494	# validate content of MODULE_LICENSE against list from include/linux/module.h
7495	if ($line =~ /\bMODULE_LICENSE\s$\s($String)\s*$/) {
7496	my $extracted_string = get_quoted_string($line, $rawline);
7497	my $valid_licenses = qr{
7498	GPL\|
7499	GPL\ v2\|
7500	GPL\ and\ additional\ rights\|
7501	Dual\ BSD/GPL\|
7502	Dual\ MIT/GPL\|
7503	Dual\ MPL/GPL\|
7504	Proprietary
7505	}x;
7506	if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7507	WARN("MODULE_LICENSE",
7508	"unknown module license " . $extracted_string . "\n" . $herecurr);
7509	}
7510	if (!$file && $extracted_string eq '"GPL v2"') {
7511	if (WARN("MODULE_LICENSE",
7512	"Prefer \"GPL\" over \"GPL v2\" - see commit bf7fbeeae6db (\"module: Cure the MODULE_LICENSE \"GPL\" vs. \"GPL v2\" bogosity\")\n" . $herecurr) &&
7513	$fix) {
7514	$fixed[$fixlinenr] =~ s/\bMODULE_LICENSE\s$\s"GPL v2"\s*$/MODULE_LICENSE("GPL")/;
7515	}
7516	}
7517	}
7518
7519	# check for sysctl duplicate constants
7520	if ($line =~ /\.extra[12]\s=\s&(zero\|one\|int_max)\b/) {
7521	WARN("DUPLICATED_SYSCTL_CONST",
7522	"duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7523	}
7524	}
7525
7526	# If we have no input at all, then there is nothing to report on
7527	# so just keep quiet.
7528	if ($#rawlines == -1) {
7529	exit(0);
7530	}
7531
7532	# In mailback mode only produce a report in the negative, for
7533	# things that appear to be patches.
7534	if ($mailback && ($clean == 1 \|\| !$is_patch)) {
7535	exit(0);
7536	}
7537
7538	# This is not a patch, and we are in 'no-patch' mode so
7539	# just keep quiet.
7540	if (!$chk_patch && !$is_patch) {
7541	exit(0);
7542	}
7543
7544	if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7545	ERROR("NOT_UNIFIED_DIFF",
7546	"Does not appear to be a unified-diff format patch\n");
7547	}
7548	if ($is_patch && $has_commit_log && $chk_signoff) {
7549	if ($signoff == 0) {
7550	ERROR("MISSING_SIGN_OFF",
7551	"Missing Signed-off-by: line(s)\n");
7552	} elsif ($authorsignoff != 1) {
7553	# authorsignoff values:
7554	# 0 -> missing sign off
7555	# 1 -> sign off identical
7556	# 2 -> names and addresses match, comments mismatch
7557	# 3 -> addresses match, names different
7558	# 4 -> names match, addresses different
7559	# 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7560
7561	my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7562
7563	if ($authorsignoff == 0) {
7564	ERROR("NO_AUTHOR_SIGN_OFF",
7565	"Missing Signed-off-by: line by nominal patch author '$author'\n");
7566	} elsif ($authorsignoff == 2) {
7567	CHK("FROM_SIGN_OFF_MISMATCH",
7568	"From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7569	} elsif ($authorsignoff == 3) {
7570	WARN("FROM_SIGN_OFF_MISMATCH",
7571	"From:/Signed-off-by: email name mismatch: $sob_msg\n");
7572	} elsif ($authorsignoff == 4) {
7573	WARN("FROM_SIGN_OFF_MISMATCH",
7574	"From:/Signed-off-by: email address mismatch: $sob_msg\n");
7575	} elsif ($authorsignoff == 5) {
7576	WARN("FROM_SIGN_OFF_MISMATCH",
7577	"From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7578	}
7579	}
7580	}
7581
7582	print report_dump();
7583	if ($summary && !($clean == 1 && $quiet == 1)) {
7584	print "$filename " if ($summary_file);
7585	print "total: $cnt_error errors, $cnt_warn warnings, " .
7586	(($check)? "$cnt_chk checks, " : "") .
7587	"$cnt_lines lines checked\n";
7588	}
7589
7590	if ($quiet == 0) {
7591	# If there were any defects found and not already fixing them
7592	if (!$clean and !$fix) {
7593	print << "EOM"
7594
7595	NOTE: For some of the reported defects, checkpatch may be able to
7596	mechanically convert to the typical style using --fix or --fix-inplace.
7597	EOM
7598	}
7599	# If there were whitespace errors which cleanpatch can fix
7600	# then suggest that.
7601	if ($rpt_cleaners) {
7602	$rpt_cleaners = 0;
7603	print << "EOM"
7604
7605	NOTE: Whitespace errors detected.
7606	You may wish to use scripts/cleanpatch or scripts/cleanfile
7607	EOM
7608	}
7609	}
7610
7611	if ($clean == 0 && $fix &&
7612	("@rawlines" ne "@fixed" \|\|
7613	$#fixed_inserted >= 0 \|\| $#fixed_deleted >= 0)) {
7614	my $newfile = $filename;
7615	$newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7616	my $linecount = 0;
7617	my $f;
7618
7619	@fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7620
7621	open($f, '>', $newfile)
7622	or die "$P: Can't open $newfile for write\n";
7623	foreach my $fixed_line (@fixed) {
7624	$linecount++;
7625	if ($file) {
7626	if ($linecount > 3) {
7627	$fixed_line =~ s/^\+//;
7628	print $f $fixed_line . "\n";
7629	}
7630	} else {
7631	print $f $fixed_line . "\n";
7632	}
7633	}
7634	close($f);
7635
7636	if (!$quiet) {
7637	print << "EOM";
7638
7639	Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7640
7641	Do _NOT_ trust the results written to this file.
7642	Do _NOT_ submit these changes without inspecting them for correctness.
7643
7644	This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7645	No warranties, expressed or implied...
7646	EOM
7647	}
7648	}
7649
7650	if ($quiet == 0) {
7651	print "\n";
7652	if ($clean == 1) {
7653	print "$vname has no obvious style problems and is ready for submission.\n";
7654	} else {
7655	print "$vname has style problems, please review.\n";
7656	}
7657	}
7658	return $clean;
7659	}