tools/extract_kernel.py - platform/build - Git at Google


            
            #!/usr/bin/env python

            
            #

            
            # Copyright (C) 2018 The Android Open Source Project

            
            #

            
            # Licensed under the Apache License, Version 2.0 (the "License");

            
            # you may not use this file except in compliance with the License.

            
            # You may obtain a copy of the License at

            
            #

            
            #      http://www.apache.org/licenses/LICENSE-2.0

            
            #

            
            # Unless required by applicable law or agreed to in writing, software

            
            # distributed under the License is distributed on an "AS IS" BASIS,

            
            # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

            
            # See the License for the specific language governing permissions and

            
            # limitations under the License.


            """

            
            A tool to extract kernel information from a kernel image.

            
            """


            import argparse

            
            import subprocess

            
            import sys

            
            import re


            CONFIG_PREFIX = b'IKCFG_ST'

            
            GZIP_HEADER = b'\037\213\010'

            
            COMPRESSION_ALGO = (

            
                (["gzip", "-d"], GZIP_HEADER),

            
                (["xz", "-d"], b'\3757zXZ\000'),

            
                (["bzip2", "-d"], b'BZh'),

            
                (["lz4", "-d", "-l"], b'\002\041\114\030'),


                # These are not supported in the build system yet.

            
                # (["unlzma"], b'\135\0\0\0'),

            
                # (["lzop", "-d"], b'\211\114\132'),

            
            )


            # "Linux version " UTS_RELEASE " (" LINUX_COMPILE_BY "@"

            
            # LINUX_COMPILE_HOST ") (" LINUX_COMPILER ") " UTS_VERSION "\n";

            
            LINUX_BANNER_PREFIX = b'Linux version '

            
            LINUX_BANNER_REGEX = LINUX_BANNER_PREFIX.decode() + \

            
                r'(?P<release>(?P<version>[0-9]+[.][0-9]+[.][0-9]+).*) \(.*@.*\) \((?P<compiler>.*)\) .*\n'


            def get_from_release(input_bytes, start_idx, key):

            
              null_idx = input_bytes.find(b'\x00', start_idx)

            
              if null_idx < 0:

            
                return None

            
              try:

            
                linux_banner = input_bytes[start_idx:null_idx].decode()

            
              except UnicodeDecodeError:

            
                return None

            
              mo = re.match(LINUX_BANNER_REGEX, linux_banner)

            
              if mo:

            
                return mo.group(key)

            
              return None


            def dump_from_release(input_bytes, key):

            
              """

            
              Helper of dump_version and dump_release

            
              """

            
              idx = 0

            
              while True:

            
                idx = input_bytes.find(LINUX_BANNER_PREFIX, idx)

            
                if idx < 0:

            
                  return None


                value = get_from_release(input_bytes, idx, key)

            
                if value:

            
                  return value.encode()


                idx += len(LINUX_BANNER_PREFIX)


            def dump_version(input_bytes):

            
              """

            
              Dump kernel version, w.x.y, from input_bytes. Search for the string

            
              "Linux version " and do pattern matching after it. See LINUX_BANNER_REGEX.

            
              """

            
              return dump_from_release(input_bytes, "version")


            def dump_compiler(input_bytes):

            
              """

            
              Dump kernel version, w.x.y, from input_bytes. Search for the string

            
              "Linux version " and do pattern matching after it. See LINUX_BANNER_REGEX.

            
              """

            
              return dump_from_release(input_bytes, "compiler")


            def dump_release(input_bytes):

            
              """

            
              Dump kernel release, w.x.y-..., from input_bytes. Search for the string

            
              "Linux version " and do pattern matching after it. See LINUX_BANNER_REGEX.

            
              """

            
              return dump_from_release(input_bytes, "release")


            def dump_configs(input_bytes):

            
              """

            
              Dump kernel configuration from input_bytes. This can be done when

            
              CONFIG_IKCONFIG is enabled, which is a requirement on Treble devices.


              The kernel configuration is archived in GZip format right after the magic

            
              string 'IKCFG_ST' in the built kernel.

            
              """


              # Search for magic string + GZip header

            
              idx = input_bytes.find(CONFIG_PREFIX + GZIP_HEADER)

            
              if idx < 0:

            
                return None


              # Seek to the start of the archive

            
              idx += len(CONFIG_PREFIX)


              sp = subprocess.Popen(["gzip", "-d", "-c"], stdin=subprocess.PIPE,

            
                                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)

            
              o, _ = sp.communicate(input=input_bytes[idx:])

            
              if sp.returncode == 1: # error

            
                return None


              # success or trailing garbage warning

            
              assert sp.returncode in (0, 2), sp.returncode


              return o


            def try_decompress_bytes(cmd, input_bytes):

            
              sp = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,

            
                                    stderr=subprocess.PIPE)

            
              o, _ = sp.communicate(input=input_bytes)

            
              # ignore errors

            
              return o


            def try_decompress(cmd, search_bytes, input_bytes):

            
              idx = 0

            
              while True:

            
                idx = input_bytes.find(search_bytes, idx)

            
                if idx < 0:

            
                  return


                yield try_decompress_bytes(cmd, input_bytes[idx:])

            
                idx += 1


            def decompress_dump(func, input_bytes):

            
              """

            
              Run func(input_bytes) first; and if that fails (returns value evaluates to

            
              False), then try different decompression algorithm before running func.

            
              """

            
              o = func(input_bytes)

            
              if o:

            
                return o

            
              for cmd, search_bytes in COMPRESSION_ALGO:

            
                for decompressed in try_decompress(cmd, search_bytes, input_bytes):

            
                  if decompressed:

            
                    o = decompress_dump(func, decompressed)

            
                    if o:

            
                      return o

            
                # Force decompress the whole file even if header doesn't match

            
                decompressed = try_decompress_bytes(cmd, input_bytes)

            
                if decompressed:

            
                  o = decompress_dump(func, decompressed)

            
                  if o:

            
                    return o


            def dump_to_file(f, dump_fn, input_bytes, desc):

            
              """

            
              Call decompress_dump(dump_fn, input_bytes) and write to f. If it fails, return

            
              False; otherwise return True.

            
              """

            
              if f is not None:

            
                o = decompress_dump(dump_fn, input_bytes)

            
                if o:

            
                  f.write(o)

            
                else:

            
                  sys.stderr.write(

            
                      "Cannot extract kernel {}".format(desc))

            
                  return False

            
              return True


            def to_bytes_io(b):

            
              """

            
              Make b, which is either sys.stdout or sys.stdin, receive bytes as arguments.

            
              """

            
              return b.buffer if sys.version_info.major == 3 else b


            def main():

            
              parser = argparse.ArgumentParser(

            
                  formatter_class=argparse.RawTextHelpFormatter,

            
                  description=__doc__ +

            
                  "\nThese algorithms are tried when decompressing the image:\n    " +

            
                  " ".join(tup[0][0] for tup in COMPRESSION_ALGO))

            
              parser.add_argument('--input',

            
                                  help='Input kernel image. If not specified, use stdin',

            
                                  metavar='FILE',

            
                                  type=argparse.FileType('rb'),

            
                                  default=to_bytes_io(sys.stdin))

            
              parser.add_argument('--output-configs',

            
                                  help='If specified, write configs. Use stdout if no file '

            
                                       'is specified.',

            
                                  metavar='FILE',

            
                                  nargs='?',

            
                                  type=argparse.FileType('wb'),

            
                                  const=to_bytes_io(sys.stdout))

            
              parser.add_argument('--output-version',

            
                                  help='If specified, write version. Use stdout if no file '

            
                                       'is specified.',

            
                                  metavar='FILE',

            
                                  nargs='?',

            
                                  type=argparse.FileType('wb'),

            
                                  const=to_bytes_io(sys.stdout))

            
              parser.add_argument('--output-release',

            
                                  help='If specified, write kernel release. Use stdout if '

            
                                       'no file is specified.',

            
                                  metavar='FILE',

            
                                  nargs='?',

            
                                  type=argparse.FileType('wb'),

            
                                  const=to_bytes_io(sys.stdout))

            
              parser.add_argument('--output-compiler',

            
                                  help='If specified, write the compiler information. Use stdout if no file '

            
                                       'is specified.',

            
                                  metavar='FILE',

            
                                  nargs='?',

            
                                  type=argparse.FileType('wb'),

            
                                  const=to_bytes_io(sys.stdout))

            
              parser.add_argument('--tools',

            
                                  help='Decompression tools to use. If not specified, PATH '

            
                                       'is searched.',

            
                                  metavar='ALGORITHM:EXECUTABLE',

            
                                  nargs='*')

            
              args = parser.parse_args()


              tools = {pair[0]: pair[1]

            
                       for pair in (token.split(':') for token in args.tools or [])}

            
              for cmd, _ in COMPRESSION_ALGO:

            
                if cmd[0] in tools:

            
                  cmd[0] = tools[cmd[0]]


              input_bytes = args.input.read()


              ret = 0

            
              if not dump_to_file(args.output_configs, dump_configs, input_bytes,

            
                                  "configs in {}".format(args.input.name)):

            
                ret = 1

            
              if not dump_to_file(args.output_version, dump_version, input_bytes,

            
                                  "version in {}".format(args.input.name)):

            
                ret = 1

            
              if not dump_to_file(args.output_release, dump_release, input_bytes,

            
                                  "kernel release in {}".format(args.input.name)):

            
                ret = 1


              if not dump_to_file(args.output_compiler, dump_compiler, input_bytes,

            
                                  "kernel compiler in {}".format(args.input.name)):

            
                ret = 1


              return ret


            if __name__ == '__main__':

            
              sys.exit(main())
	#!/usr/bin/env python
	#
	# Copyright (C) 2018 The Android Open Source Project
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.

	"""
	A tool to extract kernel information from a kernel image.
	"""

	import argparse
	import subprocess
	import sys
	import re

	CONFIG_PREFIX = b'IKCFG_ST'
	GZIP_HEADER = b'\037\213\010'
	COMPRESSION_ALGO = (
	(["gzip", "-d"], GZIP_HEADER),
	(["xz", "-d"], b'\3757zXZ\000'),
	(["bzip2", "-d"], b'BZh'),
	(["lz4", "-d", "-l"], b'\002\041\114\030'),

	# These are not supported in the build system yet.
	# (["unlzma"], b'\135\0\0\0'),
	# (["lzop", "-d"], b'\211\114\132'),
	)

	# "Linux version " UTS_RELEASE " (" LINUX_COMPILE_BY "@"
	# LINUX_COMPILE_HOST ") (" LINUX_COMPILER ") " UTS_VERSION "\n";
	LINUX_BANNER_PREFIX = b'Linux version '
	LINUX_BANNER_REGEX = LINUX_BANNER_PREFIX.decode() + \
	r'(?P<release>(?P<version>[0-9]+[.][0-9]+[.][0-9]+).) \(.@.\) \((?P<compiler>.)\) .*\n'


	def get_from_release(input_bytes, start_idx, key):
	null_idx = input_bytes.find(b'\x00', start_idx)
	if null_idx < 0:
	return None
	try:
	linux_banner = input_bytes[start_idx:null_idx].decode()
	except UnicodeDecodeError:
	return None
	mo = re.match(LINUX_BANNER_REGEX, linux_banner)
	if mo:
	return mo.group(key)
	return None


	def dump_from_release(input_bytes, key):
	"""
	Helper of dump_version and dump_release
	"""
	idx = 0
	while True:
	idx = input_bytes.find(LINUX_BANNER_PREFIX, idx)
	if idx < 0:
	return None

	value = get_from_release(input_bytes, idx, key)
	if value:
	return value.encode()

	idx += len(LINUX_BANNER_PREFIX)


	def dump_version(input_bytes):
	"""
	Dump kernel version, w.x.y, from input_bytes. Search for the string
	"Linux version " and do pattern matching after it. See LINUX_BANNER_REGEX.
	"""
	return dump_from_release(input_bytes, "version")


	def dump_compiler(input_bytes):
	"""
	Dump kernel version, w.x.y, from input_bytes. Search for the string
	"Linux version " and do pattern matching after it. See LINUX_BANNER_REGEX.
	"""
	return dump_from_release(input_bytes, "compiler")


	def dump_release(input_bytes):
	"""
	Dump kernel release, w.x.y-..., from input_bytes. Search for the string
	"Linux version " and do pattern matching after it. See LINUX_BANNER_REGEX.
	"""
	return dump_from_release(input_bytes, "release")


	def dump_configs(input_bytes):
	"""
	Dump kernel configuration from input_bytes. This can be done when
	CONFIG_IKCONFIG is enabled, which is a requirement on Treble devices.

	The kernel configuration is archived in GZip format right after the magic
	string 'IKCFG_ST' in the built kernel.
	"""

	# Search for magic string + GZip header
	idx = input_bytes.find(CONFIG_PREFIX + GZIP_HEADER)
	if idx < 0:
	return None

	# Seek to the start of the archive
	idx += len(CONFIG_PREFIX)

	sp = subprocess.Popen(["gzip", "-d", "-c"], stdin=subprocess.PIPE,
	stdout=subprocess.PIPE, stderr=subprocess.PIPE)
	o, _ = sp.communicate(input=input_bytes[idx:])
	if sp.returncode == 1: # error
	return None

	# success or trailing garbage warning
	assert sp.returncode in (0, 2), sp.returncode

	return o


	def try_decompress_bytes(cmd, input_bytes):
	sp = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
	stderr=subprocess.PIPE)
	o, _ = sp.communicate(input=input_bytes)
	# ignore errors
	return o


	def try_decompress(cmd, search_bytes, input_bytes):
	idx = 0
	while True:
	idx = input_bytes.find(search_bytes, idx)
	if idx < 0:
	return

	yield try_decompress_bytes(cmd, input_bytes[idx:])
	idx += 1


	def decompress_dump(func, input_bytes):
	"""
	Run func(input_bytes) first; and if that fails (returns value evaluates to
	False), then try different decompression algorithm before running func.
	"""
	o = func(input_bytes)
	if o:
	return o
	for cmd, search_bytes in COMPRESSION_ALGO:
	for decompressed in try_decompress(cmd, search_bytes, input_bytes):
	if decompressed:
	o = decompress_dump(func, decompressed)
	if o:
	return o
	# Force decompress the whole file even if header doesn't match
	decompressed = try_decompress_bytes(cmd, input_bytes)
	if decompressed:
	o = decompress_dump(func, decompressed)
	if o:
	return o


	def dump_to_file(f, dump_fn, input_bytes, desc):
	"""
	Call decompress_dump(dump_fn, input_bytes) and write to f. If it fails, return
	False; otherwise return True.
	"""
	if f is not None:
	o = decompress_dump(dump_fn, input_bytes)
	if o:
	f.write(o)
	else:
	sys.stderr.write(
	"Cannot extract kernel {}".format(desc))
	return False
	return True

	def to_bytes_io(b):
	"""
	Make b, which is either sys.stdout or sys.stdin, receive bytes as arguments.
	"""
	return b.buffer if sys.version_info.major == 3 else b

	def main():
	parser = argparse.ArgumentParser(
	formatter_class=argparse.RawTextHelpFormatter,
	description=__doc__ +
	"\nThese algorithms are tried when decompressing the image:\n " +
	" ".join(tup[0][0] for tup in COMPRESSION_ALGO))
	parser.add_argument('--input',
	help='Input kernel image. If not specified, use stdin',
	metavar='FILE',
	type=argparse.FileType('rb'),
	default=to_bytes_io(sys.stdin))
	parser.add_argument('--output-configs',
	help='If specified, write configs. Use stdout if no file '
	'is specified.',
	metavar='FILE',
	nargs='?',
	type=argparse.FileType('wb'),
	const=to_bytes_io(sys.stdout))
	parser.add_argument('--output-version',
	help='If specified, write version. Use stdout if no file '
	'is specified.',
	metavar='FILE',
	nargs='?',
	type=argparse.FileType('wb'),
	const=to_bytes_io(sys.stdout))
	parser.add_argument('--output-release',
	help='If specified, write kernel release. Use stdout if '
	'no file is specified.',
	metavar='FILE',
	nargs='?',
	type=argparse.FileType('wb'),
	const=to_bytes_io(sys.stdout))
	parser.add_argument('--output-compiler',
	help='If specified, write the compiler information. Use stdout if no file '
	'is specified.',
	metavar='FILE',
	nargs='?',
	type=argparse.FileType('wb'),
	const=to_bytes_io(sys.stdout))
	parser.add_argument('--tools',
	help='Decompression tools to use. If not specified, PATH '
	'is searched.',
	metavar='ALGORITHM:EXECUTABLE',
	nargs='*')
	args = parser.parse_args()

	tools = {pair[0]: pair[1]
	for pair in (token.split(':') for token in args.tools or [])}
	for cmd, _ in COMPRESSION_ALGO:
	if cmd[0] in tools:
	cmd[0] = tools[cmd[0]]

	input_bytes = args.input.read()

	ret = 0
	if not dump_to_file(args.output_configs, dump_configs, input_bytes,
	"configs in {}".format(args.input.name)):
	ret = 1
	if not dump_to_file(args.output_version, dump_version, input_bytes,
	"version in {}".format(args.input.name)):
	ret = 1
	if not dump_to_file(args.output_release, dump_release, input_bytes,
	"kernel release in {}".format(args.input.name)):
	ret = 1

	if not dump_to_file(args.output_compiler, dump_compiler, input_bytes,
	"kernel compiler in {}".format(args.input.name)):
	ret = 1

	return ret


	if __name__ == '__main__':
	sys.exit(main())