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

use strict;

my $P = $0;
10
$P =~ s@.*/@@g;
11

12
my $V = '0.10';
13
14
15
16
17
18
19

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

my $quiet = 0;
my $tree = 1;
my $chk_signoff = 1;
my $chk_patch = 1;
20
my $tst_type = 0;
21
22
23
24
25
GetOptions(
	'q|quiet'	=> \$quiet,
	'tree!'		=> \$tree,
	'signoff!'	=> \$chk_signoff,
	'patch!'	=> \$chk_patch,
26
	'test-type!'	=> \$tst_type,
27
28
29
30
31
) or exit;

my $exit = 0;

if ($#ARGV < 0) {
32
	print "usage: $P [options] patchfile\n";
33
34
35
36
37
38
39
40
41
42
43
	print "version: $V\n";
	print "options: -q           => quiet\n";
	print "         --no-tree    => run without a kernel tree\n";
	exit(1);
}

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

44
45
my @dep_includes = ();
my @dep_functions = ();
46
47
48
49
my $removal = 'Documentation/feature-removal-schedule.txt';
if ($tree && -f $removal) {
	open(REMOVE, "<$removal") || die "$P: $removal: open failed - $!\n";
	while (<REMOVE>) {
50
51
52
		if (/^Check:\s+(.*\S)/) {
			for my $entry (split(/[, ]+/, $1)) {
				if ($entry =~ m@include/(.*)@) {
53
54
					push(@dep_includes, $1);

55
56
57
				} elsif ($entry !~ m@/@) {
					push(@dep_functions, $entry);
				}
58
			}
59
60
61
62
		}
	}
}

63
my @rawlines = ();
64
65
while (<>) {
	chomp;
66
	push(@rawlines, $_);
67
	if (eof(ARGV)) {
68
		if (!process($ARGV, @rawlines)) {
69
70
			$exit = 1;
		}
71
		@rawlines = ();
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
	}
}

exit($exit);

sub top_of_kernel_tree {
	if ((-f "COPYING") && (-f "CREDITS") && (-f "Kbuild") &&
	    (-f "MAINTAINERS") && (-f "Makefile") && (-f "README") &&
	    (-d "Documentation") && (-d "arch") && (-d "include") &&
	    (-d "drivers") && (-d "fs") && (-d "init") && (-d "ipc") &&
	    (-d "kernel") && (-d "lib") && (-d "scripts")) {
		return 1;
	}
	return 0;
}

sub expand_tabs {
	my ($str) = @_;

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

	return $res;
}

109
110
111
112
113
114
115
116
117
118
119
120
121
sub line_stats {
	my ($line) = @_;

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

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

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

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
sub sanitise_line {
	my ($line) = @_;

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

	my $quote = '';

	foreach my $c (split(//, $line)) {
		if ($l ne "\\" && ($c eq "'" || $c eq '"')) {
			if ($quote eq '') {
				$quote = $c;
				$res .= $c;
				$l = $c;
				next;
			} elsif ($quote eq $c) {
				$quote = '';
			}
		}
		if ($quote && $c ne "\t") {
			$res .= "X";
		} else {
			$res .= $c;
		}

		$l = $c;
	}

	return $res;
}

153
sub ctx_block_get {
154
	my ($linenr, $remain, $outer, $open, $close, $off) = @_;
155
156
157
158
159
160
161
	my $line;
	my $start = $linenr - 1;
	my $blk = '';
	my @o;
	my @c;
	my @res = ();

162
	my $level = 0;
163
164
165
166
167
	for ($line = $start; $remain > 0; $line++) {
		next if ($rawlines[$line] =~ /^-/);
		$remain--;

		$blk .= $rawlines[$line];
168
169
170
171
172
173
		foreach my $c (split(//, $rawlines[$line])) {
			##print "C<$c>L<$level><$open$close>O<$off>\n";
			if ($off > 0) {
				$off--;
				next;
			}
174

175
176
177
178
179
180
181
			if ($c eq $close && $level > 0) {
				$level--;
				last if ($level == 0);
			} elsif ($c eq $open) {
				$level++;
			}
		}
182

183
		if (!$outer || $level <= 1) {
184
			push(@res, $rawlines[$line]);
185
186
		}

187
		last if ($level == 0);
188
189
	}

190
	return ($level, @res);
191
192
193
194
}
sub ctx_block_outer {
	my ($linenr, $remain) = @_;

195
196
	my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
	return @r;
197
198
199
200
}
sub ctx_block {
	my ($linenr, $remain) = @_;

201
202
	my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
	return @r;
203
204
}
sub ctx_statement {
205
206
207
208
209
210
	my ($linenr, $remain, $off) = @_;

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

213
	return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
214
}
215
216
217
218
219
sub ctx_statement_level {
	my ($linenr, $remain, $off) = @_;

	return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
}
220
221
222
223
224

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

	# Catch a comment on the end of the line itself.
225
	my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
226
227
228
229
230
231
232
	return $current_comment if (defined $current_comment);

	# Look through the context and try and figure out if there is a
	# comment.
	my $in_comment = 0;
	$current_comment = '';
	for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
233
234
		my $line = $rawlines[$linenr - 1];
		#warn "           $line\n";
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
		if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
			$in_comment = 1;
		}
		if ($line =~ m@/\*@) {
			$in_comment = 1;
		}
		if (!$in_comment && $current_comment ne '') {
			$current_comment = '';
		}
		$current_comment .= $line . "\n" if ($in_comment);
		if ($line =~ m@\*/@) {
			$in_comment = 0;
		}
	}

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

257
	##print "LINE: $rawlines[$end_line - 1 ]\n";
258
259
260
261
262
	##print "CMMT: $cmt\n";

	return ($cmt ne '');
}

