www.infradead.org Git - users/hch/uuid.git/blob

1 #!/usr/bin/perl -w

6 # Licensed under the terms of the GNU GPL License version 2

7

8 use strict;

9 use POSIX;

10 use File::Basename;

11 use Cwd 'abs_path';

12 use Term::ANSIColor qw(:constants);

13

14 my $P = $0;

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

16

17 my $V = '0.32';

18

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

20

21 my $quiet = 0;

22 my $tree = 1;

23 my $chk_signoff = 1;

24 my $chk_patch = 1;

25 my $tst_only;

26 my $emacs = 0;

27 my $terse = 0;

28 my $showfile = 0;

29 my $file = 0;

30 my $check = 0;

31 my $check_orig = 0;

32 my $summary = 1;

33 my $mailback = 0;

34 my $summary_file = 0;

35 my $show_types = 0;

36 my $fix = 0;

37 my $fix_inplace = 0;

38 my $root;

39 my %debug;

40 my %camelcase = ();

41 my %use_type = ();

42 my @use = ();

43 my %ignore_type = ();

44 my @ignore = ();

45 my $help = 0;

46 my $configuration_file = ".checkpatch.conf";

47 my $max_line_length = 80;

48 my $ignore_perl_version = 0;

49 my $minimum_perl_version = 5.10.0;

50 my $min_conf_desc_length = 4;

51 my $spelling_file = "$D/spelling.txt";

52 my $codespell = 0;

53 my $codespellfile = "/usr/share/codespell/dictionary.txt";

54 my $color = 1;

55

56 sub help {

57 my ($exitcode) = @_;

58

59 print << "EOM";

60 Usage: $P [OPTION]... [FILE]...

61 Version: $V

62

63 Options:

64 -q, --quiet quiet

65 --no-tree run without a kernel tree

66 --no-signoff do not check for 'Signed-off-by' line

67 --patch treat FILE as patchfile (default)

68 --emacs emacs compile window format

69 --terse one line per report

70 --showfile emit diffed file position, not input file position

71 -f, --file treat FILE as regular source file

72 --subjective, --strict enable more subjective tests

73 --types TYPE(,TYPE2...) show only these comma separated message types

74 --ignore TYPE(,TYPE2...) ignore various comma separated message types

75 --max-line-length=n set the maximum line length, if exceeded, warn

76 --min-conf-desc-length=n set the min description length, if shorter, warn

77 --show-types show the message "types" in the output

78 --root=PATH PATH to the kernel tree root

79 --no-summary suppress the per-file summary

80 --mailback only produce a report in case of warnings/errors

81 --summary-file include the filename in summary

82 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of

83 'values', 'possible', 'type', and 'attr' (default

84 is all off)

85 --test-only=WORD report only warnings/errors containing WORD

86 literally

87 --fix EXPERIMENTAL - may create horrible results

88 If correctable single-line errors exist, create

89 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"

90 with potential errors corrected to the preferred

91 checkpatch style

92 --fix-inplace EXPERIMENTAL - may create horrible results

93 Is the same as --fix, but overwrites the input

94 file. It's your fault if there's no backup or git

95 --ignore-perl-version override checking of perl version. expect

96 runtime errors.

97 --codespell Use the codespell dictionary for spelling/typos

98 (default:/usr/share/codespell/dictionary.txt)

99 --codespellfile Use this codespell dictionary

100 --color Use colors when output is STDOUT (default: on)

101 -h, --help, --version display this help and exit

102

103 When FILE is - read standard input.

104 EOM

105

106 exit($exitcode);

107 }

108

109 my $conf = which_conf($configuration_file);

110 if (-f $conf) {

111 my @conf_args;

112 open(my $conffile, '<', "$conf")

113 or warn "$P: Can't find a readable $configuration_file file $!\n";

114

115 while (<$conffile>) {

116 my $line = $_;

117

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

119 $line =~ s/^\s*//g;

120 $line =~ s/\s+/ /g;

121

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

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

124

125 my @words = split(" ", $line);

126 foreach my $word (@words) {

127 last if ($word =~ m/^#/);

128 push (@conf_args, $word);

129 }

130 }

131 close($conffile);

132 unshift(@ARGV, @conf_args) if @conf_args;

133 }

134

135 GetOptions(

136 'q|quiet+' => \$quiet,

137 'tree!' => \$tree,

138 'signoff!' => \$chk_signoff,

139 'patch!' => \$chk_patch,

140 'emacs!' => \$emacs,

141 'terse!' => \$terse,

142 'showfile!' => \$showfile,

143 'f|file!' => \$file,

144 'subjective!' => \$check,

145 'strict!' => \$check,

146 'ignore=s' => \@ignore,

147 'types=s' => \@use,

148 'show-types!' => \$show_types,

149 'max-line-length=i' => \$max_line_length,

150 'min-conf-desc-length=i' => \$min_conf_desc_length,

151 'root=s' => \$root,

152 'summary!' => \$summary,

153 'mailback!' => \$mailback,

154 'summary-file!' => \$summary_file,

155 'fix!' => \$fix,

156 'fix-inplace!' => \$fix_inplace,

157 'ignore-perl-version!' => \$ignore_perl_version,

158 'debug=s' => \%debug,

159 'test-only=s' => \$tst_only,

160 'codespell!' => \$codespell,

161 'codespellfile=s' => \$codespellfile,

162 'color!' => \$color,

163 'h|help' => \$help,

164 'version' => \$help

165 ) or help(1);

166

167 help(0) if ($help);

168

169 $fix = 1 if ($fix_inplace);

170 $check_orig = $check;

171

172 my $exit = 0;

173

174 if ($^V && $^V lt $minimum_perl_version) {

175 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;

176 if (!$ignore_perl_version) {

177 exit(1);

178 }

179 }

180

181 if ($#ARGV < 0) {

182 print "$P: no input files\n";

183 exit(1);

184 }

185

186 sub hash_save_array_words {

187 my ($hashRef, $arrayRef) = @_;

188

189 my @array = split(/,/, join(',', @$arrayRef));

190 foreach my $word (@array) {

191 $word =~ s/\s*\n?$//g;

192 $word =~ s/^\s*//g;

193 $word =~ s/\s+/ /g;

194 $word =~ tr/[a-z]/[A-Z]/;

195

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

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

198

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

200 }

201 }

202

203 sub hash_show_words {

204 my ($hashRef, $prefix) = @_;

205

206 if (keys %$hashRef) {

207 print "\nNOTE: $prefix message types:";

208 foreach my $word (sort keys %$hashRef) {

209 print " $word";

210 }

211 print "\n";

212 }

213 }

214

215 hash_save_array_words(\%ignore_type, \@ignore);

216 hash_save_array_words(\%use_type, \@use);

217

218 my $dbg_values = 0;

219 my $dbg_possible = 0;

220 my $dbg_type = 0;

221 my $dbg_attr = 0;

222 for my $key (keys %debug) {

223 ## no critic

224 eval "\${dbg_$key} = '$debug{$key}';";

225 die "$@" if ($@);

226 }

227

228 my $rpt_cleaners = 0;

229

230 if ($terse) {

231 $emacs = 1;

232 $quiet++;

233 }

234

235 if ($tree) {

236 if (defined $root) {

237 if (!top_of_kernel_tree($root)) {

238 die "$P: $root: --root does not point at a valid tree\n";

239 }

240 } else {

241 if (top_of_kernel_tree('.')) {

242 $root = '.';

243 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&

244 top_of_kernel_tree($1)) {

245 $root = $1;

246 }

247 }

248

249 if (!defined $root) {

250 print "Must be run from the top-level dir. of a kernel tree\n";

251 exit(2);

252 }

253 }

254

255 my $emitted_corrupt = 0;

256

257 our $Ident = qr{

258 [A-Za-z_][A-Za-z\d_]*

259 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*

260 }x;

261 our $Storage = qr{extern|static|asmlinkage};

262 our $Sparse = qr{

263 __user|

264 __kernel|

265 __force|

266 __iomem|

267 __pmem|

268 __must_check|

269 __init_refok|

270 __kprobes|

271 __ref|

272 __rcu|

273 __private

274 }x;

275 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};

276 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};

277 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};

278 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};

279 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};

280

281 # Notes to $Attribute:

282 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check

283 our $Attribute = qr{

284 const|

285 __percpu|

286 __nocast|

287 __safe|

288 __bitwise__|

289 __packed__|

290 __packed2__|

291 __naked|

292 __maybe_unused|

293 __always_unused|

294 __noreturn|

295 __used|

296 __cold|

297 __pure|

298 __noclone|

299 __deprecated|

300 __read_mostly|

301 __kprobes|

302 $InitAttribute|

303 ____cacheline_aligned|

304 ____cacheline_aligned_in_smp|

305 ____cacheline_internodealigned_in_smp|

306 __weak

307 }x;

308 our $Modifier;

309 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};

310 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};

311 our $Lval = qr{$Ident(?:$Member)*};

312

313 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};

314 our $Binary = qr{(?i)0b[01]+$Int_type?};

315 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};

316 our $Int = qr{[0-9]+$Int_type?};

317 our $Octal = qr{0[0-7]+$Int_type?};

318 our $String = qr{"[X\t]*"};

319 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};

320 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};

321 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};

322 our $Float = qr{$Float_hex|$Float_dec|$Float_int};

323 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};

324 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};

325 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};

326 our $Arithmetic = qr{\+|-|\*|\/|%};

327 our $Operators = qr{

328 <=|>=|==|!=|

329 =>|->|<<|>>|<|>|!|~|

330 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic

331 }x;

332

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

334

335 our $BasicType;

336 our $NonptrType;

337 our $NonptrTypeMisordered;

338 our $NonptrTypeWithAttr;

339 our $Type;

340 our $TypeMisordered;

341 our $Declare;

342 our $DeclareMisordered;

343

344 our $NON_ASCII_UTF8 = qr{

345 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte

346 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs

347 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte

348 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates

349 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3

350 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15

351 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16

352 }x;

353

354 our $UTF8 = qr{

355 [\x09\x0A\x0D\x20-\x7E] # ASCII

356 | $NON_ASCII_UTF8

357 }x;

358

359 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};

360 our $typeOtherOSTypedefs = qr{(?x:

361 u_(?:char|short|int|long) | # bsd

362 u(?:nchar|short|int|long) # sysv

363 )};

364 our $typeKernelTypedefs = qr{(?x:

365 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|

366 atomic_t

367 )};

368 our $typeTypedefs = qr{(?x:

369 $typeC99Typedefs\b|

370 $typeOtherOSTypedefs\b|

371 $typeKernelTypedefs\b

372 )};

373

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

375

376 our $logFunctions = qr{(?x:

377 printk(?:_ratelimited|_once|)|

378 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|

379 WARN(?:_RATELIMIT|_ONCE|)|

380 panic|

381 MODULE_[A-Z_]+|

382 seq_vprintf|seq_printf|seq_puts

383 )};

384

385 our $signature_tags = qr{(?xi:

386 Signed-off-by:|

387 Acked-by:|

388 Tested-by:|

389 Reviewed-by:|

390 Reported-by:|

391 Suggested-by:|

392 To:|

393 Cc:

394 )};

395

396 our @typeListMisordered = (

397 qr{char\s+(?:un)?signed},

398 qr{int\s+(?:(?:un)?signed\s+)?short\s},

399 qr{int\s+short(?:\s+(?:un)?signed)},

400 qr{short\s+int(?:\s+(?:un)?signed)},

401 qr{(?:un)?signed\s+int\s+short},

402 qr{short\s+(?:un)?signed},

403 qr{long\s+int\s+(?:un)?signed},

404 qr{int\s+long\s+(?:un)?signed},

405 qr{long\s+(?:un)?signed\s+int},

406 qr{int\s+(?:un)?signed\s+long},

407 qr{int\s+(?:un)?signed},

408 qr{int\s+long\s+long\s+(?:un)?signed},

409 qr{long\s+long\s+int\s+(?:un)?signed},

410 qr{long\s+long\s+(?:un)?signed\s+int},

411 qr{long\s+long\s+(?:un)?signed},

412 qr{long\s+(?:un)?signed},

413 );

414

415 our @typeList = (

416 qr{void},

417 qr{(?:(?:un)?signed\s+)?char},

418 qr{(?:(?:un)?signed\s+)?short\s+int},

419 qr{(?:(?:un)?signed\s+)?short},

420 qr{(?:(?:un)?signed\s+)?int},

421 qr{(?:(?:un)?signed\s+)?long\s+int},

422 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},

423 qr{(?:(?:un)?signed\s+)?long\s+long},

424 qr{(?:(?:un)?signed\s+)?long},

425 qr{(?:un)?signed},

426 qr{float},

427 qr{double},

428 qr{bool},

429 qr{struct\s+$Ident},

430 qr{union\s+$Ident},

431 qr{enum\s+$Ident},

432 qr{${Ident}_t},

433 qr{${Ident}_handler},

434 qr{${Ident}_handler_fn},

435 @typeListMisordered,

436 );

437

438 our $C90_int_types = qr{(?x:

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

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

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

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

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

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

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

446

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

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

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

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

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

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

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

454

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

456 (?:(?:un)?signed\s+)?int

457 )};

458

459 our @typeListFile = ();

460 our @typeListWithAttr = (

461 @typeList,

462 qr{struct\s+$InitAttribute\s+$Ident},

463 qr{union\s+$InitAttribute\s+$Ident},

464 );

465

466 our @modifierList = (

467 qr{fastcall},

468 );

469 our @modifierListFile = ();

470

471 our @mode_permission_funcs = (

472 ["module_param", 3],

473 ["module_param_(?:array|named|string)", 4],

474 ["module_param_array_named", 5],

475 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],

476 ["proc_create(?:_data|)", 2],

477 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],

478 );

479

480 #Create a search pattern for all these functions to speed up a loop below

481 our $mode_perms_search = "";

482 foreach my $entry (@mode_permission_funcs) {

483 $mode_perms_search .= '|' if ($mode_perms_search ne "");

484 $mode_perms_search .= $entry->[0];

485 }

486

487 our $mode_perms_world_writable = qr{

488 S_IWUGO |

489 S_IWOTH |

490 S_IRWXUGO |

491 S_IALLUGO |

492 0[0-7][0-7][2367]

493 }x;

494

495 our $allowed_asm_includes = qr{(?x:

496 irq|

497 memory|

498 time|

499 reboot

500 )};

501 # memory.h: ARM has a custom one

502

503 # Load common spelling mistakes and build regular expression list.

504 my $misspellings;

505 my %spelling_fix;

506

507 if (open(my $spelling, '<', $spelling_file)) {

508 while (<$spelling>) {

509 my $line = $_;

510

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

512 $line =~ s/^\s*//g;

513

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

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

516

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

518

519 $spelling_fix{$suspect} = $fix;

520 }

521 close($spelling);

522 } else {

523 warn "No typos will be found - file '$spelling_file': $!\n";

524 }

525

526 if ($codespell) {

527 if (open(my $spelling, '<', $codespellfile)) {

528 while (<$spelling>) {

529 my $line = $_;

530

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

532 $line =~ s/^\s*//g;

533

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

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

536 next if ($line =~ m/, disabled/i);

537

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

539

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

541

542 $spelling_fix{$suspect} = $fix;

543 }

544 close($spelling);

545 } else {

546 warn "No codespell typos will be found - file '$codespellfile': $!\n";

547 }

548 }

549

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

551

552 sub build_types {

553 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";

554 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";

555 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";

556 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";

557 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};

558 $BasicType = qr{

559 (?:$typeTypedefs\b)|

560 (?:${all}\b)

561 }x;

562 $NonptrType = qr{

563 (?:$Modifier\s+|const\s+)*

564 (?:

565 (?:typeof|__typeof__)\s*$[^$]*\)|

566 (?:$typeTypedefs\b)|

567 (?:${all}\b)

568 )

569 (?:\s+$Modifier|\s+const)*

570 }x;

571 $NonptrTypeMisordered = qr{

572 (?:$Modifier\s+|const\s+)*

573 (?:

574 (?:${Misordered}\b)

575 )

576 (?:\s+$Modifier|\s+const)*

577 }x;

578 $NonptrTypeWithAttr = qr{

579 (?:$Modifier\s+|const\s+)*

580 (?:

581 (?:typeof|__typeof__)\s*$[^$]*\)|

582 (?:$typeTypedefs\b)|

583 (?:${allWithAttr}\b)

584 )

585 (?:\s+$Modifier|\s+const)*

586 }x;

587 $Type = qr{

588 $NonptrType

589 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?

590 (?:\s+$Inline|\s+$Modifier)*

591 }x;

592 $TypeMisordered = qr{

593 $NonptrTypeMisordered

594 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?

595 (?:\s+$Inline|\s+$Modifier)*

596 }x;

597 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};

598 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};

599 }

600 build_types();

601

602 our $Typecast = qr{\s*($\s*$NonptrType\s*$){0,1}\s*};

603

604 # Using $balanced_parens, $LvalOrFunc, or $FuncArg

605 # requires at least perl version v5.10.0

606 # Any use must be runtime checked with $^V

607

608 our $balanced_parens = qr/($(?:[^\($]++|(?-1))*\))/;

609 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};

610 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};

611

