#!/usr/bin/env perl

# SPDX-License-Identifier: GPL-2.0

#

# (c) 2001, Dave Jones. (the file handling bit)

# (c) 2005, Joel Schopp <[email protected]> (the ugly bit)

# (c) 2007,2008, Andy Whitcroft <[email protected]> (new conditions, test suite)

# (c) 2008-2010 Andy Whitcroft <[email protected]>

# (c) 2010-2018 Joe Perches <[email protected]>

use strict;

use warnings;

use POSIX;

use File::Basename;

use Cwd 'abs_path';

use Term::ANSIColor qw(:constants);

use Encode qw(decode encode);

my $P = $0;

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

my $V = '0.32';

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

my $quiet = 0;

my $verbose = 0;

my %verbose_messages = ();

my %verbose_emitted = ();

my $tree = 1;

my $chk_signoff = 1;

my $chk_patch = 1;

my $tst_only;

my $emacs = 0;

my $terse = 0;

my $showfile = 0;

my $file = 0;

my $git = 0;

my %git_commits = ();

my $check = 0;

my $check_orig = 0;

my $summary = 1;

my $mailback = 0;

my $summary_file = 0;

my $show_types = 0;

my $list_types = 0;

my $fix = 0;

my $fix_inplace = 0;

my $root;

my $gitroot = $ENV{'GIT_DIR'};

$gitroot = ".git" if !defined($gitroot);

my %debug;

my %camelcase = ();

my %use_type = ();

my @use = ();

my %ignore_type = ();

my @ignore = ();

my $help = 0;

my $configuration_file = ".checkpatch.conf";

my $max_line_length = 100;

my $ignore_perl_version = 0;

my $minimum_perl_version = 5.10.0;

my $min_conf_desc_length = 4;

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

my $codespell = 0;

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

my $user_codespellfile = "";

my $conststructsfile = "$D/const_structs.checkpatch";

my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";

my $typedefsfile;

my $color = "auto";

my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE

# git output parsing needs US English output, so first set backtick child process LANGUAGE

my $git_command ='export LANGUAGE=en_US.UTF-8; git';

my $tabsize = 8;

my ${CONFIG_} = "CONFIG_";

my %maybe_linker_symbol; # for externs in c exceptions, when seen in *vmlinux.lds.h

sub help {

my ($exitcode) = @_;

print << "EOM";

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

Version: $V

Options:

-q, --quiet quiet

-v, --verbose verbose mode

--no-tree run without a kernel tree

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

--patch treat FILE as patchfile (default)

--emacs emacs compile window format

--terse one line per report

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

-g, --git treat FILE as a single commit or git revision range

single git commit with:

<rev>

<rev>^

<rev>~n

multiple git commits with:

<rev1>..<rev2>

<rev1>...<rev2>

<rev>-<count>

git merges are ignored

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

--subjective, --strict enable more subjective tests

--list-types list the possible message types

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

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

--show-types show the specific message type in the output

--max-line-length=n set the maximum line length, (default $max_line_length)

if exceeded, warn on patches

requires --strict for use with --file

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

--tab-size=n set the number of spaces for tab (default $tabsize)

--root=PATH PATH to the kernel tree root

--no-summary suppress the per-file summary

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

--summary-file include the filename in summary

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

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

is all off)

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

literally

--fix EXPERIMENTAL - may create horrible results

If correctable single-line errors exist, create

"<inputfile>.EXPERIMENTAL-checkpatch-fixes"

with potential errors corrected to the preferred

checkpatch style

--fix-inplace EXPERIMENTAL - may create horrible results

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

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

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

runtime errors.

--codespell Use the codespell dictionary for spelling/typos

(default:$codespellfile)

--codespellfile Use this codespell dictionary

--typedefsfile Read additional types from this file

--color[=WHEN] Use colors 'always', 'never', or only when output

is a terminal ('auto'). Default is 'auto'.

--kconfig-prefix=WORD use WORD as a prefix for Kconfig symbols (default

${CONFIG_})

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

When FILE is - read standard input.

EOM

exit($exitcode);

}

sub uniq {

my %seen;

return grep { !$seen{$_}++ } @_;

}

