Merge tag 'fs_for_4.21-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jack...
[linux-2.6-microblaze.git] / scripts / headers_check.pl
1 #!/usr/bin/env perl
2 # SPDX-License-Identifier: GPL-2.0
3 #
4 # headers_check.pl execute a number of trivial consistency checks
5 #
6 # Usage: headers_check.pl dir arch [files...]
7 # dir:   dir to look for included files
8 # arch:  architecture
9 # files: list of files to check
10 #
11 # The script reads the supplied files line by line and:
12 #
13 # 1) for each include statement it checks if the
14 #    included file actually exists.
15 #    Only include files located in asm* and linux* are checked.
16 #    The rest are assumed to be system include files.
17 #
18 # 2) It is checked that prototypes does not use "extern"
19 #
20 # 3) Check for leaked CONFIG_ symbols
21
22 use warnings;
23 use strict;
24 use File::Basename;
25
26 my ($dir, $arch, @files) = @ARGV;
27
28 my $ret = 0;
29 my $line;
30 my $lineno = 0;
31 my $filename;
32
33 foreach my $file (@files) {
34         $filename = $file;
35
36         open(my $fh, '<', $filename)
37                 or die "$filename: $!\n";
38         $lineno = 0;
39         while ($line = <$fh>) {
40                 $lineno++;
41                 &check_include();
42                 &check_asm_types();
43                 &check_sizetypes();
44                 &check_declarations();
45                 # Dropped for now. Too much noise &check_config();
46         }
47         close $fh;
48 }
49 exit $ret;
50
51 sub check_include
52 {
53         if ($line =~ m/^\s*#\s*include\s+<((asm|linux).*)>/) {
54                 my $inc = $1;
55                 my $found;
56                 $found = stat($dir . "/" . $inc);
57                 if (!$found) {
58                         $inc =~ s#asm/#asm-$arch/#;
59                         $found = stat($dir . "/" . $inc);
60                 }
61                 if (!$found) {
62                         printf STDERR "$filename:$lineno: included file '$inc' is not exported\n";
63                         $ret = 1;
64                 }
65         }
66 }
67
68 sub check_declarations
69 {
70         # soundcard.h is what it is
71         if ($line =~ m/^void seqbuf_dump\(void\);/) {
72                 return;
73         }
74         # drm headers are being C++ friendly
75         if ($line =~ m/^extern "C"/) {
76                 return;
77         }
78         if ($line =~ m/^(\s*extern|unsigned|char|short|int|long|void)\b/) {
79                 printf STDERR "$filename:$lineno: " .
80                               "userspace cannot reference function or " .
81                               "variable defined in the kernel\n";
82         }
83 }
84
85 sub check_config
86 {
87         if ($line =~ m/[^a-zA-Z0-9_]+CONFIG_([a-zA-Z0-9_]+)[^a-zA-Z0-9_]/) {
88                 printf STDERR "$filename:$lineno: leaks CONFIG_$1 to userspace where it is not valid\n";
89         }
90 }
91
92 my $linux_asm_types;
93 sub check_asm_types
94 {
95         if ($filename =~ /types.h|int-l64.h|int-ll64.h/o) {
96                 return;
97         }
98         if ($lineno == 1) {
99                 $linux_asm_types = 0;
100         } elsif ($linux_asm_types >= 1) {
101                 return;
102         }
103         if ($line =~ m/^\s*#\s*include\s+<asm\/types.h>/) {
104                 $linux_asm_types = 1;
105                 printf STDERR "$filename:$lineno: " .
106                 "include of <linux/types.h> is preferred over <asm/types.h>\n"
107                 # Warn until headers are all fixed
108                 #$ret = 1;
109         }
110 }
111
112 my $linux_types;
113 my %import_stack = ();
114 sub check_include_typesh
115 {
116         my $path = $_[0];
117         my $import_path;
118
119         my $fh;
120         my @file_paths = ($path, $dir . "/" .  $path, dirname($filename) . "/" . $path);
121         for my $possible ( @file_paths ) {
122             if (not $import_stack{$possible} and open($fh, '<', $possible)) {
123                 $import_path = $possible;
124                 $import_stack{$import_path} = 1;
125                 last;
126             }
127         }
128         if (eof $fh) {
129             return;
130         }
131
132         my $line;
133         while ($line = <$fh>) {
134                 if ($line =~ m/^\s*#\s*include\s+<linux\/types.h>/) {
135                         $linux_types = 1;
136                         last;
137                 }
138                 if (my $included = ($line =~ /^\s*#\s*include\s+[<"](\S+)[>"]/)[0]) {
139                         check_include_typesh($included);
140                 }
141         }
142         close $fh;
143         delete $import_stack{$import_path};
144 }
145
146 sub check_sizetypes
147 {
148         if ($filename =~ /types.h|int-l64.h|int-ll64.h/o) {
149                 return;
150         }
151         if ($lineno == 1) {
152                 $linux_types = 0;
153         } elsif ($linux_types >= 1) {
154                 return;
155         }
156         if ($line =~ m/^\s*#\s*include\s+<linux\/types.h>/) {
157                 $linux_types = 1;
158                 return;
159         }
160         if (my $included = ($line =~ /^\s*#\s*include\s+[<"](\S+)[>"]/)[0]) {
161                 check_include_typesh($included);
162         }
163         if ($line =~ m/__[us](8|16|32|64)\b/) {
164                 printf STDERR "$filename:$lineno: " .
165                               "found __[us]{8,16,32,64} type " .
166                               "without #include <linux/types.h>\n";
167                 $linux_types = 2;
168                 # Warn until headers are all fixed
169                 #$ret = 1;
170         }
171 }