612 our $declaration_macros = qr{(?x:

613 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|

614 (?:$Storage\s+)?LIST_HEAD\s*\(|

615 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(

616 )};

617

618 sub deparenthesize {

619 my ($string) = @_;

620 return "" if (!defined($string));

621

622 while ($string =~ /^\s*$.*$\s*$/) {

623 $string =~ s@^\s*\(\s*@@;

624 $string =~ s@\s*\)\s*$@@;

625 }

626

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

628

629 return $string;

630 }

631

632 sub seed_camelcase_file {

633 my ($file) = @_;

634

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

636

637 local $/;

638

639 open(my $include_file, '<', "$file")

640 or warn "$P: Can't read '$file' $!\n";

641 my $text = <$include_file>;

642 close($include_file);

643

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

645

646 foreach my $line (@lines) {

647 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);

648 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {

649 $camelcase{$1} = 1;

650 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {

651 $camelcase{$1} = 1;

652 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {

653 $camelcase{$1} = 1;

654 }

655 }

656 }

657

658 my $camelcase_seeded = 0;

659 sub seed_camelcase_includes {

660 return if ($camelcase_seeded);

661

662 my $files;

663 my $camelcase_cache = "";

664 my @include_files = ();

665

666 $camelcase_seeded = 1;

667

668 if (-e ".git") {

669 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;

670 chomp $git_last_include_commit;

671 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";

672 } else {

673 my $last_mod_date = 0;

674 $files = `find $root/include -name "*.h"`;

675 @include_files = split('\n', $files);

676 foreach my $file (@include_files) {

677 my $date = POSIX::strftime("%Y%m%d%H%M",

678 localtime((stat $file)[9]));

679 $last_mod_date = $date if ($last_mod_date < $date);

680 }

681 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";

682 }

683

684 if ($camelcase_cache ne "" && -f $camelcase_cache) {

685 open(my $camelcase_file, '<', "$camelcase_cache")

686 or warn "$P: Can't read '$camelcase_cache' $!\n";

687 while (<$camelcase_file>) {

688 chomp;

689 $camelcase{$_} = 1;

690 }

691 close($camelcase_file);

692

693 return;

694 }

695

696 if (-e ".git") {

697 $files = `git ls-files "include/*.h"`;

698 @include_files = split('\n', $files);

699 }

700

701 foreach my $file (@include_files) {

702 seed_camelcase_file($file);

703 }

704

705 if ($camelcase_cache ne "") {

706 unlink glob ".checkpatch-camelcase.*";

707 open(my $camelcase_file, '>', "$camelcase_cache")

708 or warn "$P: Can't write '$camelcase_cache' $!\n";

709 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {

710 print $camelcase_file ("$_\n");

711 }

712 close($camelcase_file);

713 }

714 }

715

716 sub git_commit_info {

717 my ($commit, $id, $desc) = @_;

718

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

720

721 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;

722 $output =~ s/^\s*//gm;

723 my @lines = split("\n", $output);

724

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

726

727 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {

728 # Maybe one day convert this block of bash into something that returns

729 # all matching commit ids, but it's very slow...

730 #

731 # echo "checking commits $1..."

732 # git rev-list --remotes | grep -i "^$1" |

733 # while read line ; do

734 # git log --format='%H %s' -1 $line |

735 # echo "commit $(cut -c 1-12,41-)"

736 # done

737 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {

738 } else {

739 $id = substr($lines[0], 0, 12);

740 $desc = substr($lines[0], 41);

741 }

742

743 return ($id, $desc);

744 }

745

746 $chk_signoff = 0 if ($file);

747

748 my @rawlines = ();

749 my @lines = ();

750 my @fixed = ();

751 my @fixed_inserted = ();

752 my @fixed_deleted = ();

753 my $fixlinenr = -1;

754

755 my $vname;

756 for my $filename (@ARGV) {

757 my $FILE;

758 if ($file) {

759 open($FILE, '-|', "diff -u /dev/null $filename") ||

760 die "$P: $filename: diff failed - $!\n";

761 } elsif ($filename eq '-') {

762 open($FILE, '<&STDIN');

763 } else {

764 open($FILE, '<', "$filename") ||

765 die "$P: $filename: open failed - $!\n";

766 }

767 if ($filename eq '-') {

768 $vname = 'Your patch';

769 } else {

770 $vname = $filename;

771 }

772 while (<$FILE>) {

773 chomp;

774 push(@rawlines, $_);

775 }

776 close($FILE);

777

778 if ($#ARGV > 0 && $quiet == 0) {

779 print '-' x length($vname) . "\n";

780 print "$vname\n";

781 print '-' x length($vname) . "\n";

782 }

783

784 if (!process($filename)) {

785 $exit = 1;

786 }

787 @rawlines = ();

788 @lines = ();

789 @fixed = ();

790 @fixed_inserted = ();

791 @fixed_deleted = ();

792 $fixlinenr = -1;

793 @modifierListFile = ();

794 @typeListFile = ();

795 build_types();

796 }

797

798 if (!$quiet) {

799 hash_show_words(\%use_type, "Used");

800 hash_show_words(\%ignore_type, "Ignored");

801

802 if ($^V lt 5.10.0) {

803 print << "EOM"

804

805 NOTE: perl $^V is not modern enough to detect all possible issues.

806 An upgrade to at least perl v5.10.0 is suggested.

807 EOM

808 }

809 if ($exit) {

810 print << "EOM"

811

812 NOTE: If any of the errors are false positives, please report

813 them to the maintainer, see CHECKPATCH in MAINTAINERS.

814 EOM

815 }

816 }

817

818 exit($exit);

819

820 sub top_of_kernel_tree {

821 my ($root) = @_;

822

823 my @tree_check = (

824 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",

825 "README", "Documentation", "arch", "include", "drivers",

826 "fs", "init", "ipc", "kernel", "lib", "scripts",

827 );

828

829 foreach my $check (@tree_check) {

830 if (! -e $root . '/' . $check) {

831 return 0;

832 }

833 }

834 return 1;

835 }

836

837 sub parse_email {

838 my ($formatted_email) = @_;

839

840 my $name = "";

841 my $address = "";

842 my $comment = "";

843

844 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {

845 $name = $1;

846 $address = $2;

847 $comment = $3 if defined $3;

848 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {

849 $address = $1;

850 $comment = $2 if defined $2;

851 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {

852 $address = $1;

853 $comment = $2 if defined $2;

854 $formatted_email =~ s/$address.*$//;

855 $name = $formatted_email;

856 $name = trim($name);

857 $name =~ s/^\"|\"$//g;

858 # If there's a name left after stripping spaces and

859 # leading quotes, and the address doesn't have both

860 # leading and trailing angle brackets, the address

861 # is invalid. ie:

862 # "joe smith joe@smith.com" bad

863 # "joe smith <joe@smith.com" bad

864 if ($name ne "" && $address !~ /^<[^>]+>$/) {

865 $name = "";

866 $address = "";

867 $comment = "";

868 }

869 }

870

871 $name = trim($name);

872 $name =~ s/^\"|\"$//g;

873 $address = trim($address);

874 $address =~ s/^\<|\>$//g;

875

876 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars

877 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes

878 $name = "\"$name\"";

879 }

880

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

882 }

883

884 sub format_email {

885 my ($name, $address) = @_;

886

887 my $formatted_email;

888

889 $name = trim($name);

890 $name =~ s/^\"|\"$//g;

891 $address = trim($address);

892

893 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars

894 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes

895 $name = "\"$name\"";

896 }

897

898 if ("$name" eq "") {

899 $formatted_email = "$address";

900 } else {

901 $formatted_email = "$name <$address>";

902 }

903

904 return $formatted_email;

905 }

906

907 sub which {

908 my ($bin) = @_;

909

910 foreach my $path (split(/:/, $ENV{PATH})) {

911 if (-e "$path/$bin") {

912 return "$path/$bin";

913 }

914 }

915

916 return "";

917 }

918

919 sub which_conf {

920 my ($conf) = @_;

921

922 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {

923 if (-e "$path/$conf") {

924 return "$path/$conf";

925 }

926 }

927

928 return "";

929 }

930

931 sub expand_tabs {

932 my ($str) = @_;

933

934 my $res = '';

935 my $n = 0;

936 for my $c (split(//, $str)) {

937 if ($c eq "\t") {

938 $res .= ' ';

939 $n++;

940 for (; ($n % 8) != 0; $n++) {

941 $res .= ' ';

942 }

943 next;

944 }

945 $res .= $c;

946 $n++;

947 }

948

949 return $res;

950 }

951 sub copy_spacing {

952 (my $res = shift) =~ tr/\t/ /c;

953 return $res;

954 }

955

956 sub line_stats {

957 my ($line) = @_;

958

959 # Drop the diff line leader and expand tabs

960 $line =~ s/^.//;

961 $line = expand_tabs($line);

962

963 # Pick the indent from the front of the line.

964 my ($white) = ($line =~ /^(\s*)/);

965

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

967 }

968

969 my $sanitise_quote = '';

970

971 sub sanitise_line_reset {

972 my ($in_comment) = @_;

973

974 if ($in_comment) {

975 $sanitise_quote = '*/';

976 } else {

977 $sanitise_quote = '';

978 }

979 }

980 sub sanitise_line {

981 my ($line) = @_;

982

983 my $res = '';

984 my $l = '';

985

986 my $qlen = 0;

987 my $off = 0;

988 my $c;

989

990 # Always copy over the diff marker.

991 $res = substr($line, 0, 1);

992

993 for ($off = 1; $off < length($line); $off++) {

994 $c = substr($line, $off, 1);

995

996 # Comments we are wacking completly including the begin

997 # and end, all to $;.

998 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {

999 $sanitise_quote = '*/';

1000

1001 substr($res, $off, 2, "$;$;");

1002 $off++;

1003 next;

1004 }

1005 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {

1006 $sanitise_quote = '';

1007 substr($res, $off, 2, "$;$;");

1008 $off++;

1009 next;

1010 }

1011 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {

1012 $sanitise_quote = '//';

1013

1014 substr($res, $off, 2, $sanitise_quote);

1015 $off++;

1016 next;

1017 }

1018

1019 # A \ in a string means ignore the next character.

1020 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&

1021 $c eq "\\") {

1022 substr($res, $off, 2, 'XX');

1023 $off++;

1024 next;

1025 }

1026 # Regular quotes.

1027 if ($c eq "'" || $c eq '"') {

1028 if ($sanitise_quote eq '') {

1029 $sanitise_quote = $c;

1030

1031 substr($res, $off, 1, $c);

1032 next;

1033 } elsif ($sanitise_quote eq $c) {

1034 $sanitise_quote = '';

1035 }

1036 }

1037

1038 #print "c<$c> SQ<$sanitise_quote>\n";

1039 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {

1040 substr($res, $off, 1, $;);

1041 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {

1042 substr($res, $off, 1, $;);

1043 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {

1044 substr($res, $off, 1, 'X');

1045 } else {

1046 substr($res, $off, 1, $c);

1047 }

1048 }

1049

1050 if ($sanitise_quote eq '//') {

1051 $sanitise_quote = '';

1052 }

1053

1054 # The pathname on a #include may be surrounded by '<' and '>'.

1055 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {

1056 my $clean = 'X' x length($1);

1057 $res =~ s@\<.*\>@<$clean>@;

1058

1059 # The whole of a #error is a string.

1060 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {

1061 my $clean = 'X' x length($1);

1062 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;

1063 }

1064

1065 return $res;

1066 }

1067

1068 sub get_quoted_string {

1069 my ($line, $rawline) = @_;

1070

1071 return "" if ($line !~ m/($String)/g);

1072 return substr($rawline, $-[0], $+[0] - $-[0]);

1073 }

1074

1075 sub ctx_statement_block {

1076 my ($linenr, $remain, $off) = @_;

1077 my $line = $linenr - 1;

1078 my $blk = '';

1079 my $soff = $off;

1080 my $coff = $off - 1;

1081 my $coff_set = 0;

1082

1083 my $loff = 0;

1084

1085 my $type = '';

1086 my $level = 0;

1087 my @stack = ();

1088 my $p;

1089 my $c;

1090 my $len = 0;

1091

1092 my $remainder;

1093 while (1) {

1094 @stack = (['', 0]) if ($#stack == -1);

1095

1096 #warn "CSB: blk<$blk> remain<$remain>\n";

1097 # If we are about to drop off the end, pull in more

1098 # context.

1099 if ($off >= $len) {

1100 for (; $remain > 0; $line++) {

1101 last if (!defined $lines[$line]);

1102 next if ($lines[$line] =~ /^-/);

1103 $remain--;

1104 $loff = $len;

1105 $blk .= $lines[$line] . "\n";

1106 $len = length($blk);

1107 $line++;

1108 last;

1109 }

1110 # Bail if there is no further context.

1111 #warn "CSB: blk<$blk> off<$off> len<$len>\n";

1112 if ($off >= $len) {

1113 last;

1114 }

1115 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {

1116 $level++;

1117 $type = '#';

1118 }

1119 }

1120 $p = $c;

1121 $c = substr($blk, $off, 1);

1122 $remainder = substr($blk, $off);

1123

1124 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";

1125

1126 # Handle nested #if/#else.

1127 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {

1128 push(@stack, [ $type, $level ]);

1129 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {

1130 ($type, $level) = @{$stack[$#stack - 1]};

1131 } elsif ($remainder =~ /^#\s*endif\b/) {

1132 ($type, $level) = @{pop(@stack)};

1133 }

1134

1135 # Statement ends at the ';' or a close '}' at the

1136 # outermost level.

1137 if ($level == 0 && $c eq ';') {

1138 last;

1139 }

1140

1141 # An else is really a conditional as long as its not else if

1142 if ($level == 0 && $coff_set == 0 &&

1143 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&

1144 $remainder =~ /^(else)(?:\s|{)/ &&

1145 $remainder !~ /^else\s+if\b/) {

1146 $coff = $off + length($1) - 1;

1147 $coff_set = 1;

1148 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";

1149 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";

1150 }

1151

1152 if (($type eq '' || $type eq '(') && $c eq '(') {

1153 $level++;

1154 $type = '(';

1155 }

1156 if ($type eq '(' && $c eq ')') {

1157 $level--;

1158 $type = ($level != 0)? '(' : '';

1159

1160 if ($level == 0 && $coff < $soff) {

1161 $coff = $off;

1162 $coff_set = 1;

1163 #warn "CSB: mark coff<$coff>\n";

1164 }

1165 }

1166 if (($type eq '' || $type eq '{') && $c eq '{') {

1167 $level++;

1168 $type = '{';

1169 }

1170 if ($type eq '{' && $c eq '}') {

1171 $level--;

1172 $type = ($level != 0)? '{' : '';

1173

1174 if ($level == 0) {

1175 if (substr($blk, $off + 1, 1) eq ';') {

1176 $off++;

1177 }

1178 last;

1179 }

1180 }

1181 # Preprocessor commands end at the newline unless escaped.

1182 if ($type eq '#' && $c eq "\n" && $p ne "\\") {

1183 $level--;

1184 $type = '';

1185 $off++;

1186 last;

1187 }

1188 $off++;

1189 }

1190 # We are truly at the end, so shuffle to the next line.

1191 if ($off == $len) {

1192 $loff = $len + 1;

1193 $line++;

1194 $remain--;

1195 }

1196

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

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

1199

1200 #warn "STATEMENT<$statement>\n";

1201 #warn "CONDITION<$condition>\n";

1202

1203 #print "coff<$coff> soff<$off> loff<$loff>\n";

1204

1205 return ($statement, $condition,

1206 $line, $remain + 1, $off - $loff + 1, $level);

1207 }

1208

1209 sub statement_lines {

1210 my ($stmt) = @_;

1211

1212 # Strip the diff line prefixes and rip blank lines at start and end.

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

1214 $stmt =~ s/^\s*//;

1215 $stmt =~ s/\s*$//;

1216

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

1218

1219 return $#stmt_lines + 2;

1220 }

1221

1222 sub statement_rawlines {

1223 my ($stmt) = @_;

1224

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

1226

1227 return $#stmt_lines + 2;

1228 }

1229

1230 sub statement_block_size {

1231 my ($stmt) = @_;

1232

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

1234 $stmt =~ s/^\s*{//;

1235 $stmt =~ s/}\s*$//;

1236 $stmt =~ s/^\s*//;

1237 $stmt =~ s/\s*$//;

1238

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

1240 my @stmt_statements = ($stmt =~ /;/g);

1241

1242 my $stmt_lines = $#stmt_lines + 2;

1243 my $stmt_statements = $#stmt_statements + 1;

1244

1245 if ($stmt_lines > $stmt_statements) {

1246 return $stmt_lines;

1247 } else {

1248 return $stmt_statements;

1249 }

1250 }

1251

1252 sub ctx_statement_full {

1253 my ($linenr, $remain, $off) = @_;

1254 my ($statement, $condition, $level);

1255

1256 my (@chunks);

1257

1258 # Grab the first conditional/block pair.

1259 ($statement, $condition, $linenr, $remain, $off, $level) =

1260 ctx_statement_block($linenr, $remain, $off);

1261 #print "F: c<$condition> s<$statement> remain<$remain>\n";

1262 push(@chunks, [ $condition, $statement ]);

1263 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {

1264 return ($level, $linenr, @chunks);

1265 }

1266

1267 # Pull in the following conditional/block pairs and see if they

1268 # could continue the statement.

1269 for (;;) {

1270 ($statement, $condition, $linenr, $remain, $off, $level) =

1271 ctx_statement_block($linenr, $remain, $off);

1272 #print "C: c<$condition> s<$statement> remain<$remain>\n";

1273 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));

1274 #print "C: push\n";

1275 push(@chunks, [ $condition, $statement ]);

1276 }

1277

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

1279 }

1280

1281 sub ctx_block_get {

1282 my ($linenr, $remain, $outer, $open, $close, $off) = @_;

1283 my $line;

1284 my $start = $linenr - 1;

1285 my $blk = '';

1286 my @o;

1287 my @c;

1288 my @res = ();

1289

1290 my $level = 0;

1291 my @stack = ($level);

1292 for ($line = $start; $remain > 0; $line++) {

1293 next if ($rawlines[$line] =~ /^-/);

1294 $remain--;

1295

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

1297

1298 # Handle nested #if/#else.

1299 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {

1300 push(@stack, $level);

1301 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {

1302 $level = $stack[$#stack - 1];

1303 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {

1304 $level = pop(@stack);

1305 }

1306

1307 foreach my $c (split(//, $lines[$line])) {

1308 ##print "C<$c>L<$level><$open$close>O<$off>\n";

1309 if ($off > 0) {

1310 $off--;

1311 next;

1312 }

1313

1314 if ($c eq $close && $level > 0) {

1315 $level--;

1316 last if ($level == 0);

1317 } elsif ($c eq $open) {

1318 $level++;

1319 }

1320 }

1321

1322 if (!$outer || $level <= 1) {

1323 push(@res, $rawlines[$line]);

1324 }

1325

1326 last if ($level == 0);

1327 }

1328

1329 return ($level, @res);

1330 }

1331 sub ctx_block_outer {

1332 my ($linenr, $remain) = @_;

1333

1334 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);

1335 return @r;

1336 }

1337 sub ctx_block {

1338 my ($linenr, $remain) = @_;

1339

1340 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);

1341 return @r;

1342 }

1343 sub ctx_statement {

1344 my ($linenr, $remain, $off) = @_;

1345

1346 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);

1347 return @r;

1348 }

1349 sub ctx_block_level {

1350 my ($linenr, $remain) = @_;

1351

1352 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);

1353 }

1354 sub ctx_statement_level {

1355 my ($linenr, $remain, $off) = @_;

1356

1357 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);

1358 }

1359

1360 sub ctx_locate_comment {

1361 my ($first_line, $end_line) = @_;

1362

1363 # Catch a comment on the end of the line itself.

1364 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);

1365 return $current_comment if (defined $current_comment);

1366

1367 # Look through the context and try and figure out if there is a

1368 # comment.

1369 my $in_comment = 0;

1370 $current_comment = '';

1371 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {

1372 my $line = $rawlines[$linenr - 1];

1373 #warn " $line\n";

1374 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {

1375 $in_comment = 1;

1376 }

1377 if ($line =~ m@/\*@) {

1378 $in_comment = 1;

1379 }

1380 if (!$in_comment && $current_comment ne '') {

1381 $current_comment = '';

1382 }

1383 $current_comment .= $line . "\n" if ($in_comment);

1384 if ($line =~ m@\*/@) {

1385 $in_comment = 0;

1386 }

1387 }

1388

1389 chomp($current_comment);

1390 return($current_comment);

1391 }

1392 sub ctx_has_comment {

1393 my ($first_line, $end_line) = @_;

1394 my $cmt = ctx_locate_comment($first_line, $end_line);

1395

1396 ##print "LINE: $rawlines[$end_line - 1 ]\n";

1397 ##print "CMMT: $cmt\n";

1398

1399 return ($cmt ne '');

1400 }

1401

1402 sub raw_line {

1403 my ($linenr, $cnt) = @_;

1404

1405 my $offset = $linenr - 1;

1406 $cnt++;

1407

1408 my $line;

1409 while ($cnt) {

1410 $line = $rawlines[$offset++];

1411 next if (defined($line) && $line =~ /^-/);

1412 $cnt--;

1413 }

1414

1415 return $line;

1416 }

1417

1418 sub cat_vet {

1419 my ($vet) = @_;

1420 my ($res, $coded);

1421

1422 $res = '';

1423 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {

1424 $res .= $1;

1425 if ($2 ne '') {

1426 $coded = sprintf("^%c", unpack('C', $2) + 64);

1427 $res .= $coded;

1428 }

1429 }

1430 $res =~ s/$/\$/;

1431

1432 return $res;

1433 }

1434

1435 my $av_preprocessor = 0;

1436 my $av_pending;

1437 my @av_paren_type;

1438 my $av_pend_colon;

1439

1440 sub annotate_reset {

1441 $av_preprocessor = 0;

1442 $av_pending = '_';

1443 @av_paren_type = ('E');

1444 $av_pend_colon = 'O';

1445 }

1446

1447 sub annotate_values {

1448 my ($stream, $type) = @_;

1449

1450 my $res;

1451 my $var = '_' x length($stream);

1452 my $cur = $stream;

1453

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

1455

1456 while (length($cur)) {

1457 @av_paren_type = ('E') if ($#av_paren_type < 0);

1458 print " <" . join('', @av_paren_type) .

1459 "> <$type> <$av_pending>" if ($dbg_values > 1);

1460 if ($cur =~ /^(\s+)/o) {

1461 print "WS($1)\n" if ($dbg_values > 1);

1462 if ($1 =~ /\n/ && $av_preprocessor) {

1463 $type = pop(@av_paren_type);

1464 $av_preprocessor = 0;

1465 }

1466

1467 } elsif ($cur =~ /^($\s*$Type\s*)$/ && $av_pending eq '_') {

1468 print "CAST($1)\n" if ($dbg_values > 1);

1469 push(@av_paren_type, $type);

1470 $type = 'c';

1471

1472 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {

1473 print "DECLARE($1)\n" if ($dbg_values > 1);

1474 $type = 'T';

1475

1476 } elsif ($cur =~ /^($Modifier)\s*/) {

1477 print "MODIFIER($1)\n" if ($dbg_values > 1);

1478 $type = 'T';

1479

1480 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {

1481 print "DEFINE($1,$2)\n" if ($dbg_values > 1);

1482 $av_preprocessor = 1;

1483 push(@av_paren_type, $type);

1484 if ($2 ne '') {

1485 $av_pending = 'N';

1486 }

1487 $type = 'E';

1488

1489 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {

1490 print "UNDEF($1)\n" if ($dbg_values > 1);

1491 $av_preprocessor = 1;

1492 push(@av_paren_type, $type);

1493

1494 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {

1495 print "PRE_START($1)\n" if ($dbg_values > 1);

1496 $av_preprocessor = 1;

1497

1498 push(@av_paren_type, $type);

1499 push(@av_paren_type, $type);

1500 $type = 'E';

1501

1502 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {

1503 print "PRE_RESTART($1)\n" if ($dbg_values > 1);

1504 $av_preprocessor = 1;

1505

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

1507

1508 $type = 'E';

1509

1510 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {

1511 print "PRE_END($1)\n" if ($dbg_values > 1);

1512

1513 $av_preprocessor = 1;

1514

1515 # Assume all arms of the conditional end as this

1516 # one does, and continue as if the #endif was not here.

1517 pop(@av_paren_type);

1518 push(@av_paren_type, $type);

1519 $type = 'E';

1520

1521 } elsif ($cur =~ /^(\\\n)/o) {

1522 print "PRECONT($1)\n" if ($dbg_values > 1);

1523

1524 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {

1525 print "ATTR($1)\n" if ($dbg_values > 1);

1526 $av_pending = $type;

1527 $type = 'N';

1528

1529 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {

1530 print "SIZEOF($1)\n" if ($dbg_values > 1);

1531 if (defined $2) {

1532 $av_pending = 'V';

1533 }

1534 $type = 'N';

1535

1536 } elsif ($cur =~ /^(if|while|for)\b/o) {

1537 print "COND($1)\n" if ($dbg_values > 1);

1538 $av_pending = 'E';

1539 $type = 'N';

1540

1541 } elsif ($cur =~/^(case)/o) {

1542 print "CASE($1)\n" if ($dbg_values > 1);

1543 $av_pend_colon = 'C';

1544 $type = 'N';

1545

1546 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {

1547 print "KEYWORD($1)\n" if ($dbg_values > 1);

1548 $type = 'N';

1549

1550 } elsif ($cur =~ /^(\()/o) {

1551 print "PAREN('$1')\n" if ($dbg_values > 1);

1552 push(@av_paren_type, $av_pending);

1553 $av_pending = '_';

1554 $type = 'N';

1555

1556 } elsif ($cur =~ /^(\))/o) {

1557 my $new_type = pop(@av_paren_type);

1558 if ($new_type ne '_') {

1559 $type = $new_type;

1560 print "PAREN('$1') -> $type\n"

1561 if ($dbg_values > 1);

1562 } else {

1563 print "PAREN('$1')\n" if ($dbg_values > 1);

1564 }

1565

1566 } elsif ($cur =~ /^($Ident)\s*\(/o) {

1567 print "FUNC($1)\n" if ($dbg_values > 1);

1568 $type = 'V';

1569 $av_pending = 'V';

1570

1571 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {

1572 if (defined $2 && $type eq 'C' || $type eq 'T') {

1573 $av_pend_colon = 'B';

1574 } elsif ($type eq 'E') {

1575 $av_pend_colon = 'L';

1576 }

1577 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);

1578 $type = 'V';

1579

1580 } elsif ($cur =~ /^($Ident|$Constant)/o) {

1581 print "IDENT($1)\n" if ($dbg_values > 1);

1582 $type = 'V';

1583

1584 } elsif ($cur =~ /^($Assignment)/o) {

1585 print "ASSIGN($1)\n" if ($dbg_values > 1);

1586 $type = 'N';

1587

1588 } elsif ($cur =~/^(;|{|})/) {

1589 print "END($1)\n" if ($dbg_values > 1);

1590 $type = 'E';

1591 $av_pend_colon = 'O';

1592

1593 } elsif ($cur =~/^(,)/) {

1594 print "COMMA($1)\n" if ($dbg_values > 1);

1595 $type = 'C';

1596

1597 } elsif ($cur =~ /^(\?)/o) {

1598 print "QUESTION($1)\n" if ($dbg_values > 1);

1599 $type = 'N';

1600

1601 } elsif ($cur =~ /^(:)/o) {

1602 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);

1603

1604 substr($var, length($res), 1, $av_pend_colon);

1605 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {

1606 $type = 'E';

1607 } else {

1608 $type = 'N';

1609 }

1610 $av_pend_colon = 'O';

1611

1612 } elsif ($cur =~ /^(\[)/o) {

1613 print "CLOSE($1)\n" if ($dbg_values > 1);

1614 $type = 'N';

1615

1616 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {

1617 my $variant;

1618

1619 print "OPV($1)\n" if ($dbg_values > 1);

1620 if ($type eq 'V') {

1621 $variant = 'B';

1622 } else {

1623 $variant = 'U';

1624 }

1625

1626 substr($var, length($res), 1, $variant);

1627 $type = 'N';

1628

1629 } elsif ($cur =~ /^($Operators)/o) {

1630 print "OP($1)\n" if ($dbg_values > 1);

1631 if ($1 ne '++' && $1 ne '--') {

1632 $type = 'N';

1633 }

1634

1635 } elsif ($cur =~ /(^.)/o) {

1636 print "C($1)\n" if ($dbg_values > 1);

1637 }

1638 if (defined $1) {

1639 $cur = substr($cur, length($1));

1640 $res .= $type x length($1);

1641 }

1642 }

1643

1644 return ($res, $var);

1645 }

1646

1647 sub possible {

1648 my ($possible, $line) = @_;

1649 my $notPermitted = qr{(?:

1650 ^(?:

1651 $Modifier|

1652 $Storage|

1653 $Type|

1654 DEFINE_\S+

1655 )$|

1656 ^(?:

1657 goto|

1658 return|

1659 case|

1660 else|

1661 asm|__asm__|

1662 do|

1663 \#|

1664 \#\#|

1665 )(?:\s|$)|

1666 ^(?:typedef|struct|enum)\b

1667 )}x;

1668 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);

1669 if ($possible !~ $notPermitted) {

1670 # Check for modifiers.

1671 $possible =~ s/\s*$Storage\s*//g;

1672 $possible =~ s/\s*$Sparse\s*//g;

1673 if ($possible =~ /^\s*$/) {

1674

1675 } elsif ($possible =~ /\s/) {

1676 $possible =~ s/\s*$Type\s*//g;

1677 for my $modifier (split(' ', $possible)) {

1678 if ($modifier !~ $notPermitted) {

1679 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);

1680 push(@modifierListFile, $modifier);

1681 }

1682 }

1683

1684 } else {

1685 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);

1686 push(@typeListFile, $possible);

1687 }

1688 build_types();

1689 } else {

1690 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);

1691 }

1692 }

1693

1694 my $prefix = '';

1695

1696 sub show_type {

1697 my ($type) = @_;

1698

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

1700

1701 return !defined $ignore_type{$type};

1702 }

1703

1704 sub report {

1705 my ($level, $type, $msg) = @_;

1706

1707 if (!show_type($type) ||

1708 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {

1709 return 0;

1710 }

1711 my $output = '';

1712 if (-t STDOUT && $color) {

1713 if ($level eq 'ERROR') {

1714 $output .= RED;

1715 } elsif ($level eq 'WARNING') {

1716 $output .= YELLOW;

1717 } else {

1718 $output .= GREEN;

1719 }

1720 }

1721 $output .= $prefix . $level . ':';

1722 if ($show_types) {

1723 $output .= BLUE if (-t STDOUT && $color);

1724 $output .= "$type:";

1725 }

1726 $output .= RESET if (-t STDOUT && $color);

1727 $output .= ' ' . $msg . "\n";

1728

1729 if ($showfile) {

1730 my @lines = split("\n", $output, -1);

1731 splice(@lines, 1, 1);

1732 $output = join("\n", @lines);

1733 }

1734 $output = (split('\n', $output))[0] . "\n" if ($terse);

1735

1736 push(our @report, $output);

1737

1738 return 1;

1739 }

1740

1741 sub report_dump {

1742 our @report;

1743 }

1744

1745 sub fixup_current_range {

1746 my ($lineRef, $offset, $length) = @_;

1747

1748 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {

1749 my $o = $1;

1750 my $l = $2;

1751 my $no = $o + $offset;

1752 my $nl = $l + $length;

1753 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;

1754 }

1755 }

1756

1757 sub fix_inserted_deleted_lines {

1758 my ($linesRef, $insertedRef, $deletedRef) = @_;

1759

1760 my $range_last_linenr = 0;

1761 my $delta_offset = 0;

1762

1763 my $old_linenr = 0;

1764 my $new_linenr = 0;

1765

1766 my $next_insert = 0;

1767 my $next_delete = 0;

1768

1769 my @lines = ();

1770

1771 my $inserted = @{$insertedRef}[$next_insert++];

1772 my $deleted = @{$deletedRef}[$next_delete++];

1773

1774 foreach my $old_line (@{$linesRef}) {

1775 my $save_line = 1;

1776 my $line = $old_line; #don't modify the array

1777 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename

1778 $delta_offset = 0;

1779 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk

1780 $range_last_linenr = $new_linenr;

1781 fixup_current_range(\$line, $delta_offset, 0);

1782 }

1783

1784 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {

1785 $deleted = @{$deletedRef}[$next_delete++];

1786 $save_line = 0;

1787 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);

1788 }

1789

1790 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {

1791 push(@lines, ${$inserted}{'LINE'});

1792 $inserted = @{$insertedRef}[$next_insert++];

1793 $new_linenr++;

1794 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);

1795 }

1796

1797 if ($save_line) {

1798 push(@lines, $line);

1799 $new_linenr++;

1800 }

1801

1802 $old_linenr++;

1803 }

1804

1805 return @lines;

1806 }

1807

1808 sub fix_insert_line {

1809 my ($linenr, $line) = @_;

1810

1811 my $inserted = {

1812 LINENR => $linenr,

1813 LINE => $line,

1814 };

1815 push(@fixed_inserted, $inserted);

1816 }

1817

1818 sub fix_delete_line {

1819 my ($linenr, $line) = @_;

1820

1821 my $deleted = {

1822 LINENR => $linenr,

1823 LINE => $line,

1824 };

1825

1826 push(@fixed_deleted, $deleted);

1827 }

1828

1829 sub ERROR {

1830 my ($type, $msg) = @_;

1831

1832 if (report("ERROR", $type, $msg)) {

1833 our $clean = 0;

1834 our $cnt_error++;

1835 return 1;

1836 }

1837 return 0;

1838 }

1839 sub WARN {

1840 my ($type, $msg) = @_;

1841

1842 if (report("WARNING", $type, $msg)) {

1843 our $clean = 0;

1844 our $cnt_warn++;

1845 return 1;

1846 }

1847 return 0;

1848 }

1849 sub CHK {

1850 my ($type, $msg) = @_;

1851

1852 if ($check && report("CHECK", $type, $msg)) {

1853 our $clean = 0;

1854 our $cnt_chk++;

1855 return 1;

1856 }

1857 return 0;

1858 }

1859

1860 sub check_absolute_file {

1861 my ($absolute, $herecurr) = @_;

1862 my $file = $absolute;

1863

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

1865

1866 # See if any suffix of this path is a path within the tree.

1867 while ($file =~ s@^[^/]*/@@) {

1868 if (-f "$root/$file") {

1869 ##print "file<$file>\n";

1870 last;

1871 }

1872 }

1873 if (! -f _) {

1874 return 0;

1875 }

1876

1877 # It is, so see if the prefix is acceptable.

1878 my $prefix = $absolute;

1879 substr($prefix, -length($file)) = '';

1880

1881 ##print "prefix<$prefix>\n";

1882 if ($prefix ne ".../") {

1883 WARN("USE_RELATIVE_PATH",

1884 "use relative pathname instead of absolute in changelog text\n" . $herecurr);

1885 }

1886 }

1887

1888 sub trim {

1889 my ($string) = @_;

1890

1891 $string =~ s/^\s+|\s+$//g;

1892

1893 return $string;

1894 }

1895

1896 sub ltrim {

1897 my ($string) = @_;

1898

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

1900

1901 return $string;

1902 }

1903

1904 sub rtrim {

1905 my ($string) = @_;

1906

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

1908

1909 return $string;

1910 }

1911

1912 sub string_find_replace {

1913 my ($string, $find, $replace) = @_;

1914

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

1916

1917 return $string;

1918 }

1919

1920 sub tabify {

1921 my ($leading) = @_;

1922

1923 my $source_indent = 8;

1924 my $max_spaces_before_tab = $source_indent - 1;

1925 my $spaces_to_tab = " " x $source_indent;

1926

1927 #convert leading spaces to tabs

1928 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;

1929 #Remove spaces before a tab

1930 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;

1931

1932 return "$leading";

1933 }

1934

1935 sub pos_last_openparen {

1936 my ($line) = @_;

1937

1938 my $pos = 0;

1939

1940 my $opens = $line =~ tr/\(/\(/;

1941 my $closes = $line =~ tr/\)/\)/;

1942

1943 my $last_openparen = 0;

1944

1945 if (($opens == 0) || ($closes >= $opens)) {

1946 return -1;

1947 }

1948

1949 my $len = length($line);

1950

1951 for ($pos = 0; $pos < $len; $pos++) {

1952 my $string = substr($line, $pos);

1953 if ($string =~ /^($FuncArg|$balanced_parens)/) {

1954 $pos += length($1) - 1;

1955 } elsif (substr($line, $pos, 1) eq '(') {

1956 $last_openparen = $pos;

1957 } elsif (index($string, '(') == -1) {

1958 last;

1959 }

1960 }

1961

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

1963 }

1964

1965 sub process {

1966 my $filename = shift;

1967

1968 my $linenr=0;

1969 my $prevline="";

1970 my $prevrawline="";

1971 my $stashline="";

1972 my $stashrawline="";

1973

1974 my $length;

1975 my $indent;

1976 my $previndent=0;

1977 my $stashindent=0;

1978

1979 our $clean = 1;

1980 my $signoff = 0;

1981 my $is_patch = 0;

1982 my $in_header_lines = $file ? 0 : 1;

1983 my $in_commit_log = 0; #Scanning lines before patch

1984 my $commit_log_possible_stack_dump = 0;

1985 my $commit_log_long_line = 0;

1986 my $commit_log_has_diff = 0;

1987 my $reported_maintainer_file = 0;

1988 my $non_utf8_charset = 0;

1989

1990 my $last_blank_line = 0;

1991 my $last_coalesced_string_linenr = -1;

1992

1993 our @report = ();

1994 our $cnt_lines = 0;

1995 our $cnt_error = 0;

1996 our $cnt_warn = 0;

1997 our $cnt_chk = 0;

1998

1999 # Trace the real file/line as we go.

2000 my $realfile = '';

2001 my $realline = 0;

2002 my $realcnt = 0;

2003 my $here = '';

2004 my $in_comment = 0;

2005 my $comment_edge = 0;

2006 my $first_line = 0;

2007 my $p1_prefix = '';

2008

2009 my $prev_values = 'E';

2010

2011 # suppression flags

2012 my %suppress_ifbraces;

2013 my %suppress_whiletrailers;

2014 my %suppress_export;

2015 my $suppress_statement = 0;

2016

2017 my %signatures = ();

2018

2019 # Pre-scan the patch sanitizing the lines.

2020 # Pre-scan the patch looking for any __setup documentation.

2021 #

2022 my @setup_docs = ();

2023 my $setup_docs = 0;

2024

2025 my $camelcase_file_seeded = 0;

2026

2027 sanitise_line_reset();

2028 my $line;

2029 foreach my $rawline (@rawlines) {

2030 $linenr++;

2031 $line = $rawline;

2032

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

2034

2035 if ($rawline=~/^\+\+\+\s+(\S+)/) {

2036 $setup_docs = 0;

2037 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {

2038 $setup_docs = 1;

2039 }

2040 #next;

2041 }

2042 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {

2043 $realline=$1-1;

2044 if (defined $2) {

2045 $realcnt=$3+1;

2046 } else {

2047 $realcnt=1+1;

2048 }

2049 $in_comment = 0;

2050

2051 # Guestimate if this is a continuing comment. Run

2052 # the context looking for a comment "edge". If this

2053 # edge is a close comment then we must be in a comment

2054 # at context start.

2055 my $edge;

2056 my $cnt = $realcnt;

2057 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {

2058 next if (defined $rawlines[$ln - 1] &&

2059 $rawlines[$ln - 1] =~ /^-/);

2060 $cnt--;

2061 #print "RAW<$rawlines[$ln - 1]>\n";

2062 last if (!defined $rawlines[$ln - 1]);

2063 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&

2064 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {

2065 ($edge) = $1;

2066 last;

2067 }

2068 }

2069 if (defined $edge && $edge eq '*/') {

2070 $in_comment = 1;

2071 }

2072

2073 # Guestimate if this is a continuing comment. If this

2074 # is the start of a diff block and this line starts

2075 # ' *' then it is very likely a comment.

2076 if (!defined $edge &&

2077 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)

2078 {

2079 $in_comment = 1;

2080 }

2081

2082 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";

2083 sanitise_line_reset($in_comment);

2084

2085 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {

2086 # Standardise the strings and chars within the input to

2087 # simplify matching -- only bother with positive lines.

2088 $line = sanitise_line($rawline);

2089 }

2090 push(@lines, $line);

2091

2092 if ($realcnt > 1) {

2093 $realcnt-- if ($line =~ /^(?:\+| |$)/);

2094 } else {

2095 $realcnt = 0;

2096 }

2097

2098 #print "==>$rawline\n";

2099 #print "-->$line\n";

2100

2101 if ($setup_docs && $line =~ /^\+/) {

2102 push(@setup_docs, $line);

2103 }

2104 }

2105

2106 $prefix = '';

2107

2108 $realcnt = 0;

2109 $linenr = 0;

2110 $fixlinenr = -1;

2111 foreach my $line (@lines) {

2112 $linenr++;

2113 $fixlinenr++;

2114 my $sline = $line; #copy of $line

2115 $sline =~ s/$;/ /g; #with comments as spaces

2116

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

2118

2119 #extract the line range in the file after the patch is applied

2120 if (!$in_commit_log &&

2121 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {

2122 $is_patch = 1;

2123 $first_line = $linenr + 1;

2124 $realline=$1-1;

2125 if (defined $2) {

2126 $realcnt=$3+1;

2127 } else {

2128 $realcnt=1+1;

2129 }

2130 annotate_reset();

2131 $prev_values = 'E';

2132

2133 %suppress_ifbraces = ();

2134 %suppress_whiletrailers = ();

2135 %suppress_export = ();

2136 $suppress_statement = 0;

2137 next;

2138

2139 # track the line number as we move through the hunk, note that

2140 # new versions of GNU diff omit the leading space on completely

2141 # blank context lines so we need to count that too.

2142 } elsif ($line =~ /^( |\+|$)/) {

2143 $realline++;

2144 $realcnt-- if ($realcnt != 0);

2145

2146 # Measure the line length and indent.

2147 ($length, $indent) = line_stats($rawline);

2148

2149 # Track the previous line.

2150 ($prevline, $stashline) = ($stashline, $line);

2151 ($previndent, $stashindent) = ($stashindent, $indent);

2152 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);

2153

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

2155

2156 } elsif ($realcnt == 1) {

2157 $realcnt--;

2158 }

2159

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

2161

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

2163 $here = "#$realline: " if ($file);

2164

2165 my $found_file = 0;

2166 # extract the filename as it passes

2167 if ($line =~ /^diff --git.*?(\S+)$/) {

2168 $realfile = $1;

2169 $realfile =~ s@^([^/]*)/@@ if (!$file);

2170 $in_commit_log = 0;

2171 $found_file = 1;

2172 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {

2173 $realfile = $1;

2174 $realfile =~ s@^([^/]*)/@@ if (!$file);

2175 $in_commit_log = 0;

2176

2177 $p1_prefix = $1;

2178 if (!$file && $tree && $p1_prefix ne '' &&

2179 -e "$root/$p1_prefix") {

2180 WARN("PATCH_PREFIX",

2181 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");

2182 }

2183

2184 if ($realfile =~ m@^include/asm/@) {

2185 ERROR("MODIFIED_INCLUDE_ASM",

2186 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");

2187 }

2188 $found_file = 1;

2189 }

2190

2191 #make up the handle for any error we report on this line

2192 if ($showfile) {

2193 $prefix = "$realfile:$realline: "

2194 } elsif ($emacs) {

2195 if ($file) {

2196 $prefix = "$filename:$realline: ";

2197 } else {

2198 $prefix = "$filename:$linenr: ";

2199 }

2200 }

2201

2202 if ($found_file) {

2203 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {

2204 $check = 1;

2205 } else {

2206 $check = $check_orig;

2207 }

2208 next;

2209 }

2210

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

2212

2213 my $hereline = "$here\n$rawline\n";

2214 my $herecurr = "$here\n$rawline\n";

2215 my $hereprev = "$here\n$prevrawline\n$rawline\n";

2216

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

2218

2219 # Check if the commit log has what seems like a diff which can confuse patch

2220 if ($in_commit_log && !$commit_log_has_diff &&

2221 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&

2222 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||

2223 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||

2224 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {

2225 ERROR("DIFF_IN_COMMIT_MSG",

2226 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);

2227 $commit_log_has_diff = 1;

2228 }

2229

2230 # Check for incorrect file permissions

2231 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {

2232 my $permhere = $here . "FILE: $realfile\n";

2233 if ($realfile !~ m@scripts/@ &&

2234 $realfile !~ /\.(py|pl|awk|sh)$/) {

2235 ERROR("EXECUTE_PERMISSIONS",

2236 "do not set execute permissions for source files\n" . $permhere);

2237 }

2238 }

2239

2240 # Check the patch for a signoff:

2241 if ($line =~ /^\s*signed-off-by:/i) {

2242 $signoff++;

2243 $in_commit_log = 0;

2244 }

2245

2246 # Check if MAINTAINERS is being updated. If so, there's probably no need to

2247 # emit the "does MAINTAINERS need updating?" message on file add/move/delete

2248 if ($line =~ /^\s*MAINTAINERS\s*\|/) {

2249 $reported_maintainer_file = 1;

2250 }

2251

2252 # Check signature styles

2253 if (!$in_header_lines &&

2254 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {

2255 my $space_before = $1;

2256 my $sign_off = $2;

2257 my $space_after = $3;

2258 my $email = $4;

2259 my $ucfirst_sign_off = ucfirst(lc($sign_off));

2260

2261 if ($sign_off !~ /$signature_tags/) {

2262 WARN("BAD_SIGN_OFF",

2263 "Non-standard signature: $sign_off\n" . $herecurr);

2264 }

2265 if (defined $space_before && $space_before ne "") {

2266 if (WARN("BAD_SIGN_OFF",

2267 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&

2268 $fix) {

2269 $fixed[$fixlinenr] =

2270 "$ucfirst_sign_off $email";

2271 }

2272 }

2273 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {

2274 if (WARN("BAD_SIGN_OFF",

2275 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&

2276 $fix) {

2277 $fixed[$fixlinenr] =

2278 "$ucfirst_sign_off $email";

2279 }

2280

2281 }

2282 if (!defined $space_after || $space_after ne " ") {

2283 if (WARN("BAD_SIGN_OFF",

2284 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&

2285 $fix) {

2286 $fixed[$fixlinenr] =

2287 "$ucfirst_sign_off $email";

2288 }

2289 }

2290

2291 my ($email_name, $email_address, $comment) = parse_email($email);

2292 my $suggested_email = format_email(($email_name, $email_address));

2293 if ($suggested_email eq "") {

2294 ERROR("BAD_SIGN_OFF",

2295 "Unrecognized email address: '$email'\n" . $herecurr);

2296 } else {

2297 my $dequoted = $suggested_email;

2298 $dequoted =~ s/^"//;

2299 $dequoted =~ s/" </ </;

2300 # Don't force email to have quotes

2301 # Allow just an angle bracketed address

2302 if ("$dequoted$comment" ne $email &&

2303 "<$email_address>$comment" ne $email &&

2304 "$suggested_email$comment" ne $email) {

2305 WARN("BAD_SIGN_OFF",

2306 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);

2307 }

2308 }

2309

2310 # Check for duplicate signatures

2311 my $sig_nospace = $line;

2312 $sig_nospace =~ s/\s//g;

2313 $sig_nospace = lc($sig_nospace);

2314 if (defined $signatures{$sig_nospace}) {

2315 WARN("BAD_SIGN_OFF",

2316 "Duplicate signature\n" . $herecurr);

2317 } else {

2318 $signatures{$sig_nospace} = 1;

2319 }

2320 }

2321

2322 # Check email subject for common tools that don't need to be mentioned

2323 if ($in_header_lines &&

2324 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {

2325 WARN("EMAIL_SUBJECT",

2326 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);

2327 }

2328

2329 # Check for old stable address

2330 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {

2331 ERROR("STABLE_ADDRESS",

2332 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);

2333 }

2334

2335 # Check for unwanted Gerrit info

2336 if ($in_commit_log && $line =~ /^\s*change-id:/i) {

2337 ERROR("GERRIT_CHANGE_ID",

2338 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);

2339 }

2340

2341 # Check if the commit log is in a possible stack dump

2342 if ($in_commit_log && !$commit_log_possible_stack_dump &&

2343 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||

2344 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||

2345 # timestamp

2346 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {

2347 # stack dump address

2348 $commit_log_possible_stack_dump = 1;

2349 }

2350

2351 # Check for line lengths > 75 in commit log, warn once

2352 if ($in_commit_log && !$commit_log_long_line &&

2353 length($line) > 75 &&

2354 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||

2355 # file delta changes

2356 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||

2357 # filename then :

2358 $line =~ /^\s*(?:Fixes:|Link:)/i ||

2359 # A Fixes: or Link: line

2360 $commit_log_possible_stack_dump)) {

2361 WARN("COMMIT_LOG_LONG_LINE",

2362 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);

2363 $commit_log_long_line = 1;

2364 }

2365

2366 # Reset possible stack dump if a blank line is found

2367 if ($in_commit_log && $commit_log_possible_stack_dump &&

2368 $line =~ /^\s*$/) {

2369 $commit_log_possible_stack_dump = 0;

2370 }

2371

2372 # Check for git id commit length and improperly formed commit descriptions

2373 if ($in_commit_log && !$commit_log_possible_stack_dump &&

2374 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||

2375 ($line =~ /\b[0-9a-f]{12,40}\b/i &&

2376 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&

2377 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {

2378 my $init_char = "c";

2379 my $orig_commit = "";

2380 my $short = 1;

2381 my $long = 0;

2382 my $case = 1;

2383 my $space = 1;

2384 my $hasdesc = 0;

2385 my $hasparens = 0;

2386 my $id = '0123456789ab';

2387 my $orig_desc = "commit description";

2388 my $description = "";

2389

2390 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {

2391 $init_char = $1;

2392 $orig_commit = lc($2);

2393 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {

2394 $orig_commit = lc($1);

2395 }

2396

2397 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);

2398 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);

2399 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);

2400 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);

2401 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+$"([^"]+)"$/i) {

2402 $orig_desc = $1;

2403 $hasparens = 1;

2404 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&

2405 defined $rawlines[$linenr] &&

2406 $rawlines[$linenr] =~ /^\s*$"([^"]+)"$/) {

2407 $orig_desc = $1;

2408 $hasparens = 1;

2409 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&

2410 defined $rawlines[$linenr] &&

2411 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {

2412 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;

2413 $orig_desc = $1;

2414 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;

2415 $orig_desc .= " " . $1;

2416 $hasparens = 1;

2417 }

2418

2419 ($id, $description) = git_commit_info($orig_commit,

2420 $id, $orig_desc);

2421

2422 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {

2423 ERROR("GIT_COMMIT_ID",

2424 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);

2425 }

2426 }

2427

2428 # Check for added, moved or deleted files

2429 if (!$reported_maintainer_file && !$in_commit_log &&

2430 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||

2431 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||

2432 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&

2433 (defined($1) || defined($2))))) {

2434 $reported_maintainer_file = 1;

2435 WARN("FILE_PATH_CHANGES",

2436 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);

2437 }

2438

2439 # Check for wrappage within a valid hunk of the file

2440 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {

2441 ERROR("CORRUPTED_PATCH",

2442 "patch seems to be corrupt (line wrapped?)\n" .

2443 $herecurr) if (!$emitted_corrupt++);

2444 }

2445

2446 # Check for absolute kernel paths.

2447 if ($tree) {

2448 while ($line =~ m{(?:^|\s)(/\S*)}g) {

2449 my $file = $1;

2450

2451 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&

2452 check_absolute_file($1, $herecurr)) {

2453 #

2454 } else {

2455 check_absolute_file($file, $herecurr);

2456 }

2457 }

2458 }

2459

2460 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php

2461 if (($realfile =~ /^$/ || $line =~ /^\+/) &&

2462 $rawline !~ m/^$UTF8*$/) {

2463 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);

2464

2465 my $blank = copy_spacing($rawline);

2466 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";

2467 my $hereptr = "$hereline$ptr\n";

2468

2469 CHK("INVALID_UTF8",

2470 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);

2471 }

2472

2473 # Check if it's the start of a commit log

2474 # (not a header line and we haven't seen the patch filename)

2475 if ($in_header_lines && $realfile =~ /^$/ &&

2476 !($rawline =~ /^\s+\S/ ||

2477 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {

2478 $in_header_lines = 0;

2479 $in_commit_log = 1;

2480 }

2481

2482 # Check if there is UTF-8 in a commit log when a mail header has explicitly

2483 # declined it, i.e defined some charset where it is missing.

2484 if ($in_header_lines &&

2485 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&

2486 $1 !~ /utf-8/i) {

2487 $non_utf8_charset = 1;

2488 }

2489

2490 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&

2491 $rawline =~ /$NON_ASCII_UTF8/) {

2492 WARN("UTF8_BEFORE_PATCH",

2493 "8-bit UTF-8 used in possible commit log\n" . $herecurr);

2494 }

2495

2496 # Check for various typo / spelling mistakes

2497 if (defined($misspellings) &&

2498 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {

2499 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {

2500 my $typo = $1;

2501 my $typo_fix = $spelling_fix{lc($typo)};

2502 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);

2503 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);

2504 my $msg_type = \&WARN;

2505 $msg_type = \&CHK if ($file);

2506 if (&{$msg_type}("TYPO_SPELLING",

2507 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&

2508 $fix) {

2509 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;

2510 }

2511 }

2512 }

2513

2514 # ignore non-hunk lines and lines being removed

2515 next if (!$hunk_line || $line =~ /^-/);

2516

2517 #trailing whitespace

2518 if ($line =~ /^\+.*\015/) {

2519 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2520 if (ERROR("DOS_LINE_ENDINGS",

2521 "DOS line endings\n" . $herevet) &&

2522 $fix) {

2523 $fixed[$fixlinenr] =~ s/[\s\015]+$//;

2524 }

2525 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {

2526 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2527 if (ERROR("TRAILING_WHITESPACE",

2528 "trailing whitespace\n" . $herevet) &&

2529 $fix) {

2530 $fixed[$fixlinenr] =~ s/\s+$//;

2531 }

2532

2533 $rpt_cleaners = 1;

2534 }

2535

2536 # Check for FSF mailing addresses.

2537 if ($rawline =~ /\bwrite to the Free/i ||

2538 $rawline =~ /\b59\s+Temple\s+Pl/i ||

2539 $rawline =~ /\b51\s+Franklin\s+St/i) {

2540 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2541 my $msg_type = \&ERROR;

2542 $msg_type = \&CHK if ($file);

2543 &{$msg_type}("FSF_MAILING_ADDRESS",

2544 "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)

2545 }

2546

2547 # check for Kconfig help text having a real description

2548 # Only applies when adding the entry originally, after that we do not have

2549 # sufficient context to determine whether it is indeed long enough.

2550 if ($realfile =~ /Kconfig/ &&

2551 $line =~ /^\+\s*config\s+/) {

2552 my $length = 0;

2553 my $cnt = $realcnt;

2554 my $ln = $linenr + 1;

2555 my $f;

2556 my $is_start = 0;

2557 my $is_end = 0;

2558 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {

2559 $f = $lines[$ln - 1];

2560 $cnt-- if ($lines[$ln - 1] !~ /^-/);

2561 $is_end = $lines[$ln - 1] =~ /^\+/;

2562

2563 next if ($f =~ /^-/);

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

2565

2566 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {

2567 $is_start = 1;

2568 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {

2569 $length = -1;

2570 }

2571

2572 $f =~ s/^.//;

2573 $f =~ s/#.*//;

2574 $f =~ s/^\s+//;

2575 next if ($f =~ /^$/);

2576 if ($f =~ /^\s*config\s/) {

2577 $is_end = 1;

2578 last;

2579 }

2580 $length++;

2581 }

2582 if ($is_start && $is_end && $length < $min_conf_desc_length) {

2583 WARN("CONFIG_DESCRIPTION",

2584 "please write a paragraph that describes the config symbol fully\n" . $herecurr);

2585 }

2586 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";

2587 }

2588

2589 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.

2590 if ($realfile =~ /Kconfig/ &&

2591 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {

2592 WARN("CONFIG_EXPERIMENTAL",

2593 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");

2594 }

2595

2596 # discourage the use of boolean for type definition attributes of Kconfig options

2597 if ($realfile =~ /Kconfig/ &&

2598 $line =~ /^\+\s*\bboolean\b/) {

2599 WARN("CONFIG_TYPE_BOOLEAN",

2600 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);

2601 }

2602

2603 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&

2604 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {

2605 my $flag = $1;

2606 my $replacement = {

2607 'EXTRA_AFLAGS' => 'asflags-y',

2608 'EXTRA_CFLAGS' => 'ccflags-y',

2609 'EXTRA_CPPFLAGS' => 'cppflags-y',

2610 'EXTRA_LDFLAGS' => 'ldflags-y',

2611 };

2612

2613 WARN("DEPRECATED_VARIABLE",

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

2615 }

2616

2617 # check for DT compatible documentation

2618 if (defined $root &&

2619 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||

2620 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {

2621

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

2623

2624 my $dt_path = $root . "/Documentation/devicetree/bindings/";

2625 my $vp_file = $dt_path . "vendor-prefixes.txt";

2626

2627 foreach my $compat (@compats) {

2628 my $compat2 = $compat;

2629 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;

2630 my $compat3 = $compat;

2631 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;

2632 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;

2633 if ( $? >> 8 ) {

2634 WARN("UNDOCUMENTED_DT_STRING",

2635 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);

2636 }

2637

2638 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;

2639 my $vendor = $1;

2640 `grep -Eq "^$vendor\\b" $vp_file`;

2641 if ( $? >> 8 ) {

2642 WARN("UNDOCUMENTED_DT_STRING",

2643 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);

2644 }

2645 }

2646 }

2647

2648 # check we are in a valid source file if not then ignore this hunk

2649 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);

2650

2651 # line length limit (with some exclusions)

2652 #

2653 # There are a few types of lines that may extend beyond $max_line_length:

2654 # logging functions like pr_info that end in a string

2655 # lines with a single string

2656 # #defines that are a single string

2657 #

2658 # There are 3 different line length message types:

2659 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength

2660 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length

2661 # LONG_LINE all other lines longer than $max_line_length

2662 #

2663 # if LONG_LINE is ignored, the other 2 types are also ignored

2664 #

2665

2666 if ($line =~ /^\+/ && $length > $max_line_length) {

2667 my $msg_type = "LONG_LINE";

2668

2669 # Check the allowed long line types first

2670

2671 # logging functions that end in a string that starts

2672 # before $max_line_length

2673 if ($line =~ /^\+\s*$logFunctions\s*$\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|$\s*;)\s*)$/ &&

2674 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {

2675 $msg_type = "";

2676

2677 # lines with only strings (w/ possible termination)

2678 # #defines with only strings

2679 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||

2680 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {

2681 $msg_type = "";

2682

2683 # Otherwise set the alternate message types

2684

2685 # a comment starts before $max_line_length

2686 } elsif ($line =~ /($;[\s$;]*)$/ &&

2687 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {

2688 $msg_type = "LONG_LINE_COMMENT"

2689

2690 # a quoted string starts before $max_line_length

2691 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&

2692 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {

2693 $msg_type = "LONG_LINE_STRING"

2694 }

2695

2696 if ($msg_type ne "" &&

2697 (show_type("LONG_LINE") || show_type($msg_type))) {

2698 WARN($msg_type,

2699 "line over $max_line_length characters\n" . $herecurr);

2700 }

2701 }

2702

2703 # check for adding lines without a newline.

2704 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {

2705 WARN("MISSING_EOF_NEWLINE",

2706 "adding a line without newline at end of file\n" . $herecurr);

2707 }

2708

2709 # Blackfin: use hi/lo macros

2710 if ($realfile =~ m@arch/blackfin/.*\.S$@) {

2711 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {

2712 my $herevet = "$here\n" . cat_vet($line) . "\n";

2713 ERROR("LO_MACRO",

2714 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);

2715 }

2716 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {

2717 my $herevet = "$here\n" . cat_vet($line) . "\n";

2718 ERROR("HI_MACRO",

2719 "use the HI() macro, not (... >> 16)\n" . $herevet);

2720 }

2721 }

2722

2723 # check we are in a valid source file C or perl if not then ignore this hunk

2724 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);

2725

2726 # at the beginning of a line any tabs must come first and anything

2727 # more than 8 must use tabs.

2728 if ($rawline =~ /^\+\s* \t\s*\S/ ||

2729 $rawline =~ /^\+\s* \s*/) {

2730 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2731 $rpt_cleaners = 1;

2732 if (ERROR("CODE_INDENT",

2733 "code indent should use tabs where possible\n" . $herevet) &&

2734 $fix) {

2735 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;

2736 }

2737 }

2738

2739 # check for space before tabs.

2740 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {

2741 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2742 if (WARN("SPACE_BEFORE_TAB",

2743 "please, no space before tabs\n" . $herevet) &&

2744 $fix) {

2745 while ($fixed[$fixlinenr] =~

2746 s/(^\+.*) {8,8}\t/$1\t\t/) {}

2747 while ($fixed[$fixlinenr] =~

2748 s/(^\+.*) +\t/$1\t/) {}

2749 }

2750 }

2751

2752 # check for && or || at the start of a line

2753 if ($rawline =~ /^\+\s*(&&|\|\|)/) {

2754 CHK("LOGICAL_CONTINUATIONS",

2755 "Logical continuations should be on the previous line\n" . $hereprev);

2756 }

2757

2758 # check indentation starts on a tab stop

2759 if ($^V && $^V ge 5.10.0 &&

2760 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {

2761 my $indent = length($1);

2762 if ($indent % 8) {

2763 if (WARN("TABSTOP",

2764 "Statements should start on a tabstop\n" . $herecurr) &&

2765 $fix) {

2766 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;

2767 }

2768 }

2769 }

2770

2771 # check multi-line statement indentation matches previous line

2772 if ($^V && $^V ge 5.10.0 &&

2773 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|$\s*\*\s*$Ident\s*$)\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {

2774 $prevline =~ /^\+(\t*)(.*)$/;

2775 my $oldindent = $1;

2776 my $rest = $2;

2777

2778 my $pos = pos_last_openparen($rest);

2779 if ($pos >= 0) {

2780 $line =~ /^(\+| )([ \t]*)/;

2781 my $newindent = $2;

2782

2783 my $goodtabindent = $oldindent .

2784 "\t" x ($pos / 8) .

2785 " " x ($pos % 8);

2786 my $goodspaceindent = $oldindent . " " x $pos;

2787

2788 if ($newindent ne $goodtabindent &&

2789 $newindent ne $goodspaceindent) {

2790

2791 if (CHK("PARENTHESIS_ALIGNMENT",

2792 "Alignment should match open parenthesis\n" . $hereprev) &&

2793 $fix && $line =~ /^\+/) {

2794 $fixed[$fixlinenr] =~

2795 s/^\+[ \t]*/\+$goodtabindent/;

2796 }

2797 }

2798 }

2799 }

2800

2801 # check for space after cast like "(int) foo" or "(struct foo) bar"

2802 # avoid checking a few false positives:

2803 # "sizeof(<type>)" or "__alignof__(<type>)"

2804 # function pointer declarations like "(*foo)(int) = bar;"

2805 # structure definitions like "(struct foo) { 0 };"

2806 # multiline macros that define functions

2807 # known attributes or the __attribute__ keyword

2808 if ($line =~ /^\+(.*)$\s*$Type\s*$([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&

2809 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {

2810 if (CHK("SPACING",

2811 "No space is necessary after a cast\n" . $herecurr) &&

2812 $fix) {

2813 $fixed[$fixlinenr] =~

2814 s/($\s*$Type\s*$)[ \t]+/$1/;

2815 }

2816 }

2817

2818 # Block comment styles

2819 # Networking with an initial /*

2820 if ($realfile =~ m@^(drivers/net/|net/)@ &&

2821 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&

2822 $rawline =~ /^\+[ \t]*\*/ &&

2823 $realline > 2) {

2824 WARN("NETWORKING_BLOCK_COMMENT_STYLE",

2825 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);

2826 }

2827

2828 # Block comments use * on subsequent lines

2829 if ($prevline =~ /$;[ \t]*$/ && #ends in comment

2830 $prevrawline =~ /^\+.*?\/\*/ && #starting /*

2831 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */

2832 $rawline =~ /^\+/ && #line is new

2833 $rawline !~ /^\+[ \t]*\*/) { #no leading *

2834 WARN("BLOCK_COMMENT_STYLE",

2835 "Block comments use * on subsequent lines\n" . $hereprev);

2836 }

2837

2838 # Block comments use */ on trailing lines

2839 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */

2840 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/

2841 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/

2842 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */

2843 WARN("BLOCK_COMMENT_STYLE",

2844 "Block comments use a trailing */ on a separate line\n" . $herecurr);

2845 }

2846

2847 # check for missing blank lines after struct/union declarations

2848 # with exceptions for various attributes and macros

2849 if ($prevline =~ /^[\+ ]};?\s*$/ &&

2850 $line =~ /^\+/ &&

2851 !($line =~ /^\+\s*$/ ||

2852 $line =~ /^\+\s*EXPORT_SYMBOL/ ||

2853 $line =~ /^\+\s*MODULE_/i ||

2854 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||

2855 $line =~ /^\+[a-z_]*init/ ||

2856 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||

2857 $line =~ /^\+\s*DECLARE/ ||

2858 $line =~ /^\+\s*__setup/)) {

2859 if (CHK("LINE_SPACING",

2860 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&

2861 $fix) {

2862 fix_insert_line($fixlinenr, "\+");

2863 }

2864 }

2865

2866 # check for multiple consecutive blank lines

2867 if ($prevline =~ /^[\+ ]\s*$/ &&

2868 $line =~ /^\+\s*$/ &&

2869 $last_blank_line != ($linenr - 1)) {

2870 if (CHK("LINE_SPACING",

2871 "Please don't use multiple blank lines\n" . $hereprev) &&

2872 $fix) {

2873 fix_delete_line($fixlinenr, $rawline);

2874 }

2875

2876 $last_blank_line = $linenr;

2877 }

2878

2879 # check for missing blank lines after declarations

2880 if ($sline =~ /^\+\s+\S/ && #Not at char 1

2881 # actual declarations

2882 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||

2883 # function pointer declarations

2884 $prevline =~ /^\+\s+$Declare\s*$\s*\*\s*$Ident\s*$\s*[=,;:\[\(]/ ||

2885 # foo bar; where foo is some local typedef or #define

2886 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||

2887 # known declaration macros

2888 $prevline =~ /^\+\s+$declaration_macros/) &&

2889 # for "else if" which can look like "$Ident $Ident"

2890 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||

2891 # other possible extensions of declaration lines

2892 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||

2893 # not starting a section or a macro "\" extended line

2894 $prevline =~ /(?:\{\s*|\\)$/) &&

2895 # looks like a declaration

2896 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||

2897 # function pointer declarations

2898 $sline =~ /^\+\s+$Declare\s*$\s*\*\s*$Ident\s*$\s*[=,;:\[\(]/ ||

2899 # foo bar; where foo is some local typedef or #define

2900 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||

2901 # known declaration macros

2902 $sline =~ /^\+\s+$declaration_macros/ ||

2903 # start of struct or union or enum

2904 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||

2905 # start or end of block or continuation of declaration

2906 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||

2907 # bitfield continuation

2908 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||

2909 # other possible extensions of declaration lines

2910 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&

2911 # indentation of previous and current line are the same

2912 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {

2913 if (WARN("LINE_SPACING",

2914 "Missing a blank line after declarations\n" . $hereprev) &&

2915 $fix) {

2916 fix_insert_line($fixlinenr, "\+");

2917 }

2918 }

2919

2920 # check for spaces at the beginning of a line.

2921 # Exceptions:

2922 # 1) within comments

2923 # 2) indented preprocessor commands

2924 # 3) hanging labels

2925 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {

2926 my $herevet = "$here\n" . cat_vet($rawline) . "\n";

2927 if (WARN("LEADING_SPACE",

2928 "please, no spaces at the start of a line\n" . $herevet) &&

2929 $fix) {

2930 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;

2931 }

2932 }

2933

2934 # check we are in a valid C source file if not then ignore this hunk

2935 next if ($realfile !~ /\.(h|c)$/);

2936

2937 # check indentation of any line with a bare else

2938 # (but not if it is a multiple line "if (foo) return bar; else return baz;")

2939 # if the previous line is a break or return and is indented 1 tab more...

2940 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {

2941 my $tabs = length($1) + 1;

2942 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||

2943 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&

2944 defined $lines[$linenr] &&

2945 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {

2946 WARN("UNNECESSARY_ELSE",

2947 "else is not generally useful after a break or return\n" . $hereprev);

2948 }

2949 }

2950

2951 # check indentation of a line with a break;

2952 # if the previous line is a goto or return and is indented the same # of tabs

2953 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {

2954 my $tabs = $1;

2955 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {

2956 WARN("UNNECESSARY_BREAK",

2957 "break is not useful after a goto or return\n" . $hereprev);

2958 }

2959 }

2960

2961 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).

2962 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {

2963 WARN("CONFIG_EXPERIMENTAL",

2964 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");

2965 }

2966

2967 # check for RCS/CVS revision markers

2968 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {

2969 WARN("CVS_KEYWORD",

2970 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);

2971 }

2972

2973 # Blackfin: don't use __builtin_bfin_[cs]sync

2974 if ($line =~ /__builtin_bfin_csync/) {

2975 my $herevet = "$here\n" . cat_vet($line) . "\n";

2976 ERROR("CSYNC",

2977 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);

2978 }

2979 if ($line =~ /__builtin_bfin_ssync/) {

2980 my $herevet = "$here\n" . cat_vet($line) . "\n";

2981 ERROR("SSYNC",

2982 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);

2983 }

2984

2985 # check for old HOTPLUG __dev<foo> section markings

2986 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {

2987 WARN("HOTPLUG_SECTION",

2988 "Using $1 is unnecessary\n" . $herecurr);

2989 }

2990

2991 # Check for potential 'bare' types

2992 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,

2993 $realline_next);

2994 #print "LINE<$line>\n";

2995 if ($linenr >= $suppress_statement &&

2996 $realcnt && $sline =~ /.\s*\S/) {

2997 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =

2998 ctx_statement_block($linenr, $realcnt, 0);

2999 $stat =~ s/\n./\n /g;

3000 $cond =~ s/\n./\n /g;

3001

3002 #print "linenr<$linenr> <$stat>\n";

3003 # If this statement has no statement boundaries within

3004 # it there is no point in retrying a statement scan

3005 # until we hit end of it.

3006 my $frag = $stat; $frag =~ s/;+\s*$//;

3007 if ($frag !~ /(?:{|;)/) {

3008 #print "skip<$line_nr_next>\n";

3009 $suppress_statement = $line_nr_next;

3010 }

3011

3012 # Find the real next line.

3013 $realline_next = $line_nr_next;

3014 if (defined $realline_next &&

3015 (!defined $lines[$realline_next - 1] ||

3016 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {

3017 $realline_next++;

3018 }

3019

3020 my $s = $stat;

3021 $s =~ s/{.*$//s;

3022

3023 # Ignore goto labels.

3024 if ($s =~ /$Ident:\*$/s) {

3025

3026 # Ignore functions being called

3027 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {

3028

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

3030

3031 # declarations always start with types

3032 } 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) {

3033 my $type = $1;

3034 $type =~ s/\s+/ /g;

3035 possible($type, "A:" . $s);

3036

3037 # definitions in global scope can only start with types

3038 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {

3039 possible($1, "B:" . $s);

3040 }

3041

3042 # any (foo ... *) is a pointer cast, and foo is a type

3043 while ($s =~ /$($Ident)(?:\s+$Sparse)*[\s\*]+\s*$/sg) {

3044 possible($1, "C:" . $s);

3045 }

3046

3047 # Check for any sort of function declaration.

3048 # int foo(something bar, other baz);

3049 # void (*store_gdt)(x86_descr_ptr *);

3050 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|$\*\s*$Ident$)\s*)\(/s) {

3051 my ($name_len) = length($1);

3052

3053 my $ctx = $s;

3054 substr($ctx, 0, $name_len + 1, '');

3055 $ctx =~ s/\)[^\)]*$//;

3056

3057 for my $arg (split(/\s*,\s*/, $ctx)) {

3058 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {

3059

3060 possible($1, "D:" . $s);

3061 }

3062 }

3063 }

3064

3065 }

3066

3067 #

3068 # Checks which may be anchored in the context.

3069 #

3070

3071 # Check for switch () and associated case and default

3072 # statements should be at the same indent.

3073 if ($line=~/\bswitch\s*$.*$/) {

3074 my $err = '';

3075 my $sep = '';

3076 my @ctx = ctx_block_outer($linenr, $realcnt);

3077 shift(@ctx);

3078 for my $ctx (@ctx) {

3079 my ($clen, $cindent) = line_stats($ctx);

3080 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&

3081 $indent != $cindent) {

3082 $err .= "$sep$ctx\n";

3083 $sep = '';

3084 } else {

3085 $sep = "[...]\n";

3086 }

3087 }

3088 if ($err ne '') {

3089 ERROR("SWITCH_CASE_INDENT_LEVEL",

3090 "switch and case should be at the same indent\n$hereline$err");

3091 }

3092 }

3093

3094 # if/while/etc brace do not go on next line, unless defining a do while loop,

3095 # or if that brace on the next line is for something else

3096 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {

3097 my $pre_ctx = "$1$2";

3098

3099 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);

3100

3101 if ($line =~ /^\+\t{6,}/) {

3102 WARN("DEEP_INDENTATION",

3103 "Too many leading tabs - consider code refactoring\n" . $herecurr);

3104 }

3105

3106 my $ctx_cnt = $realcnt - $#ctx - 1;

3107 my $ctx = join("\n", @ctx);

3108

3109 my $ctx_ln = $linenr;

3110 my $ctx_skip = $realcnt;

3111

3112 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&

3113 defined $lines[$ctx_ln - 1] &&

3114 $lines[$ctx_ln - 1] =~ /^-/)) {

3115 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";

3116 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);

3117 $ctx_ln++;

3118 }

3119

3120 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";

3121 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";

3122

3123 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {

3124 ERROR("OPEN_BRACE",

3125 "that open brace { should be on the previous line\n" .

3126 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");

3127 }

3128 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&

3129 $ctx =~ /\)\s*\;\s*$/ &&

3130 defined $lines[$ctx_ln - 1])

3131 {

3132 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);

3133 if ($nindent > $indent) {

3134 WARN("TRAILING_SEMICOLON",

3135 "trailing semicolon indicates no statements, indent implies otherwise\n" .

3136 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");

3137 }

3138 }

3139 }

3140

3141 # Check relative indent for conditionals and blocks.

3142 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {

3143 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =

3144 ctx_statement_block($linenr, $realcnt, 0)

3145 if (!defined $stat);

3146 my ($s, $c) = ($stat, $cond);

3147

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

3149

3150 # remove inline comments

3151 $s =~ s/$;/ /g;

3152 $c =~ s/$;/ /g;

3153

3154 # Find out how long the conditional actually is.

3155 my @newlines = ($c =~ /\n/gs);

3156 my $cond_lines = 1 + $#newlines;

3157

3158 # Make sure we remove the line prefixes as we have

3159 # none on the first line, and are going to readd them

3160 # where necessary.

3161 $s =~ s/\n./\n/gs;

3162 while ($s =~ /\n\s+\\\n/) {

3163 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;

3164 }

3165

3166 # We want to check the first line inside the block

3167 # starting at the end of the conditional, so remove:

3168 # 1) any blank line termination

3169 # 2) any opening brace { on end of the line

3170 # 3) any do (...) {

3171 my $continuation = 0;

3172 my $check = 0;

3173 $s =~ s/^.*\bdo\b//;

3174 $s =~ s/^\s*{//;

3175 if ($s =~ s/^\s*\\//) {

3176 $continuation = 1;

3177 }

3178 if ($s =~ s/^\s*?\n//) {

3179 $check = 1;

3180 $cond_lines++;

3181 }

3182

3183 # Also ignore a loop construct at the end of a

3184 # preprocessor statement.

3185 if (($prevline =~ /^.\s*#\s*define\s/ ||

3186 $prevline =~ /\\\s*$/) && $continuation == 0) {

3187 $check = 0;

3188 }

3189

3190 my $cond_ptr = -1;

3191 $continuation = 0;

3192 while ($cond_ptr != $cond_lines) {

3193 $cond_ptr = $cond_lines;

3194

3195 # If we see an #else/#elif then the code

3196 # is not linear.

3197 if ($s =~ /^\s*\#\s*(?:else|elif)/) {

3198 $check = 0;

3199 }

3200

3201 # Ignore:

3202 # 1) blank lines, they should be at 0,

3203 # 2) preprocessor lines, and

3204 # 3) labels.

3205 if ($continuation ||

3206 $s =~ /^\s*?\n/ ||

3207 $s =~ /^\s*#\s*?/ ||

3208 $s =~ /^\s*$Ident\s*:/) {

3209 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;

3210 if ($s =~ s/^.*?\n//) {

3211 $cond_lines++;

3212 }

3213 }

3214 }

3215

3216 my (undef, $sindent) = line_stats("+" . $s);

3217 my $stat_real = raw_line($linenr, $cond_lines);

3218

3219 # Check if either of these lines are modified, else

3220 # this is not this patch's fault.

3221 if (!defined($stat_real) ||

3222 $stat !~ /^\+/ && $stat_real !~ /^\+/) {

3223 $check = 0;

3224 }

3225 if (defined($stat_real) && $cond_lines > 1) {

3226 $stat_real = "[...]\n$stat_real";

3227 }

3228

3229 #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";

3230

3231 if ($check && $s ne '' &&

3232 (($sindent % 8) != 0 ||

3233 ($sindent < $indent) ||

3234 ($sindent > $indent + 8))) {

3235 WARN("SUSPECT_CODE_INDENT",

3236 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");

3237 }

3238 }

3239

3240 # Track the 'values' across context and added lines.

3241 my $opline = $line; $opline =~ s/^./ /;

3242 my ($curr_values, $curr_vars) =

3243 annotate_values($opline . "\n", $prev_values);

3244 $curr_values = $prev_values . $curr_values;

3245 if ($dbg_values) {

3246 my $outline = $opline; $outline =~ s/\t/ /g;

3247 print "$linenr > .$outline\n";

3248 print "$linenr > $curr_values\n";

3249 print "$linenr > $curr_vars\n";

3250 }

3251 $prev_values = substr($curr_values, -1);

3252

3253 #ignore lines not being added

3254 next if ($line =~ /^[^\+]/);

3255

3256 # check for declarations of signed or unsigned without int

3257 while ($line =~ m{($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {

3258 my $type = $1;

3259 my $var = $2;

3260 $var = "" if (!defined $var);

3261 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {

3262 my $sign = $1;

3263 my $pointer = $2;

3264

3265 $pointer = "" if (!defined $pointer);

3266

3267 if (WARN("UNSPECIFIED_INT",

3268 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&

3269 $fix) {

3270 my $decl = trim($sign) . " int ";

3271 my $comp_pointer = $pointer;

3272 $comp_pointer =~ s/\s//g;

3273 $decl .= $comp_pointer;

3274 $decl = rtrim($decl) if ($var eq "");

3275 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;

3276 }

3277 }

3278 }

3279

3280 # TEST: allow direct testing of the type matcher.

3281 if ($dbg_type) {

3282 if ($line =~ /^.\s*$Declare\s*$/) {

3283 ERROR("TEST_TYPE",

3284 "TEST: is type\n" . $herecurr);

3285 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {

3286 ERROR("TEST_NOT_TYPE",

3287 "TEST: is not type ($1 is)\n". $herecurr);

3288 }

3289 next;

3290 }

3291 # TEST: allow direct testing of the attribute matcher.

3292 if ($dbg_attr) {

3293 if ($line =~ /^.\s*$Modifier\s*$/) {

3294 ERROR("TEST_ATTR",

3295 "TEST: is attr\n" . $herecurr);

3296 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {

3297 ERROR("TEST_NOT_ATTR",

3298 "TEST: is not attr ($1 is)\n". $herecurr);

3299 }

3300 next;

3301 }

3302

3303 # check for initialisation to aggregates open brace on the next line

3304 if ($line =~ /^.\s*{/ &&

3305 $prevline =~ /(?:^|[^=])=\s*$/) {

3306 if (ERROR("OPEN_BRACE",

3307 "that open brace { should be on the previous line\n" . $hereprev) &&

3308 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {

3309 fix_delete_line($fixlinenr - 1, $prevrawline);

3310 fix_delete_line($fixlinenr, $rawline);

3311 my $fixedline = $prevrawline;

3312 $fixedline =~ s/\s*=\s*$/ = {/;

3313 fix_insert_line($fixlinenr, $fixedline);

3314 $fixedline = $line;

3315 $fixedline =~ s/^(.\s*){\s*/$1/;

3316 fix_insert_line($fixlinenr, $fixedline);

3317 }

3318 }

3319

3320 #

3321 # Checks which are anchored on the added line.

3322 #

3323

3324 # check for malformed paths in #include statements (uses RAW line)

3325 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {

3326 my $path = $1;

3327 if ($path =~ m{//}) {

3328 ERROR("MALFORMED_INCLUDE",

3329 "malformed #include filename\n" . $herecurr);

3330 }

3331 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {

3332 ERROR("UAPI_INCLUDE",

3333 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);

3334 }

3335 }

3336

3337 # no C99 // comments

3338 if ($line =~ m{//}) {

3339 if (ERROR("C99_COMMENTS",

3340 "do not use C99 // comments\n" . $herecurr) &&

3341 $fix) {

3342 my $line = $fixed[$fixlinenr];

3343 if ($line =~ /\/\/(.*)$/) {

3344 my $comment = trim($1);

3345 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;

3346 }

3347 }

3348 }

3349 # Remove C99 comments.

3350 $line =~ s@//.*@@;

3351 $opline =~ s@//.*@@;

3352

3353 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider

3354 # the whole statement.

3355 #print "APW <$lines[$realline_next - 1]>\n";

3356 if (defined $realline_next &&

3357 exists $lines[$realline_next - 1] &&

3358 !defined $suppress_export{$realline_next} &&

3359 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*$(.*)$/ ||

3360 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

3361 # Handle definitions which produce identifiers with

3362 # a prefix:

3363 # XXX(foo);

3364 # EXPORT_SYMBOL(something_foo);

3365 my $name = $1;

3366 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&

3367 $name =~ /^${Ident}_$2/) {

3368 #print "FOO C name<$name>\n";

3369 $suppress_export{$realline_next} = 1;

3370

3371 } elsif ($stat !~ /(?:

3372 \n.}\s*$|

3373 ^.DEFINE_$Ident$\Q$name\E$|

3374 ^.DECLARE_$Ident$\Q$name\E$|

3375 ^.LIST_HEAD$\Q$name\E$|

3376 ^.(?:$Storage\s+)?$Type\s*$\s*\*\s*\Q$name\E\s*$\s*\(|

3377 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()

3378 )/x) {

3379 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";

3380 $suppress_export{$realline_next} = 2;

3381 } else {

3382 $suppress_export{$realline_next} = 1;

3383 }

3384 }

3385 if (!defined $suppress_export{$linenr} &&

3386 $prevline =~ /^.\s*$/ &&

3387 ($line =~ /EXPORT_SYMBOL.*$(.*)$/ ||

3388 $line =~ /EXPORT_UNUSED_SYMBOL.*$(.*)$/)) {

3389 #print "FOO B <$lines[$linenr - 1]>\n";

3390 $suppress_export{$linenr} = 2;

3391 }

3392 if (defined $suppress_export{$linenr} &&

3393 $suppress_export{$linenr} == 2) {

3394 WARN("EXPORT_SYMBOL",

3395 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);

3396 }

3397

3398 # check for global initialisers.

3399 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {

3400 if (ERROR("GLOBAL_INITIALISERS",

3401 "do not initialise globals to $1\n" . $herecurr) &&

3402 $fix) {

3403 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;

3404 }

3405 }

3406 # check for static initialisers.

3407 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {

3408 if (ERROR("INITIALISED_STATIC",

3409 "do not initialise statics to $1\n" .

3410 $herecurr) &&

3411 $fix) {

3412 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;

3413 }

3414 }

3415

3416 # check for misordered declarations of char/short/int/long with signed/unsigned

3417 while ($sline =~ m{(\b$TypeMisordered\b)}g) {

3418 my $tmp = trim($1);

3419 WARN("MISORDERED_TYPE",

3420 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);

3421 }

3422

3423 # check for static const char * arrays.

3424 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {

3425 WARN("STATIC_CONST_CHAR_ARRAY",

3426 "static const char * array should probably be static const char * const\n" .

3427 $herecurr);

3428 }

3429

3430 # check for static char foo[] = "bar" declarations.

3431 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {

3432 WARN("STATIC_CONST_CHAR_ARRAY",

3433 "static char array declaration should probably be static const char\n" .

3434 $herecurr);

3435 }

3436

3437 # check for const <foo> const where <foo> is not a pointer or array type

3438 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {

3439 my $found = $1;

3440 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {

3441 WARN("CONST_CONST",

3442 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);

3443 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {

3444 WARN("CONST_CONST",

3445 "'const $found const' should probably be 'const $found'\n" . $herecurr);

3446 }

3447 }

3448

3449 # check for non-global char *foo[] = {"bar", ...} declarations.

3450 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {

3451 WARN("STATIC_CONST_CHAR_ARRAY",

3452 "char * array declaration might be better as static const\n" .

3453 $herecurr);

3454 }

3455

3456 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)

3457 if ($line =~ m@\bsizeof\s*$\s*($Lval)\s*$@) {

3458 my $array = $1;

3459 if ($line =~ m@\b(sizeof\s*$\s*\Q$array\E\s*$\s*/\s*sizeof\s*$\s*\Q$array\E\s*\[\s*0\s*\]\s*$)@) {

3460 my $array_div = $1;

3461 if (WARN("ARRAY_SIZE",

3462 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&

3463 $fix) {

3464 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;

3465 }

3466 }

3467 }

3468

3469 # check for function declarations without arguments like "int foo()"

3470 if ($line =~ /(\b$Type\s+$Ident)\s*$\s*$/) {

3471 if (ERROR("FUNCTION_WITHOUT_ARGS",

3472 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&

3473 $fix) {

3474 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*$\s*$/$2 $3(void)/;

3475 }

3476 }

3477

3478 # check for uses of DEFINE_PCI_DEVICE_TABLE

3479 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*$\s*(\w+)\s*$\s*=/) {

3480 if (WARN("DEFINE_PCI_DEVICE_TABLE",

3481 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&

3482 $fix) {

3483 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*$\s*(\w+)\s*$\s*=\s*/static const struct pci_device_id $1\[\] = /;

3484 }

3485 }

3486

3487 # check for new typedefs, only function parameters and sparse annotations

3488 # make sense.

3489 if ($line =~ /\btypedef\s/ &&

3490 $line !~ /\btypedef\s+$Type\s*$\s*\*?$Ident\s*$\s*\(/ &&

3491 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&

3492 $line !~ /\b$typeTypedefs\b/ &&

3493 $line !~ /\b__bitwise(?:__|)\b/) {

3494 WARN("NEW_TYPEDEFS",

3495 "do not add new typedefs\n" . $herecurr);

3496 }

3497

3498 # * goes on variable not on type

3499 # (char*[ const])

3500 while ($line =~ m{($$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)$)}g) {

3501 #print "AA<$1>\n";

3502 my ($ident, $from, $to) = ($1, $2, $2);

3503

3504 # Should start with a space.

3505 $to =~ s/^(\S)/ $1/;

3506 # Should not end with a space.

3507 $to =~ s/\s+$//;

3508 # '*'s should not have spaces between.

3509 while ($to =~ s/\*\s+\*/\*\*/) {

3510 }

3511

3512 ## print "1: from<$from> to<$to> ident<$ident>\n";

3513 if ($from ne $to) {

3514 if (ERROR("POINTER_LOCATION",

3515 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&

3516 $fix) {

3517 my $sub_from = $ident;

3518 my $sub_to = $ident;

3519 $sub_to =~ s/\Q$from\E/$to/;

3520 $fixed[$fixlinenr] =~

3521 s@\Q$sub_from\E@$sub_to@;

3522 }

3523 }

3524 }

3525 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {

3526 #print "BB<$1>\n";

3527 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);

3528

3529 # Should start with a space.

3530 $to =~ s/^(\S)/ $1/;

3531 # Should not end with a space.

3532 $to =~ s/\s+$//;

3533 # '*'s should not have spaces between.

3534 while ($to =~ s/\*\s+\*/\*\*/) {

3535 }

3536 # Modifiers should have spaces.

3537 $to =~ s/(\b$Modifier$)/$1 /;

3538

3539 ## print "2: from<$from> to<$to> ident<$ident>\n";

3540 if ($from ne $to && $ident !~ /^$Modifier$/) {

3541 if (ERROR("POINTER_LOCATION",

3542 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&

3543 $fix) {

3544

3545 my $sub_from = $match;

3546 my $sub_to = $match;

3547 $sub_to =~ s/\Q$from\E/$to/;

3548 $fixed[$fixlinenr] =~

3549 s@\Q$sub_from\E@$sub_to@;

3550 }

3551 }

3552 }

3553

3554 # avoid BUG() or BUG_ON()

3555 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {

3556 my $msg_type = \&WARN;

3557 $msg_type = \&CHK if ($file);

3558 &{$msg_type}("AVOID_BUG",

3559 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);

3560 }

3561

3562 # avoid LINUX_VERSION_CODE

3563 if ($line =~ /\bLINUX_VERSION_CODE\b/) {

3564 WARN("LINUX_VERSION_CODE",

3565 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);

3566 }

3567

3568 # check for uses of printk_ratelimit

3569 if ($line =~ /\bprintk_ratelimit\s*\(/) {

3570 WARN("PRINTK_RATELIMITED",

3571 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);

3572 }

3573

3574 # printk should use KERN_* levels. Note that follow on printk's on the

3575 # same line do not need a level, so we use the current block context

3576 # to try and find and validate the current printk. In summary the current

3577 # printk includes all preceding printk's which have no newline on the end.

3578 # we assume the first bad printk is the one to report.

3579 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {

3580 my $ok = 0;

3581 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {

3582 #print "CHECK<$lines[$ln - 1]\n";

3583 # we have a preceding printk if it ends

3584 # with "\n" ignore it, else it is to blame

3585 if ($lines[$ln - 1] =~ m{\bprintk\(}) {

3586 if ($rawlines[$ln - 1] !~ m{\\n"}) {

3587 $ok = 1;

3588 }

3589 last;

3590 }

3591 }

3592 if ($ok == 0) {

3593 WARN("PRINTK_WITHOUT_KERN_LEVEL",

3594 "printk() should include KERN_ facility level\n" . $herecurr);

3595 }

3596 }

3597

3598 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {

3599 my $orig = $1;

3600 my $level = lc($orig);

3601 $level = "warn" if ($level eq "warning");

3602 my $level2 = $level;

3603 $level2 = "dbg" if ($level eq "debug");

3604 WARN("PREFER_PR_LEVEL",

3605 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);

3606 }

3607

3608 if ($line =~ /\bpr_warning\s*\(/) {

3609 if (WARN("PREFER_PR_LEVEL",

3610 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&

3611 $fix) {

3612 $fixed[$fixlinenr] =~

3613 s/\bpr_warning\b/pr_warn/;

3614 }

3615 }

3616

3617 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {

3618 my $orig = $1;

3619 my $level = lc($orig);

3620 $level = "warn" if ($level eq "warning");

3621 $level = "dbg" if ($level eq "debug");

3622 WARN("PREFER_DEV_LEVEL",

3623 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);

3624 }

3625

3626 # ENOSYS means "bad syscall nr" and nothing else. This will have a small

3627 # number of false positives, but assembly files are not checked, so at

3628 # least the arch entry code will not trigger this warning.

3629 if ($line =~ /\bENOSYS\b/) {

3630 WARN("ENOSYS",

3631 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);

3632 }

3633

3634 # function brace can't be on same line, except for #defines of do while,

3635 # or if closed on same line

3636 if (($line=~/$Type\s*$Ident$.*$.*\s*{/) and

3637 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {

3638 if (ERROR("OPEN_BRACE",

3639 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&

3640 $fix) {

3641 fix_delete_line($fixlinenr, $rawline);

3642 my $fixed_line = $rawline;

3643 $fixed_line =~ /(^..*$Type\s*$Ident$.*$\s*){(.*)$/;

3644 my $line1 = $1;

3645 my $line2 = $2;

3646 fix_insert_line($fixlinenr, ltrim($line1));

3647 fix_insert_line($fixlinenr, "\+{");

3648 if ($line2 !~ /^\s*$/) {

3649 fix_insert_line($fixlinenr, "\+\t" . trim($line2));

3650 }

3651 }

3652 }

3653

3654 # open braces for enum, union and struct go on the same line.

3655 if ($line =~ /^.\s*{/ &&

3656 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {

3657 if (ERROR("OPEN_BRACE",

3658 "open brace '{' following $1 go on the same line\n" . $hereprev) &&

3659 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {

3660 fix_delete_line($fixlinenr - 1, $prevrawline);

3661 fix_delete_line($fixlinenr, $rawline);

3662 my $fixedline = rtrim($prevrawline) . " {";

3663 fix_insert_line($fixlinenr, $fixedline);

3664 $fixedline = $rawline;

3665 $fixedline =~ s/^(.\s*){\s*/$1\t/;

3666 if ($fixedline !~ /^\+\s*$/) {

3667 fix_insert_line($fixlinenr, $fixedline);

3668 }

3669 }

3670 }

3671

3672 # missing space after union, struct or enum definition

3673 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {

3674 if (WARN("SPACING",

3675 "missing space after $1 definition\n" . $herecurr) &&

3676 $fix) {

3677 $fixed[$fixlinenr] =~

3678 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;

3679 }

3680 }

3681

3682 # Function pointer declarations

3683 # check spacing between type, funcptr, and args

3684 # canonical declaration is "type (*funcptr)(args...)"

3685 if ($line =~ /^.\s*($Declare)$(\s*)\*(\s*)($Ident)(\s*)$(\s*)\(/) {

3686 my $declare = $1;

3687 my $pre_pointer_space = $2;

3688 my $post_pointer_space = $3;

3689 my $funcname = $4;

3690 my $post_funcname_space = $5;

3691 my $pre_args_space = $6;

3692

3693 # the $Declare variable will capture all spaces after the type

3694 # so check it for a missing trailing missing space but pointer return types

3695 # don't need a space so don't warn for those.

3696 my $post_declare_space = "";

3697 if ($declare =~ /(\s+)$/) {

3698 $post_declare_space = $1;

3699 $declare = rtrim($declare);

3700 }

3701 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {

3702 WARN("SPACING",

3703 "missing space after return type\n" . $herecurr);

3704 $post_declare_space = " ";

3705 }

3706

3707 # unnecessary space "type (*funcptr)(args...)"

3708 # This test is not currently implemented because these declarations are

3709 # equivalent to

3710 # int foo(int bar, ...)

3711 # and this is form shouldn't/doesn't generate a checkpatch warning.

3712 #

3713 # elsif ($declare =~ /\s{2,}$/) {

3714 # WARN("SPACING",

3715 # "Multiple spaces after return type\n" . $herecurr);

3716 # }

3717

3718 # unnecessary space "type ( *funcptr)(args...)"

3719 if (defined $pre_pointer_space &&

3720 $pre_pointer_space =~ /^\s/) {

3721 WARN("SPACING",

3722 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);

3723 }

3724

3725 # unnecessary space "type (* funcptr)(args...)"

3726 if (defined $post_pointer_space &&

3727 $post_pointer_space =~ /^\s/) {

3728 WARN("SPACING",

3729 "Unnecessary space before function pointer name\n" . $herecurr);

3730 }

3731

3732 # unnecessary space "type (*funcptr )(args...)"

3733 if (defined $post_funcname_space &&

3734 $post_funcname_space =~ /^\s/) {

3735 WARN("SPACING",

3736 "Unnecessary space after function pointer name\n" . $herecurr);

3737 }

3738

3739 # unnecessary space "type (*funcptr) (args...)"

3740 if (defined $pre_args_space &&

3741 $pre_args_space =~ /^\s/) {

3742 WARN("SPACING",

3743 "Unnecessary space before function pointer arguments\n" . $herecurr);

3744 }

3745

3746 if (show_type("SPACING") && $fix) {

3747 $fixed[$fixlinenr] =~

3748 s/^(.\s*)$Declare\s*$\s*\*\s*$Ident\s*$\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;

3749 }

3750 }

3751

3752 # check for spacing round square brackets; allowed:

3753 # 1. with a type on the left -- int [] a;

3754 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,

3755 # 3. inside a curly brace -- = { [0...10] = 5 }

3756 while ($line =~ /(.*?\s)\[/g) {

3757 my ($where, $prefix) = ($-[1], $1);

3758 if ($prefix !~ /$Type\s+$/ &&

3759 ($where != 0 || $prefix !~ /^.\s+$/) &&

3760 $prefix !~ /[{,]\s+$/) {

3761 if (ERROR("BRACKET_SPACE",

3762 "space prohibited before open square bracket '['\n" . $herecurr) &&

3763 $fix) {

3764 $fixed[$fixlinenr] =~

3765 s/^(\+.*?)\s+\[/$1\[/;

3766 }

3767 }

3768 }

3769

3770 # check for spaces between functions and their parentheses.

3771 while ($line =~ /($Ident)\s+\(/g) {

3772 my $name = $1;

3773 my $ctx_before = substr($line, 0, $-[1]);

3774 my $ctx = "$ctx_before$name";

3775

3776 # Ignore those directives where spaces _are_ permitted.

3777 if ($name =~ /^(?:

3779 volatile|__volatile__|

3780 __attribute__|format|__extension__|

3781 asm|__asm__)$/x)

3782 {

3783 # cpp #define statements have non-optional spaces, ie

3784 # if there is a space between the name and the open

3785 # parenthesis it is simply not a parameter group.

3786 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {

3787

3788 # cpp #elif statement condition may start with a (

3789 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {

3790

3791 # If this whole things ends with a type its most

3792 # likely a typedef for a function.

3793 } elsif ($ctx =~ /$Type$/) {

3794

3795 } else {

3796 if (WARN("SPACING",

3797 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&

3798 $fix) {

3799 $fixed[$fixlinenr] =~

3800 s/\b$name\s+\(/$name\(/;

3801 }

3802 }

3803 }

3804

3805 # Check operator spacing.

3806 if (!($line=~/\#\s*include/)) {

3807 my $fixed_line = "";

3808 my $line_fixed = 0;

3809

3810 my $ops = qr{

3811 <<=|>>=|<=|>=|==|!=|

3812 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|

3813 =>|->|<<|>>|<|>|=|!|~|

3814 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|

3815 \?:|\?|:

3816 }x;

3817 my @elements = split(/($ops|;)/, $opline);

3818

3819 ## print("element count: <" . $#elements . ">\n");

3820 ## foreach my $el (@elements) {

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

3822 ## }

3823

3824 my @fix_elements = ();

3825 my $off = 0;

3826

3827 foreach my $el (@elements) {

3828 push(@fix_elements, substr($rawline, $off, length($el)));

3829 $off += length($el);

3830 }

3831

3832 $off = 0;

3833

3834 my $blank = copy_spacing($opline);

3835 my $last_after = -1;

3836

3837 for (my $n = 0; $n < $#elements; $n += 2) {

3838

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

3840

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

3842

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

3844

3845 # Pick up the preceding and succeeding characters.

3846 my $ca = substr($opline, 0, $off);

3847 my $cc = '';

3848 if (length($opline) >= ($off + length($elements[$n + 1]))) {

3849 $cc = substr($opline, $off + length($elements[$n + 1]));

3850 }

3851 my $cb = "$ca$;$cc";

3852

3853 my $a = '';

3854 $a = 'V' if ($elements[$n] ne '');

3855 $a = 'W' if ($elements[$n] =~ /\s$/);

3856 $a = 'C' if ($elements[$n] =~ /$;$/);

3857 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);

3858 $a = 'O' if ($elements[$n] eq '');

3859 $a = 'E' if ($ca =~ /^\s*$/);

3860

3861 my $op = $elements[$n + 1];

3862

3863 my $c = '';

3864 if (defined $elements[$n + 2]) {

3865 $c = 'V' if ($elements[$n + 2] ne '');

3866 $c = 'W' if ($elements[$n + 2] =~ /^\s/);

3867 $c = 'C' if ($elements[$n + 2] =~ /^$;/);

3868 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);

3869 $c = 'O' if ($elements[$n + 2] eq '');

3870 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);

3871 } else {

3872 $c = 'E';

3873 }

3874

3875 my $ctx = "${a}x${c}";

3876

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

3878

3879 my $ptr = substr($blank, 0, $off) . "^";

3880 my $hereptr = "$hereline$ptr\n";

3881

3882 # Pull out the value of this operator.

3883 my $op_type = substr($curr_values, $off + 1, 1);

3884

3885 # Get the full operator variant.

3886 my $opv = $op . substr($curr_vars, $off, 1);

3887

3888 # Ignore operators passed as parameters.

3889 if ($op_type ne 'V' &&

3890 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {

3891

3892 # # Ignore comments

3893 # } elsif ($op =~ /^$;+$/) {

3894

3895 # ; should have either the end of line or a space or \ after it

3896 } elsif ($op eq ';') {

3897 if ($ctx !~ /.x[WEBC]/ &&

3898 $cc !~ /^\\/ && $cc !~ /^;/) {

3899 if (ERROR("SPACING",

3900 "space required after that '$op' $at\n" . $hereptr)) {

3901 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";

3902 $line_fixed = 1;

3903 }

3904 }

3905

3906 # // is a comment

3907 } elsif ($op eq '//') {

3908

3909 # : when part of a bitfield

3910 } elsif ($opv eq ':B') {

3911 # skip the bitfield test for now

3912

3913 # No spaces for:

3914 # ->

3915 } elsif ($op eq '->') {

3916 if ($ctx =~ /Wx.|.xW/) {

3917 if (ERROR("SPACING",

3918 "spaces prohibited around that '$op' $at\n" . $hereptr)) {

3919 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

3920 if (defined $fix_elements[$n + 2]) {

3921 $fix_elements[$n + 2] =~ s/^\s+//;

3922 }

3923 $line_fixed = 1;

3924 }

3925 }

3926

3927 # , must not have a space before and must have a space on the right.

3928 } elsif ($op eq ',') {

3929 my $rtrim_before = 0;

3930 my $space_after = 0;

3931 if ($ctx =~ /Wx./) {

3932 if (ERROR("SPACING",

3933 "space prohibited before that '$op' $at\n" . $hereptr)) {

3934 $line_fixed = 1;

3935 $rtrim_before = 1;

3936 }

3937 }

3938 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {

3939 if (ERROR("SPACING",

3940 "space required after that '$op' $at\n" . $hereptr)) {

3941 $line_fixed = 1;

3942 $last_after = $n;

3943 $space_after = 1;

3944 }

3945 }

3946 if ($rtrim_before || $space_after) {

3947 if ($rtrim_before) {

3948 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

3949 } else {

3950 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);

3951 }

3952 if ($space_after) {

3953 $good .= " ";

3954 }

3955 }

3956

3957 # '*' as part of a type definition -- reported already.

3958 } elsif ($opv eq '*_') {

3959 #warn "'*' is part of type\n";

3960

3961 # unary operators should have a space before and

3962 # none after. May be left adjacent to another

3963 # unary operator, or a cast

3964 } elsif ($op eq '!' || $op eq '~' ||

3965 $opv eq '*U' || $opv eq '-U' ||

3966 $opv eq '&U' || $opv eq '&&U') {

3967 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {

3968 if (ERROR("SPACING",

3969 "space required before that '$op' $at\n" . $hereptr)) {

3970 if ($n != $last_after + 2) {

3971 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);

3972 $line_fixed = 1;

3973 }

3974 }

3975 }

3976 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {

3977 # A unary '*' may be const

3978

3979 } elsif ($ctx =~ /.xW/) {

3980 if (ERROR("SPACING",

3981 "space prohibited after that '$op' $at\n" . $hereptr)) {

3982 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);

3983 if (defined $fix_elements[$n + 2]) {

3984 $fix_elements[$n + 2] =~ s/^\s+//;

3985 }

3986 $line_fixed = 1;

3987 }

3988 }

3989

3990 # unary ++ and unary -- are allowed no space on one side.

3991 } elsif ($op eq '++' or $op eq '--') {

3992 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {

3993 if (ERROR("SPACING",

3994 "space required one side of that '$op' $at\n" . $hereptr)) {

3995 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";

3996 $line_fixed = 1;

3997 }

3998 }

3999 if ($ctx =~ /Wx[BE]/ ||

4000 ($ctx =~ /Wx./ && $cc =~ /^;/)) {

4001 if (ERROR("SPACING",

4002 "space prohibited before that '$op' $at\n" . $hereptr)) {

4003 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

4004 $line_fixed = 1;

4005 }

4006 }

4007 if ($ctx =~ /ExW/) {

4008 if (ERROR("SPACING",

4009 "space prohibited after that '$op' $at\n" . $hereptr)) {

4010 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);

4011 if (defined $fix_elements[$n + 2]) {

4012 $fix_elements[$n + 2] =~ s/^\s+//;

4013 }

4014 $line_fixed = 1;

4015 }

4016 }

4017

4018 # << and >> may either have or not have spaces both sides

4019 } elsif ($op eq '<<' or $op eq '>>' or

4020 $op eq '&' or $op eq '^' or $op eq '|' or

4021 $op eq '+' or $op eq '-' or

4022 $op eq '*' or $op eq '/' or

4023 $op eq '%')

4024 {

4025 if ($check) {

4026 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {

4027 if (CHK("SPACING",

4028 "spaces preferred around that '$op' $at\n" . $hereptr)) {

4029 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";

4030 $fix_elements[$n + 2] =~ s/^\s+//;

4031 $line_fixed = 1;

4032 }

4033 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {

4034 if (CHK("SPACING",

4035 "space preferred before that '$op' $at\n" . $hereptr)) {

4036 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);

4037 $line_fixed = 1;

4038 }

4039 }

4040 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {

4041 if (ERROR("SPACING",

4042 "need consistent spacing around '$op' $at\n" . $hereptr)) {

4043 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";

4044 if (defined $fix_elements[$n + 2]) {

4045 $fix_elements[$n + 2] =~ s/^\s+//;

4046 }

4047 $line_fixed = 1;

4048 }

4049 }

4050

4051 # A colon needs no spaces before when it is

4052 # terminating a case value or a label.

4053 } elsif ($opv eq ':C' || $opv eq ':L') {

4054 if ($ctx =~ /Wx./) {

4055 if (ERROR("SPACING",

4056 "space prohibited before that '$op' $at\n" . $hereptr)) {

4057 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);

4058 $line_fixed = 1;

4059 }

4060 }

4061

4062 # All the others need spaces both sides.

4063 } elsif ($ctx !~ /[EWC]x[CWE]/) {

4064 my $ok = 0;

4065

4066 # Ignore email addresses <foo@bar>

4067 if (($op eq '<' &&

4068 $cc =~ /^\S+\@\S+>/) ||

4069 ($op eq '>' &&

4070 $ca =~ /<\S+\@\S+$/))

4071 {

4072 $ok = 1;

4073 }

4074

4075 # for asm volatile statements

4076 # ignore a colon with another

4077 # colon immediately before or after

4078 if (($op eq ':') &&

4079 ($ca =~ /:$/ || $cc =~ /^:/)) {

4080 $ok = 1;

4081 }

4082

4083 # messages are ERROR, but ?: are CHK

4084 if ($ok == 0) {

4085 my $msg_type = \&ERROR;

4086 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);

4087

4088 if (&{$msg_type}("SPACING",

4089 "spaces required around that '$op' $at\n" . $hereptr)) {

4090 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";

4091 if (defined $fix_elements[$n + 2]) {

4092 $fix_elements[$n + 2] =~ s/^\s+//;

4093 }

4094 $line_fixed = 1;

4095 }

4096 }

4097 }

4098 $off += length($elements[$n + 1]);

4099

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

4101

4102 $fixed_line = $fixed_line . $good;

4103 }

4104

4105 if (($#elements % 2) == 0) {

4106 $fixed_line = $fixed_line . $fix_elements[$#elements];

4107 }

4108

4109 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {

4110 $fixed[$fixlinenr] = $fixed_line;

4111 }

4112

4113

4114 }

4115

4116 # check for whitespace before a non-naked semicolon

4117 if ($line =~ /^\+.*\S\s+;\s*$/) {

4118 if (WARN("SPACING",

4119 "space prohibited before semicolon\n" . $herecurr) &&

4120 $fix) {

4121 1 while $fixed[$fixlinenr] =~

4122 s/^(\+.*\S)\s+;/$1;/;

4123 }

4124 }

4125

4126 # check for multiple assignments

4127 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {

4128 CHK("MULTIPLE_ASSIGNMENTS",

4129 "multiple assignments should be avoided\n" . $herecurr);

4130 }

4131

4132 ## # check for multiple declarations, allowing for a function declaration

4133 ## # continuation.

4134 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&

4135 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {

4136 ##

4137 ## # Remove any bracketed sections to ensure we do not

4138 ## # falsly report the parameters of functions.

4139 ## my $ln = $line;

4140 ## while ($ln =~ s/$[^\($]*\)//g) {

4141 ## }

4142 ## if ($ln =~ /,/) {

4143 ## WARN("MULTIPLE_DECLARATION",

4144 ## "declaring multiple variables together should be avoided\n" . $herecurr);

4145 ## }

4146 ## }

4147

4148 #need space before brace following if, while, etc

4149 if (($line =~ /$.*$\{/ && $line !~ /$$Type$\{/) ||

4150 $line =~ /do\{/) {

4151 if (ERROR("SPACING",

4152 "space required before the open brace '{'\n" . $herecurr) &&

4153 $fix) {

4154 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;

4155 }

4156 }

4157

4158 ## # check for blank lines before declarations

4159 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&

4160 ## $prevrawline =~ /^.\s*$/) {

4161 ## WARN("SPACING",

4162 ## "No blank lines before declarations\n" . $hereprev);

4163 ## }

4164 ##

4165

4166 # closing brace should have a space following it when it has anything

4167 # on the line

4168 if ($line =~ /}(?!(?:,|;|\)))\S/) {

4169 if (ERROR("SPACING",

4170 "space required after that close brace '}'\n" . $herecurr) &&

4171 $fix) {

4172 $fixed[$fixlinenr] =~

4173 s/}((?!(?:,|;|\)))\S)/} $1/;

4174 }

4175 }

4176

4177 # check spacing on square brackets

4178 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {

4179 if (ERROR("SPACING",

4180 "space prohibited after that open square bracket '['\n" . $herecurr) &&

4181 $fix) {

4182 $fixed[$fixlinenr] =~

4183 s/\[\s+/\[/;

4184 }

4185 }

4186 if ($line =~ /\s\]/) {

4187 if (ERROR("SPACING",

4188 "space prohibited before that close square bracket ']'\n" . $herecurr) &&

4189 $fix) {

4190 $fixed[$fixlinenr] =~

4191 s/\s+\]/\]/;

4192 }

4193 }

4194

4195 # check spacing on parentheses

4196 if ($line =~ /$\s/ && $line !~ /\(\s*(?:\$?$/ &&

4197 $line !~ /for\s*\(\s+;/) {

4198 if (ERROR("SPACING",

4199 "space prohibited after that open parenthesis '('\n" . $herecurr) &&

4200 $fix) {

4201 $fixed[$fixlinenr] =~

4202 s/\(\s+/\(/;

4203 }

4204 }

4205 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&

4206 $line !~ /for\s*$.*;\s+$/ &&

4207 $line !~ /:\s+\)/) {

4208 if (ERROR("SPACING",

4209 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&

4210 $fix) {

4211 $fixed[$fixlinenr] =~

4212 s/\s+\)/\)/;

4213 }

4214 }

4215

4216 # check unnecessary parentheses around addressof/dereference single $Lvals

4217 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar

4218

4219 while ($line =~ /(?:[^&]&\s*|\*)$\s*($Ident\s*(?:$Member\s*)+)\s*$/g) {

4220 my $var = $1;

4221 if (CHK("UNNECESSARY_PARENTHESES",

4222 "Unnecessary parentheses around $var\n" . $herecurr) &&

4223 $fix) {

4224 $fixed[$fixlinenr] =~ s/$\s*\Q$var\E\s*$/$var/;

4225 }

4226 }

4227

4228 # check for unnecessary parentheses around function pointer uses

4229 # ie: (foo->bar)(); should be foo->bar();

4230 # but not "if (foo->bar) (" to avoid some false positives

4231 if ($line =~ /(\bif\s*|)($\s*$Ident\s*(?:$Member\s*)+$)[ \t]*\(/ && $1 !~ /^if/) {

4232 my $var = $2;

4233 if (CHK("UNNECESSARY_PARENTHESES",

4234 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&

4235 $fix) {

4236 my $var2 = deparenthesize($var);

4237 $var2 =~ s/\s//g;

4238 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;

4239 }

4240 }

4241

4242 #goto labels aren't indented, allow a single space however

4243 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and

4244 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {

4245 if (WARN("INDENTED_LABEL",

4246 "labels should not be indented\n" . $herecurr) &&

4247 $fix) {

4248 $fixed[$fixlinenr] =~

4249 s/^(.)\s+/$1/;

4250 }

4251 }

4252

4253 # return is not a function

4254 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {

4255 my $spacing = $1;

4256 if ($^V && $^V ge 5.10.0 &&

4257 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {

4258 my $value = $1;

4259 $value = deparenthesize($value);

4260 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {

4261 ERROR("RETURN_PARENTHESES",

4262 "return is not a function, parentheses are not required\n" . $herecurr);

4263 }

4264 } elsif ($spacing !~ /\s+/) {

4265 ERROR("SPACING",

4266 "space required before the open parenthesis '('\n" . $herecurr);

4267 }

4268 }

4269

4270 # unnecessary return in a void function

4271 # at end-of-function, with the previous line a single leading tab, then return;

4272 # and the line before that not a goto label target like "out:"

4273 if ($sline =~ /^[ \+]}\s*$/ &&

4274 $prevline =~ /^\+\treturn\s*;\s*$/ &&

4275 $linenr >= 3 &&

4276 $lines[$linenr - 3] =~ /^[ +]/ &&

4277 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {

4278 WARN("RETURN_VOID",

4279 "void function return statements are not generally useful\n" . $hereprev);

4280 }

4281

4282 # if statements using unnecessary parentheses - ie: if ((foo == bar))

4283 if ($^V && $^V ge 5.10.0 &&

4284 $line =~ /\bif\s*((?:\(\s*){2,})/) {

4285 my $openparens = $1;

4286 my $count = $openparens =~ tr@\(@\(@;

4287 my $msg = "";

4288 if ($line =~ /\bif\s*(?:$\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*$){$count,$count}/) {

4289 my $comp = $4; #Not $1 because of $LvalOrFunc

4290 $msg = " - maybe == should be = ?" if ($comp eq "==");

4291 WARN("UNNECESSARY_PARENTHESES",

4292 "Unnecessary parentheses$msg\n" . $herecurr);

4293 }

4294 }

4295

4296 # comparisons with a constant or upper case identifier on the left

4297 # avoid cases like "foo + BAR < baz"

4298 # only fix matches surrounded by parentheses to avoid incorrect

4299 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"

4300 if ($^V && $^V ge 5.10.0 &&

4301 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {

4302 my $lead = $1;

4303 my $const = $2;

4304 my $comp = $3;

4305 my $to = $4;

4306 my $newcomp = $comp;

4307 if ($lead !~ /(?:$Operators|\.)\s*$/ &&

4308 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&

4309 WARN("CONSTANT_COMPARISON",

4310 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&

4311 $fix) {

4312 if ($comp eq "<") {

4313 $newcomp = ">";

4314 } elsif ($comp eq "<=") {

4315 $newcomp = ">=";

4316 } elsif ($comp eq ">") {

4317 $newcomp = "<";

4318 } elsif ($comp eq ">=") {

4319 $newcomp = "<=";

4320 }

4321 $fixed[$fixlinenr] =~ s/$\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*$/($to $newcomp $const)/;

4322 }

4323 }

4324

4325 # Return of what appears to be an errno should normally be negative

4326 if ($sline =~ /\breturn(?:\s*$+\s*|\s+)(E[A-Z]+)(?:\s*$+\s*|\s*)[;:,]/) {

4327 my $name = $1;

4328 if ($name ne 'EOF' && $name ne 'ERROR') {

4329 WARN("USE_NEGATIVE_ERRNO",

4330 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);

4331 }

4332 }

4333

4334 # Need a space before open parenthesis after if, while etc

4335 if ($line =~ /\b(if|while|for|switch)\(/) {

4336 if (ERROR("SPACING",

4337 "space required before the open parenthesis '('\n" . $herecurr) &&

4338 $fix) {

4339 $fixed[$fixlinenr] =~

4340 s/\b(if|while|for|switch)\(/$1 \(/;

4341 }

4342 }

4343

4344 # Check for illegal assignment in if conditional -- and check for trailing

4345 # statements after the conditional.

4346 if ($line =~ /do\s*(?!{)/) {

4347 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =

4348 ctx_statement_block($linenr, $realcnt, 0)

4349 if (!defined $stat);

4350 my ($stat_next) = ctx_statement_block($line_nr_next,

4351 $remain_next, $off_next);

4352 $stat_next =~ s/\n./\n /g;

4353 ##print "stat<$stat> stat_next<$stat_next>\n";

4354

4355 if ($stat_next =~ /^\s*while\b/) {

4356 # If the statement carries leading newlines,

4357 # then count those as offsets.

4358 my ($whitespace) =

4359 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);

4360 my $offset =

4361 statement_rawlines($whitespace) - 1;

4362

4363 $suppress_whiletrailers{$line_nr_next +

4364 $offset} = 1;

4365 }

4366 }

4367 if (!defined $suppress_whiletrailers{$linenr} &&

4368 defined($stat) && defined($cond) &&

4369 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {

4370 my ($s, $c) = ($stat, $cond);

4371

4372 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {

4373 ERROR("ASSIGN_IN_IF",

4374 "do not use assignment in if condition\n" . $herecurr);

4375 }

4376

4377 # Find out what is on the end of the line after the

4378 # conditional.

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

4380 $s =~ s/\n.*//g;

4381 $s =~ s/$;//g; # Remove any comments

4382 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&

4383 $c !~ /}\s*while\s*/)

4384 {

4385 # Find out how long the conditional actually is.

4386 my @newlines = ($c =~ /\n/gs);

4387 my $cond_lines = 1 + $#newlines;

4388 my $stat_real = '';

4389

4390 $stat_real = raw_line($linenr, $cond_lines)

4391 . "\n" if ($cond_lines);

4392 if (defined($stat_real) && $cond_lines > 1) {

4393 $stat_real = "[...]\n$stat_real";

4394 }

4395

4396 ERROR("TRAILING_STATEMENTS",

4397 "trailing statements should be on next line\n" . $herecurr . $stat_real);

4398 }

4399 }

4400

4401 # Check for bitwise tests written as boolean

4402 if ($line =~ /

4403 (?:

4404 (?:\[|\(|\&\&|\|\|)

4405 \s*0[xX][0-9]+\s*

4406 (?:\&\&|\|\|)

4407 |

4408 (?:\&\&|\|\|)

4409 \s*0[xX][0-9]+\s*

4410 (?:\&\&|\|\||\)|\])

4411 )/x)

4412 {

4413 WARN("HEXADECIMAL_BOOLEAN_TEST",

4414 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);

4415 }

4416

4417 # if and else should not have general statements after it

4418 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {

4419 my $s = $1;

4420 $s =~ s/$;//g; # Remove any comments

4421 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {

4422 ERROR("TRAILING_STATEMENTS",

4423 "trailing statements should be on next line\n" . $herecurr);

4424 }

4425 }

4426 # if should not continue a brace

4427 if ($line =~ /}\s*if\b/) {

4428 ERROR("TRAILING_STATEMENTS",

4429 "trailing statements should be on next line (or did you mean 'else if'?)\n" .

4430 $herecurr);

4431 }

4432 # case and default should not have general statements after them

4433 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&

4434 $line !~ /\G(?:

4435 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|

4436 \s*return\s+

4437 )/xg)

4438 {

4439 ERROR("TRAILING_STATEMENTS",

4440 "trailing statements should be on next line\n" . $herecurr);

4441 }

4442

4443 # Check for }<nl>else {, these must be at the same

4444 # indent level to be relevant to each other.

4445 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&

4446 $previndent == $indent) {

4447 if (ERROR("ELSE_AFTER_BRACE",

4448 "else should follow close brace '}'\n" . $hereprev) &&

4449 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {

4450 fix_delete_line($fixlinenr - 1, $prevrawline);

4451 fix_delete_line($fixlinenr, $rawline);

4452 my $fixedline = $prevrawline;

4453 $fixedline =~ s/}\s*$//;

4454 if ($fixedline !~ /^\+\s*$/) {

4455 fix_insert_line($fixlinenr, $fixedline);

4456 }

4457 $fixedline = $rawline;

4458 $fixedline =~ s/^(.\s*)else/$1} else/;

4459 fix_insert_line($fixlinenr, $fixedline);

4460 }

4461 }

4462

4463 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&

4464 $previndent == $indent) {

4465 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);

4466

4467 # Find out what is on the end of the line after the

4468 # conditional.

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

4470 $s =~ s/\n.*//g;

4471

4472 if ($s =~ /^\s*;/) {

4473 if (ERROR("WHILE_AFTER_BRACE",

4474 "while should follow close brace '}'\n" . $hereprev) &&

4475 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {

4476 fix_delete_line($fixlinenr - 1, $prevrawline);

4477 fix_delete_line($fixlinenr, $rawline);

4478 my $fixedline = $prevrawline;

4479 my $trailing = $rawline;

4480 $trailing =~ s/^\+//;

4481 $trailing = trim($trailing);

4482 $fixedline =~ s/}\s*$/} $trailing/;

4483 fix_insert_line($fixlinenr, $fixedline);

4484 }

4485 }

4486 }

4487

4488 #Specific variable tests

4489 while ($line =~ m{($Constant|$Lval)}g) {

4490 my $var = $1;

4491

4492 #gcc binary extension

4493 if ($var =~ /^$Binary$/) {

4494 if (WARN("GCC_BINARY_CONSTANT",

4495 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&

4496 $fix) {

4497 my $hexval = sprintf("0x%x", oct($var));

4498 $fixed[$fixlinenr] =~

4499 s/\b$var\b/$hexval/;

4500 }

4501 }

4502

4503 #CamelCase

4504 if ($var !~ /^$Constant$/ &&

4505 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&

4506 #Ignore Page<foo> variants

4507 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&

4508 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)

4509 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&

4510 #Ignore some three character SI units explicitly, like MiB and KHz

4511 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {

4512 while ($var =~ m{($Ident)}g) {

4513 my $word = $1;

4514 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);

4515 if ($check) {

4516 seed_camelcase_includes();

4517 if (!$file && !$camelcase_file_seeded) {

4518 seed_camelcase_file($realfile);

4519 $camelcase_file_seeded = 1;

4520 }

4521 }

4522 if (!defined $camelcase{$word}) {

4523 $camelcase{$word} = 1;

4524 CHK("CAMELCASE",

4525 "Avoid CamelCase: <$word>\n" . $herecurr);

4526 }

4527 }

4528 }

4529 }

4530

4531 #no spaces allowed after \ in define

4532 if ($line =~ /\#\s*define.*\\\s+$/) {

4533 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",

4534 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&

4535 $fix) {

4536 $fixed[$fixlinenr] =~ s/\s+$//;

4537 }

4538 }

4539

4540 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes

4541 # itself <asm/foo.h> (uses RAW line)

4542 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {

4543 my $file = "$1.h";

4544 my $checkfile = "include/linux/$file";

4545 if (-f "$root/$checkfile" &&

4546 $realfile ne $checkfile &&

4547 $1 !~ /$allowed_asm_includes/)

4548 {

4549 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;

4550 if ($asminclude > 0) {

4551 if ($realfile =~ m{^arch/}) {

4552 CHK("ARCH_INCLUDE_LINUX",

4553 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

4554 } else {

4555 WARN("INCLUDE_LINUX",

4556 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);

4557 }

4558 }

4559 }

4560 }

4561

4562 # multi-statement macros should be enclosed in a do while loop, grab the

4563 # first statement and ensure its the whole macro if its not enclosed

4564 # in a known good container

4565 if ($realfile !~ m@/vmlinux.lds.h$@ &&

4566 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {

4567 my $ln = $linenr;

4568 my $cnt = $realcnt;

4569 my ($off, $dstat, $dcond, $rest);

4570 my $ctx = '';

4571 my $has_flow_statement = 0;

4572 my $has_arg_concat = 0;

4573 ($dstat, $dcond, $ln, $cnt, $off) =

4574 ctx_statement_block($linenr, $realcnt, 0);

4575 $ctx = $dstat;

4576 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";

4577 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";

4578

4579 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);

4580 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);

4581

4582 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:$[^$]*\))?\s*//;

4583 $dstat =~ s/$;//g;

4584 $dstat =~ s/\\\n.//g;

4585 $dstat =~ s/^\s*//s;

4586 $dstat =~ s/\s*$//s;

4587

4588 # Flatten any parentheses and braces

4589 while ($dstat =~ s/$[^\($]*\)/1/ ||

4590 $dstat =~ s/\{[^\{\}]*\}/1/ ||

4591 $dstat =~ s/.\[[^\[\]]*\]/1/)

4592 {

4593 }

4594

4595 # Flatten any obvious string concatentation.

4596 while ($dstat =~ s/($String)\s*$Ident/$1/ ||

4597 $dstat =~ s/$Ident\s*($String)/$1/)

4598 {

4599 }

4600

4601 # Make asm volatile uses seem like a generic function

4602 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;

4603

4604 my $exceptions = qr{

4605 $Declare|

4606 module_param_named|

4607 MODULE_PARM_DESC|

4608 DECLARE_PER_CPU|

4609 DEFINE_PER_CPU|

4610 __typeof__\(|

4611 union|

4612 struct|

4613 \.$Ident\s*=\s*|

4614 ^\"|\"$|

4615 ^\[

4616 }x;

4617 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";

4618 if ($dstat ne '' &&

4619 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),

4620 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();

4621 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz

4622 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants

4623 $dstat !~ /$exceptions/ &&

4624 $dstat !~ /^\.$Ident\s*=/ && # .foo =

4625 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo

4626 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)

4627 $dstat !~ /^for\s*$Constant$/ && # for (...)

4628 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()

4629 $dstat !~ /^do\s*{/ && # do {...

4630 $dstat !~ /^\(\{/ && # ({...

4631 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)

4632 {

4633 $ctx =~ s/\n*$//;

4634 my $herectx = $here . "\n";

4635 my $cnt = statement_rawlines($ctx);

4636

4637 for (my $n = 0; $n < $cnt; $n++) {

4638 $herectx .= raw_line($linenr, $n) . "\n";

4639 }

4640

4641 if ($dstat =~ /;/) {

4642 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",

4643 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");

4644 } else {

4645 ERROR("COMPLEX_MACRO",

4646 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");

4647 }

4648 }

4649

4650 # check for macros with flow control, but without ## concatenation

4651 # ## concatenation is commonly a macro that defines a function so ignore those

4652 if ($has_flow_statement && !$has_arg_concat) {

4653 my $herectx = $here . "\n";

4654 my $cnt = statement_rawlines($ctx);

4655

4656 for (my $n = 0; $n < $cnt; $n++) {

4657 $herectx .= raw_line($linenr, $n) . "\n";

4658 }

4659 WARN("MACRO_WITH_FLOW_CONTROL",

4660 "Macros with flow control statements should be avoided\n" . "$herectx");

4661 }

4662

4663 # check for line continuations outside of #defines, preprocessor #, and asm

4664

4665 } else {

4666 if ($prevline !~ /^..*\\$/ &&

4667 $line !~ /^\+\s*\#.*\\$/ && # preprocessor

4668 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm

4669 $line =~ /^\+.*\\$/) {

4670 WARN("LINE_CONTINUATIONS",

4671 "Avoid unnecessary line continuations\n" . $herecurr);

4672 }

4673 }

4674

4675 # do {} while (0) macro tests:

4676 # single-statement macros do not need to be enclosed in do while (0) loop,

4677 # macro should not end with a semicolon

4678 if ($^V && $^V ge 5.10.0 &&

4679 $realfile !~ m@/vmlinux.lds.h$@ &&

4680 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {

4681 my $ln = $linenr;

4682 my $cnt = $realcnt;

4683 my ($off, $dstat, $dcond, $rest);

4684 my $ctx = '';

4685 ($dstat, $dcond, $ln, $cnt, $off) =

4686 ctx_statement_block($linenr, $realcnt, 0);

4687 $ctx = $dstat;

4688

4689 $dstat =~ s/\\\n.//g;

4690 $dstat =~ s/$;/ /g;

4691

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

4693 my $stmts = $2;

4694 my $semis = $3;

4695

4696 $ctx =~ s/\n*$//;

4697 my $cnt = statement_rawlines($ctx);

4698 my $herectx = $here . "\n";

4699

4700 for (my $n = 0; $n < $cnt; $n++) {

4701 $herectx .= raw_line($linenr, $n) . "\n";

4702 }

4703

4704 if (($stmts =~ tr/;/;/) == 1 &&

4705 $stmts !~ /^\s*(if|while|for|switch)\b/) {

4706 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",

4707 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");

4708 }

4709 if (defined $semis && $semis ne "") {

4710 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",

4711 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");

4712 }

4713 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {

4714 $ctx =~ s/\n*$//;

4715 my $cnt = statement_rawlines($ctx);

4716 my $herectx = $here . "\n";

4717

4718 for (my $n = 0; $n < $cnt; $n++) {

4719 $herectx .= raw_line($linenr, $n) . "\n";

4720 }

4721

4722 WARN("TRAILING_SEMICOLON",

4723 "macros should not use a trailing semicolon\n" . "$herectx");

4724 }

4725 }

4726

4727 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...

4728 # all assignments may have only one of the following with an assignment:

4729 # .

4730 # ALIGN(...)

4731 # VMLINUX_SYMBOL(...)

4732 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {

4733 WARN("MISSING_VMLINUX_SYMBOL",

4734 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);

4735 }

4736

4737 # check for redundant bracing round if etc

4738 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {

4739 my ($level, $endln, @chunks) =

4740 ctx_statement_full($linenr, $realcnt, 1);

4741 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";

4742 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";

4743 if ($#chunks > 0 && $level == 0) {

4744 my @allowed = ();

4745 my $allow = 0;

4746 my $seen = 0;

4747 my $herectx = $here . "\n";

4748 my $ln = $linenr - 1;

4749 for my $chunk (@chunks) {

4750 my ($cond, $block) = @{$chunk};

4751

4752 # If the condition carries leading newlines, then count those as offsets.

4753 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);

4754 my $offset = statement_rawlines($whitespace) - 1;

4755

4756 $allowed[$allow] = 0;

4757 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";

4758

4759 # We have looked at and allowed this specific line.

4760 $suppress_ifbraces{$ln + $offset} = 1;

4761

4762 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";

4763 $ln += statement_rawlines($block) - 1;

4764

4765 substr($block, 0, length($cond), '');

4766

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

4768

4769 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";

4770 if (statement_lines($cond) > 1) {

4771 #print "APW: ALLOWED: cond<$cond>\n";

4772 $allowed[$allow] = 1;

4773 }

4774 if ($block =~/\b(?:if|for|while)\b/) {

4775 #print "APW: ALLOWED: block<$block>\n";

4776 $allowed[$allow] = 1;

4777 }

4778 if (statement_block_size($block) > 1) {

4779 #print "APW: ALLOWED: lines block<$block>\n";

4780 $allowed[$allow] = 1;

4781 }

4782 $allow++;

4783 }

4784 if ($seen) {

4785 my $sum_allowed = 0;

4786 foreach (@allowed) {

4787 $sum_allowed += $_;

4788 }

4789 if ($sum_allowed == 0) {

4790 WARN("BRACES",

4791 "braces {} are not necessary for any arm of this statement\n" . $herectx);

4792 } elsif ($sum_allowed != $allow &&

4793 $seen != $allow) {

4794 CHK("BRACES",

4795 "braces {} should be used on all arms of this statement\n" . $herectx);

4796 }

4797 }

4798 }

4799 }

4800 if (!defined $suppress_ifbraces{$linenr - 1} &&

4801 $line =~ /\b(if|while|for|else)\b/) {

4802 my $allowed = 0;

4803

4804 # Check the pre-context.

4805 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {

4806 #print "APW: ALLOWED: pre<$1>\n";

4807 $allowed = 1;

4808 }

4809

4810 my ($level, $endln, @chunks) =

4811 ctx_statement_full($linenr, $realcnt, $-[0]);

4812

4813 # Check the condition.

4814 my ($cond, $block) = @{$chunks[0]};

4815 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";

4816 if (defined $cond) {

4817 substr($block, 0, length($cond), '');

4818 }

4819 if (statement_lines($cond) > 1) {

4820 #print "APW: ALLOWED: cond<$cond>\n";

4821 $allowed = 1;

4822 }

4823 if ($block =~/\b(?:if|for|while)\b/) {

4824 #print "APW: ALLOWED: block<$block>\n";

4825 $allowed = 1;

4826 }

4827 if (statement_block_size($block) > 1) {

4828 #print "APW: ALLOWED: lines block<$block>\n";

4829 $allowed = 1;

4830 }

4831 # Check the post-context.

4832 if (defined $chunks[1]) {

4833 my ($cond, $block) = @{$chunks[1]};

4834 if (defined $cond) {

4835 substr($block, 0, length($cond), '');

4836 }

4837 if ($block =~ /^\s*\{/) {

4838 #print "APW: ALLOWED: chunk-1 block<$block>\n";

4839 $allowed = 1;

4840 }

4841 }

4842 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {

4843 my $herectx = $here . "\n";

4844 my $cnt = statement_rawlines($block);

4845

4846 for (my $n = 0; $n < $cnt; $n++) {

4847 $herectx .= raw_line($linenr, $n) . "\n";

4848 }

4849

4850 WARN("BRACES",

4851 "braces {} are not necessary for single statement blocks\n" . $herectx);

4852 }

4853 }

4854

4855 # check for unnecessary blank lines around braces

4856 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {

4857 if (CHK("BRACES",

4858 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&

4859 $fix && $prevrawline =~ /^\+/) {

4860 fix_delete_line($fixlinenr - 1, $prevrawline);

4861 }

4862 }

4863 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {

4864 if (CHK("BRACES",

4865 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&

4866 $fix) {

4867 fix_delete_line($fixlinenr, $rawline);

4868 }

4869 }

4870

4871 # no volatiles please

4872 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};

4873 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {

4874 WARN("VOLATILE",

4875 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);

4876 }

4877

4878 # Check for user-visible strings broken across lines, which breaks the ability

4879 # to grep for the string. Make exceptions when the previous string ends in a

4880 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'

4881 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value

4882 if ($line =~ /^\+\s*$String/ &&

4883 $prevline =~ /"\s*$/ &&

4884 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {

4885 if (WARN("SPLIT_STRING",

4886 "quoted string split across lines\n" . $hereprev) &&

4887 $fix &&

4888 $prevrawline =~ /^\+.*"\s*$/ &&

4889 $last_coalesced_string_linenr != $linenr - 1) {

4890 my $extracted_string = get_quoted_string($line, $rawline);

4891 my $comma_close = "";

4892 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {

4893 $comma_close = $1;

4894 }

4895

4896 fix_delete_line($fixlinenr - 1, $prevrawline);

4897 fix_delete_line($fixlinenr, $rawline);

4898 my $fixedline = $prevrawline;

4899 $fixedline =~ s/"\s*$//;

4900 $fixedline .= substr($extracted_string, 1) . trim($comma_close);

4901 fix_insert_line($fixlinenr - 1, $fixedline);

4902 $fixedline = $rawline;

4903 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;

4904 if ($fixedline !~ /\+\s*$/) {

4905 fix_insert_line($fixlinenr, $fixedline);

4906 }

4907 $last_coalesced_string_linenr = $linenr;

4908 }

4909 }

4910

4911 # check for missing a space in a string concatenation

4912 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {

4913 WARN('MISSING_SPACE',

4914 "break quoted strings at a space character\n" . $hereprev);

4915 }

4916

4917 # check for spaces before a quoted newline

4918 if ($rawline =~ /^.*\".*\s\\n/) {

4919 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",

4920 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&

4921 $fix) {

4922 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;

4923 }

4924

4925 }

4926

4927 # concatenated string without spaces between elements

4928 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {

4929 CHK("CONCATENATED_STRING",

4930 "Concatenated strings should use spaces between elements\n" . $herecurr);

4931 }

4932

4933 # uncoalesced string fragments

4934 if ($line =~ /$String\s*"/) {

4935 WARN("STRING_FRAGMENTS",

4936 "Consecutive strings are generally better as a single string\n" . $herecurr);

4937 }

4938

4939 # check for %L{u,d,i} and 0x%[udi] in strings

4940 my $string;

4941 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {

4942 $string = substr($rawline, $-[1], $+[1] - $-[1]);

4943 $string =~ s/%%/__/g;

4944 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {

4945 WARN("PRINTF_L",

4946 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);

4947 last;

4948 }

4949 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {

4950 ERROR("PRINTF_0xDECIMAL",

4951 "Prefixing 0x with decimal output is defective\n" . $herecurr);

4952 }

4953 }

4954

4955 # check for line continuations in quoted strings with odd counts of "

4956 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {

4957 WARN("LINE_CONTINUATIONS",

4958 "Avoid line continuations in quoted strings\n" . $herecurr);

4959 }

4960

4961 # warn about #if 0

4962 if ($line =~ /^.\s*\#\s*if\s+0\b/) {

4963 CHK("REDUNDANT_CODE",

4964 "if this code is redundant consider removing it\n" .

4965 $herecurr);

4966 }

4967

4968 # check for needless "if (<foo>) fn(<foo>)" uses

4969 if ($prevline =~ /\bif\s*$\s*($Lval)\s*$/) {

4970 my $tested = quotemeta($1);

4971 my $expr = '\s*$\s*' . $tested . '\s*$\s*;';

4972 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {

4973 my $func = $1;

4974 if (WARN('NEEDLESS_IF',

4975 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&

4976 $fix) {

4977 my $do_fix = 1;

4978 my $leading_tabs = "";

4979 my $new_leading_tabs = "";

4980 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*$\s*$tested\s*$\s*$/) {

4981 $leading_tabs = $1;

4982 } else {

4983 $do_fix = 0;

4984 }

4985 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*$\s*$tested\s*$\s*;\s*$/) {

4986 $new_leading_tabs = $1;

4987 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {

4988 $do_fix = 0;

4989 }

4990 } else {

4991 $do_fix = 0;

4992 }

4993 if ($do_fix) {

4994 fix_delete_line($fixlinenr - 1, $prevrawline);

4995 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;

4996 }

4997 }

4998 }

4999 }

5000

5001 # check for unnecessary "Out of Memory" messages

5002 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&

5003 $prevline =~ /^[ \+]\s*if\s*$\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*$/ &&

5004 (defined $1 || defined $3) &&

5005 $linenr > 3) {

5006 my $testval = $2;

5007 my $testline = $lines[$linenr - 3];

5008

5009 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);

5010 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");

5011

5012 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:$[^$]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {

5013 WARN("OOM_MESSAGE",

5014 "Possible unnecessary 'out of memory' message\n" . $hereprev);

5015 }

5016 }

5017

5018 # check for logging functions with KERN_<LEVEL>

5019 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&

5020 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {

5021 my $level = $1;

5022 if (WARN("UNNECESSARY_KERN_LEVEL",

5023 "Possible unnecessary $level\n" . $herecurr) &&

5024 $fix) {

5025 $fixed[$fixlinenr] =~ s/\s*$level\s*//;

5026 }

5027 }

5028

5029 # check for mask then right shift without a parentheses

5030 if ($^V && $^V ge 5.10.0 &&

5031 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&

5032 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so

5033 WARN("MASK_THEN_SHIFT",

5034 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);

5035 }

5036

5037 # check for pointer comparisons to NULL

5038 if ($^V && $^V ge 5.10.0) {

5039 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {

5040 my $val = $1;

5041 my $equal = "!";

5042 $equal = "" if ($4 eq "!=");

5043 if (CHK("COMPARISON_TO_NULL",

5044 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&

5045 $fix) {

5046 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;

5047 }

5048 }

5049 }

5050

5051 # check for bad placement of section $InitAttribute (e.g.: __initdata)

5052 if ($line =~ /(\b$InitAttribute\b)/) {

5053 my $attr = $1;

5054 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {

5055 my $ptr = $1;

5056 my $var = $2;

5057 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&

5058 ERROR("MISPLACED_INIT",

5059 "$attr should be placed after $var\n" . $herecurr)) ||

5060 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&

5061 WARN("MISPLACED_INIT",

5062 "$attr should be placed after $var\n" . $herecurr))) &&

5063 $fix) {

5064 $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;

5065 }

5066 }

5067 }

5068

5069 # check for $InitAttributeData (ie: __initdata) with const

5070 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {

5071 my $attr = $1;

5072 $attr =~ /($InitAttributePrefix)(.*)/;

5073 my $attr_prefix = $1;

5074 my $attr_type = $2;

5075 if (ERROR("INIT_ATTRIBUTE",

5076 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&

5077 $fix) {

5078 $fixed[$fixlinenr] =~

5079 s/$InitAttributeData/${attr_prefix}initconst/;

5080 }

5081 }

5082

5083 # check for $InitAttributeConst (ie: __initconst) without const

5084 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {

5085 my $attr = $1;

5086 if (ERROR("INIT_ATTRIBUTE",

5087 "Use of $attr requires a separate use of const\n" . $herecurr) &&

5088 $fix) {

5089 my $lead = $fixed[$fixlinenr] =~

5090 /(^\+\s*(?:static\s+))/;

5091 $lead = rtrim($1);

5092 $lead = "$lead " if ($lead !~ /^\+$/);

5093 $lead = "${lead}const ";

5094 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;

5095 }

5096 }

5097

5098 # check for __read_mostly with const non-pointer (should just be const)

5099 if ($line =~ /\b__read_mostly\b/ &&

5100 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {

5101 if (ERROR("CONST_READ_MOSTLY",

5102 "Invalid use of __read_mostly with const type\n" . $herecurr) &&

5103 $fix) {

5104 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;

5105 }

5106 }

5107

5108 # don't use __constant_<foo> functions outside of include/uapi/

5109 if ($realfile !~ m@^include/uapi/@ &&

5110 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {

5111 my $constant_func = $1;

5112 my $func = $constant_func;

5113 $func =~ s/^__constant_//;

5114 if (WARN("CONSTANT_CONVERSION",

5115 "$constant_func should be $func\n" . $herecurr) &&

5116 $fix) {

5117 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;

5118 }

5119 }

5120

5121 # prefer usleep_range over udelay

5122 if ($line =~ /\budelay\s*$\s*(\d+)\s*$/) {

5123 my $delay = $1;

5124 # ignore udelay's < 10, however

5125 if (! ($delay < 10) ) {

5126 CHK("USLEEP_RANGE",

5127 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);

5128 }

5129 if ($delay > 2000) {

5130 WARN("LONG_UDELAY",

5131 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);

5132 }

5133 }

5134

5135 # warn about unexpectedly long msleep's

5136 if ($line =~ /\bmsleep\s*$(\d+)$;/) {

5137 if ($1 < 20) {

5138 WARN("MSLEEP",

5139 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);

5140 }

5141 }

5142

5143 # check for comparisons of jiffies

5144 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {

5145 WARN("JIFFIES_COMPARISON",

5146 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);

5147 }

5148

5149 # check for comparisons of get_jiffies_64()

5150 if ($line =~ /\bget_jiffies_64\s*$\s*$\s*$Compare|$Compare\s*get_jiffies_64\s*$\s*$/) {

5151 WARN("JIFFIES_COMPARISON",

5152 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);

5153 }

5154

5155 # warn about #ifdefs in C files

5156 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {

5157 # print "#ifdef in C files should be avoided\n";

5158 # print "$herecurr";

5159 # $clean = 0;

5160 # }

5161

5162 # warn about spacing in #ifdefs

5163 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {

5164 if (ERROR("SPACING",

5165 "exactly one space required after that #$1\n" . $herecurr) &&

5166 $fix) {

5167 $fixed[$fixlinenr] =~

5168 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;

5169 }

5170

5171 }

5172

5173 # check for spinlock_t definitions without a comment.

5174 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||

5175 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {

5176 my $which = $1;

5177 if (!ctx_has_comment($first_line, $linenr)) {

5178 CHK("UNCOMMENTED_DEFINITION",

5179 "$1 definition without comment\n" . $herecurr);

5180 }

5181 }

5182 # check for memory barriers without a comment.

5183

5184 my $barriers = qr{

5185 mb|

5186 rmb|

5187 wmb|

5188 read_barrier_depends

5189 }x;

5190 my $barrier_stems = qr{

5191 mb__before_atomic|

5192 mb__after_atomic|

5193 store_release|

5194 load_acquire|

5195 store_mb|

5196 (?:$barriers)

5197 }x;

5198 my $all_barriers = qr{

5199 (?:$barriers)|

5200 smp_(?:$barrier_stems)|

5201 virt_(?:$barrier_stems)

5202 }x;

5203

5204 if ($line =~ /\b(?:$all_barriers)\s*\(/) {

5205 if (!ctx_has_comment($first_line, $linenr)) {

5206 WARN("MEMORY_BARRIER",

5207 "memory barrier without comment\n" . $herecurr);

5208 }

5209 }

5210

5211 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;

5212

5213 if ($realfile !~ m@^include/asm-generic/@ &&

5214 $realfile !~ m@/barrier\.h$@ &&

5215 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&

5216 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {

5217 WARN("MEMORY_BARRIER",

5218 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);

5219 }

5220

5221 # check for waitqueue_active without a comment.

5222 if ($line =~ /\bwaitqueue_active\s*\(/) {

5223 if (!ctx_has_comment($first_line, $linenr)) {

5224 WARN("WAITQUEUE_ACTIVE",

5225 "waitqueue_active without comment\n" . $herecurr);

5226 }

5227 }

5228

5229 # Check for expedited grace periods that interrupt non-idle non-nohz

5230 # online CPUs. These expedited can therefore degrade real-time response

5231 # if used carelessly, and should be avoided where not absolutely

5232 # needed. It is always OK to use synchronize_rcu_expedited() and

5233 # synchronize_sched_expedited() at boot time (before real-time applications

5234 # start) and in error situations where real-time response is compromised in

5235 # any case. Note that synchronize_srcu_expedited() does -not- interrupt

5236 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().

5237 # Of course, nothing comes for free, and srcu_read_lock() and

5238 # srcu_read_unlock() do contain full memory barriers in payment for

5239 # synchronize_srcu_expedited() non-interruption properties.

5240 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {

5241 WARN("EXPEDITED_RCU_GRACE_PERIOD",

5242 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);

5243

5244 }

5245

5246 # check of hardware specific defines

5247 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {

5248 CHK("ARCH_DEFINES",

5249 "architecture specific defines should be avoided\n" . $herecurr);

5250 }

5251

5252 # Check that the storage class is at the beginning of a declaration

5253 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {

5254 WARN("STORAGE_CLASS",

5255 "storage class should be at the beginning of the declaration\n" . $herecurr)

5256 }

5257

5258 # check the location of the inline attribute, that it is between

5259 # storage class and type.

5260 if ($line =~ /\b$Type\s+$Inline\b/ ||

5261 $line =~ /\b$Inline\s+$Storage\b/) {

5262 ERROR("INLINE_LOCATION",

5263 "inline keyword should sit between storage class and type\n" . $herecurr);

5264 }

5265

5266 # Check for __inline__ and __inline, prefer inline

5267 if ($realfile !~ m@\binclude/uapi/@ &&

5268 $line =~ /\b(__inline__|__inline)\b/) {

5269 if (WARN("INLINE",

5270 "plain inline is preferred over $1\n" . $herecurr) &&

5271 $fix) {

5272 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;

5273

5274 }

5275 }

5276

5277 # Check for __attribute__ packed, prefer __packed

5278 if ($realfile !~ m@\binclude/uapi/@ &&

5279 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {

5280 WARN("PREFER_PACKED",

5281 "__packed is preferred over __attribute__((packed))\n" . $herecurr);

5282 }

5283

5284 # Check for __attribute__ aligned, prefer __aligned

5285 if ($realfile !~ m@\binclude/uapi/@ &&

5286 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {

5287 WARN("PREFER_ALIGNED",

5288 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);

5289 }

5290

5291 # Check for __attribute__ format(printf, prefer __printf

5292 if ($realfile !~ m@\binclude/uapi/@ &&

5293 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {

5294 if (WARN("PREFER_PRINTF",

5295 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&

5296 $fix) {

5297 $fixed[$fixlinenr] =~ s/\b__attribute__\s*$\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)$\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;

5298

5299 }

5300 }

5301

5302 # Check for __attribute__ format(scanf, prefer __scanf

5303 if ($realfile !~ m@\binclude/uapi/@ &&

5304 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {

5305 if (WARN("PREFER_SCANF",

5306 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&

5307 $fix) {

5308 $fixed[$fixlinenr] =~ s/\b__attribute__\s*$\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)$\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;

5309 }

5310 }

5311

5312 # Check for __attribute__ weak, or __weak declarations (may have link issues)

5313 if ($^V && $^V ge 5.10.0 &&

5314 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&

5315 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||

5316 $line =~ /\b__weak\b/)) {

5317 ERROR("WEAK_DECLARATION",

5318 "Using weak declarations can have unintended link defects\n" . $herecurr);

5319 }

5320

5321 # check for c99 types like uint8_t used outside of uapi/

5322 if ($realfile !~ m@\binclude/uapi/@ &&

5323 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {

5324 my $type = $1;

5325 if ($type =~ /\b($typeC99Typedefs)\b/) {

5326 $type = $1;

5327 my $kernel_type = 'u';

5328 $kernel_type = 's' if ($type =~ /^_*[si]/);

5329 $type =~ /(\d+)/;

5330 $kernel_type .= $1;

5331 if (CHK("PREFER_KERNEL_TYPES",

5332 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&

5333 $fix) {

5334 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;

5335 }

5336 }

5337 }

5338

5339 # check for cast of C90 native int or longer types constants

5340 if ($line =~ /($\s*$C90_int_types\s*$\s*)($Constant)\b/) {

5341 my $cast = $1;

5342 my $const = $2;

5343 if (WARN("TYPECAST_INT_CONSTANT",

5344 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&

5345 $fix) {

5346 my $suffix = "";

5347 my $newconst = $const;

5348 $newconst =~ s/${Int_type}$//;

5349 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);

5350 if ($cast =~ /\blong\s+long\b/) {

5351 $suffix .= 'LL';

5352 } elsif ($cast =~ /\blong\b/) {

5353 $suffix .= 'L';

5354 }

5355 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;

5356 }

5357 }

5358

5359 # check for sizeof(&)

5360 if ($line =~ /\bsizeof\s*\(\s*\&/) {

5361 WARN("SIZEOF_ADDRESS",

5362 "sizeof(& should be avoided\n" . $herecurr);

5363 }

5364

5365 # check for sizeof without parenthesis

5366 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {

5367 if (WARN("SIZEOF_PARENTHESIS",

5368 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&

5369 $fix) {

5370 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;

5371 }

5372 }

5373

5374 # check for struct spinlock declarations

5375 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {

5376 WARN("USE_SPINLOCK_T",

5377 "struct spinlock should be spinlock_t\n" . $herecurr);

5378 }

5379

5380 # check for seq_printf uses that could be seq_puts

5381 if ($sline =~ /\bseq_printf\s*$.*"\s*$\s*;\s*$/) {

5382 my $fmt = get_quoted_string($line, $rawline);

5383 $fmt =~ s/%%//g;

5384 if ($fmt !~ /%/) {

5385 if (WARN("PREFER_SEQ_PUTS",

5386 "Prefer seq_puts to seq_printf\n" . $herecurr) &&

5387 $fix) {

5388 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;

5389 }

5390 }

5391 }

5392

5393 # Check for misused memsets

5394 if ($^V && $^V ge 5.10.0 &&

5395 defined $stat &&

5396 $stat =~ /^\+(?:.*?)\bmemset\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*$/) {

5397

5398 my $ms_addr = $2;

5399 my $ms_val = $7;

5400 my $ms_size = $12;

5401

5402 if ($ms_size =~ /^(0x|)0$/i) {

5403 ERROR("MEMSET",

5404 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");

5405 } elsif ($ms_size =~ /^(0x|)1$/i) {

5406 WARN("MEMSET",

5407 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");

5408 }

5409 }

5410

5411 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)

5412 if ($^V && $^V ge 5.10.0 &&

5413 defined $stat &&

5414 $stat =~ /^\+(?:.*?)\bmemcpy\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*$/) {

5415 if (WARN("PREFER_ETHER_ADDR_COPY",

5416 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&

5417 $fix) {

5418 $fixed[$fixlinenr] =~ s/\bmemcpy\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*$/ether_addr_copy($2, $7)/;

5419 }

5420 }

5421

5422 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)

5423 if ($^V && $^V ge 5.10.0 &&

5424 defined $stat &&

5425 $stat =~ /^\+(?:.*?)\bmemcmp\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*$/) {

5426 WARN("PREFER_ETHER_ADDR_EQUAL",

5427 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")

5428 }

5429

5430 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr

5431 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr

5432 if ($^V && $^V ge 5.10.0 &&

5433 defined $stat &&

5434 $stat =~ /^\+(?:.*?)\bmemset\s*$\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*$/) {

5435

5436 my $ms_val = $7;

5437

5438 if ($ms_val =~ /^(?:0x|)0+$/i) {

5439 if (WARN("PREFER_ETH_ZERO_ADDR",

5440 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&

5441 $fix) {

5442 $fixed[$fixlinenr] =~ s/\bmemset\s*$\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*$/eth_zero_addr($2)/;

5443 }

5444 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {

5445 if (WARN("PREFER_ETH_BROADCAST_ADDR",

5446 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&

5447 $fix) {

5448 $fixed[$fixlinenr] =~ s/\bmemset\s*$\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*$/eth_broadcast_addr($2)/;

5449 }

5450 }

5451 }

5452

5453 # typecasts on min/max could be min_t/max_t

5454 if ($^V && $^V ge 5.10.0 &&

5455 defined $stat &&

5456 $stat =~ /^\+(?:.*?)\b(min|max)\s*$\s*$FuncArg\s*,\s*$FuncArg\s*$/) {

5457 if (defined $2 || defined $7) {

5458 my $call = $1;

5459 my $cast1 = deparenthesize($2);

5460 my $arg1 = $3;

5461 my $cast2 = deparenthesize($7);

5462 my $arg2 = $8;

5463 my $cast;

5464

5465 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {

5466 $cast = "$cast1 or $cast2";

5467 } elsif ($cast1 ne "") {

5468 $cast = $cast1;

5469 } else {

5470 $cast = $cast2;

5471 }

5472 WARN("MINMAX",

5473 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");

5474 }

5475 }

5476

5477 # check usleep_range arguments

5478 if ($^V && $^V ge 5.10.0 &&

5479 defined $stat &&

5480 $stat =~ /^\+(?:.*?)\busleep_range\s*$\s*($FuncArg)\s*,\s*($FuncArg)\s*$/) {

5481 my $min = $1;

5482 my $max = $7;

5483 if ($min eq $max) {

5484 WARN("USLEEP_RANGE",

5485 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");

5486 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&

5487 $min > $max) {

5488 WARN("USLEEP_RANGE",

5489 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");

5490 }

5491 }

5492

5493 # check for naked sscanf

5494 if ($^V && $^V ge 5.10.0 &&

5495 defined $stat &&

5496 $line =~ /\bsscanf\b/ &&

5497 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&

5498 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&

5499 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {

5500 my $lc = $stat =~ tr@\n@@;

5501 $lc = $lc + $linenr;

5502 my $stat_real = raw_line($linenr, 0);

5503 for (my $count = $linenr + 1; $count <= $lc; $count++) {

5504 $stat_real = $stat_real . "\n" . raw_line($count, 0);

5505 }

5506 WARN("NAKED_SSCANF",

5507 "unchecked sscanf return value\n" . "$here\n$stat_real\n");

5508 }

5509

5510 # check for simple sscanf that should be kstrto<foo>

5511 if ($^V && $^V ge 5.10.0 &&

5512 defined $stat &&

5513 $line =~ /\bsscanf\b/) {

5514 my $lc = $stat =~ tr@\n@@;

5515 $lc = $lc + $linenr;

5516 my $stat_real = raw_line($linenr, 0);

5517 for (my $count = $linenr + 1; $count <= $lc; $count++) {

5518 $stat_real = $stat_real . "\n" . raw_line($count, 0);

5519 }

5520 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {

5521 my $format = $6;

5522 my $count = $format =~ tr@%@%@;

5523 if ($count == 1 &&

5524 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {

5525 WARN("SSCANF_TO_KSTRTO",

5526 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");

5527 }

5528 }

5529 }

5530

5531 # check for new externs in .h files.

5532 if ($realfile =~ /\.h$/ &&

5533 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {

5534 if (CHK("AVOID_EXTERNS",

5535 "extern prototypes should be avoided in .h files\n" . $herecurr) &&

5536 $fix) {

5537 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;

5538 }

5539 }

5540

5541 # check for new externs in .c files.

5542 if ($realfile =~ /\.c$/ && defined $stat &&

5543 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)

5544 {

5545 my $function_name = $1;

5546 my $paren_space = $2;

5547

5548 my $s = $stat;

5549 if (defined $cond) {

5550 substr($s, 0, length($cond), '');

5551 }

5552 if ($s =~ /^\s*;/ &&

5553 $function_name ne 'uninitialized_var')

5554 {

5555 WARN("AVOID_EXTERNS",

5556 "externs should be avoided in .c files\n" . $herecurr);

5557 }

5558

5559 if ($paren_space =~ /\n/) {

5560 WARN("FUNCTION_ARGUMENTS",

5561 "arguments for function declarations should follow identifier\n" . $herecurr);

5562 }

5563

5564 } elsif ($realfile =~ /\.c$/ && defined $stat &&

5565 $stat =~ /^.\s*extern\s+/)

5566 {

5567 WARN("AVOID_EXTERNS",

5568 "externs should be avoided in .c files\n" . $herecurr);

5569 }

5570

5571 # checks for new __setup's

5572 if ($rawline =~ /\b__setup\("([^"]*)"/) {

5573 my $name = $1;

5574

5575 if (!grep(/$name/, @setup_docs)) {

5576 CHK("UNDOCUMENTED_SETUP",

5577 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);

5578 }

5579 }

5580

5581 # check for pointless casting of kmalloc return

5582 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {

5583 WARN("UNNECESSARY_CASTS",

5584 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);

5585 }

5586

5587 # alloc style

5588 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)

5589 if ($^V && $^V ge 5.10.0 &&

5590 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*$\s*(sizeof\s*\(\s*struct\s+$Lval\s*$)/) {

5591 CHK("ALLOC_SIZEOF_STRUCT",

5592 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);

5593 }

5594

5595 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc

5596 if ($^V && $^V ge 5.10.0 &&

5597 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {

5598 my $oldfunc = $3;

5599 my $a1 = $4;

5600 my $a2 = $10;

5601 my $newfunc = "kmalloc_array";

5602 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");

5603 my $r1 = $a1;

5604 my $r2 = $a2;

5605 if ($a1 =~ /^sizeof\s*\S/) {

5606 $r1 = $a2;

5607 $r2 = $a1;

5608 }

5609 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&

5610 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {

5611 if (WARN("ALLOC_WITH_MULTIPLY",

5612 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&

5613 $fix) {

5614 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;

5615

5616 }

5617 }

5618 }

5619

5620 # check for krealloc arg reuse

5621 if ($^V && $^V ge 5.10.0 &&

5622 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {

5623 WARN("KREALLOC_ARG_REUSE",

5624 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);

5625 }

5626

5627 # check for alloc argument mismatch

5628 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {

5629 WARN("ALLOC_ARRAY_ARGS",

5630 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);

5631 }

5632

5633 # check for multiple semicolons

5634 if ($line =~ /;\s*;\s*$/) {

5635 if (WARN("ONE_SEMICOLON",

5636 "Statements terminations use 1 semicolon\n" . $herecurr) &&

5637 $fix) {

5638 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;

5639 }

5640 }

5641

5642 # check for #defines like: 1 << <digit> that could be BIT(digit)

5643 if ($line =~ /#\s*define\s+\w+\s+$?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*$?/) {

5644 my $ull = "";

5645 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);

5646 if (CHK("BIT_MACRO",

5647 "Prefer using the BIT$ull macro\n" . $herecurr) &&

5648 $fix) {

5649 $fixed[$fixlinenr] =~ s/$?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*$?/BIT${ull}($1)/;

5650 }

5651 }

5652

5653 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE

5654 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*$?\s*|\s+)(CONFIG_[A-Z_]+)\s*$?\s*\|\|\s*defined(?:\s*$?\s*|\s+)\1_MODULE\s*$?\s*$/) {

5655 my $config = $1;

5656 if (WARN("PREFER_IS_ENABLED",

5657 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&

5658 $fix) {

5659 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";

5660 }

5661 }

5662

5663 # check for case / default statements not preceded by break/fallthrough/switch

5664 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {

5665 my $has_break = 0;

5666 my $has_statement = 0;

5667 my $count = 0;

5668 my $prevline = $linenr;

5669 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {

5670 $prevline--;

5671 my $rline = $rawlines[$prevline - 1];

5672 my $fline = $lines[$prevline - 1];

5673 last if ($fline =~ /^\@\@/);

5674 next if ($fline =~ /^\-/);

5675 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);

5676 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);

5677 next if ($fline =~ /^.[\s$;]*$/);

5678 $has_statement = 1;

5679 $count++;

5680 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);

5681 }

5682 if (!$has_break && $has_statement) {

5683 WARN("MISSING_BREAK",

5684 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);

5685 }

5686 }

5687

5688 # check for switch/default statements without a break;

5689 if ($^V && $^V ge 5.10.0 &&

5690 defined $stat &&

5691 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {

5692 my $ctx = '';

5693 my $herectx = $here . "\n";

5694 my $cnt = statement_rawlines($stat);

5695 for (my $n = 0; $n < $cnt; $n++) {

5696 $herectx .= raw_line($linenr, $n) . "\n";

5697 }

5698 WARN("DEFAULT_NO_BREAK",

5699 "switch default: should use break\n" . $herectx);

5700 }

5701

5702 # check for gcc specific __FUNCTION__

5703 if ($line =~ /\b__FUNCTION__\b/) {

5704 if (WARN("USE_FUNC",

5705 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&

5706 $fix) {

5707 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;

5708 }

5709 }

5710

5711 # check for uses of __DATE__, __TIME__, __TIMESTAMP__

5712 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {

5713 ERROR("DATE_TIME",

5714 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);

5715 }

5716

5717 # check for use of yield()

5718 if ($line =~ /\byield\s*$\s*$/) {

5719 WARN("YIELD",

5720 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);

5721 }

5722

5723 # check for comparisons against true and false

5724 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {

5725 my $lead = $1;

5726 my $arg = $2;

5727 my $test = $3;

5728 my $otype = $4;

5729 my $trail = $5;

5730 my $op = "!";

5731

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

5733

5734 my $type = lc($otype);

5735 if ($type =~ /^(?:true|false)$/) {

5736 if (("$test" eq "==" && "$type" eq "true") ||

5737 ("$test" eq "!=" && "$type" eq "false")) {

5738 $op = "";

5739 }

5740

5741 CHK("BOOL_COMPARISON",

5742 "Using comparison to $otype is error prone\n" . $herecurr);

5743

5744 ## maybe suggesting a correct construct would better

5745 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);

5746

5747 }

5748 }

5749

5750 # check for semaphores initialized locked

5751 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {

5752 WARN("CONSIDER_COMPLETION",

5753 "consider using a completion\n" . $herecurr);

5754 }

5755

5756 # recommend kstrto* over simple_strto* and strict_strto*

5757 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {

5758 WARN("CONSIDER_KSTRTO",

5759 "$1 is obsolete, use k$3 instead\n" . $herecurr);

5760 }

5761

5762 # check for __initcall(), use device_initcall() explicitly or more appropriate function please

5763 if ($line =~ /^.\s*__initcall\s*\(/) {

5764 WARN("USE_DEVICE_INITCALL",

5765 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);

5766 }

5767

5768 # check for various structs that are normally const (ops, kgdb, device_tree)

5769 my $const_structs = qr{

5770 acpi_dock_ops|

5771 address_space_operations|

5772 backlight_ops|

5773 block_device_operations|

5774 dentry_operations|

5775 dev_pm_ops|

5776 dma_map_ops|

5777 extent_io_ops|

5778 file_lock_operations|

5779 file_operations|

5780 hv_ops|

5781 ide_dma_ops|

5782 intel_dvo_dev_ops|

5783 item_operations|

5784 iwl_ops|

5785 kgdb_arch|

5786 kgdb_io|

5787 kset_uevent_ops|

5788 lock_manager_operations|

5789 microcode_ops|

5790 mtrr_ops|

5791 neigh_ops|

5792 nlmsvc_binding|

5793 of_device_id|

5794 pci_raw_ops|

5795 pipe_buf_operations|

5796 platform_hibernation_ops|

5797 platform_suspend_ops|

5798 proto_ops|

5799 rpc_pipe_ops|

5800 seq_operations|

5801 snd_ac97_build_ops|

5802 soc_pcmcia_socket_ops|

5803 stacktrace_ops|

5804 sysfs_ops|

5805 tty_operations|

5806 uart_ops|

5807 usb_mon_operations|

5808 wd_ops}x;

5809 if ($line !~ /\bconst\b/ &&

5810 $line =~ /\bstruct\s+($const_structs)\b/) {

5811 WARN("CONST_STRUCT",

5812 "struct $1 should normally be const\n" .

5813 $herecurr);

5814 }

5815

5816 # use of NR_CPUS is usually wrong

5817 # ignore definitions of NR_CPUS and usage to define arrays as likely right

5818 if ($line =~ /\bNR_CPUS\b/ &&

5819 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&

5820 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&

5821 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&

5822 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&

5823 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)

5824 {

5825 WARN("NR_CPUS",

5826 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);

5827 }

5828

5829 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.

5830 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {

5831 ERROR("DEFINE_ARCH_HAS",

5832 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);

5833 }

5834

5835 # likely/unlikely comparisons similar to "(likely(foo) > 0)"

5836 if ($^V && $^V ge 5.10.0 &&

5837 $line =~ /\b((?:un)?likely)\s*$\s*$FuncArg\s*$\s*$Compare/) {

5838 WARN("LIKELY_MISUSE",

5839 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);

5840 }

5841

5842 # whine mightly about in_atomic

5843 if ($line =~ /\bin_atomic\s*\(/) {

5844 if ($realfile =~ m@^drivers/@) {

5845 ERROR("IN_ATOMIC",

5846 "do not use in_atomic in drivers\n" . $herecurr);

5847 } elsif ($realfile !~ m@^kernel/@) {

5848 WARN("IN_ATOMIC",

5849 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);

5850 }

5851 }

5852

5853 # whine about ACCESS_ONCE

5854 if ($^V && $^V ge 5.10.0 &&

5855 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {

5856 my $par = $1;

5857 my $eq = $2;

5858 my $fun = $3;

5859 $par =~ s/^$\s*(.*)\s*$$/$1/;

5860 if (defined($eq)) {

5861 if (WARN("PREFER_WRITE_ONCE",

5862 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&

5863 $fix) {

5864 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*$\s*\Q$par\E\s*$\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;

5865 }

5866 } else {

5867 if (WARN("PREFER_READ_ONCE",

5868 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&

5869 $fix) {

5870 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*$\s*\Q$par\E\s*$/READ_ONCE($par)/;

5871 }

5872 }

5873 }

5874

5875 # check for lockdep_set_novalidate_class

5876 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||

5877 $line =~ /__lockdep_no_validate__\s*\)/ ) {

5878 if ($realfile !~ m@^kernel/lockdep@ &&

5879 $realfile !~ m@^include/linux/lockdep@ &&

5880 $realfile !~ m@^drivers/base/core@) {

5881 ERROR("LOCKDEP",

5882 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);

5883 }

5884 }

5885

5886 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||

5887 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {

5888 WARN("EXPORTED_WORLD_WRITABLE",

5889 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);

5890 }

5891

5892 # Mode permission misuses where it seems decimal should be octal

5893 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop

5894 if ($^V && $^V ge 5.10.0 &&

5895 $line =~ /$mode_perms_search/) {

5896 foreach my $entry (@mode_permission_funcs) {

5897 my $func = $entry->[0];

5898 my $arg_pos = $entry->[1];

5899

5900 my $skip_args = "";

5901 if ($arg_pos > 1) {

5902 $arg_pos--;

5903 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";

5904 }

5905 my $test = "\\b$func\\s*\$${skip_args}([\\d]+)\\s*[,\$]";

5906 if ($line =~ /$test/) {

5907 my $val = $1;

5908 $val = $6 if ($skip_args ne "");

5909

5910 if ($val !~ /^0$/ &&

5911 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||

5912 length($val) ne 4)) {

5913 ERROR("NON_OCTAL_PERMISSIONS",

5914 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);

5915 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {

5916 ERROR("EXPORTED_WORLD_WRITABLE",

5917 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);

5918 }

5919 }

5920 }

5921 }

5922

5923 # validate content of MODULE_LICENSE against list from include/linux/module.h

5924 if ($line =~ /\bMODULE_LICENSE\s*$\s*($String)\s*$/) {

5925 my $extracted_string = get_quoted_string($line, $rawline);

5926 my $valid_licenses = qr{

5927 GPL|

5928 GPL\ v2|

5929 GPL\ and\ additional\ rights|

5930 Dual\ BSD/GPL|

5931 Dual\ MIT/GPL|

5932 Dual\ MPL/GPL|

5933 Proprietary

5934 }x;

5935 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {

5936 WARN("MODULE_LICENSE",

5937 "unknown module license " . $extracted_string . "\n" . $herecurr);

5938 }

5939 }

5940 }

5941

5942 # If we have no input at all, then there is nothing to report on

5943 # so just keep quiet.

5944 if ($#rawlines == -1) {

5945 exit(0);

5946 }

5947

5948 # In mailback mode only produce a report in the negative, for

5949 # things that appear to be patches.

5950 if ($mailback && ($clean == 1 || !$is_patch)) {

5951 exit(0);

5952 }

5953

5954 # This is not a patch, and we are are in 'no-patch' mode so

5955 # just keep quiet.

5956 if (!$chk_patch && !$is_patch) {

5957 exit(0);

5958 }

5959

5960 if (!$is_patch && $file !~ /cover-letter\.patch$/) {

5961 ERROR("NOT_UNIFIED_DIFF",

5962 "Does not appear to be a unified-diff format patch\n");

5963 }

5964 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {

5965 ERROR("MISSING_SIGN_OFF",

5966 "Missing Signed-off-by: line(s)\n");

5967 }

5968

5969 print report_dump();

5970 if ($summary && !($clean == 1 && $quiet == 1)) {

5971 print "$filename " if ($summary_file);

5972 print "total: $cnt_error errors, $cnt_warn warnings, " .

5973 (($check)? "$cnt_chk checks, " : "") .

5974 "$cnt_lines lines checked\n";

5975 }

5976

5977 if ($quiet == 0) {

5978 # If there were whitespace errors which cleanpatch can fix

5979 # then suggest that.

5980 if ($rpt_cleaners) {

5981 $rpt_cleaners = 0;

5982 print << "EOM"

5983

5984 NOTE: Whitespace errors detected.

5985 You may wish to use scripts/cleanpatch or scripts/cleanfile

5986 EOM

5987 }

5988 }

5989

5990 if ($clean == 0 && $fix &&

5991 ("@rawlines" ne "@fixed" ||

5992 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {

5993 my $newfile = $filename;

5994 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);

5995 my $linecount = 0;

5996 my $f;

5997

5998 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);

5999

6000 open($f, '>', $newfile)

6001 or die "$P: Can't open $newfile for write\n";

6002 foreach my $fixed_line (@fixed) {

6003 $linecount++;

6004 if ($file) {

6005 if ($linecount > 3) {

6006 $fixed_line =~ s/^\+//;

6007 print $f $fixed_line . "\n";

6008 }

6009 } else {

6010 print $f $fixed_line . "\n";

6011 }

6012 }

6013 close($f);

6014

6015 if (!$quiet) {

6016 print << "EOM";

6017

6018 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'

6019

6020 Do _NOT_ trust the results written to this file.

6021 Do _NOT_ submit these changes without inspecting them for correctness.

6022

6023 This EXPERIMENTAL file is simply a convenience to help rewrite patches.

6024 No warranties, expressed or implied...

6025 EOM

6026 }

6027 }

6028

6029 if ($quiet == 0) {

6030 print "\n";

6031 if ($clean == 1) {

6032 print "$vname has no obvious style problems and is ready for submission.\n";

6033 } else {

6034 print "$vname has style problems, please review.\n";

6035 }

6036 }

6037 return $clean;

6038 }