sub list_types {

my ($exitcode) = @_;

my $count = 0;

local $/ = undef;

open(my $script, '<', abs_path($P)) or

die "$P: Can't read '$P' $!\n";

my $text = <$script>;

close($script);

my %types = ();

# Also catch when type or level is passed through a variable

while ($text =~ /(?:(\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {

if (defined($1)) {

if (exists($types{$2})) {

$types{$2} .= ",$1" if ($types{$2} ne $1);

} else {

$types{$2} = $1;

}

} else {

$types{$2} = "UNDETERMINED";

}

}

print("#\tMessage type\n\n");

if ($color) {

print(" ( Color coding: ");

print(RED . "ERROR" . RESET);

print(" | ");

print(YELLOW . "WARNING" . RESET);

print(" | ");

print(GREEN . "CHECK" . RESET);

print(" | ");

print("Multiple levels / Undetermined");

print(" )\n\n");

}

foreach my $type (sort keys %types) {

my $orig_type = $type;

if ($color) {

my $level = $types{$type};

if ($level eq "ERROR") {

$type = RED . $type . RESET;

} elsif ($level eq "WARN") {

$type = YELLOW . $type . RESET;

} elsif ($level eq "CHK") {

$type = GREEN . $type . RESET;

}

}

print(++$count . "\t" . $type . "\n");

if ($verbose && exists($verbose_messages{$orig_type})) {

my $message = $verbose_messages{$orig_type};

$message =~ s/\n/\n\t/g;

print("\t" . $message . "\n\n");

}

}

exit($exitcode);

}

my $conf = which_conf($configuration_file);

if (-f $conf) {

my @conf_args;

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

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

while (<$conffile>) {

my $line = $_;

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

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

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

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

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

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

foreach my $word (@words) {

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

push (@conf_args, $word);

}

}

close($conffile);

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

}

sub load_docs {

open(my $docs, '<', "$docsfile")

or warn "$P: Can't read the documentation file $docsfile $!\n";

my $type = '';

my $desc = '';

my $in_desc = 0;

while (<$docs>) {

chomp;

my $line = $_;

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

if ($line =~ /^\s*\*\*(.+)\*\*$/) {

if ($desc ne '') {

$verbose_messages{$type} = trim($desc);

}

$type = $1;

$desc = '';

$in_desc = 1;

} elsif ($in_desc) {

if ($line =~ /^(?:\s{4,}|$)/) {

$line =~ s/^\s{4}//;

$desc .= $line;

$desc .= "\n";

} else {

$verbose_messages{$type} = trim($desc);

$type = '';

$desc = '';

$in_desc = 0;

}

}

}

if ($desc ne '') {

$verbose_messages{$type} = trim($desc);

}

close($docs);

}

# Perl's Getopt::Long allows options to take optional arguments after a space.

# Prevent --color by itself from consuming other arguments

foreach (@ARGV) {

if ($_ eq "--color" || $_ eq "-color") {

$_ = "--color=$color";

}

}

GetOptions(

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

'v|verbose!' => \$verbose,

'tree!' => \$tree,

'signoff!' => \$chk_signoff,

'patch!' => \$chk_patch,

'emacs!' => \$emacs,

'terse!' => \$terse,

'showfile!' => \$showfile,

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

'g|git!' => \$git,

'subjective!' => \$check,

'strict!' => \$check,

'ignore=s' => \@ignore,

'types=s' => \@use,

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

'list-types!' => \$list_types,

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

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

'tab-size=i' => \$tabsize,

'root=s' => \$root,

'summary!' => \$summary,

'mailback!' => \$mailback,

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

'fix!' => \$fix,

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

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

'debug=s' => \%debug,

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

'codespell!' => \$codespell,

'codespellfile=s' => \$user_codespellfile,

'typedefsfile=s' => \$typedefsfile,

'color=s' => \$color,

'no-color' => \$color, #keep old behaviors of -nocolor

'nocolor' => \$color, #keep old behaviors of -nocolor

'kconfig-prefix=s' => \${CONFIG_},

'h|help' => \$help,

'version' => \$help

) or $help = 2;

if ($user_codespellfile) {

# Use the user provided codespell file unconditionally

$codespellfile = $user_codespellfile;

} elsif (!(-f $codespellfile)) {

# If /usr/share/codespell/dictionary.txt is not present, try to find it

# under codespell's install directory: <codespell_root>/data/dictionary.txt

if (($codespell || $help) && which("python3") ne "") {

my $python_codespell_dict = << "EOF";

import os.path as op

import codespell_lib

codespell_dir = op.dirname(codespell_lib.__file__)

codespell_file = op.join(codespell_dir, 'data', 'dictionary.txt')

print(codespell_file, end='')

EOF

my $codespell_dict = `python3 -c "$python_codespell_dict" 2> /dev/null`;

$codespellfile = $codespell_dict if (-f $codespell_dict);

}

}

# $help is 1 if either -h, --help or --version is passed as option - exitcode: 0

# $help is 2 if invalid option is passed - exitcode: 1

help($help - 1) if ($help);

die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));

die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);

