mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-12-25 07:55:32 +00:00
435 lines
17 KiB
Python
Executable file
435 lines
17 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
"""
|
|
This file is part of Mbed TLS (https://tls.mbed.org)
|
|
|
|
Copyright (c) 2018, Arm Limited, All Rights Reserved
|
|
|
|
Purpose
|
|
|
|
This script is a small wrapper around the abi-compliance-checker and
|
|
abi-dumper tools, applying them to compare the ABI and API of the library
|
|
files from two different Git revisions within an Mbed TLS repository.
|
|
The results of the comparison are either formatted as HTML and stored at
|
|
a configurable location, or are given as a brief list of problems.
|
|
Returns 0 on success, 1 on ABI/API non-compliance, and 2 if there is an error
|
|
while running the script. Note: must be run from Mbed TLS root.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import traceback
|
|
import shutil
|
|
import subprocess
|
|
import argparse
|
|
import logging
|
|
import tempfile
|
|
import fnmatch
|
|
from types import SimpleNamespace
|
|
|
|
import xml.etree.ElementTree as ET
|
|
|
|
|
|
class AbiChecker(object):
|
|
"""API and ABI checker."""
|
|
|
|
def __init__(self, old_version, new_version, configuration):
|
|
"""Instantiate the API/ABI checker.
|
|
|
|
old_version: RepoVersion containing details to compare against
|
|
new_version: RepoVersion containing details to check
|
|
report_dir: directory for output files
|
|
keep_all_reports: if false, delete old reports
|
|
brief: if true, output shorter report to stdout
|
|
skip_file: path to file containing symbols and types to skip
|
|
"""
|
|
self.repo_path = "."
|
|
self.log = None
|
|
self.verbose = configuration.verbose
|
|
self._setup_logger()
|
|
self.report_dir = os.path.abspath(configuration.report_dir)
|
|
self.keep_all_reports = configuration.keep_all_reports
|
|
self.can_remove_report_dir = not (os.path.isdir(self.report_dir) or
|
|
self.keep_all_reports)
|
|
self.old_version = old_version
|
|
self.new_version = new_version
|
|
self.skip_file = configuration.skip_file
|
|
self.brief = configuration.brief
|
|
self.git_command = "git"
|
|
self.make_command = "make"
|
|
|
|
@staticmethod
|
|
def check_repo_path():
|
|
current_dir = os.path.realpath('.')
|
|
root_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
|
|
if current_dir != root_dir:
|
|
raise Exception("Must be run from Mbed TLS root")
|
|
|
|
def _setup_logger(self):
|
|
self.log = logging.getLogger()
|
|
if self.verbose:
|
|
self.log.setLevel(logging.DEBUG)
|
|
else:
|
|
self.log.setLevel(logging.INFO)
|
|
self.log.addHandler(logging.StreamHandler())
|
|
|
|
@staticmethod
|
|
def check_abi_tools_are_installed():
|
|
for command in ["abi-dumper", "abi-compliance-checker"]:
|
|
if not shutil.which(command):
|
|
raise Exception("{} not installed, aborting".format(command))
|
|
|
|
def _get_clean_worktree_for_git_revision(self, version):
|
|
"""Make a separate worktree with version.revision checked out.
|
|
Do not modify the current worktree."""
|
|
git_worktree_path = tempfile.mkdtemp()
|
|
if version.repository:
|
|
self.log.debug(
|
|
"Checking out git worktree for revision {} from {}".format(
|
|
version.revision, version.repository
|
|
)
|
|
)
|
|
fetch_process = subprocess.Popen(
|
|
[self.git_command, "fetch",
|
|
version.repository, version.revision],
|
|
cwd=self.repo_path,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
fetch_output, _ = fetch_process.communicate()
|
|
self.log.debug(fetch_output.decode("utf-8"))
|
|
if fetch_process.returncode != 0:
|
|
raise Exception("Fetching revision failed, aborting")
|
|
worktree_rev = "FETCH_HEAD"
|
|
else:
|
|
self.log.debug("Checking out git worktree for revision {}".format(
|
|
version.revision
|
|
))
|
|
worktree_rev = version.revision
|
|
worktree_process = subprocess.Popen(
|
|
[self.git_command, "worktree", "add", "--detach",
|
|
git_worktree_path, worktree_rev],
|
|
cwd=self.repo_path,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
worktree_output, _ = worktree_process.communicate()
|
|
self.log.debug(worktree_output.decode("utf-8"))
|
|
if worktree_process.returncode != 0:
|
|
raise Exception("Checking out worktree failed, aborting")
|
|
return git_worktree_path
|
|
|
|
def _update_git_submodules(self, git_worktree_path, version):
|
|
"""If the crypto submodule is present, initialize it.
|
|
if version.crypto_revision exists, update it to that revision,
|
|
otherwise update it to the default revision"""
|
|
process = subprocess.Popen(
|
|
[self.git_command, "submodule", "update", "--init", '--recursive'],
|
|
cwd=git_worktree_path,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
output, _ = process.communicate()
|
|
self.log.debug(output.decode("utf-8"))
|
|
if process.returncode != 0:
|
|
raise Exception("git submodule update failed, aborting")
|
|
if not (os.path.exists(os.path.join(git_worktree_path, "crypto"))
|
|
and version.crypto_revision):
|
|
return
|
|
|
|
if version.crypto_repository:
|
|
fetch_process = subprocess.Popen(
|
|
[self.git_command, "fetch", version.crypto_repository,
|
|
version.crypto_revision],
|
|
cwd=os.path.join(git_worktree_path, "crypto"),
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
fetch_output, _ = fetch_process.communicate()
|
|
self.log.debug(fetch_output.decode("utf-8"))
|
|
if fetch_process.returncode != 0:
|
|
raise Exception("git fetch failed, aborting")
|
|
crypto_rev = "FETCH_HEAD"
|
|
else:
|
|
crypto_rev = version.crypto_revision
|
|
|
|
checkout_process = subprocess.Popen(
|
|
[self.git_command, "checkout", crypto_rev],
|
|
cwd=os.path.join(git_worktree_path, "crypto"),
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
checkout_output, _ = checkout_process.communicate()
|
|
self.log.debug(checkout_output.decode("utf-8"))
|
|
if checkout_process.returncode != 0:
|
|
raise Exception("git checkout failed, aborting")
|
|
|
|
def _build_shared_libraries(self, git_worktree_path, version):
|
|
"""Build the shared libraries in the specified worktree."""
|
|
my_environment = os.environ.copy()
|
|
my_environment["CFLAGS"] = "-g -Og"
|
|
my_environment["SHARED"] = "1"
|
|
my_environment["USE_CRYPTO_SUBMODULE"] = "1"
|
|
make_process = subprocess.Popen(
|
|
[self.make_command, "lib"],
|
|
env=my_environment,
|
|
cwd=git_worktree_path,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
make_output, _ = make_process.communicate()
|
|
self.log.debug(make_output.decode("utf-8"))
|
|
for root, dirs, files in os.walk(git_worktree_path): # pylint: disable=unused-variable
|
|
for file in fnmatch.filter(files, "*.so"):
|
|
version.modules[os.path.splitext(file)[0]] = (
|
|
os.path.join(root, file)
|
|
)
|
|
if make_process.returncode != 0:
|
|
raise Exception("make failed, aborting")
|
|
|
|
def _get_abi_dumps_from_shared_libraries(self, version):
|
|
"""Generate the ABI dumps for the specified git revision.
|
|
The shared libraries must have been built and the module paths
|
|
present in version.modules."""
|
|
for mbed_module, module_path in version.modules.items():
|
|
output_path = os.path.join(
|
|
self.report_dir, "{}-{}-{}.dump".format(
|
|
mbed_module, version.revision, version.version
|
|
)
|
|
)
|
|
abi_dump_command = [
|
|
"abi-dumper",
|
|
module_path,
|
|
"-o", output_path,
|
|
"-lver", version.revision
|
|
]
|
|
abi_dump_process = subprocess.Popen(
|
|
abi_dump_command,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
abi_dump_output, _ = abi_dump_process.communicate()
|
|
self.log.debug(abi_dump_output.decode("utf-8"))
|
|
if abi_dump_process.returncode != 0:
|
|
raise Exception("abi-dumper failed, aborting")
|
|
version.abi_dumps[mbed_module] = output_path
|
|
|
|
def _cleanup_worktree(self, git_worktree_path):
|
|
"""Remove the specified git worktree."""
|
|
shutil.rmtree(git_worktree_path)
|
|
worktree_process = subprocess.Popen(
|
|
[self.git_command, "worktree", "prune"],
|
|
cwd=self.repo_path,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
worktree_output, _ = worktree_process.communicate()
|
|
self.log.debug(worktree_output.decode("utf-8"))
|
|
if worktree_process.returncode != 0:
|
|
raise Exception("Worktree cleanup failed, aborting")
|
|
|
|
def _get_abi_dump_for_ref(self, version):
|
|
"""Generate the ABI dumps for the specified git revision."""
|
|
git_worktree_path = self._get_clean_worktree_for_git_revision(version)
|
|
self._update_git_submodules(git_worktree_path, version)
|
|
self._build_shared_libraries(git_worktree_path, version)
|
|
self._get_abi_dumps_from_shared_libraries(version)
|
|
self._cleanup_worktree(git_worktree_path)
|
|
|
|
def _remove_children_with_tag(self, parent, tag):
|
|
children = parent.getchildren()
|
|
for child in children:
|
|
if child.tag == tag:
|
|
parent.remove(child)
|
|
else:
|
|
self._remove_children_with_tag(child, tag)
|
|
|
|
def _remove_extra_detail_from_report(self, report_root):
|
|
for tag in ['test_info', 'test_results', 'problem_summary',
|
|
'added_symbols', 'removed_symbols', 'affected']:
|
|
self._remove_children_with_tag(report_root, tag)
|
|
|
|
for report in report_root:
|
|
for problems in report.getchildren()[:]:
|
|
if not problems.getchildren():
|
|
report.remove(problems)
|
|
|
|
def get_abi_compatibility_report(self):
|
|
"""Generate a report of the differences between the reference ABI
|
|
and the new ABI. ABI dumps from self.old_version and self.new_version
|
|
must be available."""
|
|
compatibility_report = ""
|
|
compliance_return_code = 0
|
|
shared_modules = list(set(self.old_version.modules.keys()) &
|
|
set(self.new_version.modules.keys()))
|
|
for mbed_module in shared_modules:
|
|
output_path = os.path.join(
|
|
self.report_dir, "{}-{}-{}.html".format(
|
|
mbed_module, self.old_version.revision,
|
|
self.new_version.revision
|
|
)
|
|
)
|
|
abi_compliance_command = [
|
|
"abi-compliance-checker",
|
|
"-l", mbed_module,
|
|
"-old", self.old_version.abi_dumps[mbed_module],
|
|
"-new", self.new_version.abi_dumps[mbed_module],
|
|
"-strict",
|
|
"-report-path", output_path,
|
|
]
|
|
if self.skip_file:
|
|
abi_compliance_command += ["-skip-symbols", self.skip_file,
|
|
"-skip-types", self.skip_file]
|
|
if self.brief:
|
|
abi_compliance_command += ["-report-format", "xml",
|
|
"-stdout"]
|
|
abi_compliance_process = subprocess.Popen(
|
|
abi_compliance_command,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT
|
|
)
|
|
abi_compliance_output, _ = abi_compliance_process.communicate()
|
|
if abi_compliance_process.returncode == 0:
|
|
compatibility_report += (
|
|
"No compatibility issues for {}\n".format(mbed_module)
|
|
)
|
|
if not (self.keep_all_reports or self.brief):
|
|
os.remove(output_path)
|
|
elif abi_compliance_process.returncode == 1:
|
|
if self.brief:
|
|
self.log.info(
|
|
"Compatibility issues found for {}".format(mbed_module)
|
|
)
|
|
report_root = ET.fromstring(abi_compliance_output.decode("utf-8"))
|
|
self._remove_extra_detail_from_report(report_root)
|
|
self.log.info(ET.tostring(report_root).decode("utf-8"))
|
|
else:
|
|
compliance_return_code = 1
|
|
self.can_remove_report_dir = False
|
|
compatibility_report += (
|
|
"Compatibility issues found for {}, "
|
|
"for details see {}\n".format(mbed_module, output_path)
|
|
)
|
|
else:
|
|
raise Exception(
|
|
"abi-compliance-checker failed with a return code of {},"
|
|
" aborting".format(abi_compliance_process.returncode)
|
|
)
|
|
os.remove(self.old_version.abi_dumps[mbed_module])
|
|
os.remove(self.new_version.abi_dumps[mbed_module])
|
|
if self.can_remove_report_dir:
|
|
os.rmdir(self.report_dir)
|
|
self.log.info(compatibility_report)
|
|
return compliance_return_code
|
|
|
|
def check_for_abi_changes(self):
|
|
"""Generate a report of ABI differences
|
|
between self.old_rev and self.new_rev."""
|
|
self.check_repo_path()
|
|
self.check_abi_tools_are_installed()
|
|
self._get_abi_dump_for_ref(self.old_version)
|
|
self._get_abi_dump_for_ref(self.new_version)
|
|
return self.get_abi_compatibility_report()
|
|
|
|
|
|
def run_main():
|
|
try:
|
|
parser = argparse.ArgumentParser(
|
|
description=(
|
|
"""This script is a small wrapper around the
|
|
abi-compliance-checker and abi-dumper tools, applying them
|
|
to compare the ABI and API of the library files from two
|
|
different Git revisions within an Mbed TLS repository.
|
|
The results of the comparison are either formatted as HTML and
|
|
stored at a configurable location, or are given as a brief list
|
|
of problems. Returns 0 on success, 1 on ABI/API non-compliance,
|
|
and 2 if there is an error while running the script.
|
|
Note: must be run from Mbed TLS root."""
|
|
)
|
|
)
|
|
parser.add_argument(
|
|
"-v", "--verbose", action="store_true",
|
|
help="set verbosity level",
|
|
)
|
|
parser.add_argument(
|
|
"-r", "--report-dir", type=str, default="reports",
|
|
help="directory where reports are stored, default is reports",
|
|
)
|
|
parser.add_argument(
|
|
"-k", "--keep-all-reports", action="store_true",
|
|
help="keep all reports, even if there are no compatibility issues",
|
|
)
|
|
parser.add_argument(
|
|
"-o", "--old-rev", type=str, help="revision for old version.",
|
|
required=True,
|
|
)
|
|
parser.add_argument(
|
|
"-or", "--old-repo", type=str, help="repository for old version."
|
|
)
|
|
parser.add_argument(
|
|
"-oc", "--old-crypto-rev", type=str,
|
|
help="revision for old crypto submodule."
|
|
)
|
|
parser.add_argument(
|
|
"-ocr", "--old-crypto-repo", type=str,
|
|
help="repository for old crypto submodule."
|
|
)
|
|
parser.add_argument(
|
|
"-n", "--new-rev", type=str, help="revision for new version",
|
|
required=True,
|
|
)
|
|
parser.add_argument(
|
|
"-nr", "--new-repo", type=str, help="repository for new version."
|
|
)
|
|
parser.add_argument(
|
|
"-nc", "--new-crypto-rev", type=str,
|
|
help="revision for new crypto version"
|
|
)
|
|
parser.add_argument(
|
|
"-ncr", "--new-crypto-repo", type=str,
|
|
help="repository for new crypto submodule."
|
|
)
|
|
parser.add_argument(
|
|
"-s", "--skip-file", type=str,
|
|
help="path to file containing symbols and types to skip"
|
|
)
|
|
parser.add_argument(
|
|
"-b", "--brief", action="store_true",
|
|
help="output only the list of issues to stdout, instead of a full report",
|
|
)
|
|
abi_args = parser.parse_args()
|
|
old_version = SimpleNamespace(
|
|
version="old",
|
|
repository=abi_args.old_repo,
|
|
revision=abi_args.old_rev,
|
|
crypto_repository=abi_args.old_crypto_repo,
|
|
crypto_revision=abi_args.old_crypto_rev,
|
|
abi_dumps={},
|
|
modules={}
|
|
)
|
|
new_version = SimpleNamespace(
|
|
version="new",
|
|
repository=abi_args.new_repo,
|
|
revision=abi_args.new_rev,
|
|
crypto_repository=abi_args.new_crypto_repo,
|
|
crypto_revision=abi_args.new_crypto_rev,
|
|
abi_dumps={},
|
|
modules={}
|
|
)
|
|
configuration = SimpleNamespace(
|
|
verbose=abi_args.verbose,
|
|
report_dir=abi_args.report_dir,
|
|
keep_all_reports=abi_args.keep_all_reports,
|
|
brief=abi_args.brief,
|
|
skip_file=abi_args.skip_file
|
|
)
|
|
abi_check = AbiChecker(old_version, new_version, configuration)
|
|
return_code = abi_check.check_for_abi_changes()
|
|
sys.exit(return_code)
|
|
except Exception:
|
|
traceback.print_exc()
|
|
sys.exit(2)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
run_main()
|