263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
sub ctx_expr_before {
	my ($line) = @_;

	##print "CHECK<$line>\n";

	my $pos = length($line) - 1;
	my $count = 0;
	my $c;

	for (; $pos >= 0; $pos--) {
		$c = substr($line, $pos, 1);
		##print "CHECK: c<$c> count<$count>\n";
		if ($c eq ')') {
			$count++;
		} elsif ($c eq '(') {
			last if (--$count == 0);
		}
	}

	##print "CHECK: result<" . substr($line, 0, $pos) . ">\n";

	return substr($line, 0, $pos);
}

287
288
sub cat_vet {
	my ($vet) = @_;
289
	my ($res, $coded);
290

291
292
293
294
295
296
	$res = '';
	while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]])/g) {
		$coded = sprintf("^%c", unpack('C', $2) + 64);
		$res .= $1 . $coded;
	}
	$res =~ s/$/\$/;
297

298
	return $res;
299
300
}

301
302
303
304
305
306
307
my @report = ();
sub report {
	push(@report, $_[0]);
}
sub report_dump {
	@report;
}
308
sub ERROR {
309
	report("ERROR: $_[0]\n");
310
311
312
	our $clean = 0;
}
sub WARN {
313
	report("WARNING: $_[0]\n");
314
315
316
	our $clean = 0;
}
sub CHK {
317
	report("CHECK: $_[0]\n");
318
319
320
	our $clean = 0;
}

321
322
323
324
325
326
327
328
sub process {
	my $filename = shift;
	my @lines = @_;

	my $linenr=0;
	my $prevline="";
	my $stashline="";

329
	my $length;
330
331
332
333
	my $indent;
	my $previndent=0;
	my $stashindent=0;

334
	our $clean = 1;
335
336
337
338
339
340
341
342
343
344
345
	my $signoff = 0;
	my $is_patch = 0;

	# Trace the real file/line as we go.
	my $realfile = '';
	my $realline = 0;
	my $realcnt = 0;
	my $here = '';
	my $in_comment = 0;
	my $first_line = 0;

346
	my $Ident	= qr{[A-Za-z\d_]+};
347
348
349
350
351
352
353
354
355
356
357
	my $Storage	= qr{extern|static|asmlinkage};
	my $Sparse	= qr{
				__user|
				__kernel|
				__force|
				__iomem|
				__must_check|
				__init_refok|
				fastcall
			}x;
	my $Inline	= qr{inline|__always_inline|noinline};
358
359
360
361
362
363
364
365
366
367
368
369
370
	my $NonptrType	= qr{
				\b
				(?:const\s+)?
				(?:unsigned\s+)?
				(?:
					void|
					char|
					short|
					int|
					long|
					unsigned|
					float|
					double|
371
					bool|
372
373
374
					long\s+int|
					long\s+long|
					long\s+long\s+int|
375
376
					u8|u16|u32|u64|
					s8|s16|s32|s64|
377
378
					struct\s+$Ident|
					union\s+$Ident|
379
					enum\s+$Ident|
380
381
382
383
384
385
386
					${Ident}_t
				)
				(?:\s+$Sparse)*
				\b
			  }x;
	my $Type	= qr{
				\b$NonptrType\b
387
388
				(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
				(?:\s+$Sparse)*
389
390
			  }x;
	my $Declare	= qr{(?:$Storage\s+)?$Type};
391
392
393
394
395
	my $Attribute	= qr{
				const|
				__read_mostly|
				__(?:mem|cpu|dev|)(?:initdata|init)
			  }x;
396
397
	my $Member	= qr{->$Ident|\.$Ident|\[[^]]*\]};
	my $Lval	= qr{$Ident(?:$Member)*};
398

399
400
401
402
	# Possible bare types.
	my @bare = ();
	my $Bare = $NonptrType;

403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
	# Pre-scan the patch looking for any __setup documentation.
	my @setup_docs = ();
	my $setup_docs = 0;
	foreach my $line (@lines) {
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$setup_docs = 0;
			if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
				$setup_docs = 1;
			}
			next;
		}

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