if ($color =~ /^[01]$/) {

$color = !$color;

} elsif ($color =~ /^always$/i) {

$color = 1;

} elsif ($color =~ /^never$/i) {

$color = 0;

} elsif ($color =~ /^auto$/i) {

$color = (-t STDOUT);

} else {

die "$P: Invalid color mode: $color\n";

}

load_docs() if ($verbose);

list_types(0) if ($list_types);

$fix = 1 if ($fix_inplace);

$check_orig = $check;

my $exit = 0;

my $perl_version_ok = 1;

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

$perl_version_ok = 0;

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

exit(1) if (!$ignore_perl_version);

}

#if no filenames are given, push '-' to read patch from stdin

if ($#ARGV < 0) {

push(@ARGV, '-');

}

# skip TAB size 1 to avoid additional checks on $tabsize - 1

die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);

sub hash_save_array_words {

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

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

foreach my $word (@array) {

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

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

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

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

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

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

$hashRef->{$word}++;

}

}

sub hash_show_words {

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

if (keys %$hashRef) {

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

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

print " $word";

}

print "\n";

}

}

hash_save_array_words(\%ignore_type, \@ignore);

hash_save_array_words(\%use_type, \@use);

my $dbg_values = 0;

my $dbg_possible = 0;

my $dbg_type = 0;

my $dbg_attr = 0;

for my $key (keys %debug) {

## no critic

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

die "$@" if ($@);

}

my $rpt_cleaners = 0;

if ($terse) {

$emacs = 1;

$quiet++;

}

if ($tree) {

if (defined $root) {

if (!top_of_kernel_tree($root)) {

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

}

} else {

if (top_of_kernel_tree('.')) {

$root = '.';

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

top_of_kernel_tree($1)) {

$root = $1;

}

}

if (!defined $root) {

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

exit(2);

}

}

my $emitted_corrupt = 0;

our $Ident = qr{

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

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

}x;

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

our $Sparse = qr{

__user|

__kernel|

__force|

__iomem|

__must_check|

__kprobes|

__ref|

__refconst|

__refdata|

__rcu|

__private

}x;

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

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

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

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

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

# Notes to $Attribute:

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

our $Attribute = qr{

const|

volatile|

__percpu|

__nocast|

__safe|

__bitwise|

__packed__|

__packed2__|

__naked|

__maybe_unused|

__always_unused|

__noreturn|

__used|

__cold|

__pure|

__noclone|

__deprecated|

__read_mostly|

__ro_after_init|

__kprobes|

$InitAttribute|

__aligned\s*\(.*\)|

____cacheline_aligned|

____cacheline_aligned_in_smp|

____cacheline_internodealigned_in_smp|

__weak|

__alloc_size\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\)

}x;

our $Modifier;

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

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

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

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

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

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

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

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

our $String = qr{(?:\b[Lu])?"[X\t]*"};

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

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

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

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

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

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

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

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

our $Operators = qr{

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

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

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

}x;

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

our $BasicType;

our $NonptrType;

our $NonptrTypeMisordered;

our $NonptrTypeWithAttr;

our $Type;

our $TypeMisordered;

our $Declare;

our $DeclareMisordered;

our $NON_ASCII_UTF8 = qr{

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

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

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

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

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

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

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

}x;

our $UTF8 = qr{

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

| $NON_ASCII_UTF8

}x;

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

our $typeOtherOSTypedefs = qr{(?x:

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

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

)};

our $typeKernelTypedefs = qr{(?x:

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

atomic_t

)};

our $typeStdioTypedefs = qr{(?x:

FILE

)};

