175 lines
5.1 KiB
Python
Executable file
175 lines
5.1 KiB
Python
Executable file
#!/usr/bin/env python
|
|
#
|
|
# this program is used to find source code that includes linux kernel headers directly
|
|
# (e.g. with #include <linux/...> or #include <asm/...>)
|
|
#
|
|
# then it lists
|
|
|
|
import sys, cpp, glob, os, re, getopt, kernel
|
|
from utils import *
|
|
from defaults import *
|
|
|
|
program_dir = find_program_dir()
|
|
|
|
wanted_archs = kernel_archs
|
|
wanted_include = os.path.normpath(program_dir + '/../original')
|
|
wanted_config = os.path.normpath(program_dir + '/../original/config')
|
|
|
|
def usage():
|
|
print """\
|
|
usage: find_headers.py [options] (file|directory|@listfile)+
|
|
|
|
options:
|
|
-d <include-dir> specify alternate kernel headers
|
|
'include' directory
|
|
('%s' by default)
|
|
|
|
-c <file> specify alternate .config file
|
|
('%s' by default)
|
|
|
|
-a <archs> used to specify an alternative list
|
|
of architectures to support
|
|
('%s' by default)
|
|
|
|
-v enable verbose mode
|
|
|
|
this program is used to find all the kernel headers that are used
|
|
by a set of source files or directories containing them. the search
|
|
is recursive to find *all* required files.
|
|
|
|
""" % ( wanted_include, wanted_config, string.join(kernel_archs,",") )
|
|
sys.exit(1)
|
|
|
|
|
|
try:
|
|
optlist, args = getopt.getopt( sys.argv[1:], 'vc:d:a:' )
|
|
except:
|
|
# unrecognized option
|
|
print "error: unrecognized option"
|
|
usage()
|
|
|
|
for opt, arg in optlist:
|
|
if opt == '-a':
|
|
wanted_archs = string.split(arg,',')
|
|
elif opt == '-d':
|
|
wanted_include = arg
|
|
elif opt == '-c':
|
|
wanted_config = arg
|
|
elif opt == '-v':
|
|
kernel.verboseSearch = 1
|
|
kernel.verboseFind = 1
|
|
verbose = 1
|
|
else:
|
|
usage()
|
|
|
|
if len(args) < 1:
|
|
usage()
|
|
|
|
kernel_root = wanted_include
|
|
if not os.path.exists(kernel_root):
|
|
sys.stderr.write( "error: directory '%s' does not exist\n" % kernel_root )
|
|
sys.exit(1)
|
|
|
|
if not os.path.isdir(kernel_root):
|
|
sys.stderr.write( "error: '%s' is not a directory\n" % kernel_root )
|
|
sys.exit(1)
|
|
|
|
if not os.path.isdir(kernel_root+"/linux"):
|
|
sys.stderr.write( "error: '%s' does not have a 'linux' directory\n" % kernel_root )
|
|
sys.exit(1)
|
|
|
|
if not os.path.exists(wanted_config):
|
|
sys.stderr.write( "error: file '%s' does not exist\n" % wanted_config )
|
|
sys.exit(1)
|
|
|
|
if not os.path.isfile(wanted_config):
|
|
sys.stderr.write( "error: '%s' is not a file\n" % wanted_config )
|
|
sys.exit(1)
|
|
|
|
# find all architectures in the kernel tree
|
|
re_asm_ = re.compile(r"asm-(\w+)")
|
|
archs = []
|
|
for dir in os.listdir(kernel_root):
|
|
m = re_asm_.match(dir)
|
|
if m:
|
|
if verbose: print ">> found kernel arch '%s'" % m.group(1)
|
|
archs.append(m.group(1))
|
|
|
|
# if we're using the 'kernel_headers' directory, there is only asm/
|
|
# and no other asm-<arch> directories (arm is assumed, which sucks)
|
|
#
|
|
in_kernel_headers = False
|
|
if len(archs) == 0:
|
|
# this can happen when we're using the 'kernel_headers' directory
|
|
if os.path.isdir(kernel_root+"/asm"):
|
|
in_kernel_headers = True
|
|
archs = [ "arm" ]
|
|
|
|
# if the user has specified some architectures with -a <archs> ensure that
|
|
# all those he wants are available from the kernel include tree
|
|
if wanted_archs != None:
|
|
if in_kernel_headers and wanted_archs != [ "arm" ]:
|
|
sys.stderr.write( "error: when parsing kernel_headers, 'arm' architecture only is supported at the moment\n" )
|
|
sys.exit(1)
|
|
missing = []
|
|
for arch in wanted_archs:
|
|
if arch not in archs:
|
|
missing.append(arch)
|
|
if len(missing) > 0:
|
|
sys.stderr.write( "error: the following requested architectures are not in the kernel tree: " )
|
|
for a in missing:
|
|
sys.stderr.write( " %s" % a )
|
|
sys.stderr.write( "\n" )
|
|
sys.exit(1)
|
|
|
|
archs = wanted_archs
|
|
|
|
# helper function used to walk the user files
|
|
def parse_file(path, parser):
|
|
parser.parseFile(path)
|
|
|
|
|
|
# remove previous destination directory
|
|
#destdir = "/tmp/bionic-kernel-headers/"
|
|
#cleanup_dir(destdir)
|
|
|
|
# try to read the config file
|
|
try:
|
|
cparser = kernel.ConfigParser()
|
|
cparser.parseFile( wanted_config )
|
|
except:
|
|
sys.stderr.write( "error: can't parse '%s'" % wanted_config )
|
|
sys.exit(1)
|
|
|
|
kernel_config = cparser.getDefinitions()
|
|
|
|
# first, obtain the list of kernel files used by our clients
|
|
fparser = kernel.HeaderScanner()
|
|
walk_source_files( args, parse_file, fparser, excludes=["kernel_headers"] )
|
|
headers = fparser.getHeaders()
|
|
files = fparser.getFiles()
|
|
|
|
# now recursively scan the kernel headers for additionnal sub-included headers
|
|
hparser = kernel.KernelHeaderFinder(headers,archs,kernel_root,kernel_config)
|
|
headers = hparser.scanForAllArchs()
|
|
|
|
if 0: # just for debugging
|
|
dumpHeaderUsers = False
|
|
|
|
print "the following %d headers:" % len(headers)
|
|
for h in sorted(headers):
|
|
if dumpHeaderUsers:
|
|
print " %s (%s)" % (h, repr(hparser.getHeaderUsers(h)))
|
|
else:
|
|
print " %s" % h
|
|
|
|
print "are used by the following %d files:" % len(files)
|
|
for f in sorted(files):
|
|
print " %s" % f
|
|
|
|
sys.exit(0)
|
|
|
|
for h in sorted(headers):
|
|
print h
|
|
|
|
sys.exit(0)
|