d12c332018
This changes the scripts so that if some kernel files exists in external/kernel-headers/modified, that they will be preferred over the same files found in original. This is to support the case where the kernel headers cannot be taken without some small modifications. Included with this change, is a general cleanup of the python scripts. This also modifies the generate uapi headers script to indicate if the source of the modified headers has changed. Change-Id: Id13523b244ced52a2ecd9f1399c43996dd8296fa
226 lines
7.1 KiB
Python
Executable File
226 lines
7.1 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
#------------------------------------------------------------------------------
|
|
# Description of the header clean process
|
|
#------------------------------------------------------------------------------
|
|
# Here is the list of actions performed by this script to clean the original
|
|
# kernel headers.
|
|
#
|
|
# 1. Optimize well-known macros (e.g. __KERNEL__, __KERNEL_STRICT_NAMES)
|
|
#
|
|
# This pass gets rid of everything that is guarded by a well-known macro
|
|
# definition. This means that a block like:
|
|
#
|
|
# #ifdef __KERNEL__
|
|
# ....
|
|
# #endif
|
|
#
|
|
# Will be totally omitted from the output. The optimizer is smart enough to
|
|
# handle all complex C-preprocessor conditional expression appropriately.
|
|
# This means that, for example:
|
|
#
|
|
# #if defined(__KERNEL__) || defined(FOO)
|
|
# ...
|
|
# #endif
|
|
#
|
|
# Will be transformed into:
|
|
#
|
|
# #ifdef FOO
|
|
# ...
|
|
# #endif
|
|
#
|
|
# See tools/defaults.py for the list of well-known macros used in this pass,
|
|
# in case you need to update it in the future.
|
|
#
|
|
# Note that this also removes any reference to a kernel-specific
|
|
# configuration macro like CONFIG_FOO from the clean headers.
|
|
#
|
|
#
|
|
# 2. Remove variable and function declarations:
|
|
#
|
|
# This pass scans non-directive text and only keeps things that look like a
|
|
# typedef/struct/union/enum declaration. This allows us to get rid of any
|
|
# variables or function declarations that should only be used within the
|
|
# kernel anyway (and which normally *should* be guarded by an #ifdef
|
|
# __KERNEL__ ... #endif block, if the kernel writers were not so messy).
|
|
#
|
|
# There are, however, a few exceptions: it is seldom useful to keep the
|
|
# definition of some static inline functions performing very simple
|
|
# operations. A good example is the optimized 32-bit byte-swap function
|
|
# found in:
|
|
#
|
|
# arch-arm/asm/byteorder.h
|
|
#
|
|
# The list of exceptions is in tools/defaults.py in case you need to update
|
|
# it in the future.
|
|
#
|
|
# Note that we do *not* remove macro definitions, including these macro that
|
|
# perform a call to one of these kernel-header functions, or even define other
|
|
# functions. We consider it safe since userland applications have no business
|
|
# using them anyway.
|
|
#
|
|
#
|
|
# 3. Add a standard disclaimer:
|
|
#
|
|
# The message:
|
|
#
|
|
# /* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
|
|
#
|
|
# Is prepended to each generated header.
|
|
#------------------------------------------------------------------------------
|
|
|
|
import sys, cpp, kernel, glob, os, re, getopt
|
|
from defaults import *
|
|
from utils import *
|
|
|
|
def print_error(no_update, msg):
|
|
if no_update:
|
|
panic(msg)
|
|
sys.stderr.write("warning: " + msg)
|
|
|
|
|
|
def cleanupFile(dst_dir, src_dir, rel_path, no_update = True):
|
|
"""reads an original header and perform the cleanup operation on it
|
|
this functions returns the destination path and the clean header
|
|
as a single string"""
|
|
# check the header path
|
|
full_path = os.path.join(src_dir, rel_path)
|
|
|
|
if not os.path.exists(full_path):
|
|
print_error(no_update, "file does not exist: '%s'\n" % full_path)
|
|
return None, None
|
|
|
|
if not os.path.isfile(full_path):
|
|
print_error(no_update, "path is not a file: '%s'\n" % full_path)
|
|
return None, None
|
|
|
|
# convert into destination path, extracting architecture if needed
|
|
# and the corresponding list of known static functions
|
|
#
|
|
arch = None
|
|
statics = kernel_known_generic_statics
|
|
m = re.match(r"asm-([\w\d_\+\.\-]+)(/.*)", rel_path)
|
|
if m and m.group(1) != 'generic':
|
|
dst_path = "arch-%s/asm/%s" % m.groups()
|
|
arch = m.group(1)
|
|
statics = statics.union(kernel_known_statics.get(arch, set()))
|
|
else:
|
|
# process headers under the uapi directory
|
|
# note the "asm" level has been explicitly added in the original
|
|
# kernel header tree for architectural-dependent uapi headers
|
|
m_uapi = re.match(r"(uapi)/([\w\d_\+\.\-]+)(/.*)", rel_path)
|
|
if m_uapi:
|
|
dst_path = rel_path
|
|
m_uapi_arch = re.match(r"asm-([\w\d_\+\.\-]+)", m_uapi.group(2))
|
|
if m_uapi_arch and m_uapi_arch.group(1) != 'generic':
|
|
arch = m_uapi_arch.group(1)
|
|
statics = statics.union(kernel_known_statics.get(arch, set()))
|
|
# common headers (ie non-asm and non-uapi)
|
|
else:
|
|
dst_path = os.path.join("common", rel_path)
|
|
|
|
dst_path = os.path.join(dst_dir, dst_path)
|
|
|
|
# now, let's parse the file
|
|
#
|
|
parser = cpp.BlockParser()
|
|
blocks = parser.parseFile(full_path)
|
|
if not parser.parsed:
|
|
print_error(no_update, "can't parse '%s'%" % full_path)
|
|
return None, None
|
|
|
|
macros = kernel_known_macros.copy()
|
|
if arch and arch in kernel_default_arch_macros:
|
|
macros.update(kernel_default_arch_macros[arch])
|
|
|
|
if arch and arch in kernel_arch_token_replacements:
|
|
blocks.replaceTokens(kernel_arch_token_replacements[arch])
|
|
|
|
blocks.optimizeMacros(macros)
|
|
blocks.optimizeIf01()
|
|
blocks.removeVarsAndFuncs(statics)
|
|
blocks.replaceTokens(kernel_token_replacements)
|
|
blocks.removeMacroDefines(kernel_ignored_macros)
|
|
|
|
out = StringOutput()
|
|
out.write(kernel_disclaimer)
|
|
blocks.writeWithWarning(out, kernel_warning, 4)
|
|
return dst_path, out.get()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
def usage():
|
|
print """\
|
|
usage: %s [options] <header_path>
|
|
|
|
options:
|
|
-v enable verbose mode
|
|
|
|
-u enabled update mode
|
|
this will try to update the corresponding 'clean header'
|
|
if the content has changed. with this, you can pass more
|
|
than one file on the command-line
|
|
|
|
-k<path> specify path of original kernel headers
|
|
-d<path> specify path of cleaned kernel headers
|
|
|
|
<header_path> must be in a subdirectory of 'original'
|
|
""" % os.path.basename(sys.argv[0])
|
|
sys.exit(1)
|
|
|
|
try:
|
|
optlist, args = getopt.getopt(sys.argv[1:], 'uvk:d:')
|
|
except:
|
|
# unrecognized option
|
|
sys.stderr.write("error: unrecognized option\n")
|
|
usage()
|
|
|
|
no_update = True
|
|
dst_dir = get_kernel_dir()
|
|
src_dir = get_kernel_headers_original_dir()
|
|
for opt, arg in optlist:
|
|
if opt == '-u':
|
|
no_update = False
|
|
elif opt == '-v':
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
elif opt == '-k':
|
|
src_dir = arg
|
|
elif opt == '-d':
|
|
dst_dir = arg
|
|
|
|
if len(args) == 0:
|
|
usage()
|
|
|
|
if no_update:
|
|
for path in args:
|
|
dst_path, newdata = cleanupFile(dst_dir, src_dir, path)
|
|
print newdata
|
|
|
|
sys.exit(0)
|
|
|
|
# now let's update our files.
|
|
|
|
b = BatchFileUpdater()
|
|
|
|
for path in args:
|
|
dst_path, newdata = cleanupFile(dst_dir, src_dir, path, no_update)
|
|
if not dst_path:
|
|
continue
|
|
|
|
b.readFile(dst_path)
|
|
r = b.editFile(dst_path, newdata)
|
|
if r == 0:
|
|
r = "unchanged"
|
|
elif r == 1:
|
|
r = "edited"
|
|
else:
|
|
r = "added"
|
|
|
|
print "cleaning: %-*s -> %-*s (%s)" % (35, path, 35, dst_path, r)
|
|
|
|
|
|
b.updateGitFiles()
|
|
|
|
sys.exit(0)
|