our $typeTypedefs = qr{(?x:

$typeC99Typedefs\b|

$typeOtherOSTypedefs\b|

$typeKernelTypedefs\b|

$typeStdioTypedefs\b

)};

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

our $logFunctions = qr{(?x:

printk(?:_ratelimited|_once|_deferred_once|_deferred|)|

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

TP_printk|

WARN(?:_RATELIMIT|_ONCE|)|

panic|

MODULE_[A-Z_]+|

seq_vprintf|seq_printf|seq_puts

)};

our $allocFunctions = qr{(?x:

(?:(?:devm_)?

(?:kv|k|v)[czm]alloc(?:_array)?(?:_node)? |

kstrdup(?:_const)? |

kmemdup(?:_nul)?) |

(?:\w+)?alloc_skb(?:_ip_align)? |

# dev_alloc_skb/netdev_alloc_skb, et al

dma_alloc_coherent

)};

our $signature_tags = qr{(?xi:

Signed-off-by:|

Co-developed-by:|

Acked-by:|

Tested-by:|

Reviewed-by:|

Reported-by:|

Suggested-by:|

Approved-by:|

Co-authored-by:|

GitHub-Fixes:|

GitHub-Closes:|

To:|

Cc:

)};

our @link_tags = qw(Link Closes);

#Create a search and print patterns for all these strings to be used directly below

our $link_tags_search = "";

our $link_tags_print = "";

foreach my $entry (@link_tags) {

if ($link_tags_search ne "") {

$link_tags_search .= '|';

$link_tags_print .= ' or ';

}

$entry .= ':';

$link_tags_search .= $entry;

$link_tags_print .= "'$entry'";

}

$link_tags_search = "(?:${link_tags_search})";

our $tracing_logging_tags = qr{(?xi:

[=-]*> |

<[=-]* |

\[ |

\] |

start |

called |

entered |

entry |

enter |

in |

inside |

here |

begin |

exit |

end |

done |

leave |

completed |

out |

return |

[\.\!:\s]*

)};

sub edit_distance_min {

my (@arr) = @_;

my $len = scalar @arr;

if ((scalar @arr) < 1) {

# if underflow, return

return;

}

my $min = $arr[0];

for my $i (0 .. ($len-1)) {

if ($arr[$i] < $min) {

$min = $arr[$i];

}

}

return $min;

}

sub get_edit_distance {

my ($str1, $str2) = @_;

$str1 = lc($str1);

$str2 = lc($str2);

$str1 =~ s/-//g;

$str2 =~ s/-//g;

my $len1 = length($str1);

my $len2 = length($str2);

# two dimensional array storing minimum edit distance

my @distance;

for my $i (0 .. $len1) {

for my $j (0 .. $len2) {

if ($i == 0) {

$distance[$i][$j] = $j;

} elsif ($j == 0) {

$distance[$i][$j] = $i;

} elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {

$distance[$i][$j] = $distance[$i - 1][$j - 1];

} else {

my $dist1 = $distance[$i][$j - 1]; #insert distance

my $dist2 = $distance[$i - 1][$j]; # remove

my $dist3 = $distance[$i - 1][$j - 1]; #replace

$distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);

}

}

}

return $distance[$len1][$len2];

}

sub find_standard_signature {

my ($sign_off) = @_;

my @standard_signature_tags = (

'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',

'Reviewed-by:', 'Reported-by:', 'Suggested-by:'

);

foreach my $signature (@standard_signature_tags) {

return $signature if (get_edit_distance($sign_off, $signature) <= 2);

}

return "";

}

our $obsolete_archives = qr{(?xi:

\Qfreedesktop.org/archives/dri-devel\E |

\Qlists.infradead.org\E |

\Qlkml.org\E |

\Qmail-archive.com\E |

\Qmailman.alsa-project.org/pipermail\E |

\Qmarc.info\E |

\Qozlabs.org/pipermail\E |

\Qspinics.net\E

)};

our @typeListMisordered = (

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

);

our @typeList = (

qr{void},

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

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

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

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

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

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

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

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

qr{(?:un)?signed},

qr{float},

qr{double},

qr{bool},

qr{struct\s+$Ident},

qr{union\s+$Ident},

qr{enum\s+$Ident},

qr{${Ident}_t},

qr{${Ident}_handler},

qr{${Ident}_handler_fn},

@typeListMisordered,

);

our $C90_int_types = qr{(?x:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

)};