420
421
422
	foreach my $line (@lines) {
		$linenr++;

423
424
		my $rawline = $line;

425
426
427
#extract the filename as it passes
		if ($line=~/^\+\+\+\s+(\S+)/) {
			$realfile=$1;
428
			$realfile =~ s@^[^/]*/@@;
429
430
431
432
433
434
			$in_comment = 0;
			next;
		}
#extract the line range in the file after the patch is applied
		if ($line=~/^\@\@ -\d+,\d+ \+(\d+)(,(\d+))? \@\@/) {
			$is_patch = 1;
435
			$first_line = $linenr + 1;
436
437
438
439
440
441
442
443
444
445
			$in_comment = 0;
			$realline=$1-1;
			if (defined $2) {
				$realcnt=$3+1;
			} else {
				$realcnt=1+1;
			}
			next;
		}

446
447
448
449
# track the line number as we move through the hunk, note that
# new versions of GNU diff omit the leading space on completely
# blank context lines so we need to count that too.
		if ($line =~ /^( |\+|$)/) {
450
			$realline++;
451
			$realcnt-- if ($realcnt != 0);
452
453
454
455
456
457
458
459

			# track any sort of multi-line comment.  Obviously if
			# the added text or context do not include the whole
			# comment we will not see it. Such is life.
			#
			# Guestimate if this is a continuing comment.  If this
			# is the start of a diff block and this line starts
			# ' *' then it is very likely a comment.
460
			if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
461
462
463
464
465
466
467
468
469
				$in_comment = 1;
			}
			if ($line =~ m@/\*@) {
				$in_comment = 1;
			}
			if ($line =~ m@\*/@) {
				$in_comment = 0;
			}

470
471
			# Measure the line length and indent.
			($length, $indent) = line_stats($line);
472
473
474
475

			# Track the previous line.
			($prevline, $stashline) = ($stashline, $line);
			($previndent, $stashindent) = ($stashindent, $indent);
476
477
		} elsif ($realcnt == 1) {
			$realcnt--;
478
479
480
		}

#make up the handle for any error we report on this line
481
482
		$here = "#$linenr: ";
		$here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
483

484
		my $hereline = "$here\n$line\n";
485
486
		my $herecurr = "$here\n$line\n";
		my $hereprev = "$here\n$prevline\n$line\n";
487
488

#check the patch for a signoff:
489
		if ($line =~ /^\s*signed-off-by:/i) {
490
491
			# This is a signoff, if ugly, so do not double report.
			$signoff++;
492
			if (!($line =~ /^\s*Signed-off-by:/)) {
493
494
				WARN("Signed-off-by: is the preferred form\n" .
					$herecurr);
495
496
			}
			if ($line =~ /^\s*signed-off-by:\S/i) {
497
498
				WARN("need space after Signed-off-by:\n" .
					$herecurr);
499
500
501
			}
		}

502
503
# Check for wrappage within a valid hunk of the file
		if ($realcnt != 0 && $line !~ m{^(?:\+|-| |$)}) {
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
			ERROR("patch seems to be corrupt (line wrapped?)\n" .
				$herecurr);
		}

# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
		if (($realfile =~ /^$/ || $line =~ /^\+/) &&
		     !($line =~ m/^(
				[\x09\x0A\x0D\x20-\x7E]              # ASCII
				| [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
				|  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
				| [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
				|  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
				|  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
				| [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
				|  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
				)*$/x )) {
			ERROR("Invalid UTF-8\n" . $herecurr);
521
522
523
524
		}

#ignore lines being removed
		if ($line=~/^-/) {next;}
525

526
527
# check we are in a valid source file if not then ignore this hunk
		next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
528
529

#trailing whitespace
530
531
532
533
534
		if ($line =~ /^\+.*\015/) {
			my $herevet = "$here\n" . cat_vet($line) . "\n";
			ERROR("DOS line endings\n" . $herevet);

		} elsif ($line =~ /^\+.*\S\s+$/ || $line =~ /^\+\s+$/) {
535
536
			my $herevet = "$here\n" . cat_vet($line) . "\n";
			ERROR("trailing whitespace\n" . $herevet);
537
538
		}
#80 column limit
539
		if ($line =~ /^\+/ && !($prevline=~/\/\*\*/) && $length > 80) {
540
			WARN("line over 80 characters\n" . $herecurr);
541
542
543
544
545
546
547
548
		}

# check we are in a valid source file *.[hc] if not then ignore this hunk
		next if ($realfile !~ /\.[hc]$/);

# at the beginning of a line any tabs must come first and anything
# more than 8 must use tabs.
		if ($line=~/^\+\s* \t\s*\S/ or $line=~/^\+\s*        \s*/) {
549
550
			my $herevet = "$here\n" . cat_vet($line) . "\n";
			ERROR("use tabs not spaces\n" . $herevet);
551
552
		}

553
# Remove comments from the line before processing.
554
555
556
557
558
559
560
561
		my $comment_edge = ($line =~ s@/\*.*\*/@@g) +
				   ($line =~ s@/\*.*@@) +
				   ($line =~ s@^(.).*\*/@$1@);

# The rest of our checks refer specifically to C style
# only apply those _outside_ comments.  Only skip
# lines in the middle of comments.
		next if (!$comment_edge && $in_comment);
562

563
564
565
# Standardise the strings and chars within the input to simplify matching.
		$line = sanitise_line($line);

566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
# Check for potential 'bare' types
		if ($realcnt &&
		    $line !~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?$Type\b/ &&
		    $line !~ /$Ident:\s*$/ &&
		    $line !~ /^.\s*$Ident\s*\(/ &&
		    ($line =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?($Ident)\b/ ||
		     $line =~ /^.\s*(?:$Storage\s+)?($Ident)\b\s*\**\s*$Ident\s*(?:;|=)/)) {
			my $possible = $1;
			if ($possible !~ /^(?:$Storage|$Type|DEFINE_\S+)$/ &&
			    $possible ne 'goto' && $possible ne 'return' &&
			    $possible ne 'struct' && $possible ne 'enum' &&
			    $possible ne 'case' && $possible ne 'else' &&
			    $possible ne 'typedef') {
				#print "POSSIBLE<$possible>\n";
				push(@bare, $possible);
				my $bare = join("|", @bare);
				$Bare	= qr{
						\b(?:$bare)\b
						(?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
						(?:\s+$Sparse)*
					  }x;
			}
		}

590
591
592
#
# Checks which may be anchored in the context.
#
593

594
595
# Check for switch () and associated case and default
# statements should be at the same indent.
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
		if ($line=~/\bswitch\s*\(.*\)/) {
			my $err = '';
			my $sep = '';
			my @ctx = ctx_block_outer($linenr, $realcnt);
			shift(@ctx);
			for my $ctx (@ctx) {
				my ($clen, $cindent) = line_stats($ctx);
				if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
							$indent != $cindent) {
					$err .= "$sep$ctx\n";
					$sep = '';
				} else {
					$sep = "[...]\n";
				}
			}
			if ($err ne '') {
612
				ERROR("switch and case should be at the same indent\n$hereline$err");
613
614
615
616
617
618
			}
		}

# if/while/etc brace do not go on next line, unless defining a do while loop,
# or if that brace on the next line is for something else
		if ($line =~ /\b(?:(if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.#/) {
619
			my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
620
621
622
623
			my $ctx_ln = $linenr + $#ctx + 1;
			my $ctx_cnt = $realcnt - $#ctx - 1;
			my $ctx = join("\n", @ctx);

624
			# Skip over any removed lines in the context following statement.
625
626
627
628
629
630
631
			while ($ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^-/) {
				$ctx_ln++;
				$ctx_cnt--;
			}
			##warn "line<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>";

			if ($ctx !~ /{\s*/ && $ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
632
				ERROR("That open brace { should be on the previous line\n" .
633
					"$here\n$ctx\n$lines[$ctx_ln - 1]");
634
			}
635
636
637
638
639
640
641
			if ($level == 0 && $ctx =~ /\)\s*\;\s*$/ && defined $lines[$ctx_ln - 1]) {
				my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
				if ($nindent > $indent) {
					WARN("Trailing semicolon indicates no statements, indent implies otherwise\n" .
						"$here\n$ctx\n$lines[$ctx_ln - 1]");
				}
			}
642
643
644
645
646
		}

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

647
648
# TEST: allow direct testing of the type matcher.
		if ($tst_type && $line =~ /^.$Declare$/) {
649
			ERROR("TEST: is type $Declare\n" . $herecurr);
650
651
652
			next;
		}

653
654
655
656
657
658
# check for initialisation to aggregates open brace on the next line
		if ($prevline =~ /$Declare\s*$Ident\s*=\s*$/ &&
		    $line =~ /^.\s*{/) {
			ERROR("That open brace { should be on the previous line\n" . $hereprev);
		}

659
660
661
662
663
664
665
666
#
# Checks which are anchored on the added line.
#

# check for malformed paths in #include statements (uses RAW line)
		if ($rawline =~ m{^.#\s*include\s+[<"](.*)[">]}) {
			my $path = $1;
			if ($path =~ m{//}) {
667
668
				ERROR("malformed #include filename\n" .
					$herecurr);
669
670
671
672
673
			}
			# Sanitise this special form of string.
			$path = 'X' x length($path);
			$line =~ s{\<.*\>}{<$path>};
		}
674

675
# no C99 // comments
676
		if ($line =~ m{//}) {
677
			ERROR("do not use C99 // comments\n" . $herecurr);
678
		}
679
		# Remove C99 comments.
680
681
682
		$line =~ s@//.*@@;

#EXPORT_SYMBOL should immediately follow its function closing }.
683
684
685
		if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
		    ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
			my $name = $1;
686
687
			if (($prevline !~ /^}/) &&
			   ($prevline !~ /^\+}/) &&
688
			   ($prevline !~ /^ }/) &&
689
			   ($prevline !~ /\b\Q$name\E(?:\s+$Attribute)?\s*(?:;|=)/)) {
690
				WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
691
692
693
			}
		}

694
695
696
697
698
# check for external initialisers.
		if ($line =~ /^.$Type\s*$Ident\s*=\s*(0|NULL);/) {
			ERROR("do not initialise externals to 0 or NULL\n" .
				$herecurr);
		}
699
# check for static initialisers.
700
		if ($line =~ /\s*static\s.*=\s*(0|NULL);/) {
701
702
			ERROR("do not initialise statics to 0 or NULL\n" .
				$herecurr);
703
704
		}

705
706
707
# check for new typedefs, only function parameters and sparse annotations
# make sense.
		if ($line =~ /\btypedef\s/ &&
708
		    $line !~ /\btypedef\s+$Type\s+\(\s*\*?$Ident\s*\)\s*\(/ &&
709
		    $line !~ /\b__bitwise(?:__|)\b/) {
710
			WARN("do not add new typedefs\n" . $herecurr);
711
712
713
		}

# * goes on variable not on type
714
		if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
715
716
			ERROR("\"(foo$1)\" should be \"(foo $1)\"\n" .
				$herecurr);
717
718

		} elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) {
719
720
			ERROR("\"(foo $1 )\" should be \"(foo $1)\"\n" .
				$herecurr);
721

722
		} elsif ($line =~ m{$NonptrType(\*+)(?:\s+(?:$Attribute|$Sparse))?\s+[A-Za-z\d_]+}) {
723
724
			ERROR("\"foo$1 bar\" should be \"foo $1bar\"\n" .
				$herecurr);
725

726
		} elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+(?:$Attribute|$Sparse))\s+[A-Za-z\d_]+}) {
727
728
			ERROR("\"foo $1 bar\" should be \"foo $1bar\"\n" .
				$herecurr);
729
730
731
732
733
734
735
736
737
		}

# # no BUG() or BUG_ON()
# 		if ($line =~ /\b(BUG|BUG_ON)\b/) {
# 			print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
# 			print "$herecurr";
# 			$clean = 0;
# 		}

738
739
740
741
742
# printk should use KERN_* levels.  Note that follow on printk's on the
# same line do not need a level, so we use the current block context
# to try and find and validate the current printk.  In summary the current
# printk includes all preceeding printk's which have no newline on the end.
# we assume the first bad printk is the one to report.
743
		if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
744
745
746
747
748
749
750
751
752
753
754
755
756
			my $ok = 0;
			for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
				#print "CHECK<$lines[$ln - 1]\n";
				# we have a preceeding printk if it ends
				# with "\n" ignore it, else it is to blame
				if ($lines[$ln - 1] =~ m{\bprintk\(}) {
					if ($rawlines[$ln - 1] !~ m{\\n"}) {
						$ok = 1;
					}
					last;
				}
			}
			if ($ok == 0) {
757
				WARN("printk() should include KERN_ facility level\n" . $herecurr);
758
			}
759
760
		}

761
762
# function brace can't be on same line, except for #defines of do while,
# or if closed on same line
763
		if (($line=~/$Type\s*[A-Za-z\d_]+\(.*\).* {/) and
764
		    !($line=~/\#define.*do\s{/) and !($line=~/}/)) {
765
			ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);
766
		}
767

768
769
# check for spaces between functions and their parentheses.
		if ($line =~ /($Ident)\s+\(/ &&
770
		    $1 !~ /^(?:if|for|while|switch|return|volatile|__volatile__|__attribute__|format|__extension__|Copyright)$/ &&
771
		    $line !~ /$Type\s+\(/ && $line !~ /^.\#\s*define\b/) {
772
			WARN("no space between function name and open parenthesis '('\n" . $herecurr);
773
		}
774
# Check operator spacing.
775
776
777
		# Note we expand the line with the leading + as the real
		# line will be displayed with the leading + and the tabs
		# will therefore also expand that way.
778
		my $opline = $line;
779
		$opline = expand_tabs($opline);
780
		$opline =~ s/^./ /;
781
		if (!($line=~/\#\s*include/)) {
782
783
784
785
786
787
788
			my $ops = qr{
				<<=|>>=|<=|>=|==|!=|
				\+=|-=|\*=|\/=|%=|\^=|\|=|&=|
				=>|->|<<|>>|<|>|=|!|~|
				&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/
			}x;
			my @elements = split(/($ops|;)/, $opline);
789
			my $off = 0;
790
			for (my $n = 0; $n < $#elements; $n += 2) {
791
792
793
794
795
796
797
798
799
				$off += length($elements[$n]);

				my $a = '';
				$a = 'V' if ($elements[$n] ne '');
				$a = 'W' if ($elements[$n] =~ /\s$/);
				$a = 'B' if ($elements[$n] =~ /(\[|\()$/);
				$a = 'O' if ($elements[$n] eq '');
				$a = 'E' if ($elements[$n] eq '' && $n == 0);

800
				my $op = $elements[$n + 1];
801
802

				my $c = '';
803
				if (defined $elements[$n + 2]) {
804
805
806
807
					$c = 'V' if ($elements[$n + 2] ne '');
					$c = 'W' if ($elements[$n + 2] =~ /^\s/);
					$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
					$c = 'O' if ($elements[$n + 2] eq '');
808
					$c = 'E' if ($elements[$n + 2] =~ /\s*\\$/);
809
810
				} else {
					$c = 'E';
811
812
				}

813
				# Pick up the preceeding and succeeding characters.
814
				my $ca = substr($opline, 0, $off);
815
				my $cc = '';
816
				if (length($opline) >= ($off + length($elements[$n + 1]))) {
817
					$cc = substr($opline, $off + length($elements[$n + 1]));
818
				}
819
				my $cb = "$ca$;$cc";
820

821
822
823
824
825
				my $ctx = "${a}x${c}";

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

				my $ptr = (" " x $off) . "^";
826
				my $hereptr = "$hereline$ptr\n";
827

828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
				# Classify operators into binary, unary, or
				# definitions (* only) where they have more
				# than one mode.
				my $unary_ctx = $prevline . $ca;
				$unary_ctx =~ s/^./ /;
				my $is_unary = 0;
				my $Unary = qr{
					(?:
						^|;|,|$ops|\(|\?|:|
						\(\s*$Type\s*\)|
						$Type|
						return|case|else|
						\{|\}|
						\[|
						^.\#\s*define\s+$Ident\s*(?:\([^\)]*\))?|
						^.\#\s*else|
						^.\#\s*endif|
						^.\#\s*(?:if|ifndef|ifdef)\b.*
					)\s*(?:|\\)\s*$
				}x;
				my $UnaryFalse = qr{
					sizeof\s*\(\s*$Type\s*\)\s*$
				}x;
				my $UnaryDefine = qr{
					 (?:$Type|$Bare)\s*|
					 (?:$Type|$Bare).*,\s*\**
				}x;
				if ($op eq '-' || $op eq '&' || $op eq '*') {
					# An operator is binary if the left hand
					# side is a value.  Pick out the known
					# non-values.
					if ($unary_ctx =~ /$Unary$/s &&
					    $unary_ctx !~ /$UnaryFalse$/s) {
						$is_unary = 1;

					# Special handling for ')' check if this
					# brace represents a conditional, if so
					# we are unary.
					} elsif ($unary_ctx =~ /\)\s*$/) {
						my $before = ctx_expr_before($unary_ctx);
						if ($before =~ /(?:for|if|while)\s*$/) {
							$is_unary = 1;
						}
					}

					# Check for type definition for of '*'.
					if ($op eq '*' && $unary_ctx =~ /$UnaryDefine$/) {
						$is_unary = 2;
					}
				}

				#if ($op eq '-' || $op eq '&' || $op eq '*') {
				#	print "UNARY: <$is_unary $a:$op:$c> <$ca:$op:$cc> <$unary_ctx>\n";
				#}
882

883
884
				# ; should have either the end of line or a space or \ after it
				if ($op eq ';') {
885
886
887
					if ($ctx !~ /.x[WEB]/ && $cc !~ /^\\/ &&
					    $cc !~ /^;/) {
						ERROR("need space after that '$op' $at\n" . $hereptr);
888
889
890
891
					}

				# // is a comment
				} elsif ($op eq '//') {
892
893
894

				# -> should have no spaces
				} elsif ($op eq '->') {
895
					if ($ctx =~ /Wx.|.xW/) {
896
						ERROR("no spaces around that '$op' $at\n" . $hereptr);
897
898
899
900
					}

				# , must have a space on the right.
				} elsif ($op eq ',') {
901
					if ($ctx !~ /.xW|.xE/ && $cc !~ /^}/) {
902
						ERROR("need space after that '$op' $at\n" . $hereptr);
903
904
					}

905
906
907
908
909
910
911
912
913
914
				# '*' as part of a type definition -- reported already.
				} elsif ($op eq '*' && $is_unary == 2) {
					#warn "'*' is part of type\n";

				# unary operators should have a space before and
				# none after.  May be left adjacent to another
				# unary operator, or a cast
				} elsif ($op eq '!' || $op eq '~' ||
				         ($is_unary && ($op eq '*' || $op eq '-' || $op eq '&'))) {
					if ($ctx !~ /[WEB]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
915
						ERROR("need space before that '$op' $at\n" . $hereptr);
916
					}
917
					if ($ctx =~ /.xW/) {
918
						ERROR("no space after that '$op' $at\n" . $hereptr);
919
920
921
922
					}

				# unary ++ and unary -- are allowed no space on one side.
				} elsif ($op eq '++' or $op eq '--') {
923
					if ($ctx !~ /[WOB]x[^W]/ && $ctx !~ /[^W]x[WOBE]/) {
924
						ERROR("need space one side of that '$op' $at\n" . $hereptr);
925
					}
926
					if ($ctx =~ /Wx./ && $cc =~ /^;/) {
927
						ERROR("no space before that '$op' $at\n" . $hereptr);
928
					}
929
930

				# << and >> may either have or not have spaces both sides
931
932
933
934
				} elsif ($op eq '<<' or $op eq '>>' or
					 $op eq '&' or $op eq '^' or $op eq '|' or
					 $op eq '+' or $op eq '-' or
					 $op eq '*' or $op eq '/')
935
				{
936
					if ($ctx !~ /VxV|WxW|VxE|WxE|VxO/) {
937
938
						ERROR("need consistent spacing around '$op' $at\n" .
							$hereptr);
939
940
941
					}

				# All the others need spaces both sides.
942
				} elsif ($ctx !~ /[EW]x[WE]/) {
943
944
945
946
947
					# Ignore email addresses <foo@bar>
					if (!($op eq '<' && $cb =~ /$;\S+\@\S+>/) &&
					    !($op eq '>' && $cb =~ /<\S+\@\S+$;/)) {
						ERROR("need spaces around that '$op' $at\n" . $hereptr);
					}
948
				}
949
				$off += length($elements[$n + 1]);
950
951
952
			}
		}

953
954
955
956
957
# check for multiple assignments
		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
			WARN("multiple assignments should be avoided\n" . $herecurr);
		}

958
959
960
961
962
963
964
965
966
967
968
969
970
971
## # check for multiple declarations, allowing for a function declaration
## # continuation.
## 		if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
## 		    $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
##
## 			# Remove any bracketed sections to ensure we do not
## 			# falsly report the parameters of functions.
## 			my $ln = $line;
## 			while ($ln =~ s/\([^\(\)]*\)//g) {
## 			}
## 			if ($ln =~ /,/) {
## 				WARN("declaring multiple variables together should be avoided\n" . $herecurr);
## 			}
## 		}
972

973
#need space before brace following if, while, etc
974
975
		if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
		    $line =~ /do{/) {
976
977
978
979
980
981
982
			ERROR("need a space before the open brace '{'\n" . $herecurr);
		}

# closing brace should have a space following it when it has anything
# on the line
		if ($line =~ /}(?!(?:,|;|\)))\S/) {
			ERROR("need a space after that close brace '}'\n" . $herecurr);
983
984
		}

985
986
987
988
989
990
991
992
993
# check spacing on square brackets
		if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
			ERROR("no space after that open square bracket '['\n" . $herecurr);
		}
		if ($line =~ /\s\]/) {
			ERROR("no space before that close square bracket ']'\n" . $herecurr);
		}

# check spacing on paretheses
994
995
		if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
		    $line !~ /for\s*\(\s+;/) {
996
997
			ERROR("no space after that open parenthesis '('\n" . $herecurr);
		}
998
999
		if ($line =~ /\s\)/ && $line !~ /^.\s*\)/ &&
		    $line !~ /for\s*\(.*;\s+\)/) {
1000
1001
1002
			ERROR("no space before that close parenthesis ')'\n" . $herecurr);
		}

1003
#goto labels aren't indented, allow a single space however
1004
		if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
1005
		   !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
1006
			WARN("labels should not be indented\n" . $herecurr);
1007
1008
1009
		}

