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