our @typeListFile = ();

our @typeListWithAttr = (

@typeList,

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

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

);

our @modifierList = (

qr{fastcall},

);

our @modifierListFile = ();

our @mode_permission_funcs = (

["module_param", 3],

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

["module_param_array_named", 5],

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

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

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

["IIO_DEV_ATTR_[A-Z_]+", 1],

["SENSOR_(?:DEVICE_|)ATTR_2", 2],

["SENSOR_TEMPLATE(?:_2|)", 3],

["__ATTR", 2],

);

my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';

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

our $mode_perms_search = "";

foreach my $entry (@mode_permission_funcs) {

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

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

}

$mode_perms_search = "(?:${mode_perms_search})";

our %deprecated_apis = (

"synchronize_rcu_bh" => "synchronize_rcu",

"synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",

"call_rcu_bh" => "call_rcu",

"rcu_barrier_bh" => "rcu_barrier",

"synchronize_sched" => "synchronize_rcu",

"synchronize_sched_expedited" => "synchronize_rcu_expedited",

"call_rcu_sched" => "call_rcu",

"rcu_barrier_sched" => "rcu_barrier",

"get_state_synchronize_sched" => "get_state_synchronize_rcu",

"cond_synchronize_sched" => "cond_synchronize_rcu",

"kmap" => "kmap_local_page",

"kunmap" => "kunmap_local",

"kmap_atomic" => "kmap_local_page",

"kunmap_atomic" => "kunmap_local",

);

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

our $deprecated_apis_search = "";

foreach my $entry (keys %deprecated_apis) {

$deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");

$deprecated_apis_search .= $entry;

}

$deprecated_apis_search = "(?:${deprecated_apis_search})";

our $mode_perms_world_writable = qr{

S_IWUGO |

S_IWOTH |

S_IRWXUGO |

S_IALLUGO |

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

}x;

our %mode_permission_string_types = (

"S_IRWXU" => 0700,

"S_IRUSR" => 0400,

"S_IWUSR" => 0200,

"S_IXUSR" => 0100,

"S_IRWXG" => 0070,

"S_IRGRP" => 0040,

"S_IWGRP" => 0020,

"S_IXGRP" => 0010,

"S_IRWXO" => 0007,

"S_IROTH" => 0004,

"S_IWOTH" => 0002,

"S_IXOTH" => 0001,

"S_IRWXUGO" => 0777,

"S_IRUGO" => 0444,

"S_IWUGO" => 0222,

"S_IXUGO" => 0111,

);

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

our $mode_perms_string_search = "";

foreach my $entry (keys %mode_permission_string_types) {

$mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");

$mode_perms_string_search .= $entry;

}

our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";

our $multi_mode_perms_string_search = qr{

${single_mode_perms_string_search}

(?:\s*\|\s*${single_mode_perms_string_search})*

}x;

sub perms_to_octal {

my ($string) = @_;

return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);

my $val = "";

my $oval = "";

my $to = 0;

my $curpos = 0;

my $lastpos = 0;

while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {

$curpos = pos($string);

my $match = $2;

my $omatch = $1;

last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));

$lastpos = $curpos;

$to |= $mode_permission_string_types{$match};

$val .= '\s*\|\s*' if ($val ne "");

$val .= $match;

$oval .= $omatch;

}

$oval =~ s/^\s*\|\s*//;

$oval =~ s/\s*\|\s*$//;

return sprintf("%04o", $to);

}

our $allowed_asm_includes = qr{(?x:

irq|

memory|

time|

reboot

)};

# memory.h: ARM has a custom one

# Load common spelling mistakes and build regular expression list.

my $misspellings;

my %spelling_fix;

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

while (<$spelling>) {

my $line = $_;

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

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

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

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

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

$spelling_fix{$suspect} = $fix;

}

close($spelling);

} else {

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

}

if ($codespell) {

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

while (<$spelling>) {

my $line = $_;

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

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

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

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

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

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

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

$spelling_fix{$suspect} = $fix;

}

close($spelling);

} else {

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

}

}

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

sub read_words {

my ($wordsRef, $file) = @_;

if (open(my $words, '<', $file)) {

while (<$words>) {

my $line = $_;

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

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

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

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

if ($line =~ /\s/) {

print("$file: '$line' invalid - ignored\n");

next;

}