# Need a space before open parenthesis after if, while etc
1010
		if ($line=~/\b(if|while|for|switch)\(/) {
1011
			ERROR("need a space before the open parenthesis '('\n" . $herecurr);
1012
1013
1014
		}

# Check for illegal assignment in if conditional.
1015
		if ($line=~/\bif\s*\(.*[^<>!=]=[^=].*\)/) {
1016
			#next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/);
1017
			ERROR("do not use assignment in if condition\n" . $herecurr);
1018
1019
1020
1021
1022
1023
		}

		# Check for }<nl>else {, these must be at the same
		# indent level to be relevant to each other.
		if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
						$previndent == $indent) {
1024
			ERROR("else should follow close brace '}'\n" . $hereprev);
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
		}

#studly caps, commented out until figure out how to distinguish between use of existing and adding new
#		if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
#		    print "No studly caps, use _\n";
#		    print "$herecurr";
#		    $clean = 0;
#		}

#no spaces allowed after \ in define
		if ($line=~/\#define.*\\\s$/) {
1036
			WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);
1037
1038
		}

1039
1040
#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
		if ($tree && $rawline =~ m{^.\#\s*include\s*\<asm\/(.*)\.h\>}) {
1041
1042
			my $checkfile = "include/linux/$1.h";
			if (-f $checkfile) {
1043
1044
				CHK("Use #include <linux/$1.h> instead of <asm/$1.h>\n" .
					$herecurr);
1045
1046
1047
			}
		}

1048
1049
# if and else should not have general statements after it
		if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/ &&
1050
1051
		    $1 !~ /^\s*(?:\sif|{|\\|$)/) {
			ERROR("trailing statements should be on next line\n" . $herecurr);
1052
1053
		}

1054
1055
1056
# multi-statement macros should be enclosed in a do while loop, grab the
# first statement and ensure its the whole macro if its not enclosed
# in a known goot container
1057
1058
1059
1060
		if ($prevline =~ /\#define.*\\/ &&
		   $prevline !~/(?:do\s+{|\(\{|\{)/ &&
		   $line !~ /(?:do\s+{|\(\{|\{)/ &&
		   $line !~ /^.\s*$Declare\s/) {
1061
1062
1063
			# Grab the first statement, if that is the entire macro
			# its ok.  This may start either on the #define line
			# or the one below.
1064
1065
			my $ln = $linenr;
			my $cnt = $realcnt;
1066
			my $off = 0;
1067

1068
1069
1070
1071
			# If the macro starts on the define line start
			# grabbing the statement after the identifier
			$prevline =~ m{^(.#\s*define\s*$Ident(?:\([^\)]*\))?\s*)(.*)\\\s*$};
			##print "1<$1> 2<$2>\n";
1072
			if (defined $2 && $2 ne '') {
1073
				$off = length($1);
1074
1075
1076
				$ln--;
				$cnt++;
			}
1077
			my @ctx = ctx_statement($ln, $cnt, $off);
1078
1079
1080
1081
1082
1083
1084
1085
1086
			my $ctx_ln = $ln + $#ctx + 1;
			my $ctx = join("\n", @ctx);

			# Pull in any empty extension lines.
			while ($ctx =~ /\\$/ &&
			       $lines[$ctx_ln - 1] =~ /^.\s*(?:\\)?$/) {
				$ctx .= $lines[$ctx_ln - 1];
				$ctx_ln++;
			}
1087
1088
1089

			if ($ctx =~ /\\$/) {
				if ($ctx =~ /;/) {
1090
					ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
1091
				} else {
1092
					ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
1093
				}
1094
			}
1095
1096
		}

1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
# check for redundant bracing round if etc
		if ($line =~ /\b(if|while|for|else)\b/) {
			# Locate the end of the opening statement.
			my @control = ctx_statement($linenr, $realcnt, 0);
			my $nr = $linenr + (scalar(@control) - 1);
			my $cnt = $realcnt - (scalar(@control) - 1);

			my $off = $realcnt - $cnt;
			#print "$off: line<$line>end<" . $lines[$nr - 1] . ">\n";

			# If this is is a braced statement group check it
			if ($lines[$nr - 1] =~ /{\s*$/) {
				my ($lvl, @block) = ctx_block_level($nr, $cnt);

				my $stmt = join(' ', @block);
1112
1113
1114
1115
				$stmt =~ s/(^[^{]*){//;
				my $before = $1;
				$stmt =~ s/}([^}]*$)//;
				my $after = $1;
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126

				#print "block<" . join(' ', @block) . "><" . scalar(@block) . ">\n";
				#print "stmt<$stmt>\n\n";

				# Count the ;'s if there is fewer than two
				# then there can only be one statement,
				# if there is a brace inside we cannot
				# trivially detect if its one statement.
				# Also nested if's often require braces to
				# disambiguate the else binding so shhh there.
				my @semi = ($stmt =~ /;/g);
1127
				push(@semi, "/**/") if ($stmt =~ m@/\*@);
1128
1129
				##print "semi<" . scalar(@semi) . ">\n";
				if ($lvl == 0 && scalar(@semi) < 2 &&
1130
1131
				    $stmt !~ /{/ && $stmt !~ /\bif\b/ &&
				    $before !~ /}/ && $after !~ /{/) {
1132
1133
				    	my $herectx = "$here\n" . join("\n", @control, @block[1 .. $#block]) . "\n";
				    	shift(@block);
1134
					WARN("braces {} are not necessary for single statement blocks\n" . $herectx);
1135
1136
1137
1138
				}
			}
		}

1139
# don't include deprecated include files (uses RAW line)
1140
		for my $inc (@dep_includes) {
1141
			if ($rawline =~ m@\#\s*include\s*\<$inc>@) {
1142
				ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
1143
1144
1145
			}
		}

1146
1147
# don't use deprecated functions
		for my $func (@dep_functions) {
1148
			if ($line =~ /\b$func\b/) {
1149
				ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
1150
1151
1152
1153
			}
		}

# no volatiles please
1154
		if ($line =~ /\bvolatile\b/ && $line !~ /\basm\s+volatile\b/) {
1155
			WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
1156
1157
		}

1158
1159
1160
1161
1162
# SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated
		if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {
			ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);
		}

1163
1164
# warn about #if 0
		if ($line =~ /^.#\s*if\s+0\b/) {
1165
1166
			CHK("if this code is redundant consider removing it\n" .
				$herecurr);
1167
1168
		}

1169
1170
1171
1172
1173
1174
1175
1176
# check for needless kfree() checks
		if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
			my $expr = $1;
			if ($line =~ /\bkfree\(\Q$expr\E\);/) {
				WARN("kfree(NULL) is safe this check is probabally not required\n" . $hereprev);
			}
		}

1177
1178
1179
1180
1181
1182
1183
# warn about #ifdefs in C files
#		if ($line =~ /^.#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
#			print "#ifdef in C files should be avoided\n";
#			print "$herecurr";
#			$clean = 0;
#		}

1184
1185
1186
1187
1188
# warn about spacing in #ifdefs
		if ($line =~ /^.#\s*(ifdef|ifndef|elif)\s\s+/) {
			ERROR("exactly one space required after that #$1\n" . $herecurr);
		}

1189
1190
1191
1192
# check for spinlock_t definitions without a comment.
		if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/) {
			my $which = $1;
			if (!ctx_has_comment($first_line, $linenr)) {
1193
				CHK("$1 definition without comment\n" . $herecurr);
1194
1195
1196
1197
1198
			}
		}
# check for memory barriers without a comment.
		if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
			if (!ctx_has_comment($first_line, $linenr)) {
1199
				CHK("memory barrier without comment\n" . $herecurr);
1200
1201
1202
			}
		}
# check of hardware specific defines
1203
		if ($line =~ m@^.#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
1204
			CHK("architecture specific defines should be avoided\n" .  $herecurr);
1205
		}
1206

1207
1208
# check the location of the inline attribute, that it is between
# storage class and type.
1209
1210
		if ($line =~ /\b$Type\s+$Inline\b/ ||
		    $line =~ /\b$Inline\s+$Storage\b/) {
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
			ERROR("inline keyword should sit between storage class and type\n" . $herecurr);
		}

# check for new externs in .c files.
		if ($line =~ /^.\s*extern\s/ && ($realfile =~ /\.c$/)) {
			WARN("externs should be avoided in .c files\n" .  $herecurr);
		}

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

			if (!grep(/$name/, @setup_docs)) {
				CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
			}
1226
		}
1227
1228
1229
1230
1231

# check for pointless casting of kmalloc return
		if ($line =~ /\*\s*\)\s*k[czm]alloc\b/) {
			WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
		}
1232
1233
1234
	}

	if ($chk_patch && !$is_patch) {
1235
		ERROR("Does not appear to be a unified-diff format patch\n");
1236
1237
	}
	if ($is_patch && $chk_signoff && $signoff == 0) {
1238
		ERROR("Missing Signed-off-by: line(s)\n");
1239
1240
	}

1241
1242
1243
	if ($clean == 0 && ($chk_patch || $is_patch)) {
		print report_dump();
	}
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
	if ($clean == 1 && $quiet == 0) {
		print "Your patch has no obvious style problems and is ready for submission.\n"
	}
	if ($clean == 0 && $quiet == 0) {
		print "Your patch has style problems, please review.  If any of these errors\n";
		print "are false positives report them to the maintainer, see\n";
		print "CHECKPATCH in MAINTAINERS.\n";
	}
	return $clean;
}