Bump buidlroot version to 2018.02.6
This commit is contained in:
jbnadal
97
bsp/buildroot/support/testing/infra/__init__.py
Normal file
97
bsp/buildroot/support/testing/infra/__init__.py
Normal file
@@ -0,0 +1,97 @@
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import tempfile
|
||||
import subprocess
|
||||
from urllib2 import urlopen, HTTPError, URLError
|
||||
|
||||
ARTIFACTS_URL = "http://autobuild.buildroot.net/artefacts/"
|
||||
|
||||
|
||||
def open_log_file(builddir, stage, logtofile=True):
|
||||
"""
|
||||
Open a file for logging and return its handler.
|
||||
If logtofile is True, returns sys.stdout. Otherwise opens a file
|
||||
with a suitable name in the build directory.
|
||||
"""
|
||||
if logtofile:
|
||||
fhandle = open("{}-{}.log".format(builddir, stage), 'a+')
|
||||
else:
|
||||
fhandle = sys.stdout
|
||||
return fhandle
|
||||
|
||||
|
||||
def filepath(relpath):
|
||||
return os.path.join(os.getcwd(), "support/testing", relpath)
|
||||
|
||||
|
||||
def download(dldir, filename):
|
||||
finalpath = os.path.join(dldir, filename)
|
||||
if os.path.exists(finalpath):
|
||||
return finalpath
|
||||
|
||||
if not os.path.exists(dldir):
|
||||
os.makedirs(dldir)
|
||||
|
||||
tmpfile = tempfile.mktemp(dir=dldir)
|
||||
print "Downloading to {}".format(tmpfile)
|
||||
|
||||
try:
|
||||
url_fh = urlopen(os.path.join(ARTIFACTS_URL, filename))
|
||||
with open(tmpfile, "w+") as tmpfile_fh:
|
||||
tmpfile_fh.write(url_fh.read())
|
||||
except (HTTPError, URLError), err:
|
||||
os.unlink(tmpfile)
|
||||
raise err
|
||||
|
||||
print "Renaming from %s to %s" % (tmpfile, finalpath)
|
||||
os.rename(tmpfile, finalpath)
|
||||
return finalpath
|
||||
|
||||
|
||||
def get_elf_arch_tag(builddir, prefix, fpath, tag):
|
||||
"""
|
||||
Runs the cross readelf on 'fpath', then extracts the value of tag 'tag'.
|
||||
Example:
|
||||
>>> get_elf_arch_tag('output', 'arm-none-linux-gnueabi-',
|
||||
'bin/busybox', 'Tag_CPU_arch')
|
||||
v5TEJ
|
||||
>>>
|
||||
"""
|
||||
cmd = ["host/bin/{}-readelf".format(prefix),
|
||||
"-A", os.path.join("target", fpath)]
|
||||
out = subprocess.check_output(cmd, cwd=builddir, env={"LANG": "C"})
|
||||
regexp = re.compile("^ {}: (.*)$".format(tag))
|
||||
for line in out.splitlines():
|
||||
m = regexp.match(line)
|
||||
if not m:
|
||||
continue
|
||||
return m.group(1)
|
||||
return None
|
||||
|
||||
|
||||
def get_file_arch(builddir, prefix, fpath):
|
||||
return get_elf_arch_tag(builddir, prefix, fpath, "Tag_CPU_arch")
|
||||
|
||||
|
||||
def get_elf_prog_interpreter(builddir, prefix, fpath):
|
||||
"""
|
||||
Runs the cross readelf on 'fpath' to extract the program interpreter
|
||||
name and returns it.
|
||||
Example:
|
||||
>>> get_elf_prog_interpreter('br-tests/TestExternalToolchainLinaroArm',
|
||||
'arm-linux-gnueabihf',
|
||||
'bin/busybox')
|
||||
/lib/ld-linux-armhf.so.3
|
||||
>>>
|
||||
"""
|
||||
cmd = ["host/bin/{}-readelf".format(prefix),
|
||||
"-l", os.path.join("target", fpath)]
|
||||
out = subprocess.check_output(cmd, cwd=builddir, env={"LANG": "C"})
|
||||
regexp = re.compile("^ *\[Requesting program interpreter: (.*)\]$")
|
||||
for line in out.splitlines():
|
||||
m = regexp.match(line)
|
||||
if not m:
|
||||
continue
|
||||
return m.group(1)
|
||||
return None
|
||||
71
bsp/buildroot/support/testing/infra/basetest.py
Normal file
71
bsp/buildroot/support/testing/infra/basetest.py
Normal file
@@ -0,0 +1,71 @@
|
||||
import unittest
|
||||
import os
|
||||
import datetime
|
||||
|
||||
from infra.builder import Builder
|
||||
from infra.emulator import Emulator
|
||||
|
||||
BASIC_TOOLCHAIN_CONFIG = \
|
||||
"""
|
||||
BR2_arm=y
|
||||
BR2_TOOLCHAIN_EXTERNAL=y
|
||||
BR2_TOOLCHAIN_EXTERNAL_CUSTOM=y
|
||||
BR2_TOOLCHAIN_EXTERNAL_DOWNLOAD=y
|
||||
BR2_TOOLCHAIN_EXTERNAL_URL="http://autobuild.buildroot.org/toolchains/tarballs/br-arm-full-2017.05-1078-g95b1dae.tar.bz2"
|
||||
BR2_TOOLCHAIN_EXTERNAL_GCC_4_9=y
|
||||
BR2_TOOLCHAIN_EXTERNAL_HEADERS_3_10=y
|
||||
BR2_TOOLCHAIN_EXTERNAL_LOCALE=y
|
||||
# BR2_TOOLCHAIN_EXTERNAL_HAS_THREADS_DEBUG is not set
|
||||
BR2_TOOLCHAIN_EXTERNAL_CXX=y
|
||||
"""
|
||||
|
||||
MINIMAL_CONFIG = \
|
||||
"""
|
||||
BR2_INIT_NONE=y
|
||||
BR2_SYSTEM_BIN_SH_NONE=y
|
||||
# BR2_PACKAGE_BUSYBOX is not set
|
||||
# BR2_TARGET_ROOTFS_TAR is not set
|
||||
"""
|
||||
|
||||
|
||||
class BRTest(unittest.TestCase):
|
||||
config = None
|
||||
downloaddir = None
|
||||
outputdir = None
|
||||
logtofile = True
|
||||
keepbuilds = False
|
||||
jlevel = 0
|
||||
timeout_multiplier = 1
|
||||
|
||||
def __init__(self, names):
|
||||
super(BRTest, self).__init__(names)
|
||||
self.testname = self.__class__.__name__
|
||||
self.builddir = self.outputdir and os.path.join(self.outputdir, self.testname)
|
||||
self.emulator = None
|
||||
self.config += "\nBR2_JLEVEL={}\n".format(self.jlevel)
|
||||
|
||||
def show_msg(self, msg):
|
||||
print "{} {:40s} {}".format(datetime.datetime.now().strftime("%H:%M:%S"),
|
||||
self.testname, msg)
|
||||
|
||||
def setUp(self):
|
||||
self.show_msg("Starting")
|
||||
self.b = Builder(self.config, self.builddir, self.logtofile)
|
||||
|
||||
if not self.keepbuilds:
|
||||
self.b.delete()
|
||||
|
||||
if not self.b.is_finished():
|
||||
self.show_msg("Building")
|
||||
self.b.build()
|
||||
self.show_msg("Building done")
|
||||
|
||||
self.emulator = Emulator(self.builddir, self.downloaddir,
|
||||
self.logtofile, self.timeout_multiplier)
|
||||
|
||||
def tearDown(self):
|
||||
self.show_msg("Cleaning up")
|
||||
if self.emulator:
|
||||
self.emulator.stop()
|
||||
if self.b and not self.keepbuilds:
|
||||
self.b.delete()
|
||||
49
bsp/buildroot/support/testing/infra/builder.py
Normal file
49
bsp/buildroot/support/testing/infra/builder.py
Normal file
@@ -0,0 +1,49 @@
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
|
||||
import infra
|
||||
|
||||
|
||||
class Builder(object):
|
||||
def __init__(self, config, builddir, logtofile):
|
||||
self.config = '\n'.join([line.lstrip() for line in
|
||||
config.splitlines()]) + '\n'
|
||||
self.builddir = builddir
|
||||
self.logfile = infra.open_log_file(builddir, "build", logtofile)
|
||||
|
||||
def build(self):
|
||||
if not os.path.isdir(self.builddir):
|
||||
os.makedirs(self.builddir)
|
||||
|
||||
config_file = os.path.join(self.builddir, ".config")
|
||||
with open(config_file, "w+") as cf:
|
||||
cf.write(self.config)
|
||||
# dump the defconfig to the logfile for easy debugging
|
||||
self.logfile.write("> start defconfig\n" + self.config +
|
||||
"> end defconfig\n")
|
||||
self.logfile.flush()
|
||||
|
||||
cmd = ["make",
|
||||
"O={}".format(self.builddir),
|
||||
"olddefconfig"]
|
||||
ret = subprocess.call(cmd, stdout=self.logfile, stderr=self.logfile)
|
||||
if ret != 0:
|
||||
raise SystemError("Cannot olddefconfig")
|
||||
|
||||
cmd = ["make", "-C", self.builddir]
|
||||
ret = subprocess.call(cmd, stdout=self.logfile, stderr=self.logfile)
|
||||
if ret != 0:
|
||||
raise SystemError("Build failed")
|
||||
|
||||
open(self.stamp_path(), 'a').close()
|
||||
|
||||
def stamp_path(self):
|
||||
return os.path.join(self.builddir, "build-done")
|
||||
|
||||
def is_finished(self):
|
||||
return os.path.exists(self.stamp_path())
|
||||
|
||||
def delete(self):
|
||||
if os.path.exists(self.builddir):
|
||||
shutil.rmtree(self.builddir)
|
||||
119
bsp/buildroot/support/testing/infra/emulator.py
Normal file
119
bsp/buildroot/support/testing/infra/emulator.py
Normal file
@@ -0,0 +1,119 @@
|
||||
import pexpect
|
||||
|
||||
import infra
|
||||
|
||||
|
||||
class Emulator(object):
|
||||
|
||||
def __init__(self, builddir, downloaddir, logtofile, timeout_multiplier):
|
||||
self.qemu = None
|
||||
self.downloaddir = downloaddir
|
||||
self.logfile = infra.open_log_file(builddir, "run", logtofile)
|
||||
# We use elastic runners on the cloud to runs our tests. Those runners
|
||||
# can take a long time to run the emulator. Use a timeout multiplier
|
||||
# when running the tests to avoid sporadic failures.
|
||||
self.timeout_multiplier = timeout_multiplier
|
||||
|
||||
# Start Qemu to boot the system
|
||||
#
|
||||
# arch: Qemu architecture to use
|
||||
#
|
||||
# kernel: path to the kernel image, or the special string
|
||||
# 'builtin'. 'builtin' means a pre-built kernel image will be
|
||||
# downloaded from ARTEFACTS_URL and suitable options are
|
||||
# automatically passed to qemu and added to the kernel cmdline. So
|
||||
# far only armv5, armv7 and i386 builtin kernels are available.
|
||||
# If None, then no kernel is used, and we assume a bootable device
|
||||
# will be specified.
|
||||
#
|
||||
# kernel_cmdline: array of kernel arguments to pass to Qemu -append option
|
||||
#
|
||||
# options: array of command line options to pass to Qemu
|
||||
#
|
||||
def boot(self, arch, kernel=None, kernel_cmdline=None, options=None):
|
||||
if arch in ["armv7", "armv5"]:
|
||||
qemu_arch = "arm"
|
||||
else:
|
||||
qemu_arch = arch
|
||||
|
||||
qemu_cmd = ["qemu-system-{}".format(qemu_arch),
|
||||
"-serial", "stdio",
|
||||
"-display", "none"]
|
||||
|
||||
if options:
|
||||
qemu_cmd += options
|
||||
|
||||
if kernel_cmdline is None:
|
||||
kernel_cmdline = []
|
||||
|
||||
if kernel:
|
||||
if kernel == "builtin":
|
||||
if arch in ["armv7", "armv5"]:
|
||||
kernel_cmdline.append("console=ttyAMA0")
|
||||
|
||||
if arch == "armv7":
|
||||
kernel = infra.download(self.downloaddir,
|
||||
"kernel-vexpress")
|
||||
dtb = infra.download(self.downloaddir,
|
||||
"vexpress-v2p-ca9.dtb")
|
||||
qemu_cmd += ["-dtb", dtb]
|
||||
qemu_cmd += ["-M", "vexpress-a9"]
|
||||
elif arch == "armv5":
|
||||
kernel = infra.download(self.downloaddir,
|
||||
"kernel-versatile")
|
||||
qemu_cmd += ["-M", "versatilepb"]
|
||||
|
||||
qemu_cmd += ["-kernel", kernel]
|
||||
|
||||
if kernel_cmdline:
|
||||
qemu_cmd += ["-append", " ".join(kernel_cmdline)]
|
||||
|
||||
self.logfile.write("> starting qemu with '%s'\n" % " ".join(qemu_cmd))
|
||||
self.qemu = pexpect.spawn(qemu_cmd[0], qemu_cmd[1:],
|
||||
timeout=5 * self.timeout_multiplier,
|
||||
env={"QEMU_AUDIO_DRV": "none"})
|
||||
# We want only stdout into the log to avoid double echo
|
||||
self.qemu.logfile_read = self.logfile
|
||||
|
||||
# Wait for the login prompt to appear, and then login as root with
|
||||
# the provided password, or no password if not specified.
|
||||
def login(self, password=None):
|
||||
# The login prompt can take some time to appear when running multiple
|
||||
# instances in parallel, so set the timeout to a large value
|
||||
index = self.qemu.expect(["buildroot login:", pexpect.TIMEOUT],
|
||||
timeout=60 * self.timeout_multiplier)
|
||||
if index != 0:
|
||||
self.logfile.write("==> System does not boot")
|
||||
raise SystemError("System does not boot")
|
||||
|
||||
self.qemu.sendline("root")
|
||||
if password:
|
||||
self.qemu.expect("Password:")
|
||||
self.qemu.sendline(password)
|
||||
index = self.qemu.expect(["# ", pexpect.TIMEOUT])
|
||||
if index != 0:
|
||||
raise SystemError("Cannot login")
|
||||
self.run("dmesg -n 1")
|
||||
|
||||
# Run the given 'cmd' with a 'timeout' on the target
|
||||
# return a tuple (output, exit_code)
|
||||
def run(self, cmd, timeout=-1):
|
||||
self.qemu.sendline(cmd)
|
||||
if timeout != -1:
|
||||
timeout *= self.timeout_multiplier
|
||||
self.qemu.expect("# ", timeout=timeout)
|
||||
# Remove double carriage return from qemu stdout so str.splitlines()
|
||||
# works as expected.
|
||||
output = self.qemu.before.replace("\r\r", "\r").splitlines()[1:]
|
||||
|
||||
self.qemu.sendline("echo $?")
|
||||
self.qemu.expect("# ")
|
||||
exit_code = self.qemu.before.splitlines()[2]
|
||||
exit_code = int(exit_code)
|
||||
|
||||
return output, exit_code
|
||||
|
||||
def stop(self):
|
||||
if self.qemu is None:
|
||||
return
|
||||
self.qemu.terminate(force=True)
|
||||
Reference in New Issue
Block a user