Version bump.

2025-09-23 20:31:54 +01:00 · 2015-11-13 08:26:36 +00:00
150 changed files with 1877 additions and 37389 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,3 @@
 *.orig
 .ropeproject
 *.egg-info
 devlib/bin/scripts/shutils
 doc/_build/
 build/
 dist/
--- a/.readthedocs.yml
+++ b/.readthedocs.yml
@@ -1,20 +0,0 @@
 # .readthedocs.yml
 # Read the Docs configuration file
 # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
 # Required
 version: 2
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
  builder: html
  configuration: doc/conf.py
 # Build the docs in additional formats such as PDF and ePub
 formats: all
 # Set the version of Python and requirements required to build your docs
 python:
   version: 3.7
   install:
     - requirements: doc/requirements.txt
--- a/201
+++ b/201
@@ -1,201 +0,0 @@
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
   Copyright 2024 Arm Ltd.
   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/README.rst
+++ b/README.rst
@@ -14,20 +14,10 @@ Installation
        sudo -H pip install devlib
 Dependencies
 ------------
 ``devlib`` should install all dependencies automatically, however if you run
 into issues please ensure you are using that latest version of pip.
 On some systems there may additional steps required to install the dependency
 ``paramiko`` please consult the `module documentation <http://www.paramiko.org/installing.html>`_
 for more information.
 Usage
 -----
-Please refer  to the "Overview" section of the `documentation <http://devlib.readthedocs.io/en/latest/>`_.
+Please refer  to the "Overview" section of the documentation.
 License
--- a/devlib/init.py
+++ b/devlib/init.py
@@ -1,83 +1,18 @@
-#    Copyright 2024 ARM Limited
+from devlib.target import Target, LinuxTarget, AndroidTarget, LocalLinuxTarget
-#
+from devlib.host import PACKAGE_BIN_DIRECTORY
-# Licensed under the Apache License, Version 2.0 (the "License");
+from devlib.exception import DevlibError, TargetError, HostError, TargetNotRespondingError
 # 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.
 #
 '''
 Initializations for devlib module
 '''
 from devlib.target import (
        Target, LinuxTarget, AndroidTarget, LocalLinuxTarget,
        ChromeOsTarget,
 )
 from devlib.host import (
        PACKAGE_BIN_DIRECTORY,
        LocalConnection,
 )
 from devlib.exception import (
        DevlibError, DevlibTransientError, DevlibStableError,
        TargetError, TargetTransientError, TargetStableError,
        TargetNotRespondingError, HostError,
 )
 from devlib.module import Module, HardRestModule, BootModule, FlashModule
 from devlib.module import get_module, register_module
 from devlib.platform import Platform
 from devlib.platform.arm import TC2, Juno, JunoEnergyInstrument
 from devlib.platform.gem5 import Gem5SimulationPlatform
 from devlib.instrument import Instrument, InstrumentChannel, Measurement, MeasurementsCsv
 from devlib.instrument import MEASUREMENT_TYPES, INSTANTANEOUS, CONTINUOUS
 from devlib.instrument.daq import DaqInstrument
 from devlib.instrument.energy_probe import EnergyProbeInstrument
 from devlib.instrument.arm_energy_probe import ArmEnergyProbeInstrument
 from devlib.instrument.frames import GfxInfoFramesInstrument, SurfaceFlingerFramesInstrument
 from devlib.instrument.hwmon import HwmonInstrument
 from devlib.instrument.monsoon import MonsoonInstrument
 from devlib.instrument.netstats import NetstatsInstrument
 from devlib.instrument.gem5power import Gem5PowerInstrument
 from devlib.instrument.baylibre_acme import (
        BaylibreAcmeNetworkInstrument,
        BaylibreAcmeXMLInstrument,
        BaylibreAcmeLocalInstrument,
        BaylibreAcmeInstrument,
 )
-from devlib.derived import DerivedMeasurements, DerivedMetric
+from devlib.trace.ftrace import FtraceCollector
 from devlib.derived.energy import DerivedEnergyMeasurements
 from devlib.derived.fps import DerivedGfxInfoStats, DerivedSurfaceFlingerStats
 from devlib.collector.ftrace import FtraceCollector
 from devlib.collector.perfetto import PerfettoCollector
 from devlib.collector.perf import PerfCollector
 from devlib.collector.serial_trace import SerialTraceCollector
 from devlib.collector.dmesg import DmesgCollector
 from devlib.collector.logcat import LogcatCollector
 from devlib.utils.android import AdbConnection
 from devlib.utils.ssh import SshConnection, TelnetConnection, Gem5Connection
 from devlib.utils.version import (get_devlib_version as __get_devlib_version,
                                  get_commit as __get_commit)
 __version__ = __get_devlib_version()
 __commit = __get_commit()
 if __commit:
    __full_version__ = f'{__version__}+{__commit}'
 else:
    __full_version__ = __version__
--- a/devlib/_target_runner.py
+++ b/devlib/_target_runner.py
@@ -1,284 +0,0 @@
 #    Copyright 2024 ARM Limited
 #
 # 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.
 #
 """
 Target runner and related classes are implemented here.
 """
 import logging
 import os
 import time
 from platform import machine
 from devlib.exception import (TargetStableError, HostError)
 from devlib.target import LinuxTarget
 from devlib.utils.misc import get_subprocess, which
 from devlib.utils.ssh import SshConnection
 class TargetRunner:
    """
    A generic class for interacting with targets runners.
    It mainly aims to provide framework support for QEMU like target runners
    (e.g., :class:`QEMUTargetRunner`).
    :param target: Specifies type of target per :class:`Target` based classes.
    :type target: Target
    """
    def __init__(self,
                 target):
        self.target = target
        self.logger = logging.getLogger(self.__class__.__name__)
    def __enter__(self):
        return self
    def __exit__(self, *_):
        pass
 class SubprocessTargetRunner(TargetRunner):
    """
    Class for providing subprocess support to the target runners.
    :param runner_cmd: The command to start runner process (e.g.,
        ``qemu-system-aarch64 -kernel Image -append "console=ttyAMA0" ...``).
    :type runner_cmd: list(str)
    :param target: Specifies type of target per :class:`Target` based classes.
    :type target: Target
    :param connect: Specifies if :class:`TargetRunner` should try to connect
        target after launching it, defaults to True.
    :type connect: bool or None
    :param boot_timeout: Timeout for target's being ready for SSH access in
        seconds, defaults to 60.
    :type boot_timeout: int or None
    :raises HostError: if it cannot execute runner command successfully.
    :raises TargetStableError: if Target is inaccessible.
    """
    def __init__(self,
                 runner_cmd,
                 target,
                 connect=True,
                 boot_timeout=60):
        super().__init__(target=target)
        self.boot_timeout = boot_timeout
        self.logger.info('runner_cmd: %s', runner_cmd)
        try:
            self.runner_process = get_subprocess(runner_cmd)
        except Exception as ex:
            raise HostError(f'Error while running "{runner_cmd}": {ex}') from ex
        if connect:
            self.wait_boot_complete()
    def __enter__(self):
        return self
    def __exit__(self, *_):
        """
        Exit routine for contextmanager.
        Ensure ``SubprocessTargetRunner.runner_process`` is terminated on exit.
        """
        self.terminate()
    def wait_boot_complete(self):
        """
        Wait for target OS to finish boot up and become accessible over SSH in at most
        ``SubprocessTargetRunner.boot_timeout`` seconds.
        :raises TargetStableError: In case of timeout.
        """
        start_time = time.time()
        elapsed = 0
        while self.boot_timeout >= elapsed:
            try:
                self.target.connect(timeout=self.boot_timeout - elapsed)
                self.logger.debug('Target is ready.')
                return
            # pylint: disable=broad-except
            except Exception as ex:
                self.logger.info('Cannot connect target: %s', ex)
            time.sleep(1)
            elapsed = time.time() - start_time
        self.terminate()
        raise TargetStableError(f'Target is inaccessible for {self.boot_timeout} seconds!')
    def terminate(self):
        """
        Terminate ``SubprocessTargetRunner.runner_process``.
        """
        self.logger.debug('Killing target runner...')
        self.runner_process.kill()
        self.runner_process.__exit__(None, None, None)
 class NOPTargetRunner(TargetRunner):
    """
    Class for implementing a target runner which does nothing except providing .target attribute.
    :param target: Specifies type of target per :class:`Target` based classes.
    :type target: Target
    """
    def __init__(self, target):
        super().__init__(target=target)
    def __enter__(self):
        return self
    def __exit__(self, *_):
        pass
    def terminate(self):
        """
        Nothing to terminate for NOP target runners.
        Defined to be compliant with other runners (e.g., ``SubprocessTargetRunner``).
        """
 class QEMUTargetRunner(SubprocessTargetRunner):
    """
    Class for preparing necessary groundwork for launching a guest OS on QEMU.
    :param qemu_settings: A dictionary which has QEMU related parameters. The full list
        of QEMU parameters is below:
        * ``kernel_image``: This is the location of kernel image (e.g., ``Image``) which
            will be used as target's kernel.
        * ``arch``: Architecture type. Defaults to ``aarch64``.
        * ``cpu_types``: List of CPU ids for QEMU. The list only contains ``cortex-a72`` by
            default. This parameter is valid for Arm architectures only.
        * ``initrd_image``: This points to the location of initrd image (e.g.,
            ``rootfs.cpio.xz``) which will be used as target's root filesystem if kernel
            does not include one already.
        * ``mem_size``: Size of guest memory in MiB.
        * ``num_cores``: Number of CPU cores. Guest will have ``2`` cores by default.
        * ``num_threads``: Number of CPU threads. Set to ``2`` by defaults.
        * ``cmdline``: Kernel command line parameter. It only specifies console device in
            default (i.e., ``console=ttyAMA0``) which is valid for Arm architectures.
            May be changed to ``ttyS0`` for x86 platforms.
        * ``enable_kvm``: Specifies if KVM will be used as accelerator in QEMU or not.
            Enabled by default if host architecture matches with target's for improving
            QEMU performance.
    :type qemu_settings: Dict
    :param connection_settings: the dictionary to store connection settings
        of ``Target.connection_settings``, defaults to None.
    :type connection_settings: Dict or None
    :param make_target: Lambda function for creating :class:`Target` based object.
    :type make_target: func or None
    :Variable positional arguments: Forwarded to :class:`TargetRunner`.
    :raises FileNotFoundError: if QEMU executable, kernel or initrd image cannot be found.
    """
    def __init__(self,
                 qemu_settings,
                 connection_settings=None,
                 make_target=LinuxTarget,
                 **args):
        self.connection_settings = {
            'host': '127.0.0.1',
            'port': 8022,
            'username': 'root',
            'password': 'root',
            'strict_host_check': False,
        }
        self.connection_settings = {**self.connection_settings, **(connection_settings or {})}
        qemu_args = {
            'arch': 'aarch64',
            'cpu_type': 'cortex-a72',
            'mem_size': 512,
            'num_cores': 2,
            'num_threads': 2,
            'cmdline': 'console=ttyAMA0',
            'enable_kvm': True,
        }
        qemu_args = {**qemu_args, **qemu_settings}
        qemu_executable = f'qemu-system-{qemu_args["arch"]}'
        qemu_path = which(qemu_executable)
        if qemu_path is None:
            raise FileNotFoundError(f'Cannot find {qemu_executable} executable!')
        if qemu_args.get("kernel_image"):
            if not os.path.exists(qemu_args["kernel_image"]):
                raise FileNotFoundError(f'{qemu_args["kernel_image"]} does not exist!')
        else:
            raise KeyError('qemu_settings must have kernel_image!')
        qemu_cmd = [qemu_path,
                    '-kernel', qemu_args["kernel_image"],
                    '-append', f"'{qemu_args['cmdline']}'",
                    '-m', str(qemu_args["mem_size"]),
                    '-smp', f'cores={qemu_args["num_cores"]},threads={qemu_args["num_threads"]}',
                    '-netdev', f'user,id=net0,hostfwd=tcp::{self.connection_settings["port"]}-:22',
                    '-device', 'virtio-net-pci,netdev=net0',
                    '--nographic',
                    ]
        if qemu_args.get("initrd_image"):
            if not os.path.exists(qemu_args["initrd_image"]):
                raise FileNotFoundError(f'{qemu_args["initrd_image"]} does not exist!')
            qemu_cmd.extend(['-initrd', qemu_args["initrd_image"]])
        if qemu_args["enable_kvm"]:
            # Enable KVM accelerator if host and guest architectures match.
            # Comparison is done based on x86 for the sake of simplicity.
            if (qemu_args['arch'].startswith('x86') and machine().startswith('x86')) or (
                    qemu_args['arch'].startswith('x86') and machine().startswith('x86')):
                qemu_cmd.append('--enable-kvm')
        # qemu-system-x86_64 does not support -machine virt as of now.
        if not qemu_args['arch'].startswith('x86'):
            qemu_cmd.extend(['-machine', 'virt', '-cpu', qemu_args["cpu_type"]])
        target = make_target(connect=False,
                             conn_cls=SshConnection,
                             connection_settings=self.connection_settings)
        super().__init__(runner_cmd=qemu_cmd,
                         target=target,
                         **args)
--- a/devlib/bin/arm/simpleperf
+++ b/devlib/bin/arm/simpleperf
--- a/devlib/bin/arm64/README.busybox
+++ b/devlib/bin/arm64/README.busybox
@@ -1,604 +0,0 @@
 Sources of busybox available at:
 Git commit: 1a64f6a20aaf6ea4dbba68bbfa8cc1ab7e5c57c4
 Git repository: git://git.busybox.net/busybox
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.18.3
 PRETTY_NAME="Alpine Linux v3.18"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"
 Build recipe:
 export ARCH=arm64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/arm64
 export LISA_HOME=''
 #! /bin/bash
 ALPINE_VERSION=v3.18
 ALPINE_BUILD_DEPENDENCIES=(bash gcc make musl-dev linux-headers git)
 download() {
    git clone git://git.busybox.net/busybox --branch 1_36_stable --depth=1
    git -C busybox checkout 1_36_1
 }
 build() {
    cd busybox
    make defconfig
    # We need to generate a defconfig then remove the config, then set them to
    # the value we want, as there is no make olddefconfig to fixup an edited
    # config.
    cat .config | grep -v '\bCONFIG_MODPROBE_SMALL\b' | grep -v '\bCONFIG_STATIC\b' > myconfig
    echo "CONFIG_STATIC=y" >> myconfig
    # MODPROBE_SMALL=y breaks the return code of insmod. Instead of forwarding
    # the value from the kernel mod init function, it just returns 1.
    echo "CONFIG_MODPROBE_SMALL=n" >> myconfig
    cp myconfig .config
    make -j 4 "CROSS_COMPILE=$CROSS_COMPILE"
 }
 install() {
    cp -v busybox/busybox "$LISA_ARCH_ASSETS/busybox"
    source "$LISA_HOME/tools/recipes/utils.sh"
    install_readme busybox busybox LICENSE
 }
 The sources were distributed under the following licence (content of busybox/LICENSE):
 --- A note on GPL versions
 BusyBox is distributed under version 2 of the General Public License (included
 in its entirety, below).  Version 2 is the only version of this license which
 this version of BusyBox (or modified versions derived from this one) may be
 distributed under.
 ------------------------------------------------------------------------
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year  name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/arm64/README.libtraceevent
+++ b/devlib/bin/arm64/README.libtraceevent
@@ -1,811 +0,0 @@
 Sources of libtraceevent available at:
 Git commit: 9fe4ddef53288cff64886f75561ec46975a67c33
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=arm64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/arm64
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtraceevent/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/arm64/README.libtracefs
+++ b/devlib/bin/arm64/README.libtracefs
@@ -1,811 +0,0 @@
 Sources of libtracefs available at:
 Git commit: 83323ad8695d3db29cfabdb57bf12a7683119dcb
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=arm64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/arm64
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtracefs/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/arm64/README.trace-cmd
+++ b/devlib/bin/arm64/README.trace-cmd
@@ -1,667 +0,0 @@
 Sources of trace-cmd available at:
 Git commit: 2191498dc35d629003591f727b604120fabbe02d
 Git repository: git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=arm64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/arm64
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of trace-cmd/LICENSES/GPL-2.0):
 Valid-License-Identifier: GPL-2.0
 Valid-License-Identifier: GPL-2.0-only
 Valid-License-Identifier: GPL-2.0+
 Valid-License-Identifier: GPL-2.0-or-later
 SPDX-URL: https://spdx.org/licenses/GPL-2.0.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU General Public License (GPL) version 2 only' use:
    SPDX-License-Identifier: GPL-2.0
  or
    SPDX-License-Identifier: GPL-2.0-only
  For 'GNU General Public License (GPL) version 2 or any later version' use:
    SPDX-License-Identifier: GPL-2.0+
  or
    SPDX-License-Identifier: GPL-2.0-or-later
 License-Text:
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/arm64/busybox
+++ b/devlib/bin/arm64/busybox
--- a/devlib/bin/arm64/get_clock_boottime
+++ b/devlib/bin/arm64/get_clock_boottime
--- a/devlib/bin/arm64/m5
+++ b/devlib/bin/arm64/m5
--- a/devlib/bin/arm64/perf
+++ b/devlib/bin/arm64/perf
--- a/devlib/bin/arm64/readenergy
+++ b/devlib/bin/arm64/readenergy
--- a/devlib/bin/arm64/simpleperf
+++ b/devlib/bin/arm64/simpleperf
--- a/devlib/bin/arm64/trace-cmd
+++ b/devlib/bin/arm64/trace-cmd
--- a/devlib/bin/armeabi/README.busybox
+++ b/devlib/bin/armeabi/README.busybox
@@ -1,604 +0,0 @@
 Sources of busybox available at:
 Git commit: 1a64f6a20aaf6ea4dbba68bbfa8cc1ab7e5c57c4
 Git repository: git://git.busybox.net/busybox
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.18.3
 PRETTY_NAME="Alpine Linux v3.18"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"
 Build recipe:
 export ARCH=armeabi
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/armeabi
 export LISA_HOME=''
 #! /bin/bash
 ALPINE_VERSION=v3.18
 ALPINE_BUILD_DEPENDENCIES=(bash gcc make musl-dev linux-headers git)
 download() {
    git clone git://git.busybox.net/busybox --branch 1_36_stable --depth=1
    git -C busybox checkout 1_36_1
 }
 build() {
    cd busybox
    make defconfig
    # We need to generate a defconfig then remove the config, then set them to
    # the value we want, as there is no make olddefconfig to fixup an edited
    # config.
    cat .config | grep -v '\bCONFIG_MODPROBE_SMALL\b' | grep -v '\bCONFIG_STATIC\b' > myconfig
    echo "CONFIG_STATIC=y" >> myconfig
    # MODPROBE_SMALL=y breaks the return code of insmod. Instead of forwarding
    # the value from the kernel mod init function, it just returns 1.
    echo "CONFIG_MODPROBE_SMALL=n" >> myconfig
    cp myconfig .config
    make -j 4 "CROSS_COMPILE=$CROSS_COMPILE"
 }
 install() {
    cp -v busybox/busybox "$LISA_ARCH_ASSETS/busybox"
    source "$LISA_HOME/tools/recipes/utils.sh"
    install_readme busybox busybox LICENSE
 }
 The sources were distributed under the following licence (content of busybox/LICENSE):
 --- A note on GPL versions
 BusyBox is distributed under version 2 of the General Public License (included
 in its entirety, below).  Version 2 is the only version of this license which
 this version of BusyBox (or modified versions derived from this one) may be
 distributed under.
 ------------------------------------------------------------------------
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year  name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/armeabi/README.libtraceevent
+++ b/devlib/bin/armeabi/README.libtraceevent
@@ -1,811 +0,0 @@
 Sources of libtraceevent available at:
 Git commit: 9fe4ddef53288cff64886f75561ec46975a67c33
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=armeabi
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/armeabi
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtraceevent/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/armeabi/README.libtracefs
+++ b/devlib/bin/armeabi/README.libtracefs
@@ -1,811 +0,0 @@
 Sources of libtracefs available at:
 Git commit: 83323ad8695d3db29cfabdb57bf12a7683119dcb
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=armeabi
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/armeabi
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtracefs/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/armeabi/README.trace-cmd
+++ b/devlib/bin/armeabi/README.trace-cmd
@@ -1,667 +0,0 @@
 Sources of trace-cmd available at:
 Git commit: 2191498dc35d629003591f727b604120fabbe02d
 Git repository: git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=armeabi
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/armeabi
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of trace-cmd/LICENSES/GPL-2.0):
 Valid-License-Identifier: GPL-2.0
 Valid-License-Identifier: GPL-2.0-only
 Valid-License-Identifier: GPL-2.0+
 Valid-License-Identifier: GPL-2.0-or-later
 SPDX-URL: https://spdx.org/licenses/GPL-2.0.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU General Public License (GPL) version 2 only' use:
    SPDX-License-Identifier: GPL-2.0
  or
    SPDX-License-Identifier: GPL-2.0-only
  For 'GNU General Public License (GPL) version 2 or any later version' use:
    SPDX-License-Identifier: GPL-2.0+
  or
    SPDX-License-Identifier: GPL-2.0-or-later
 License-Text:
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/armeabi/busybox
+++ b/devlib/bin/armeabi/busybox
--- a/devlib/bin/armeabi/get_clock_boottime
+++ b/devlib/bin/armeabi/get_clock_boottime
--- a/devlib/bin/armeabi/m5
+++ b/devlib/bin/armeabi/m5
--- a/devlib/bin/armeabi/perf
+++ b/devlib/bin/armeabi/perf
--- a/devlib/bin/armeabi/trace-cmd
+++ b/devlib/bin/armeabi/trace-cmd
--- a/devlib/bin/ppc64le/README.busybox
+++ b/devlib/bin/ppc64le/README.busybox
@@ -1,604 +0,0 @@
 Sources of busybox available at:
 Git commit: 1a64f6a20aaf6ea4dbba68bbfa8cc1ab7e5c57c4
 Git repository: git://git.busybox.net/busybox
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.18.3
 PRETTY_NAME="Alpine Linux v3.18"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"
 Build recipe:
 export ARCH=ppc64le
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/ppc64le
 export LISA_HOME=''
 #! /bin/bash
 ALPINE_VERSION=v3.18
 ALPINE_BUILD_DEPENDENCIES=(bash gcc make musl-dev linux-headers git)
 download() {
    git clone git://git.busybox.net/busybox --branch 1_36_stable --depth=1
    git -C busybox checkout 1_36_1
 }
 build() {
    cd busybox
    make defconfig
    # We need to generate a defconfig then remove the config, then set them to
    # the value we want, as there is no make olddefconfig to fixup an edited
    # config.
    cat .config | grep -v '\bCONFIG_MODPROBE_SMALL\b' | grep -v '\bCONFIG_STATIC\b' > myconfig
    echo "CONFIG_STATIC=y" >> myconfig
    # MODPROBE_SMALL=y breaks the return code of insmod. Instead of forwarding
    # the value from the kernel mod init function, it just returns 1.
    echo "CONFIG_MODPROBE_SMALL=n" >> myconfig
    cp myconfig .config
    make -j 4 "CROSS_COMPILE=$CROSS_COMPILE"
 }
 install() {
    cp -v busybox/busybox "$LISA_ARCH_ASSETS/busybox"
    source "$LISA_HOME/tools/recipes/utils.sh"
    install_readme busybox busybox LICENSE
 }
 The sources were distributed under the following licence (content of busybox/LICENSE):
 --- A note on GPL versions
 BusyBox is distributed under version 2 of the General Public License (included
 in its entirety, below).  Version 2 is the only version of this license which
 this version of BusyBox (or modified versions derived from this one) may be
 distributed under.
 ------------------------------------------------------------------------
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year  name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/ppc64le/README.libtraceevent
+++ b/devlib/bin/ppc64le/README.libtraceevent
@@ -1,811 +0,0 @@
 Sources of libtraceevent available at:
 Git commit: 9fe4ddef53288cff64886f75561ec46975a67c33
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=ppc64le
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/ppc64le
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtraceevent/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/ppc64le/README.libtracefs
+++ b/devlib/bin/ppc64le/README.libtracefs
@@ -1,811 +0,0 @@
 Sources of libtracefs available at:
 Git commit: 83323ad8695d3db29cfabdb57bf12a7683119dcb
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=ppc64le
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/ppc64le
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtracefs/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/ppc64le/README.trace-cmd
+++ b/devlib/bin/ppc64le/README.trace-cmd
@@ -1,667 +0,0 @@
 Sources of trace-cmd available at:
 Git commit: 2191498dc35d629003591f727b604120fabbe02d
 Git repository: git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=ppc64le
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/ppc64le
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of trace-cmd/LICENSES/GPL-2.0):
 Valid-License-Identifier: GPL-2.0
 Valid-License-Identifier: GPL-2.0-only
 Valid-License-Identifier: GPL-2.0+
 Valid-License-Identifier: GPL-2.0-or-later
 SPDX-URL: https://spdx.org/licenses/GPL-2.0.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU General Public License (GPL) version 2 only' use:
    SPDX-License-Identifier: GPL-2.0
  or
    SPDX-License-Identifier: GPL-2.0-only
  For 'GNU General Public License (GPL) version 2 or any later version' use:
    SPDX-License-Identifier: GPL-2.0+
  or
    SPDX-License-Identifier: GPL-2.0-or-later
 License-Text:
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/ppc64le/busybox
+++ b/devlib/bin/ppc64le/busybox
--- a/devlib/bin/ppc64le/trace-cmd
+++ b/devlib/bin/ppc64le/trace-cmd
--- a/devlib/bin/scripts/devlib-signal-target
+++ b/devlib/bin/scripts/devlib-signal-target
@@ -1,20 +0,0 @@
 (
    # If there is no data dir, it means we are not running as a background
    # command so we just do nothing
    if [ -e "$_DEVLIB_BG_CMD_DATA_DIR" ]; then
        pid_file="$_DEVLIB_BG_CMD_DATA_DIR/pid"
        # Atomically check if the PID file already exist and make the write
        # fail if it already does. This way we don't have any race condition
        # with the Python API, as there is either no PID or the same PID for
        # the duration of the command
        set -o noclobber
        if ! printf "%u\n" $$ > "$pid_file"; then
            echo "$0 was already called for this command" >&2
            exit 1
        fi
    fi
 ) || exit $?
 # Use exec so that the PID of the command we run is the same as the current $$
 # PID that we just registered
 exec "$@"
--- a/devlib/bin/scripts/shutils.in
+++ b/devlib/bin/scripts/shutils.in
@@ -1,369 +0,0 @@
 CMD=$1
 shift
 BUSYBOX=${BUSYBOX:-__DEVLIB_BUSYBOX__}
 FIND=${FIND:-$BUSYBOX find}
 GREP=${GREP:-$BUSYBOX grep}
 SED=${SED:-$BUSYBOX sed}
 CAT=${CAT:-$BUSYBOX cat}
 AWK=${AWK:-$BUSYBOX awk}
 PS=${PS:-$BUSYBOX ps}
 MOUNT=${MOUNT:-$BUSYBOX mount}
 PRINTF=${PRINTF:-$BUSYBOX printf}
 ################################################################################
 # CPUFrequency Utility Functions
 ################################################################################
 cpufreq_set_all_frequencies() {
 	FREQ=$1
 	for CPU in /sys/devices/system/cpu/cpu[0-9]*; do
 		echo $FREQ > $CPU/cpufreq/scaling_cur_freq
 	done
 }
 cpufreq_get_all_frequencies() {
 	$GREP '' /sys/devices/system/cpu/cpu*/cpufreq/scaling_cur_freq | \
 		$SED -e 's|/sys/devices/system/cpu/cpu||' -e 's|/cpufreq/scaling_cur_freq:| |'
 }
 cpufreq_set_all_governors() {
 	GOV=$1
 	for CPU in /sys/devices/system/cpu/cpu[0-9]*; do
 		echo $GOV > $CPU/cpufreq/scaling_governor
 	done
 }
 cpufreq_get_all_governors() {
 	$GREP '' /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor | \
 		$SED -e 's|/sys/devices/system/cpu/cpu||' -e 's|/cpufreq/scaling_governor:| |'
 }
 cpufreq_trace_all_frequencies() {
 	local TRACEFS=$(get_tracefs_mount_point)
 	local FREQS=$($CAT /sys/devices/system/cpu/cpu*/cpufreq/scaling_cur_freq)
 	local CPU=0; for F in $FREQS; do
 		printf "%s\n" "cpu_frequency_devlib: state=$F cpu_id=$CPU" > $TRACEFS/trace_marker
 		CPU=$((CPU + 1))
 	done
 }
 ################################################################################
 # DevFrequency Utility Functions
 ################################################################################
 devfreq_set_all_frequencies() {
 	FREQ=$1
 	for DEV in /sys/class/devfreq/*; do
 		echo $FREQ > $DEV/min_freq
 		echo $FREQ > $DEV/max_freq
 	done
 }
 devfreq_get_all_frequencies() {
 	for DEV in /sys/class/devfreq/*; do
 		echo "`basename $DEV` `cat $DEV/cur_freq`"
 	done
 }
 devfreq_set_all_governors() {
 	GOV=$1
 	for DEV in /sys/class/devfreq/*; do
 		echo $GOV > $DEV/governor
 	done
 }
 devfreq_get_all_governors() {
 	for DEV in /sys/class/devfreq/*; do
 		echo "`basename $DEV` `cat $DEV/governor`"
 	done
 }
 ################################################################################
 # CPUIdle Utility Functions
 ################################################################################
 cpuidle_wake_all_cpus() {
 	CPU_PATHS=/sys/devices/system/cpu/cpu[0-9]*
 	MASK=0x1; for F in $CPU_PATHS; do
 		$BUSYBOX taskset $MASK true &
 		MASK=$($BUSYBOX printf '0x%x' $((MASK * 2)))
 	done
 }
 ################################################################################
 # FTrace Utility Functions
 ################################################################################
 get_tracefs_mount_point() {
    get_fs_mount_point tracefs || $PRINTF "%s" '/sys/kernel/debug/tracing'
 }
 ftrace_get_function_stats() {
    local TRACEFS=$(get_tracefs_mount_point)
    for CPU in $(ls $TRACEFS/trace_stat | sed 's/function//'); do
        REPLACE_STRING="s/  Function/\n  Function (CPU$CPU)/"
        $CAT $TRACEFS/trace_stat/function$CPU \
            | sed "$REPLACE_STRING"
    done
 }
 ################################################################################
 # CGroups Utility Functions
 ################################################################################
 cgroups_get_attributes() {
 	test $# -eq 2 || exit -1
 	CGROUP="$1"
 	CONTROLLER="$2"
 	# Check if controller is mounted with "noprefix" option, which is quite
 	# common on Android for backward compatibility
 	ls $CGROUP/$CONTROLLER\.* 2>&1 >/dev/null
 	if [ $? -eq 0 ]; then
 		# no "noprefix" option, attributes format is:
 		#   mnt_point/controller.attribute_name
 		$GREP '' $CGROUP/* | \
 			$GREP "$CONTROLLER\." | \
 			$SED -e "s|$CONTROLLER\.||" -e "s|$CGROUP/||"
 	else
 		# "noprefix" option, attribute format is:
 		#   mnt_point/attribute_name
 		$GREP '' $(\
 			$FIND $CGROUP -type f -maxdepth 1 |
 			$GREP -v -e ".*tasks" -e ".*cgroup\..*") | \
 		$SED "s|$CGROUP/||"
 	fi
 }
 cgroups_run_into() {
 	# Control groups mount point
 	CGMOUNT=${CGMOUNT:-/sys/fs/cgroup}
 	# The control group we want to run into
 	CGP=${1}
 	shift 1
 	# The command to run
 	CMD="${@}"
 	# Execution under root CGgroup
 	if [ "x/" == "x$CGP" ]; then
 	  $FIND $CGMOUNT -type d -maxdepth 0 | \
 	  while read CGPATH; do
 		# Move this shell into that control group
 		echo $$ > $CGPATH/cgroup.procs
 		echo "Moving task into root CGroup ($CGPATH)"
 		# Check the move actually worked
 		$GREP -E "$$" $CGPATH/cgroup.procs >/dev/null 2>&1
 		if [ $? -ne 0 ]; then
 			echo "ERROR: Process was not moved into $CGP"
 			exit 1
 	  	fi
 	  done
 	  if [ $? -ne 0 ]; then
 		exit 1
 	  fi
 	# Execution under specified CGroup
 	else
 	  # Check if the required CGroup exists
 	  $FIND $CGMOUNT -type d -mindepth 1 | \
 	  $GREP -E "^$CGMOUNT/devlib_cgh[0-9]{1,2}$CGP" >/dev/null 2>&1
 	  if [ $? -ne 0 ]; then
 		echo "ERROR: could not find any $CGP cgroup under $CGMOUNT"
 		exit 1
 	  fi
 	  $FIND $CGMOUNT -type d -mindepth 1 | \
 	  $GREP -E "^$CGMOUNT/devlib_cgh[0-9]{1,2}$CGP$" | \
 	  while read CGPATH; do
 		  # Move this shell into that control group
 		  echo $$ > $CGPATH/cgroup.procs
 		  echo "Moving task into $CGPATH"
 		  # Check the move actually worked
 		  $GREP -E "$$" $CGPATH/cgroup.procs >/dev/null 2>&1
 		  if [ $? -ne 0 ]; then
 			echo "ERROR: Process was not moved into $CGP"
 			exit 1
 	  	  fi
 	  done
 	  if [ $? -ne 0 ]; then
 		exit 1
 	  fi
 	fi
 	# Execute the command
 	exec $CMD
 }
 cgroups_tasks_move() {
 	SRC_GRP=${1}
 	DST_GRP=${2}
 	shift 2
 	FILTERS=$*
 	$CAT $SRC_GRP/tasks | while read TID; do
 	  echo $TID > $DST_GRP/cgroup.procs
 	done
 	[ "x$FILTERS" = "x" ] && exit 0
 	PIDS=`$PS -o comm,pid | $GREP $FILTERS | $AWK '{print $2}'`
 	PIDS=`echo $PIDS`
 	echo "PIDs to save: [$PIDS]"
 	for TID in $PIDS; do
 	  COMM=`$CAT /proc/$TID/comm`
 	  echo "$TID : $COMM"
 	  echo $TID > $SRC_GRP/cgroup.procs || true
 	done
 }
 cgroups_tasks_in() {
 	GRP=${1}
 	for TID in $($CAT $GRP/tasks); do
 		COMM=`$CAT /proc/$TID/comm 2>/dev/null`
 		[ "$COMM" != "" ] && CMDL=`$CAT /proc/$TID/cmdline 2>/dev/null`
 		[ "$COMM" != "" ] && echo "$TID,$COMM,$CMDL"
 	done
 	exit 0
 }
 cgroups_freezer_set_state() {
    STATE=${1}
    SYSFS_ENTRY=${2}/freezer.state
    # Set the state of the freezer
    echo $STATE > $SYSFS_ENTRY
    # And check it applied cleanly
    for i in `seq 1 10`; do
        [ $($CAT $SYSFS_ENTRY) = $STATE ] && exit 0
        sleep 1
    done
    # We have an issue
    echo "ERROR: Freezer stalled while changing state to \"$STATE\"." >&2
    exit 1
 }
 ################################################################################
 # Hotplug
 ################################################################################
 hotplug_online_all() {
    for path in /sys/devices/system/cpu/cpu[0-9]*; do
        if [ $(cat $path/online) -eq 0 ]; then
            echo 1 > $path/online
        fi
    done
 }
 ################################################################################
 # Scheduler
 ################################################################################
 sched_get_kernel_attributes() {
 	MATCH=${1:-'.*'}
 	[ -d /proc/sys/kernel/ ] || exit 1
 	$GREP '' /proc/sys/kernel/sched_* | \
 		$SED -e 's|/proc/sys/kernel/sched_||' | \
 		$GREP -e "$MATCH"
 }
 ################################################################################
 # Misc
 ################################################################################
 read_tree_values() {
    BASEPATH=$1
    MAXDEPTH=$2
    if [ ! -e $BASEPATH ]; then
        echo "ERROR: $BASEPATH does not exist"
        exit 1
    fi
    PATHS=$($BUSYBOX find $BASEPATH -follow -maxdepth $MAXDEPTH)
    i=0
    for path in $PATHS; do
        i=$(expr $i + 1)
        if [ $i -gt 1 ]; then
            break;
        fi
    done
    if [ $i -gt 1 ]; then
        $BUSYBOX grep -s '' $PATHS
    fi
 }
 read_tree_tgz_b64() {
    BASEPATH=$1
    MAXDEPTH=$2
    TMPBASE=$3
    if [ ! -e $BASEPATH ]; then
        echo "ERROR: $BASEPATH does not exist"
        exit 1
    fi
    cd $TMPBASE
    TMP_FOLDER=$($BUSYBOX realpath $($BUSYBOX mktemp -d XXXXXX))
    # 'tar' doesn't work as expected on debugfs, so copy the tree first to
    # workaround the issue
    cd $BASEPATH
    for CUR_FILE in $($BUSYBOX find . -follow -type f -maxdepth $MAXDEPTH); do
        $BUSYBOX cp --parents $CUR_FILE $TMP_FOLDER/ 2> /dev/null
    done
    cd $TMP_FOLDER
    $BUSYBOX tar cz * 2>/dev/null | $BUSYBOX base64
    # Clean-up the tmp folder since we won't need it any more
    cd $TMPBASE
    rm -rf $TMP_FOLDER
 }
 get_linux_system_id() {
 	kernel=$($BUSYBOX uname -r)
 	hardware=$($BUSYBOX ip a | $BUSYBOX grep 'link/ether' | $BUSYBOX sed 's/://g' | $BUSYBOX awk '{print $2}' | $BUSYBOX tr -d '\n')
 	filesystem=$(ls /dev/disk/by-uuid | $BUSYBOX tr '\n' '-' | $BUSYBOX sed 's/-$//')
 	echo "$hardware/$kernel/$filesystem"
 }
 get_android_system_id() {
 	kernel=$($BUSYBOX uname -r)
 	hardware=$($BUSYBOX ip a | $BUSYBOX grep 'link/ether' | $BUSYBOX sed 's/://g' | $BUSYBOX awk '{print $2}' | $BUSYBOX tr -d '\n')
 	filesystem=$(content query --uri content://settings/secure --projection value --where "name='android_id'" | $BUSYBOX cut -f2 -d=)
 	echo "$hardware/$kernel/$filesystem"
 }
 get_fs_mount_point() {
    local path=$(LC_ALL=C $MOUNT -t "$1" | $SED -n "s/$1 on \(.*\) type $1 .*/\1/p;q")
    if [ "$path" == "" ]; then
        return 1
    else
        $PRINTF "%s" "$path"
        return 0
    fi
 }
 ################################################################################
 # Main Function Dispatcher
 ################################################################################
 # Use a function instead of a subshell so "exit 1" works as expected
 _command_not_found() {
    echo "Command [$CMD] not supported"
    exit 1
 }
 # Check the command exists
 type "$CMD" >/dev/null 2>&1 || _command_not_found
 "$CMD" "$@"
 # vim: tabstop=4 shiftwidth=4
--- a/devlib/bin/x86/README.busybox
+++ b/devlib/bin/x86/README.busybox
@@ -1,604 +0,0 @@
 Sources of busybox available at:
 Git commit: 1a64f6a20aaf6ea4dbba68bbfa8cc1ab7e5c57c4
 Git repository: git://git.busybox.net/busybox
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.18.3
 PRETTY_NAME="Alpine Linux v3.18"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"
 Build recipe:
 export ARCH=x86
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86
 export LISA_HOME=''
 #! /bin/bash
 ALPINE_VERSION=v3.18
 ALPINE_BUILD_DEPENDENCIES=(bash gcc make musl-dev linux-headers git)
 download() {
    git clone git://git.busybox.net/busybox --branch 1_36_stable --depth=1
    git -C busybox checkout 1_36_1
 }
 build() {
    cd busybox
    make defconfig
    # We need to generate a defconfig then remove the config, then set them to
    # the value we want, as there is no make olddefconfig to fixup an edited
    # config.
    cat .config | grep -v '\bCONFIG_MODPROBE_SMALL\b' | grep -v '\bCONFIG_STATIC\b' > myconfig
    echo "CONFIG_STATIC=y" >> myconfig
    # MODPROBE_SMALL=y breaks the return code of insmod. Instead of forwarding
    # the value from the kernel mod init function, it just returns 1.
    echo "CONFIG_MODPROBE_SMALL=n" >> myconfig
    cp myconfig .config
    make -j 4 "CROSS_COMPILE=$CROSS_COMPILE"
 }
 install() {
    cp -v busybox/busybox "$LISA_ARCH_ASSETS/busybox"
    source "$LISA_HOME/tools/recipes/utils.sh"
    install_readme busybox busybox LICENSE
 }
 The sources were distributed under the following licence (content of busybox/LICENSE):
 --- A note on GPL versions
 BusyBox is distributed under version 2 of the General Public License (included
 in its entirety, below).  Version 2 is the only version of this license which
 this version of BusyBox (or modified versions derived from this one) may be
 distributed under.
 ------------------------------------------------------------------------
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year  name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86/README.libtraceevent
+++ b/devlib/bin/x86/README.libtraceevent
@@ -1,811 +0,0 @@
 Sources of libtraceevent available at:
 Git commit: 9fe4ddef53288cff64886f75561ec46975a67c33
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=x86
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtraceevent/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86/README.libtracefs
+++ b/devlib/bin/x86/README.libtracefs
@@ -1,811 +0,0 @@
 Sources of libtracefs available at:
 Git commit: 83323ad8695d3db29cfabdb57bf12a7683119dcb
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=x86
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtracefs/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86/README.trace-cmd
+++ b/devlib/bin/x86/README.trace-cmd
@@ -1,667 +0,0 @@
 Sources of trace-cmd available at:
 Git commit: 2191498dc35d629003591f727b604120fabbe02d
 Git repository: git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=x86
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of trace-cmd/LICENSES/GPL-2.0):
 Valid-License-Identifier: GPL-2.0
 Valid-License-Identifier: GPL-2.0-only
 Valid-License-Identifier: GPL-2.0+
 Valid-License-Identifier: GPL-2.0-or-later
 SPDX-URL: https://spdx.org/licenses/GPL-2.0.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU General Public License (GPL) version 2 only' use:
    SPDX-License-Identifier: GPL-2.0
  or
    SPDX-License-Identifier: GPL-2.0-only
  For 'GNU General Public License (GPL) version 2 or any later version' use:
    SPDX-License-Identifier: GPL-2.0+
  or
    SPDX-License-Identifier: GPL-2.0-or-later
 License-Text:
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86/busybox
+++ b/devlib/bin/x86/busybox
--- a/devlib/bin/x86/simpleperf
+++ b/devlib/bin/x86/simpleperf
--- a/devlib/bin/x86/trace-cmd
+++ b/devlib/bin/x86/trace-cmd
--- a/devlib/bin/x86_64/README.busybox
+++ b/devlib/bin/x86_64/README.busybox
@@ -1,604 +0,0 @@
 Sources of busybox available at:
 Git commit: 1a64f6a20aaf6ea4dbba68bbfa8cc1ab7e5c57c4
 Git repository: git://git.busybox.net/busybox
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.18.3
 PRETTY_NAME="Alpine Linux v3.18"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"
 Build recipe:
 export ARCH=x86_64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86_64
 export LISA_HOME=''
 #! /bin/bash
 ALPINE_VERSION=v3.18
 ALPINE_BUILD_DEPENDENCIES=(bash gcc make musl-dev linux-headers git)
 download() {
    git clone git://git.busybox.net/busybox --branch 1_36_stable --depth=1
    git -C busybox checkout 1_36_1
 }
 build() {
    cd busybox
    make defconfig
    # We need to generate a defconfig then remove the config, then set them to
    # the value we want, as there is no make olddefconfig to fixup an edited
    # config.
    cat .config | grep -v '\bCONFIG_MODPROBE_SMALL\b' | grep -v '\bCONFIG_STATIC\b' > myconfig
    echo "CONFIG_STATIC=y" >> myconfig
    # MODPROBE_SMALL=y breaks the return code of insmod. Instead of forwarding
    # the value from the kernel mod init function, it just returns 1.
    echo "CONFIG_MODPROBE_SMALL=n" >> myconfig
    cp myconfig .config
    make -j 4 "CROSS_COMPILE=$CROSS_COMPILE"
 }
 install() {
    cp -v busybox/busybox "$LISA_ARCH_ASSETS/busybox"
    source "$LISA_HOME/tools/recipes/utils.sh"
    install_readme busybox busybox LICENSE
 }
 The sources were distributed under the following licence (content of busybox/LICENSE):
 --- A note on GPL versions
 BusyBox is distributed under version 2 of the General Public License (included
 in its entirety, below).  Version 2 is the only version of this license which
 this version of BusyBox (or modified versions derived from this one) may be
 distributed under.
 ------------------------------------------------------------------------
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year  name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86_64/README.libtraceevent
+++ b/devlib/bin/x86_64/README.libtraceevent
@@ -1,811 +0,0 @@
 Sources of libtraceevent available at:
 Git commit: 9fe4ddef53288cff64886f75561ec46975a67c33
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=x86_64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86_64
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtraceevent/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86_64/README.libtracefs
+++ b/devlib/bin/x86_64/README.libtracefs
@@ -1,811 +0,0 @@
 Sources of libtracefs available at:
 Git commit: 83323ad8695d3db29cfabdb57bf12a7683119dcb
 Git repository: https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=x86_64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86_64
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of libtracefs/LICENSES/LGPL-2.1):
 Valid-License-Identifier: LGPL-2.1
 Valid-License-Identifier: LGPL-2.1+
 SPDX-URL: https://spdx.org/licenses/LGPL-2.1.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU Lesser General Public License (LGPL) version 2.1 only' use:
    SPDX-License-Identifier: LGPL-2.1
  For 'GNU Lesser General Public License (LGPL) version 2.1 or any later
  version' use:
    SPDX-License-Identifier: LGPL-2.1+
 License-Text:
 GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 Copyright (C) 1991, 1999 Free Software Foundation, Inc.
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 [This is the first released version of the Lesser GPL. It also counts as
 the successor of the GNU Library Public License, version 2, hence the
 version number 2.1.]
 Preamble
 The licenses for most software are designed to take away your freedom to
 share and change it. By contrast, the GNU General Public Licenses are
 intended to guarantee your freedom to share and change free software--to
 make sure the software is free for all its users.
 This license, the Lesser General Public License, applies to some specially
 designated software packages--typically libraries--of the Free Software
 Foundation and other authors who decide to use it. You can use it too, but
 we suggest you first think carefully about whether this license or the
 ordinary General Public License is the better strategy to use in any
 particular case, based on the explanations below.
 When we speak of free software, we are referring to freedom of use, not
 price. Our General Public Licenses are designed to make sure that you have
 the freedom to distribute copies of free software (and charge for this
 service if you wish); that you receive source code or can get it if you
 want it; that you can change the software and use pieces of it in new free
 programs; and that you are informed that you can do these things.
 To protect your rights, we need to make restrictions that forbid
 distributors to deny you these rights or to ask you to surrender these
 rights. These restrictions translate to certain responsibilities for you if
 you distribute copies of the library or if you modify it.
 For example, if you distribute copies of the library, whether gratis or for
 a fee, you must give the recipients all the rights that we gave you. You
 must make sure that they, too, receive or can get the source code. If you
 link other code with the library, you must provide complete object files to
 the recipients, so that they can relink them with the library after making
 changes to the library and recompiling it. And you must show them these
 terms so they know their rights.
 We protect your rights with a two-step method: (1) we copyright the
 library, and (2) we offer you this license, which gives you legal
 permission to copy, distribute and/or modify the library.
 To protect each distributor, we want to make it very clear that there is no
 warranty for the free library. Also, if the library is modified by someone
 else and passed on, the recipients should know that what they have is not
 the original version, so that the original author's reputation will not be
 affected by problems that might be introduced by others.
 Finally, software patents pose a constant threat to the existence of any
 free program. We wish to make sure that a company cannot effectively
 restrict the users of a free program by obtaining a restrictive license
 from a patent holder. Therefore, we insist that any patent license obtained
 for a version of the library must be consistent with the full freedom of
 use specified in this license.
 Most GNU software, including some libraries, is covered by the ordinary GNU
 General Public License. This license, the GNU Lesser General Public
 License, applies to certain designated libraries, and is quite different
 from the ordinary General Public License. We use this license for certain
 libraries in order to permit linking those libraries into non-free
 programs.
 When a program is linked with a library, whether statically or using a
 shared library, the combination of the two is legally speaking a combined
 work, a derivative of the original library. The ordinary General Public
 License therefore permits such linking only if the entire combination fits
 its criteria of freedom. The Lesser General Public License permits more lax
 criteria for linking other code with the library.
 We call this license the "Lesser" General Public License because it does
 Less to protect the user's freedom than the ordinary General Public
 License. It also provides other free software developers Less of an
 advantage over competing non-free programs. These disadvantages are the
 reason we use the ordinary General Public License for many
 libraries. However, the Lesser license provides advantages in certain
 special circumstances.
 For example, on rare occasions, there may be a special need to encourage
 the widest possible use of a certain library, so that it becomes a de-facto
 standard. To achieve this, non-free programs must be allowed to use the
 library. A more frequent case is that a free library does the same job as
 widely used non-free libraries. In this case, there is little to gain by
 limiting the free library to free software only, so we use the Lesser
 General Public License.
 In other cases, permission to use a particular library in non-free programs
 enables a greater number of people to use a large body of free
 software. For example, permission to use the GNU C Library in non-free
 programs enables many more people to use the whole GNU operating system, as
 well as its variant, the GNU/Linux operating system.
 Although the Lesser General Public License is Less protective of the users'
 freedom, it does ensure that the user of a program that is linked with the
 Library has the freedom and the wherewithal to run that program using a
 modified version of the Library.
 The precise terms and conditions for copying, distribution and modification
 follow. Pay close attention to the difference between a "work based on the
 library" and a "work that uses the library". The former contains code
 derived from the library, whereas the latter must be combined with the
 library in order to run.
 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 0. This License Agreement applies to any software library or other program
   which contains a notice placed by the copyright holder or other
   authorized party saying it may be distributed under the terms of this
   Lesser General Public License (also called "this License"). Each
   licensee is addressed as "you".
   A "library" means a collection of software functions and/or data
   prepared so as to be conveniently linked with application programs
   (which use some of those functions and data) to form executables.
   The "Library", below, refers to any such software library or work which
   has been distributed under these terms. A "work based on the Library"
   means either the Library or any derivative work under copyright law:
   that is to say, a work containing the Library or a portion of it, either
   verbatim or with modifications and/or translated straightforwardly into
   another language. (Hereinafter, translation is included without
   limitation in the term "modification".)
   "Source code" for a work means the preferred form of the work for making
   modifications to it. For a library, complete source code means all the
   source code for all modules it contains, plus any associated interface
   definition files, plus the scripts used to control compilation and
   installation of the library.
    Activities other than copying, distribution and modification are not
    covered by this License; they are outside its scope. The act of running
    a program using the Library is not restricted, and output from such a
    program is covered only if its contents constitute a work based on the
    Library (independent of the use of the Library in a tool for writing
    it). Whether that is true depends on what the Library does and what the
    program that uses the Library does.
 1. You may copy and distribute verbatim copies of the Library's complete
   source code as you receive it, in any medium, provided that you
   conspicuously and appropriately publish on each copy an appropriate
   copyright notice and disclaimer of warranty; keep intact all the notices
   that refer to this License and to the absence of any warranty; and
   distribute a copy of this License along with the Library.
   You may charge a fee for the physical act of transferring a copy, and
   you may at your option offer warranty protection in exchange for a fee.
 2. You may modify your copy or copies of the Library or any portion of it,
   thus forming a work based on the Library, and copy and distribute such
   modifications or work under the terms of Section 1 above, provided that
   you also meet all of these conditions:
   a) The modified work must itself be a software library.
   b) You must cause the files modified to carry prominent notices stating
      that you changed the files and the date of any change.
   c) You must cause the whole of the work to be licensed at no charge to
      all third parties under the terms of this License.
   d) If a facility in the modified Library refers to a function or a table
      of data to be supplied by an application program that uses the
      facility, other than as an argument passed when the facility is
      invoked, then you must make a good faith effort to ensure that, in
      the event an application does not supply such function or table, the
      facility still operates, and performs whatever part of its purpose
      remains meaningful.
   (For example, a function in a library to compute square roots has a
    purpose that is entirely well-defined independent of the
    application. Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must be
    optional: if the application does not supply it, the square root
    function must still compute square roots.)
   These requirements apply to the modified work as a whole. If
   identifiable sections of that work are not derived from the Library, and
   can be reasonably considered independent and separate works in
   themselves, then this License, and its terms, do not apply to those
   sections when you distribute them as separate works. But when you
   distribute the same sections as part of a whole which is a work based on
   the Library, the distribution of the whole must be on the terms of this
   License, whose permissions for other licensees extend to the entire
   whole, and thus to each and every part regardless of who wrote it.
   Thus, it is not the intent of this section to claim rights or contest
   your rights to work written entirely by you; rather, the intent is to
   exercise the right to control the distribution of derivative or
   collective works based on the Library.
   In addition, mere aggregation of another work not based on the Library
   with the Library (or with a work based on the Library) on a volume of a
   storage or distribution medium does not bring the other work under the
   scope of this License.
 3. You may opt to apply the terms of the ordinary GNU General Public
   License instead of this License to a given copy of the Library. To do
   this, you must alter all the notices that refer to this License, so that
   they refer to the ordinary GNU General Public License, version 2,
   instead of to this License. (If a newer version than version 2 of the
   ordinary GNU General Public License has appeared, then you can specify
   that version instead if you wish.) Do not make any other change in these
   notices.
   Once this change is made in a given copy, it is irreversible for that
   copy, so the ordinary GNU General Public License applies to all
   subsequent copies and derivative works made from that copy.
   This option is useful when you wish to copy part of the code of the
   Library into a program that is not a library.
 4. You may copy and distribute the Library (or a portion or derivative of
   it, under Section 2) in object code or executable form under the terms
   of Sections 1 and 2 above provided that you accompany it with the
   complete corresponding machine-readable source code, which must be
   distributed under the terms of Sections 1 and 2 above on a medium
   customarily used for software interchange.
   If distribution of object code is made by offering access to copy from a
   designated place, then offering equivalent access to copy the source
   code from the same place satisfies the requirement to distribute the
   source code, even though third parties are not compelled to copy the
   source along with the object code.
 5. A program that contains no derivative of any portion of the Library, but
   is designed to work with the Library by being compiled or linked with
   it, is called a "work that uses the Library". Such a work, in isolation,
   is not a derivative work of the Library, and therefore falls outside the
   scope of this License.
   However, linking a "work that uses the Library" with the Library creates
   an executable that is a derivative of the Library (because it contains
   portions of the Library), rather than a "work that uses the
   library". The executable is therefore covered by this License. Section 6
   states terms for distribution of such executables.
   When a "work that uses the Library" uses material from a header file
   that is part of the Library, the object code for the work may be a
   derivative work of the Library even though the source code is
   not. Whether this is true is especially significant if the work can be
   linked without the Library, or if the work is itself a library. The
   threshold for this to be true is not precisely defined by law.
   If such an object file uses only numerical parameters, data structure
   layouts and accessors, and small macros and small inline functions (ten
   lines or less in length), then the use of the object file is
   unrestricted, regardless of whether it is legally a derivative
   work. (Executables containing this object code plus portions of the
   Library will still fall under Section 6.)
   Otherwise, if the work is a derivative of the Library, you may
   distribute the object code for the work under the terms of Section
   6. Any executables containing that work also fall under Section 6,
   whether or not they are linked directly with the Library itself.
 6. As an exception to the Sections above, you may also combine or link a
   "work that uses the Library" with the Library to produce a work
   containing portions of the Library, and distribute that work under terms
   of your choice, provided that the terms permit modification of the work
   for the customer's own use and reverse engineering for debugging such
   modifications.
   You must give prominent notice with each copy of the work that the
   Library is used in it and that the Library and its use are covered by
   this License. You must supply a copy of this License. If the work during
   execution displays copyright notices, you must include the copyright
   notice for the Library among them, as well as a reference directing the
   user to the copy of this License. Also, you must do one of these things:
   a) Accompany the work with the complete corresponding machine-readable
      source code for the Library including whatever changes were used in
      the work (which must be distributed under Sections 1 and 2 above);
      and, if the work is an executable linked with the Library, with the
      complete machine-readable "work that uses the Library", as object
      code and/or source code, so that the user can modify the Library and
      then relink to produce a modified executable containing the modified
      Library. (It is understood that the user who changes the contents of
      definitions files in the Library will not necessarily be able to
      recompile the application to use the modified definitions.)
   b) Use a suitable shared library mechanism for linking with the
      Library. A suitable mechanism is one that (1) uses at run time a copy
      of the library already present on the user's computer system, rather
      than copying library functions into the executable, and (2) will
      operate properly with a modified version of the library, if the user
      installs one, as long as the modified version is interface-compatible
      with the version that the work was made with.
   c) Accompany the work with a written offer, valid for at least three
      years, to give the same user the materials specified in Subsection
      6a, above, for a charge no more than the cost of performing this
      distribution.
   d) If distribution of the work is made by offering access to copy from a
      designated place, offer equivalent access to copy the above specified
      materials from the same place.
   e) Verify that the user has already received a copy of these materials
      or that you have already sent this user a copy.
   For an executable, the required form of the "work that uses the Library"
   must include any data and utility programs needed for reproducing the
   executable from it. However, as a special exception, the materials to be
   distributed need not include anything that is normally distributed (in
   either source or binary form) with the major components (compiler,
   kernel, and so on) of the operating system on which the executable runs,
   unless that component itself accompanies the executable.
   It may happen that this requirement contradicts the license restrictions
   of other proprietary libraries that do not normally accompany the
   operating system. Such a contradiction means you cannot use both them
   and the Library together in an executable that you distribute.
 7. You may place library facilities that are a work based on the Library
   side-by-side in a single library together with other library facilities
   not covered by this License, and distribute such a combined library,
   provided that the separate distribution of the work based on the Library
   and of the other library facilities is otherwise permitted, and provided
   that you do these two things:
   a) Accompany the combined library with a copy of the same work based on
      the Library, uncombined with any other library facilities. This must
      be distributed under the terms of the Sections above.
   b) Give prominent notice with the combined library of the fact that part
      of it is a work based on the Library, and explaining where to find
      the accompanying uncombined form of the same work.
 8. You may not copy, modify, sublicense, link with, or distribute the
   Library except as expressly provided under this License. Any attempt
   otherwise to copy, modify, sublicense, link with, or distribute the
   Library is void, and will automatically terminate your rights under this
   License. However, parties who have received copies, or rights, from you
   under this License will not have their licenses terminated so long as
   such parties remain in full compliance.
 9. You are not required to accept this License, since you have not signed
   it. However, nothing else grants you permission to modify or distribute
   the Library or its derivative works. These actions are prohibited by law
   if you do not accept this License. Therefore, by modifying or
   distributing the Library (or any work based on the Library), you
   indicate your acceptance of this License to do so, and all its terms and
   conditions for copying, distributing or modifying the Library or works
   based on it.
 10. Each time you redistribute the Library (or any work based on the
    Library), the recipient automatically receives a license from the
    original licensor to copy, distribute, link with or modify the Library
    subject to these terms and conditions. You may not impose any further
    restrictions on the recipients' exercise of the rights granted
    herein. You are not responsible for enforcing compliance by third
    parties with this License.
 11. If, as a consequence of a court judgment or allegation of patent
    infringement or for any other reason (not limited to patent issues),
    conditions are imposed on you (whether by court order, agreement or
    otherwise) that contradict the conditions of this License, they do not
    excuse you from the conditions of this License. If you cannot
    distribute so as to satisfy simultaneously your obligations under this
    License and any other pertinent obligations, then as a consequence you
    may not distribute the Library at all. For example, if a patent license
    would not permit royalty-free redistribution of the Library by all
    those who receive copies directly or indirectly through you, then the
    only way you could satisfy both it and this License would be to refrain
    entirely from distribution of the Library.
    If any portion of this section is held invalid or unenforceable under
    any particular circumstance, the balance of the section is intended to
    apply, and the section as a whole is intended to apply in other
    circumstances.
    It is not the purpose of this section to induce you to infringe any
    patents or other property right claims or to contest validity of any
    such claims; this section has the sole purpose of protecting the
    integrity of the free software distribution system which is implemented
    by public license practices. Many people have made generous
    contributions to the wide range of software distributed through that
    system in reliance on consistent application of that system; it is up
    to the author/donor to decide if he or she is willing to distribute
    software through any other system and a licensee cannot impose that
    choice.
    This section is intended to make thoroughly clear what is believed to
    be a consequence of the rest of this License.
 12. If the distribution and/or use of the Library is restricted in certain
    countries either by patents or by copyrighted interfaces, the original
    copyright holder who places the Library under this License may add an
    explicit geographical distribution limitation excluding those
    countries, so that distribution is permitted only in or among countries
    not thus excluded. In such case, this License incorporates the
    limitation as if written in the body of this License.
 13. The Free Software Foundation may publish revised and/or new versions of
    the Lesser General Public License from time to time. Such new versions
    will be similar in spirit to the present version, but may differ in
    detail to address new problems or concerns.
    Each version is given a distinguishing version number. If the Library
    specifies a version number of this License which applies to it and "any
    later version", you have the option of following the terms and
    conditions either of that version or of any later version published by
    the Free Software Foundation. If the Library does not specify a license
    version number, you may choose any version ever published by the Free
    Software Foundation.
 14. If you wish to incorporate parts of the Library into other free
    programs whose distribution conditions are incompatible with these,
    write to the author to ask for permission. For software which is
    copyrighted by the Free Software Foundation, write to the Free Software
    Foundation; we sometimes make exceptions for this. Our decision will be
    guided by the two goals of preserving the free status of all
    derivatives of our free software and of promoting the sharing and reuse
    of software generally.
 NO WARRANTY
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
    FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
    OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
    PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
    EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
    ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH
    YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
    NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
    WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
    REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR
    DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
    DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY
    (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
    INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF
    THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR
    OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 END OF TERMS AND CONDITIONS
 How to Apply These Terms to Your New Libraries
 If you develop a new library, and you want it to be of the greatest
 possible use to the public, we recommend making it free software that
 everyone can redistribute and change. You can do so by permitting
 redistribution under these terms (or, alternatively, under the terms of the
 ordinary General Public License).
 To apply these terms, attach the following notices to the library. It is
 safest to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least the
 "copyright" line and a pointer to where the full notice is found.
 one line to give the library's name and an idea of what it does.
 Copyright (C) year name of author
 This library is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or (at
 your option) any later version.
 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add
 information on how to contact you by electronic and paper mail.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the library, if
 necessary. Here is a sample; alter the names:
 Yoyodyne, Inc., hereby disclaims all copyright interest in
 the library `Frob' (a library for tweaking knobs) written
 by James Random Hacker.
 signature of Ty Coon, 1 April 1990
 Ty Coon, President of Vice
 That's all there is to it!
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86_64/README.trace-cmd
+++ b/devlib/bin/x86_64/README.trace-cmd
@@ -1,667 +0,0 @@
 Sources of trace-cmd available at:
 Git commit: 2191498dc35d629003591f727b604120fabbe02d
 Git repository: git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
 Build host info:
 NAME="Alpine Linux"
 ID=alpine
 VERSION_ID=3.13.6
 PRETTY_NAME="Alpine Linux v3.13"
 HOME_URL="https://alpinelinux.org/"
 BUG_REPORT_URL="https://bugs.alpinelinux.org/"
 Build recipe:
 export ARCH=x86_64
 export LISA_ARCH_ASSETS=/lisa/_assets/binaries/x86_64
 export LISA_HOME=''
 export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 #! /bin/bash
 ALPINE_VERSION=v3.13
 ALPINE_BUILD_DEPENDENCIES=(bash gcc git make linux-headers musl-dev pkgconfig)
 BROKEN_CROSS_COMPILATION=1
 download() {
    # Official repo lacks some old version tags
    # git clone git://git.kernel.org/pub/scm/utils/trace-cmd/trace-cmd.git
    # So we use the personal one from Steven Rostedt
    git clone git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/trace-cmd.git
    # Latest available commit after 2.9.1.
    # 2.9.1 itself require some fixes.
    git -C trace-cmd checkout 2191498dc35d629003591f727b604120fabbe02d
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
    git -C libtraceevent checkout libtraceevent-1.1.2
    git clone https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
    git -C libtracefs checkout libtracefs-1.0.2
 }
 build_libtraceevent() {
    cd libtraceevent
    make install
 }
 build_libtracefs() {
    cd libtracefs
    make install
 }
 build_tracecmd() {
    # Disable libaudit, to limit the amount of dependencies
    cd trace-cmd
    make LDFLAGS="-static" NO_AUDIT=yes
    strip "$TRACE_CMD_BIN"
 }
 # For trace-cmd v2.8.3
 TRACE_CMD_BIN=tracecmd/trace-cmd
 build() {
    export PYTHON_VERS=python3
    # Do this while waiting to have the build system working.
    # https://bugzilla.kernel.org/show_bug.cgi?id=212149
    # When fixed, replace this by what is adviced in trace-cmd/PACKAGING
    export prefix="/usr"
    export INSTALL_PATH="$(pwd)/installed_lib_dir"
    INCLUDE_PKG_PATH="$(cut -d':' -f1 <<<$(pkg-config --variable pc_path pkg-config))"
    export PKG_CONFIG="pkg-config --with-path $INSTALL_PATH/$INCLUDE_PKG_PATH --define-variable=prefix=$INSTALL_PATH/$prefix"
    export CFLAGS="-g -Wall -I$INSTALL_PATH/$prefix/include"
    export DESTDIR=$INSTALL_PATH
    (build_libtraceevent) && (build_libtracefs) && (build_tracecmd)
 }
 install() {
    cp -v trace-cmd/"$TRACE_CMD_BIN" "$LISA_ARCH_ASSETS/trace-cmd"
    source "$LISA_HOME/tools/recipes/utils.sh"
    # According to COPYING, the tools are distributed under GPL-2.0 whereas the
    # libraries are under LGLP-2.1.
    # Thus, use GPL-2.0 for trace-cmd and LGLP-2.1 for libtraceevent and
    # libtracefs.
    install_readme trace-cmd trace-cmd LICENSES/GPL-2.0
    install_readme libtraceevent libtraceevent LICENSES/LGPL-2.1
    install_readme libtracefs libtracefs LICENSES/LGPL-2.1
 }
 # Do not use libaudit unless there is a good reason, to avoid build issues in
 # non-necessary dependencies
 download_audit() {
    git clone https://github.com/linux-audit/audit-userspace.git
    git -C audit-userspace checkout master
 }
 build_audit() {
    cd audit-userspace
    ./autogen.sh
    ./configure --disable-shared
    make
 }
 The sources were distributed under the following licence (content of trace-cmd/LICENSES/GPL-2.0):
 Valid-License-Identifier: GPL-2.0
 Valid-License-Identifier: GPL-2.0-only
 Valid-License-Identifier: GPL-2.0+
 Valid-License-Identifier: GPL-2.0-or-later
 SPDX-URL: https://spdx.org/licenses/GPL-2.0.html
 Usage-Guide:
  To use this license in source code, put one of the following SPDX
  tag/value pairs into a comment according to the placement
  guidelines in the licensing rules documentation.
  For 'GNU General Public License (GPL) version 2 only' use:
    SPDX-License-Identifier: GPL-2.0
  or
    SPDX-License-Identifier: GPL-2.0-only
  For 'GNU General Public License (GPL) version 2 or any later version' use:
    SPDX-License-Identifier: GPL-2.0+
  or
    SPDX-License-Identifier: GPL-2.0-or-later
 License-Text:
 		    GNU GENERAL PUBLIC LICENSE
 		       Version 2, June 1991
 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
 			    Preamble
  The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
 License is intended to guarantee your freedom to share and change free
 software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
  When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 in new free programs; and that you know you can do these things.
  To protect your rights, we need to make restrictions that forbid
 anyone to deny you these rights or to ask you to surrender the rights.
 These restrictions translate to certain responsibilities for you if you
 distribute copies of the software, or if you modify it.
  For example, if you distribute copies of such a program, whether
 gratis or for a fee, you must give the recipients all the rights that
 you have.  You must make sure that they, too, receive or can get the
 source code.  And you must show them these terms so they know their
 rights.
  We protect your rights with two steps: (1) copyright the software, and
 (2) offer you this license which gives you legal permission to copy,
 distribute and/or modify the software.
  Also, for each author's protection and ours, we want to make certain
 that everyone understands that there is no warranty for this free
 software.  If the software is modified by someone else and passed on, we
 want its recipients to know that what they have is not the original, so
 that any problems introduced by others will not reflect on the original
 authors' reputations.
  Finally, any free program is threatened constantly by software
 patents.  We wish to avoid the danger that redistributors of a free
 program will individually obtain patent licenses, in effect making the
 program proprietary.  To prevent this, we have made it clear that any
 patent must be licensed for everyone's free use or not licensed at all.
  The precise terms and conditions for copying, distribution and
 modification follow.
 		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains
 a notice placed by the copyright holder saying it may be distributed
 under the terms of this General Public License.  The "Program", below,
 refers to any such program or work, and a "work based on the Program"
 means either the Program or any derivative work under copyright law:
 that is to say, a work containing the Program or a portion of it,
 either verbatim or with modifications and/or translated into another
 language.  (Hereinafter, translation is included without limitation in
 the term "modification".)  Each licensee is addressed as "you".
 Activities other than copying, distribution and modification are not
 covered by this License; they are outside its scope.  The act of
 running the Program is not restricted, and the output from the Program
 is covered only if its contents constitute a work based on the
 Program (independent of having been made by running the Program).
 Whether that is true depends on what the Program does.
  1. You may copy and distribute verbatim copies of the Program's
 source code as you receive it, in any medium, provided that you
 conspicuously and appropriately publish on each copy an appropriate
 copyright notice and disclaimer of warranty; keep intact all the
 notices that refer to this License and to the absence of any warranty;
 and give any other recipients of the Program a copy of this License
 along with the Program.
 You may charge a fee for the physical act of transferring a copy, and
 you may at your option offer warranty protection in exchange for a fee.
  2. You may modify your copy or copies of the Program or any portion
 of it, thus forming a work based on the Program, and copy and
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.
    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.
    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
 themselves, then this License, and its terms, do not apply to those
 sections when you distribute them as separate works.  But when you
 distribute the same sections as part of a whole which is a work based
 on the Program, the distribution of the whole must be on the terms of
 this License, whose permissions for other licensees extend to the
 entire whole, and thus to each and every part regardless of who wrote it.
 Thus, it is not the intent of this section to claim rights or contest
 your rights to work written entirely by you; rather, the intent is to
 exercise the right to control the distribution of derivative or
 collective works based on the Program.
 In addition, mere aggregation of another work not based on the Program
 with the Program (or with a work based on the Program) on a volume of
 a storage or distribution medium does not bring the other work under
 the scope of this License.
  3. You may copy and distribute the Program (or a work based on it,
 under Section 2) in object code or executable form under the terms of
 Sections 1 and 2 above provided that you also do one of the following:
    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,
    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,
    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)
 The source code for a work means the preferred form of the work for
 making modifications to it.  For an executable work, complete source
 code means all the source code for all modules it contains, plus any
 associated interface definition files, plus the scripts used to
 control compilation and installation of the executable.  However, as a
 special exception, the source code distributed need not include
 anything that is normally distributed (in either source or binary
 form) with the major components (compiler, kernel, and so on) of the
 operating system on which the executable runs, unless that component
 itself accompanies the executable.
 If distribution of executable or object code is made by offering
 access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
  4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
 void, and will automatically terminate your rights under this License.
 However, parties who have received copies, or rights, from you under
 this License will not have their licenses terminated so long as such
 parties remain in full compliance.
  5. You are not required to accept this License, since you have not
 signed it.  However, nothing else grants you permission to modify or
 distribute the Program or its derivative works.  These actions are
 prohibited by law if you do not accept this License.  Therefore, by
 modifying or distributing the Program (or any work based on the
 Program), you indicate your acceptance of this License to do so, and
 all its terms and conditions for copying, distributing or modifying
 the Program or works based on it.
  6. Each time you redistribute the Program (or any work based on the
 Program), the recipient automatically receives a license from the
 original licensor to copy, distribute or modify the Program subject to
 these terms and conditions.  You may not impose any further
 restrictions on the recipients' exercise of the rights granted herein.
 You are not responsible for enforcing compliance by third parties to
 this License.
  7. If, as a consequence of a court judgment or allegation of patent
 infringement or for any other reason (not limited to patent issues),
 conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot
 distribute so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you
 may not distribute the Program at all.  For example, if a patent
 license would not permit royalty-free redistribution of the Program by
 all those who receive copies directly or indirectly through you, then
 the only way you could satisfy both it and this License would be to
 refrain entirely from distribution of the Program.
 If any portion of this section is held invalid or unenforceable under
 any particular circumstance, the balance of the section is intended to
 apply and the section as a whole is intended to apply in other
 circumstances.
 It is not the purpose of this section to induce you to infringe any
 patents or other property right claims or to contest validity of any
 such claims; this section has the sole purpose of protecting the
 integrity of the free software distribution system, which is
 implemented by public license practices.  Many people have made
 generous contributions to the wide range of software distributed
 through that system in reliance on consistent application of that
 system; it is up to the author/donor to decide if he or she is willing
 to distribute software through any other system and a licensee cannot
 impose that choice.
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
  8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
 may add an explicit geographical distribution limitation excluding
 those countries, so that distribution is permitted only in or among
 countries not thus excluded.  In such case, this License incorporates
 the limitation as if written in the body of this License.
  9. The Free Software Foundation may publish revised and/or new versions
 of the General Public License from time to time.  Such new versions will
 be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program
 specifies a version number of this License which applies to it and "any
 later version", you have the option of following the terms and conditions
 either of that version or of any later version published by the Free
 Software Foundation.  If the Program does not specify a version number of
 this License, you may choose any version ever published by the Free Software
 Foundation.
  10. If you wish to incorporate parts of the Program into other free
 programs whose distribution conditions are different, write to the author
 to ask for permission.  For software which is copyrighted by the Free
 Software Foundation, write to the Free Software Foundation; we sometimes
 make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 			    NO WARRANTY
  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 REPAIR OR CORRECTION.
  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 		     END OF TERMS AND CONDITIONS
 	    How to Apply These Terms to Your New Programs
  If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
  To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Also add information on how to contact you by electronic and paper mail.
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 mouse-clicks or menu items--whatever suits your program.
 You should also get your employer (if you work as a programmer) or your
 school, if any, to sign a "copyright disclaimer" for the program, if
 necessary.  Here is a sample; alter the names:
  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
 The sources were compiled with musl-libc (content of COPYRIGHT):
 musl as a whole is licensed under the following standard MIT license:
 ----------------------------------------------------------------------
 Copyright © 2005-2020 Rich Felker, et al.
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ----------------------------------------------------------------------
 Authors/contributors include:
 A. Wilcox
 Ada Worcester
 Alex Dowad
 Alex Suykov
 Alexander Monakov
 Andre McCurdy
 Andrew Kelley
 Anthony G. Basile
 Aric Belsito
 Arvid Picciani
 Bartosz Brachaczek
 Benjamin Peterson
 Bobby Bingham
 Boris Brezillon
 Brent Cook
 Chris Spiegel
 Clément Vasseur
 Daniel Micay
 Daniel Sabogal
 Daurnimator
 David Carlier
 David Edelsohn
 Denys Vlasenko
 Dmitry Ivanov
 Dmitry V. Levin
 Drew DeVault
 Emil Renner Berthing
 Fangrui Song
 Felix Fietkau
 Felix Janda
 Gianluca Anzolin
 Hauke Mehrtens
 He X
 Hiltjo Posthuma
 Isaac Dunham
 Jaydeep Patil
 Jens Gustedt
 Jeremy Huntwork
 Jo-Philipp Wich
 Joakim Sindholt
 John Spencer
 Julien Ramseier
 Justin Cormack
 Kaarle Ritvanen
 Khem Raj
 Kylie McClain
 Leah Neukirchen
 Luca Barbato
 Luka Perkov
 M Farkas-Dyck (Strake)
 Mahesh Bodapati
 Markus Wichmann
 Masanori Ogino
 Michael Clark
 Michael Forney
 Mikhail Kremnyov
 Natanael Copa
 Nicholas J. Kain
 orc
 Pascal Cuoq
 Patrick Oppenlander
 Petr Hosek
 Petr Skocik
 Pierre Carrier
 Reini Urban
 Rich Felker
 Richard Pennington
 Ryan Fairfax
 Samuel Holland
 Segev Finer
 Shiz
 sin
 Solar Designer
 Stefan Kristiansson
 Stefan O'Rear
 Szabolcs Nagy
 Timo Teräs
 Trutz Behn
 Valentin Ochs
 Will Dietz
 William Haddon
 William Pitcock
 Portions of this software are derived from third-party works licensed
 under terms compatible with the above MIT license:
 The TRE regular expression implementation (src/regex/reg* and
 src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
 under a 2-clause BSD license (license text in the source files). The
 included version has been heavily modified by Rich Felker in 2012, in
 the interests of size, simplicity, and namespace cleanliness.
 Much of the math library code (src/math/* and src/complex/*) is
 Copyright © 1993,2004 Sun Microsystems or
 Copyright © 2003-2011 David Schultz or
 Copyright © 2003-2009 Steven G. Kargl or
 Copyright © 2003-2009 Bruce D. Evans or
 Copyright © 2008 Stephen L. Moshier or
 Copyright © 2017-2018 Arm Limited
 and labelled as such in comments in the individual source files. All
 have been licensed under extremely permissive terms.
 The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
 The Android Open Source Project and is licensed under a two-clause BSD
 license. It was taken from Bionic libc, used on Android.
 The AArch64 memcpy and memset code (src/string/aarch64/*) are
 Copyright © 1999-2019, Arm Limited.
 The implementation of DES for crypt (src/crypt/crypt_des.c) is
 Copyright © 1994 David Burren. It is licensed under a BSD license.
 The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
 originally written by Solar Designer and placed into the public
 domain. The code also comes with a fallback permissive license for use
 in jurisdictions that may not recognize the public domain.
 The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
 Valentin Ochs and is licensed under an MIT-style license.
 The x86_64 port was written by Nicholas J. Kain and is licensed under
 the standard MIT terms.
 The mips and microblaze ports were originally written by Richard
 Pennington for use in the ellcc project. The original code was adapted
 by Rich Felker for build system and code conventions during upstream
 integration. It is licensed under the standard MIT terms.
 The mips64 port was contributed by Imagination Technologies and is
 licensed under the standard MIT terms.
 The powerpc port was also originally written by Richard Pennington,
 and later supplemented and integrated by John Spencer. It is licensed
 under the standard MIT terms.
 All other files which have no copyright comments are original works
 produced specifically for use as part of this library, written either
 by Rich Felker, the main author of the library, or by one or more
 contibutors listed above. Details on authorship of individual files
 can be found in the git version control history of the project. The
 omission of copyright and license comments in each file is in the
 interest of source tree size.
 In addition, permission is hereby granted for all public header files
 (include/* and arch/*/bits/*) and crt files intended to be linked into
 applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
 the copyright notice and permission notice otherwise required by the
 license, and to use these files without any requirement of
 attribution. These files include substantial contributions from:
 Bobby Bingham
 John Spencer
 Nicholas J. Kain
 Rich Felker
 Richard Pennington
 Stefan Kristiansson
 Szabolcs Nagy
 all of whom have explicitly granted such permission.
 This file previously contained text expressing a belief that most of
 the files covered by the above exception were sufficiently trivial not
 to be subject to copyright, resulting in confusion over whether it
 negated the permissions granted in the license. In the spirit of
 permissive licensing, and of not having licensing issues being an
 obstacle to adoption, that text has been removed.
--- a/devlib/bin/x86_64/busybox
+++ b/devlib/bin/x86_64/busybox
--- a/devlib/bin/x86_64/simpleperf
+++ b/devlib/bin/x86_64/simpleperf
--- a/devlib/bin/x86_64/trace-cmd
+++ b/devlib/bin/x86_64/trace-cmd
--- a/devlib/collector/init.py
+++ b/devlib/collector/init.py
@@ -1,75 +0,0 @@
 #    Copyright 2015 ARM Limited
 #
 # 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.
 #
 import logging
 from devlib.utils.types import caseless_string
 class CollectorBase(object):
    def __init__(self, target):
        self.target = target
        self.logger = logging.getLogger(self.__class__.__name__)
        self.output_path = None
    def reset(self):
        pass
    def start(self):
        pass
    def stop(self):
        pass
    def set_output(self, output_path):
        self.output_path = output_path
    def get_data(self):
        return CollectorOutput()
    def __enter__(self):
        self.reset()
        self.start()
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        self.stop()
 class CollectorOutputEntry(object):
    path_kinds = ['file', 'directory']
    def __init__(self, path, path_kind):
        self.path = path
        path_kind = caseless_string(path_kind)
        if path_kind not in self.path_kinds:
            msg = '{} is not a valid path_kind [{}]'
            raise ValueError(msg.format(path_kind, ' '.join(self.path_kinds)))
        self.path_kind = path_kind
    def __str__(self):
        return self.path
    def __repr__(self):
        return '<{} ({})>'.format(self.path, self.path_kind)
    def __fspath__(self):
        """Allow using with os.path operations"""
        return self.path
 class CollectorOutput(list):
    pass
--- a/devlib/collector/dmesg.py
+++ b/devlib/collector/dmesg.py
@@ -1,321 +0,0 @@
 #    Copyright 2024 ARM Limited
 #
 # 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.
 #
 import re
 from itertools import takewhile
 from datetime import timedelta
 import logging
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.exception import TargetStableError
 from devlib.utils.misc import memoized
 _LOGGER = logging.getLogger('dmesg')
 class KernelLogEntry(object):
    """
    Entry of the kernel ring buffer.
    :param facility: facility the entry comes from
    :type facility: str
    :param level: log level
    :type level: str
    :param timestamp: Timestamp of the entry
    :type timestamp: datetime.timedelta
    :param msg: Content of the entry
    :type msg: str
    :param line_nr: Line number at which this entry appeared in the ``dmesg``
        output. Note that this is not guaranteed to be unique across collectors, as
        the buffer can be cleared. The timestamp is the only reliable index.
    :type line_nr: int
    """
    _TIMESTAMP_MSG_REGEX = re.compile(r'\[(.*?)\] (.*)')
    _RAW_LEVEL_REGEX = re.compile(r'<([0-9]+)>(.*)')
    _PRETTY_LEVEL_REGEX = re.compile(r'\s*([a-z]+)\s*:([a-z]+)\s*:\s*(.*)')
    def __init__(self, facility, level, timestamp, msg, line_nr=0):
        self.facility = facility
        self.level = level
        self.timestamp = timestamp
        self.msg = msg
        self.line_nr = line_nr
    @classmethod
    def from_str(cls, line, line_nr=0):
        """
        Parses a "dmesg --decode" output line, formatted as following:
        kern  :err   : [3618282.310743] nouveau 0000:01:00.0: systemd-logind[988]: nv50cal_space: -16
        Or the more basic output given by "dmesg -r":
        <3>[3618282.310743] nouveau 0000:01:00.0: systemd-logind[988]: nv50cal_space: -16
        """
        def parse_raw_level(line):
            match = cls._RAW_LEVEL_REGEX.match(line)
            if not match:
                raise ValueError(f'dmesg entry format not recognized: {line}')
            level, remainder = match.groups()
            levels = DmesgCollector.LOG_LEVELS
            # BusyBox dmesg can output numbers that need to wrap around
            level = levels[int(level) % len(levels)]
            return level, remainder
        def parse_pretty_level(line):
            match = cls._PRETTY_LEVEL_REGEX.match(line)
            if not match:
                raise ValueError(f'dmesg entry pretty format not recognized: {line}')
            facility, level, remainder = match.groups()
            return facility, level, remainder
        def parse_timestamp_msg(line):
            match = cls._TIMESTAMP_MSG_REGEX.match(line)
            if not match:
                raise ValueError(f'dmesg entry timestamp format not recognized: {line}')
            timestamp, msg = match.groups()
            timestamp = timedelta(seconds=float(timestamp.strip()))
            return timestamp, msg
        line = line.strip()
        # If we can parse the raw prio directly, that is a basic line
        try:
            level, remainder = parse_raw_level(line)
            facility = None
        except ValueError:
            facility, level, remainder = parse_pretty_level(line)
        timestamp, msg = parse_timestamp_msg(remainder)
        return cls(
            facility=facility,
            level=level,
            timestamp=timestamp,
            msg=msg.strip(),
            line_nr=line_nr,
        )
    @classmethod
    def from_dmesg_output(cls, dmesg_out, error=None):
        """
        Return a generator of :class:`KernelLogEntry` for each line of the
        output of dmesg command.
        :param error: If ``"raise"`` or ``None``, an exception will be raised
            if a parsing error occurs. If ``"warn"``, it will be logged at
            WARNING level. If ``"ignore"``, it will be ignored. If a callable
            is passed, the exception will be passed to it.
        :type error: str or None or typing.Callable[[BaseException], None]
        .. note:: The same restrictions on the dmesg output format as for
            :meth:`from_str` apply.
        """
        for i, line in enumerate(dmesg_out.splitlines()):
            if line.strip():
                try:
                    yield cls.from_str(line, line_nr=i)
                except Exception as e:
                    if error in (None, 'raise'):
                        raise e
                    elif error == 'warn':
                        _LOGGER.warn(f'error while parsing line "{line!r}": {e}')
                    elif error == 'ignore':
                        pass
                    elif callable(error):
                        error(e)
                    else:
                        raise ValueError(f'Unknown error handling strategy: {error}')
    def __str__(self):
        facility = self.facility + ': ' if self.facility else ''
        return '{facility}{level}: [{timestamp}] {msg}'.format(
            facility=facility,
            level=self.level,
            timestamp=self.timestamp.total_seconds(),
            msg=self.msg,
        )
 class DmesgCollector(CollectorBase):
    """
    Dmesg output collector.
    :param level: Minimum log level to enable. All levels that are more
        critical will be collected as well.
    :type level: str
    :param facility: Facility to record, see dmesg --help for the list.
    :type level: str
    :param empty_buffer: If ``True``, the kernel dmesg ring buffer will be
        emptied before starting. Note that this will break nesting of collectors,
        so it's not recommended unless it's really necessary.
    :type empty_buffer: bool
    .. warning:: If BusyBox dmesg is used, facility and level will be ignored,
        and the parsed entries will also lack that information.
    """
    # taken from "dmesg --help"
    # This list needs to be ordered by priority
    LOG_LEVELS = [
        "emerg",        # system is unusable
        "alert",        # action must be taken immediately
        "crit",         # critical conditions
        "err",          # error conditions
        "warn",         # warning conditions
        "notice",       # normal but significant condition
        "info",         # informational
        "debug",        # debug-level messages
    ]
    def __init__(self, target, level=LOG_LEVELS[-1], facility='kern', empty_buffer=False, parse_error=None):
        super(DmesgCollector, self).__init__(target)
        if not target.is_rooted:
            raise TargetStableError('Cannot collect dmesg on non-rooted target')
        self.output_path = None
        if level not in self.LOG_LEVELS:
            raise ValueError('level needs to be one of: {}'.format(
                ', '.join(self.LOG_LEVELS)
            ))
        self.level = level
        # Check if we have a dmesg from a recent util-linux build, rather than
        # e.g. busybox's dmesg or the one shipped on some Android versions
        # (toybox).  Note: BusyBox dmesg does not support -h, but will still
        # print the help with an exit code of 1
        help_ = self.target.execute('dmesg -h', check_exit_code=False)
        self.basic_dmesg = not all(
            opt in help_
            for opt in ('--facility', '--force-prefix', '--decode', '--level')
        )
        self.facility = facility
        try:
            needs_root = target.read_sysctl('kernel.dmesg_restrict')
        except ValueError:
            needs_root = True
        else:
            needs_root = bool(int(needs_root))
        self.needs_root = needs_root
        self._begin_timestamp = None
        self.empty_buffer = empty_buffer
        self._dmesg_out = None
        self._parse_error = parse_error
    @property
    def dmesg_out(self):
        out = self._dmesg_out
        if out is None:
            return None
        else:
            try:
                entry = self.entries[0]
            except IndexError:
                return ''
            else:
                i = entry.line_nr
                return '\n'.join(out.splitlines()[i:])
    @property
    def entries(self):
        return self._get_entries(
            self._dmesg_out,
            self._begin_timestamp,
            error=self._parse_error,
        )
    @memoized
    def _get_entries(self, dmesg_out, timestamp, error):
        entries = KernelLogEntry.from_dmesg_output(dmesg_out, error=error)
        entries = list(entries)
        if timestamp is None:
            return entries
        else:
            try:
                first = entries[0]
            except IndexError:
                pass
            else:
                if first.timestamp > timestamp:
                    msg = 'The dmesg ring buffer has ran out of memory or has been cleared and some entries have been lost'
                    raise ValueError(msg)
            return [
                entry
                for entry in entries
                # Only select entries that are more recent than the one at last
                # reset()
                if entry.timestamp > timestamp
            ]
    def _get_output(self):
        levels_list = list(takewhile(
            lambda level: level != self.level,
            self.LOG_LEVELS
        ))
        levels_list.append(self.level)
        if self.basic_dmesg:
            cmd = 'dmesg -r'
        else:
            cmd = 'dmesg --facility={facility} --force-prefix --decode --level={levels}'.format(
                levels=','.join(levels_list),
                facility=self.facility,
            )
        self._dmesg_out = self.target.execute(cmd, as_root=self.needs_root)
    def reset(self):
        self._dmesg_out = None
    def start(self):
        # If the buffer is emptied on start(), it does not matter as we will
        # not end up with entries dating from before start()
        if self.empty_buffer:
            # Empty the dmesg ring buffer. This requires root in all cases
            self.target.execute('dmesg -c', as_root=True)
        else:
            self._get_output()
            try:
                entry = self.entries[-1]
            except IndexError:
                pass
            else:
                self._begin_timestamp = entry.timestamp
    def stop(self):
        self._get_output()
    def set_output(self, output_path):
        self.output_path = output_path
    def get_data(self):
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        with open(self.output_path, 'wt') as f:
            f.write((self.dmesg_out or '') + '\n')
        return CollectorOutput([CollectorOutputEntry(self.output_path, 'file')])
--- a/devlib/collector/ftrace.py
+++ b/devlib/collector/ftrace.py
@@ -1,554 +0,0 @@
 #    Copyright 2015-2018 ARM Limited
 #
 # 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.
 #
 import os
 import json
 import time
 import re
 import subprocess
 import sys
 import contextlib
 from shlex import quote
 import signal
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.exception import TargetStableError, HostError
 from devlib.utils.misc import check_output, which, memoized
 from devlib.utils.asyn import asyncf
 TRACE_MARKER_START = 'TRACE_MARKER_START'
 TRACE_MARKER_STOP = 'TRACE_MARKER_STOP'
 OUTPUT_TRACE_FILE = 'trace.dat'
 OUTPUT_PROFILE_FILE = 'trace_stat.dat'
 DEFAULT_EVENTS = [
    'cpu_frequency',
    'cpu_idle',
    'sched_migrate_task',
    'sched_process_exec',
    'sched_process_fork',
    'sched_stat_iowait',
    'sched_switch',
    'sched_wakeup',
    'sched_wakeup_new',
 ]
 TIMEOUT = 180
 # Regexps for parsing of function profiling data
 CPU_RE = re.compile(r'  Function \(CPU([0-9]+)\)')
 STATS_RE = re.compile(r'([^ ]*) +([0-9]+) +([0-9.]+) us +([0-9.]+) us +([0-9.]+) us')
 class FtraceCollector(CollectorBase):
    # pylint: disable=too-many-locals,too-many-branches,too-many-statements
    def __init__(self, target,
                 events=None,
                 functions=None,
                 tracer=None,
                 trace_children_functions=False,
                 buffer_size=None,
                 top_buffer_size=None,
                 buffer_size_step=1000,
                 tracing_path=None,
                 automark=True,
                 autoreport=True,
                 autoview=False,
                 no_install=False,
                 strict=False,
                 report_on_target=False,
                 trace_clock='local',
                 saved_cmdlines_nr=4096,
                 mode='write-to-memory',
                 ):
        super(FtraceCollector, self).__init__(target)
        self.events = events if events is not None else DEFAULT_EVENTS
        self.functions = functions
        self.tracer = tracer
        self.trace_children_functions = trace_children_functions
        self.buffer_size = buffer_size
        self.top_buffer_size = top_buffer_size
        self.tracing_path = self._resolve_tracing_path(target, tracing_path)
        self.automark = automark
        self.autoreport = autoreport
        self.autoview = autoview
        self.strict = strict
        self.report_on_target = report_on_target
        self.target_output_file = target.path.join(self.target.working_directory, OUTPUT_TRACE_FILE)
        text_file_name = target.path.splitext(OUTPUT_TRACE_FILE)[0] + '.txt'
        self.target_text_file = target.path.join(self.target.working_directory, text_file_name)
        self.output_path = None
        self.target_binary = None
        self.host_binary = None
        self.start_time = None
        self.stop_time = None
        self.function_string = None
        self.trace_clock = trace_clock
        self.saved_cmdlines_nr = saved_cmdlines_nr
        self._reset_needed = True
        self.mode = mode
        self._bg_cmd = None
        # pylint: disable=bad-whitespace
        # Setup tracing paths
        self.available_events_file    = self.target.path.join(self.tracing_path, 'available_events')
        self.available_functions_file = self.target.path.join(self.tracing_path, 'available_filter_functions')
        self.current_tracer_file      = self.target.path.join(self.tracing_path, 'current_tracer')
        self.function_profile_file    = self.target.path.join(self.tracing_path, 'function_profile_enabled')
        self.marker_file              = self.target.path.join(self.tracing_path, 'trace_marker')
        self.ftrace_filter_file       = self.target.path.join(self.tracing_path, 'set_ftrace_filter')
        self.available_tracers_file   = self.target.path.join(self.tracing_path, 'available_tracers')
        self.kprobe_events_file       = self.target.path.join(self.tracing_path, 'kprobe_events')
        self.host_binary = which('trace-cmd')
        self.kernelshark = which('kernelshark')
        if not self.target.is_rooted:
            raise TargetStableError('trace-cmd instrument cannot be used on an unrooted device.')
        if self.autoreport and not self.report_on_target and self.host_binary is None:
            raise HostError('trace-cmd binary must be installed on the host if autoreport=True.')
        if self.autoview and self.kernelshark is None:
            raise HostError('kernelshark binary must be installed on the host if autoview=True.')
        if not no_install:
            host_file = os.path.join(PACKAGE_BIN_DIRECTORY, self.target.abi, 'trace-cmd')
            self.target_binary = self.target.install(host_file)
        else:
            if not self.target.is_installed('trace-cmd'):
                raise TargetStableError('No trace-cmd found on device and no_install=True is specified.')
            self.target_binary = 'trace-cmd'
        # Validate required events to be traced
        def event_to_regex(event):
            if not event.startswith('*'):
                event = '*' + event
            return re.compile(event.replace('*', '.*'))
        def event_is_in_list(event, events):
            return any(
                event_to_regex(event).match(_event)
                for _event in events
            )
        available_events = self.available_events
        unavailable_events = [
            event
            for event in self.events
            if not event_is_in_list(event, available_events)
        ]
        if unavailable_events:
            message = 'Events not available for tracing: {}'.format(
                ', '.join(unavailable_events)
            )
            if self.strict:
                raise TargetStableError(message)
            else:
                self.target.logger.warning(message)
        selected_events = sorted(set(self.events) - set(unavailable_events))
        if self.tracer and self.tracer not in self.available_tracers:
            raise TargetStableError('Unsupported tracer "{}". Available tracers: {}'.format(
                self.tracer, ', '.join(self.available_tracers)))
        # Check for function tracing support
        if self.functions:
            # Validate required functions to be traced
            selected_functions = []
            for function in self.functions:
                if function not in self.available_functions:
                    message = 'Function [{}] not available for tracing/profiling'.format(function)
                    if self.strict:
                        raise TargetStableError(message)
                    self.target.logger.warning(message)
                else:
                    selected_functions.append(function)
            # Function profiling
            if self.tracer is None:
                if not self.target.file_exists(self.function_profile_file):
                    raise TargetStableError('Function profiling not supported. '\
                                            'A kernel build with CONFIG_FUNCTION_PROFILER enable is required')
                self.function_string = _build_trace_functions(selected_functions)
                # If function profiling is enabled we always need at least one event.
                # Thus, if not other events have been specified, try to add at least
                # a tracepoint which is always available and possibly triggered few
                # times.
                if not selected_events:
                    selected_events = ['sched_wakeup_new']
            # Function tracing
            elif self.tracer == 'function':
                self.function_string = _build_graph_functions(selected_functions, False)
            # Function graphing
            elif self.tracer == 'function_graph':
                self.function_string = _build_graph_functions(selected_functions, trace_children_functions)
        self._selected_events = selected_events
    @property
    def _buffer_size(self):
        top = self.top_buffer_size
        nontop = self.buffer_size
        if top is None and nontop is None:
            return None
        elif top is None:
            return nontop
        elif nontop is None:
            return top
        else:
            return max(top, nontop)
    @property
    def event_string(self):
        return _build_trace_events(self._selected_events)
    @classmethod
    def _resolve_tracing_path(cls, target, path):
        if path is None:
            return cls.find_tracing_path(target)
        else:
            return path
    @classmethod
    def find_tracing_path(cls, target):
        fs_list = [
            fs.mount_point
            for fs in target.list_file_systems()
            if fs.fs_type == 'tracefs'
        ]
        try:
            return fs_list[0]
        except IndexError:
            # Default legacy value, when the kernel did not have a tracefs yet
            return '/sys/kernel/debug/tracing'
    @property
    @memoized
    def available_tracers(self):
        """
        List of ftrace tracers supported by the target's kernel.
        """
        return self.target.read_value(self.available_tracers_file).split(' ')
    @property
    def available_events(self):
        """
        List of ftrace events supported by the target's kernel.
        """
        return self.target.read_value(self.available_events_file).splitlines()
    @property
    @memoized
    def available_functions(self):
        """
        List of functions whose tracing/profiling is supported by the target's kernel.
        """
        return self.target.read_value(self.available_functions_file).splitlines()
    def reset(self):
        # Save kprobe events
        try:
            kprobe_events = self.target.read_value(self.kprobe_events_file)
        except TargetStableError:
            kprobe_events = None
        self.target.execute('{} reset'.format(self.target_binary),
                            as_root=True, timeout=TIMEOUT)
        # This code is currently not necessary as we are not using alternate
        # instances (not using -B parameter). If we end up using it again, it
        # may very well be that trace-cmd at that point takes care of that
        # problem itself somehow, so this should be re-evaluated.
        # trace-cmd start will not set the top-level buffer size if passed -B
        # parameter, but unfortunately some events still end up there (e.g.
        # print event). So we still need to set that size, otherwise the buffer
        # might be too small and some event lost.
        #  top_buffer_size = self.top_buffer_size or self.buffer_size
        #  if top_buffer_size:
            #  self.target.write_value(
                #  self.target.path.join(self.tracing_path, 'buffer_size_kb'),
                #  top_buffer_size, verify=False
            #  )
        if self.functions:
            self.target.write_value(self.function_profile_file, 0, verify=False)
        # Restore kprobe events
        if kprobe_events:
            self.target.write_value(self.kprobe_events_file, kprobe_events)
        self._reset_needed = False
    def _trace_frequencies(self):
        if 'cpu_frequency' in self._selected_events:
            self.logger.debug('Trace CPUFreq frequencies')
            try:
                mod = self.target.cpufreq
            except TargetStableError as e:
                self.logger.error(f'Could not trace CPUFreq frequencies as the cpufreq module cannot be loaded: {e}')
            else:
                mod.trace_frequencies()
    def _trace_idle(self):
        if 'cpu_idle' in self._selected_events:
            self.logger.debug('Trace CPUIdle states')
            try:
                mod = self.target.cpuidle
            except TargetStableError as e:
                self.logger.error(f'Could not trace CPUIdle states as the cpuidle module cannot be loaded: {e}')
            else:
                mod.perturb_cpus()
    @asyncf
    async def start(self):
        self.start_time = time.time()
        if self._reset_needed:
            self.reset()
        if self.tracer is not None and 'function' in self.tracer:
            tracecmd_functions = self.function_string
        else:
            tracecmd_functions = ''
        tracer_string = '-p {}'.format(self.tracer) if self.tracer else ''
        # Ensure kallsyms contains addresses if possible, so that function the
        # collected trace contains enough data for pretty printing
        with contextlib.suppress(TargetStableError):
            self.target.write_value('/proc/sys/kernel/kptr_restrict', 0)
        params = '{buffer_size} {cmdlines_size} {clock} {events} {tracer} {functions}'.format(
            events=self.event_string,
            tracer=tracer_string,
            functions=tracecmd_functions,
            buffer_size='-b {}'.format(self._buffer_size) if self._buffer_size is not None else '',
            clock='-C {}'.format(self.trace_clock) if self.trace_clock else '',
            cmdlines_size='--cmdlines-size {}'.format(self.saved_cmdlines_nr) if self.saved_cmdlines_nr is not None else '',
        )
        mode = self.mode
        if mode == 'write-to-disk':
            bg_cmd = self.target.background(
                # cd into the working_directory first to workaround this issue:
                # https://lore.kernel.org/linux-trace-devel/20240119162743.1a107fa9@gandalf.local.home/
                f'cd {self.target.working_directory} && devlib-signal-target {self.target_binary} record -o {quote(self.target_output_file)} {params}',
                as_root=True,
            )
            assert self._bg_cmd is None
            self._bg_cmd = bg_cmd.__enter__()
        elif mode == 'write-to-memory':
            self.target.execute(
                f'{self.target_binary} start {params}',
                as_root=True,
            )
        else:
            raise ValueError(f'Unknown mode {mode}')
        if self.automark:
            self.mark_start()
        self._trace_frequencies()
        self._trace_idle()
        # Enable kernel function profiling
        if self.functions and self.tracer is None:
            target = self.target
            await target.async_manager.concurrently(
                execute.asyn('echo nop > {}'.format(self.current_tracer_file),
                                    as_root=True),
                execute.asyn('echo 0 > {}'.format(self.function_profile_file),
                                    as_root=True),
                execute.asyn('echo {} > {}'.format(self.function_string, self.ftrace_filter_file),
                                    as_root=True),
                execute.asyn('echo 1 > {}'.format(self.function_profile_file),
                                    as_root=True),
            )
    def stop(self):
        # Disable kernel function profiling
        if self.functions and self.tracer is None:
            self.target.execute('echo 0 > {}'.format(self.function_profile_file),
                                as_root=True)
        self.stop_time = time.time()
        if self.automark:
            self.mark_stop()
        mode = self.mode
        if mode == 'write-to-disk':
            bg_cmd = self._bg_cmd
            self._bg_cmd = None
            assert bg_cmd is not None
            bg_cmd.send_signal(signal.SIGINT)
            bg_cmd.communicate()
            bg_cmd.__exit__(None, None, None)
        elif mode == 'write-to-memory':
            self.target.execute('{} stop'.format(self.target_binary),
                                timeout=TIMEOUT, as_root=True)
        else:
            raise ValueError(f'Unknown mode {mode}')
        self._reset_needed = True
    def set_output(self, output_path):
        if os.path.isdir(output_path):
            output_path = os.path.join(output_path, os.path.basename(self.target_output_file))
        self.output_path = output_path
    def get_data(self):
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        busybox = quote(self.target.busybox)
        mode = self.mode
        if mode == 'write-to-disk':
            # Interrupting trace-cmd record will make it create the file
            pass
        elif mode == 'write-to-memory':
            cmd = f'{self.target_binary} extract -o {self.target_output_file} && {busybox} chmod 666 {self.target_output_file}'
            self.target.execute(cmd, timeout=TIMEOUT, as_root=True)
        else:
            raise ValueError(f'Unknown mode {mode}')
        # The size of trace.dat will depend on how long trace-cmd was running.
        # Therefore timout for the pull command must also be adjusted
        # accordingly.
        pull_timeout = 10 * (self.stop_time - self.start_time)
        self.target.pull(self.target_output_file, self.output_path, timeout=pull_timeout)
        output = CollectorOutput()
        if not os.path.isfile(self.output_path):
            self.logger.warning('Binary trace not pulled from device.')
        else:
            output.append(CollectorOutputEntry(self.output_path, 'file'))
            if self.autoreport:
                textfile = os.path.splitext(self.output_path)[0] + '.txt'
                if self.report_on_target:
                    self.generate_report_on_target()
                    self.target.pull(self.target_text_file,
                                     textfile, timeout=pull_timeout)
                else:
                    self.report(self.output_path, textfile)
                output.append(CollectorOutputEntry(textfile, 'file'))
            if self.autoview:
                self.view(self.output_path)
        return output
    def get_stats(self, outfile):
        if not (self.functions and self.tracer is None):
            return
        if os.path.isdir(outfile):
            outfile = os.path.join(outfile, OUTPUT_PROFILE_FILE)
        # pylint: disable=protected-access
        output = self.target._execute_util('ftrace_get_function_stats',
                                            as_root=True)
        function_stats = {}
        for line in output.splitlines():
            # Match a new CPU dataset
            match = CPU_RE.search(line)
            if match:
                cpu_id = int(match.group(1))
                function_stats[cpu_id] = {}
                self.logger.debug("Processing stats for CPU%d...", cpu_id)
                continue
            # Match a new function dataset
            match = STATS_RE.search(line)
            if match:
                fname = match.group(1)
                function_stats[cpu_id][fname] = {
                        'hits' : int(match.group(2)),
                        'time' : float(match.group(3)),
                        'avg'  : float(match.group(4)),
                        's_2'  : float(match.group(5)),
                    }
                self.logger.debug(" %s: %s",
                             fname, function_stats[cpu_id][fname])
        self.logger.debug("FTrace stats output [%s]...", outfile)
        with open(outfile, 'w') as fh:
            json.dump(function_stats, fh, indent=4)
        self.logger.debug("FTrace function stats save in [%s]", outfile)
        return function_stats
    def report(self, binfile, destfile):
        # To get the output of trace.dat, trace-cmd must be installed
        # This is done host-side because the generated file is very large
        try:
            command = '{} report {} > {}'.format(self.host_binary, binfile, destfile)
            self.logger.debug(command)
            process = subprocess.Popen(command, stderr=subprocess.PIPE, shell=True)
            _, error = process.communicate()
            error = error.decode(sys.stdout.encoding or 'utf-8', 'replace')
            if process.returncode:
                raise TargetStableError('trace-cmd returned non-zero exit code {}'.format(process.returncode))
            if error:
                # logged at debug level, as trace-cmd always outputs some
                # errors that seem benign.
                self.logger.debug(error)
            if os.path.isfile(destfile):
                self.logger.debug('Verifying traces.')
                with open(destfile) as fh:
                    for line in fh:
                        if 'EVENTS DROPPED' in line:
                            self.logger.warning('Dropped events detected.')
                            break
                    else:
                        self.logger.debug('Trace verified.')
            else:
                self.logger.warning('Could not generate trace.txt.')
        except OSError:
            raise HostError('Could not find trace-cmd. Please make sure it is installed and is in PATH.')
    def generate_report_on_target(self):
        command = '{} report {} > {}'.format(self.target_binary,
                                             self.target_output_file,
                                             self.target_text_file)
        self.target.execute(command, timeout=TIMEOUT)
    def view(self, binfile):
        check_output('{} {}'.format(self.kernelshark, binfile), shell=True)
    def teardown(self):
        self.target.remove(self.target.path.join(self.target.working_directory, OUTPUT_TRACE_FILE))
    def mark_start(self):
        self.target.write_value(self.marker_file, TRACE_MARKER_START, verify=False)
    def mark_stop(self):
        self.target.write_value(self.marker_file, TRACE_MARKER_STOP, verify=False)
 def _build_trace_events(events):
    event_string = ' '.join(['-e {}'.format(e) for e in events])
    return event_string
 def _build_trace_functions(functions):
    function_string = " ".join(functions)
    return function_string
 def _build_graph_functions(functions, trace_children_functions):
    opt = 'g' if trace_children_functions else 'l'
    return ' '.join(
        '-{} {}'.format(opt, quote(f))
        for f in functions
    )
--- a/devlib/collector/logcat.py
+++ b/devlib/collector/logcat.py
@@ -1,78 +0,0 @@
 #    Copyright 2024 ARM Limited
 #
 # 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.
 #
 import os
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.utils.android import LogcatMonitor
 class LogcatCollector(CollectorBase):
    def __init__(self, target, regexps=None, logcat_format=None):
        super(LogcatCollector, self).__init__(target)
        self.regexps = regexps
        self.logcat_format = logcat_format
        self.output_path = None
        self._collecting = False
        self._prev_log = None
        self._monitor = None
    def reset(self):
        """
        Clear Collector data but do not interrupt collection
        """
        if not self._monitor:
            return
        if self._collecting:
            self._monitor.clear_log()
        elif self._prev_log:
            os.remove(self._prev_log)
            self._prev_log = None
    def start(self):
        """
        Start collecting logcat lines
        """
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        self._monitor = LogcatMonitor(self.target, self.regexps, logcat_format=self.logcat_format)
        if self._prev_log:
            # Append new data collection to previous collection
            self._monitor.start(self._prev_log)
        else:
            self._monitor.start(self.output_path)
        self._collecting = True
    def stop(self):
        """
        Stop collecting logcat lines
        """
        if not self._collecting:
            raise RuntimeError('Logcat monitor not running, nothing to stop')
        self._monitor.stop()
        self._collecting = False
        self._prev_log = self._monitor.logfile
    def set_output(self, output_path):
        self.output_path = output_path
    def get_data(self):
        if self.output_path is None:
            raise RuntimeError("No data collected.")
        return CollectorOutput([CollectorOutputEntry(self.output_path, 'file')])
--- a/devlib/collector/perf.py
+++ b/devlib/collector/perf.py
@@ -1,283 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import os
 import re
 import time
 from past.builtins import basestring, zip
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.utils.misc import ensure_file_directory_exists as _f
 PERF_STAT_COMMAND_TEMPLATE = '{binary} {command} {options} {events} {sleep_cmd} > {outfile} 2>&1 '
 PERF_REPORT_COMMAND_TEMPLATE= '{binary} report {options} -i {datafile} > {outfile} 2>&1 '
 PERF_REPORT_SAMPLE_COMMAND_TEMPLATE= '{binary} report-sample {options} -i {datafile} > {outfile} '
 PERF_RECORD_COMMAND_TEMPLATE= '{binary} record {options} {events} -o {outfile}'
 PERF_DEFAULT_EVENTS = [
    'cpu-migrations',
    'context-switches',
 ]
 SIMPLEPERF_DEFAULT_EVENTS = [
    'raw-cpu-cycles',
    'raw-l1-dcache',
    'raw-l1-dcache-refill',
    'raw-br-mis-pred',
    'raw-instruction-retired',
 ]
 DEFAULT_EVENTS = {'perf':PERF_DEFAULT_EVENTS, 'simpleperf':SIMPLEPERF_DEFAULT_EVENTS}
 class PerfCollector(CollectorBase):
    """
    Perf is a Linux profiling with performance counters.
    Simpleperf is an Android profiling tool with performance counters.
    It is highly recomended to use perf_type = simpleperf when using this instrument
    on android devices, since it recognises android symbols in record mode and is much more stable
    when reporting record .data files. For more information see simpleperf documentation at:
    https://android.googlesource.com/platform/system/extras/+/master/simpleperf/doc/README.md
    Performance counters are CPU hardware registers that count hardware events
    such as instructions executed, cache-misses suffered, or branches
    mispredicted. They form a basis for profiling applications to trace dynamic
    control flow and identify hotspots.
    Perf accepts options and events. If no option is given the default '-a' is
    used. For events, the default events are migrations and cs for perf and raw-cpu-cycles,
    raw-l1-dcache, raw-l1-dcache-refill, raw-instructions-retired. They both can
    be specified in the config file.
    Events must be provided as a list that contains them and they will look like
    this ::
        perf_events = ['migrations', 'cs']
    Events can be obtained by typing the following in the command line on the
    device ::
        perf list
        simpleperf list
    Whereas options, they can be provided as a single string as following ::
        perf_options = '-a -i'
    Options can be obtained by running the following in the command line ::
        man perf-stat
    """
    def __init__(self,
                 target,
                 perf_type='perf',
                 command='stat',
                 events=None,
                 optionstring=None,
                 report_options=None,
                 run_report_sample=False,
                 report_sample_options=None,
                 labels=None,
                 force_install=False,
                 validate_events=True):
        super(PerfCollector, self).__init__(target)
        self.force_install = force_install
        self.labels = labels
        self.report_options = report_options
        self.run_report_sample = run_report_sample
        self.report_sample_options = report_sample_options
        self.output_path = None
        self.validate_events = validate_events
        # Validate parameters
        if isinstance(optionstring, list):
            self.optionstrings = optionstring
        else:
            self.optionstrings = [optionstring]
        if perf_type in ['perf', 'simpleperf']:
            self.perf_type = perf_type
        else:
            raise ValueError('Invalid perf type: {}, must be perf or simpleperf'.format(perf_type))
        if not events:
            self.events = DEFAULT_EVENTS[self.perf_type]
        else:
            self.events = events
        if isinstance(self.events, basestring):
            self.events = [self.events]
        if not self.labels:
            self.labels = ['perf_{}'.format(i) for i in range(len(self.optionstrings))]
        if len(self.labels) != len(self.optionstrings):
            raise ValueError('The number of labels must match the number of optstrings provided for perf.')
        if command in ['stat', 'record']:
            self.command = command
        else:
            raise ValueError('Unsupported perf command, must be stat or record')
        if report_options and (command != 'record'):
            raise ValueError('report_options specified, but command is not record')
        if report_sample_options and (command != 'record'):
            raise ValueError('report_sample_options specified, but command is not record')
        self.binary = self.target.get_installed(self.perf_type)
        if self.force_install or not self.binary:
            self.binary = self._deploy_perf()
        if self.validate_events:
            self._validate_events(self.events)
        self.commands = self._build_commands()
    def reset(self):
        self.target.killall(self.perf_type, as_root=self.target.is_rooted)
        self.target.remove(self.target.get_workpath('TemporaryFile*'))
        for label in self.labels:
            filepath = self._get_target_file(label, 'data')
            self.target.remove(filepath)
            filepath = self._get_target_file(label, 'rpt')
            self.target.remove(filepath)
            filepath = self._get_target_file(label, 'rptsamples')
            self.target.remove(filepath)
    def start(self):
        for command in self.commands:
            self.target.background(command, as_root=self.target.is_rooted)
    def stop(self):
        self.target.killall(self.perf_type, signal='SIGINT',
                            as_root=self.target.is_rooted)
        if self.perf_type == "perf" and self.command == "stat":
            # perf doesn't transmit the signal to its sleep call so handled here:
            self.target.killall('sleep', as_root=self.target.is_rooted)
            # NB: we hope that no other "important" sleep is on-going
    def set_output(self, output_path):
        self.output_path = output_path
    def get_data(self):
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        output = CollectorOutput()
        for label in self.labels:
            if self.command == 'record':
                self._wait_for_data_file_write(label, self.output_path)
                path = self._pull_target_file_to_host(label, 'rpt', self.output_path)
                output.append(CollectorOutputEntry(path, 'file'))
                if self.run_report_sample:
                    report_samples_path = self._pull_target_file_to_host(label, 'rptsamples', self.output_path)
                    output.append(CollectorOutputEntry(report_samples_path, 'file'))
            else:
                path = self._pull_target_file_to_host(label, 'out', self.output_path)
                output.append(CollectorOutputEntry(path, 'file'))
        return output
    def _deploy_perf(self):
        host_executable = os.path.join(PACKAGE_BIN_DIRECTORY,
                                       self.target.abi, self.perf_type)
        return self.target.install(host_executable)
    def _get_target_file(self, label, extension):
        return self.target.get_workpath('{}.{}'.format(label, extension))
    def _build_commands(self):
        commands = []
        for opts, label in zip(self.optionstrings, self.labels):
            if self.command == 'stat':
                commands.append(self._build_perf_stat_command(opts, self.events, label))
            else:
                commands.append(self._build_perf_record_command(opts, label))
        return commands
    def _build_perf_stat_command(self, options, events, label):
        event_string = ' '.join(['-e {}'.format(e) for e in events])
        sleep_cmd = 'sleep 1000' if self.perf_type == 'perf' else ''
        command = PERF_STAT_COMMAND_TEMPLATE.format(binary = self.binary,
                                               command = self.command,
                                               options = options or '',
                                               events = event_string,
                                               sleep_cmd = sleep_cmd,
                                               outfile = self._get_target_file(label, 'out'))
        return command
    def _build_perf_report_command(self, report_options, label):
        command = PERF_REPORT_COMMAND_TEMPLATE.format(binary=self.binary,
                                                      options=report_options or '',
                                                      datafile=self._get_target_file(label, 'data'),
                                                      outfile=self._get_target_file(label, 'rpt'))
        return command
    def _build_perf_report_sample_command(self, label):
        command = PERF_REPORT_SAMPLE_COMMAND_TEMPLATE.format(binary=self.binary,
                                                      options=self.report_sample_options or '',
                                                      datafile=self._get_target_file(label, 'data'),
                                                      outfile=self._get_target_file(label, 'rptsamples'))
        return command
    def _build_perf_record_command(self, options, label):
        event_string = ' '.join(['-e {}'.format(e) for e in self.events])
        command = PERF_RECORD_COMMAND_TEMPLATE.format(binary=self.binary,
                                                      options=options or '',
                                                      events=event_string,
                                                      outfile=self._get_target_file(label, 'data'))
        return command
    def _pull_target_file_to_host(self, label, extension, output_path):
        target_file = self._get_target_file(label, extension)
        host_relpath = os.path.basename(target_file)
        host_file = _f(os.path.join(output_path, host_relpath))
        self.target.pull(target_file, host_file)
        return host_file
    def _wait_for_data_file_write(self, label, output_path):
        data_file_finished_writing = False
        max_tries = 80
        current_tries = 0
        while not data_file_finished_writing:
            files = self.target.execute('cd {} && ls'.format(self.target.get_workpath('')))
            # Perf stores data in tempory files whilst writing to data output file. Check if they have been removed.
            if 'TemporaryFile' in files and current_tries <= max_tries:
                time.sleep(0.25)
                current_tries += 1
            else:
                if current_tries >= max_tries:
                    self.logger.warning('''writing {}.data file took longer than expected,
                                        file may not have written correctly'''.format(label))
                data_file_finished_writing = True
        report_command = self._build_perf_report_command(self.report_options, label)
        self.target.execute(report_command)
        if self.run_report_sample:
            report_sample_command = self._build_perf_report_sample_command(label)
            self.target.execute(report_sample_command)
    def _validate_events(self, events):
        available_events_string = self.target.execute('{} list | {} cat'.format(self.perf_type, self.target.busybox))
        available_events = available_events_string.splitlines()
        for available_event in available_events:
            if available_event == '':
                continue
            if 'OR' in available_event:
                available_events.append(available_event.split('OR')[1])
            available_events[available_events.index(available_event)] = available_event.split()[0].strip()
        # Raw hex event codes can also be passed in that do not appear on perf/simpleperf list, prefixed with 'r'
        raw_event_code_regex = re.compile(r"^r(0x|0X)?[A-Fa-f0-9]+$")
        for event in events:
            if event in available_events or re.match(raw_event_code_regex, event):
                continue
            else:
                raise ValueError('Event: {} is not in available event list for {}'.format(event, self.perf_type))
--- a/devlib/collector/perfetto.py
+++ b/devlib/collector/perfetto.py
@@ -1,119 +0,0 @@
 #    Copyright 2023 ARM Limited
 #
 # 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.
 #
 import os
 import subprocess
 from shlex import quote
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.exception import TargetStableError, HostError
 OUTPUT_PERFETTO_TRACE = 'devlib-trace.perfetto-trace'
 class PerfettoCollector(CollectorBase):
    """
    Perfetto is a production-grade open-source stack for performance instrumentation
    and trace analysis developed by Google. It offers services and libraries for
    recording system-level and app-level traces, native + java heap profiling,
    a library for analyzing traces using SQL and a web-based UI to visualize and
    explore multi-GB traces.
    This collector takes a path to a perfetto config file saved on disk and passes
    it directly to the tool.
    On Android platfroms Perfetto is included in the framework starting with Android 9.
    On Android 8 and below, follow the Linux instructions below to build and include
    the standalone tracebox binary.
    On Linux platforms, either traced (Perfetto tracing daemon) needs to be running
    in the background or the tracebox binary needs to be built from source and placed
    in the Package Bin directory. The build instructions can be found here:
    It is also possible to force using the prebuilt tracebox binary on platforms which
    already have traced running using the force_tracebox collector parameter.
    https://perfetto.dev/docs/contributing/build-instructions
    After building the 'tracebox' binary should be copied to devlib/bin/<arch>/.
    For more information consult the official documentation:
    https://perfetto.dev/docs/
    """
    def __init__(self, target, config=None, force_tracebox=False):
        super().__init__(target)
        self.bg_cmd = None
        self.config = config
        self.target_binary = 'perfetto'
        target_output_path = self.target.working_directory
        install_tracebox = force_tracebox or (target.os in ['linux', 'android'] and not target.is_running('traced'))
        # Install Perfetto through tracebox
        if install_tracebox:
            self.target_binary = 'tracebox'
            if not self.target.get_installed(self.target_binary):
                host_executable = os.path.join(PACKAGE_BIN_DIRECTORY,
                                               self.target.abi, self.target_binary)
                if not os.path.exists(host_executable):
                    raise HostError("{} not found on the host".format(self.target_binary))
                self.target.install(host_executable)
        # Use Android's built-in Perfetto
        elif target.os == 'android':
            os_version = target.os_version['release']
            if int(os_version) >= 9:
                # Android requires built-in Perfetto to write to this directory
                target_output_path = '/data/misc/perfetto-traces'
                # Android 9 and 10 require traced to be enabled manually
                if int(os_version) <= 10:
                    target.execute('setprop persist.traced.enable 1')
        self.target_output_file = target.path.join(target_output_path, OUTPUT_PERFETTO_TRACE)
    def start(self):
        cmd = "{} cat {} | {} --txt -c - -o {}".format(
            quote(self.target.busybox), quote(self.config), quote(self.target_binary), quote(self.target_output_file)
        )
        # start tracing
        if self.bg_cmd is None:
            self.bg_cmd = self.target.background(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        else:
            raise TargetStableError('Perfetto collector is not re-entrant')
    def stop(self):
        # stop tracing
        self.bg_cmd.cancel()
        self.bg_cmd = None
    def set_output(self, output_path):
        if os.path.isdir(output_path):
            output_path = os.path.join(output_path, os.path.basename(self.target_output_file))
        self.output_path = output_path
    def get_data(self):
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        if not self.target.file_exists(self.target_output_file):
            raise RuntimeError("Output file not found on the device")
        self.target.pull(self.target_output_file, self.output_path)
        output = CollectorOutput()
        if not os.path.isfile(self.output_path):
            self.logger.warning('Perfetto trace not pulled from device.')
        else:
            output.append(CollectorOutputEntry(self.output_path, 'file'))
        return output
--- a/devlib/collector/screencapture.py
+++ b/devlib/collector/screencapture.py
@@ -1,113 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import logging
 import os
 import sys
 import threading
 import time
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.exception import WorkerThreadError
 class ScreenCapturePoller(threading.Thread):
    def __init__(self, target, period, timeout=30):
        super(ScreenCapturePoller, self).__init__()
        self.target = target
        self.logger = logging.getLogger('screencapture')
        self.period = period
        self.timeout = timeout
        self.stop_signal = threading.Event()
        self.lock = threading.Lock()
        self.last_poll = 0
        self.daemon = True
        self.exc = None
        self.output_path = None
    def set_output(self, output_path):
        self.output_path = output_path
    def run(self):
        self.logger.debug('Starting screen capture polling')
        try:
            if self.output_path is None:
                raise RuntimeError("Output path was not set.")
            while True:
                if self.stop_signal.is_set():
                    break
                with self.lock:
                    current_time = time.time()
                    if (current_time - self.last_poll) >= self.period:
                        self.poll()
                time.sleep(0.5)
        except Exception:  # pylint: disable=W0703
            self.exc = WorkerThreadError(self.name, sys.exc_info())
    def stop(self):
        self.logger.debug('Stopping screen capture polling')
        self.stop_signal.set()
        self.join(self.timeout)
        if self.is_alive():
            self.logger.error('Could not join screen capture poller thread.')
        if self.exc:
            raise self.exc  # pylint: disable=E0702
    def poll(self):
        self.last_poll = time.time()
        self.target.capture_screen(os.path.join(self.output_path, "screencap_{ts}.png"))
 class ScreenCaptureCollector(CollectorBase):
    def __init__(self, target, period=None):
        super(ScreenCaptureCollector, self).__init__(target)
        self._collecting = False
        self.output_path = None
        self.period = period
        self.target = target
    def set_output(self, output_path):
        self.output_path = output_path
    def reset(self):
        self._poller = ScreenCapturePoller(self.target, self.period)
    def get_data(self):
        if self.output_path is None:
            raise RuntimeError("No data collected.")
        return CollectorOutput([CollectorOutputEntry(self.output_path, 'directory')])
    def start(self):
        """
        Start collecting the screenshots
        """
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        self._poller.set_output(self.output_path)
        self._poller.start()
        self._collecting = True
    def stop(self):
        """
        Stop collecting the screenshots
        """
        if not self._collecting:
            raise RuntimeError('Screen capture collector is not running, nothing to stop')
        self._poller.stop()
        self._collecting = False
--- a/devlib/collector/serial_trace.py
+++ b/devlib/collector/serial_trace.py
@@ -1,97 +0,0 @@
 #    Copyright 2024 ARM Limited
 #
 # 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.
 #
 from pexpect.exceptions import TIMEOUT
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.utils.serial_port import get_connection
 class SerialTraceCollector(CollectorBase):
    @property
    def collecting(self):
        return self._collecting
    def __init__(self, target, serial_port, baudrate, timeout=20):
        super(SerialTraceCollector, self).__init__(target)
        self.serial_port = serial_port
        self.baudrate = baudrate
        self.timeout = timeout
        self.output_path = None
        self._serial_target = None
        self._conn = None
        self._outfile_fh = None
        self._collecting = False
    def reset(self):
        if self._collecting:
            raise RuntimeError("reset was called whilst collecting")
        if self._outfile_fh:
            self._outfile_fh.close()
            self._outfile_fh = None
    def start(self):
        if self._collecting:
            raise RuntimeError("start was called whilst collecting")
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        self._outfile_fh = open(self.output_path, 'wb')
        start_marker = "-------- Starting serial logging --------\n"
        self._outfile_fh.write(start_marker.encode('utf-8'))
        self._serial_target, self._conn = get_connection(port=self.serial_port,
                                                         baudrate=self.baudrate,
                                                         timeout=self.timeout,
                                                         logfile=self._outfile_fh,
                                                         init_dtr=0)
        self._collecting = True
    def stop(self):
        if not self._collecting:
            raise RuntimeError("stop was called whilst not collecting")
        # We expect the below to fail, but we need to get pexpect to
        # do something so that it interacts with the serial device,
        # and hence updates the logfile.
        try:
            self._serial_target.expect(".", timeout=1)
        except TIMEOUT:
            pass
        self._serial_target.close()
        del self._conn
        stop_marker = "-------- Stopping serial logging --------\n"
        self._outfile_fh.write(stop_marker.encode('utf-8'))
        self._outfile_fh.flush()
        self._outfile_fh.close()
        self._outfile_fh = None
        self._collecting = False
    def set_output(self, output_path):
        self.output_path = output_path
    def get_data(self):
        if self._collecting:
            raise RuntimeError("get_data was called whilst collecting")
        if self.output_path is None:
            raise RuntimeError("No data collected.")
        return CollectorOutput([CollectorOutputEntry(self.output_path, 'file')])
--- a/devlib/collector/systrace.py
+++ b/devlib/collector/systrace.py
@@ -1,163 +0,0 @@
 #    Copyright 2024 ARM Limited
 #
 # 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.
 #
 import os
 import subprocess
 from devlib.collector import (CollectorBase, CollectorOutput,
                              CollectorOutputEntry)
 from devlib.exception import TargetStableError, HostError
 import devlib.utils.android
 from devlib.utils.misc import memoized
 DEFAULT_CATEGORIES = [
    'gfx',
    'view',
    'sched',
    'freq',
    'idle'
 ]
 class SystraceCollector(CollectorBase):
    """
    A trace collector based on Systrace
    For more details, see https://developer.android.com/studio/command-line/systrace
    :param target: Devlib target
    :type target: AndroidTarget
    :param outdir: Working directory to use on the host
    :type outdir: str
    :param categories: Systrace categories to trace. See `available_categories`
    :type categories: list(str)
    :param buffer_size: Buffer size in kb
    :type buffer_size: int
    :param strict: Raise an exception if any of the requested categories
        are not available
    :type strict: bool
    """
    @property
    @memoized
    def available_categories(self):
        lines = subprocess.check_output(
            [self.systrace_binary, '-l'], universal_newlines=True
        ).splitlines()
        return [line.split()[0] for line in lines if line]
    def __init__(self, target,
                 categories=None,
                 buffer_size=None,
                 strict=False):
        super(SystraceCollector, self).__init__(target)
        self.categories = categories or DEFAULT_CATEGORIES
        self.buffer_size = buffer_size
        self.output_path = None
        self._systrace_process = None
        self._outfile_fh = None
        # Try to find a systrace binary
        self.systrace_binary = None
        platform_tools = devlib.utils.android.platform_tools
        systrace_binary_path = os.path.join(platform_tools, 'systrace', 'systrace.py')
        if not os.path.isfile(systrace_binary_path):
            raise HostError('Could not find any systrace binary under {}'.format(platform_tools))
        self.systrace_binary = systrace_binary_path
        # Filter the requested categories
        for category in self.categories:
            if category not in self.available_categories:
                message = 'Category [{}] not available for tracing'.format(category)
                if strict:
                    raise TargetStableError(message)
                self.logger.warning(message)
        self.categories = list(set(self.categories) & set(self.available_categories))
        if not self.categories:
            raise TargetStableError('None of the requested categories are available')
    def __del__(self):
        self.reset()
    def _build_cmd(self):
        self._outfile_fh = open(self.output_path, 'w')
        # pylint: disable=attribute-defined-outside-init
        self.systrace_cmd = 'python2 -u {} -o {} -e {}'.format(
            self.systrace_binary,
            self._outfile_fh.name,
            self.target.adb_name
        )
        if self.buffer_size:
            self.systrace_cmd += ' -b {}'.format(self.buffer_size)
        self.systrace_cmd += ' {}'.format(' '.join(self.categories))
    def reset(self):
        if self._systrace_process:
            self.stop()
    def start(self):
        if self._systrace_process:
            raise RuntimeError("Tracing is already underway, call stop() first")
        if self.output_path is None:
            raise RuntimeError("Output path was not set.")
        self.reset()
        self._build_cmd()
        self._systrace_process = subprocess.Popen(
            self.systrace_cmd,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            shell=True,
            universal_newlines=True
        )
        self._systrace_process.stdout.read(1)
    def stop(self):
        if not self._systrace_process:
            raise RuntimeError("No tracing to stop, call start() first")
        # Systrace expects <enter> to stop
        self._systrace_process.communicate('\n')
        self._systrace_process = None
        if self._outfile_fh:
            self._outfile_fh.close()
            self._outfile_fh = None
    def set_output(self, output_path):
        self.output_path = output_path
    def get_data(self):
        if self._systrace_process:
            raise RuntimeError("Tracing is underway, call stop() first")
        if self.output_path is None:
            raise RuntimeError("No data collected.")
        return CollectorOutput([CollectorOutputEntry(self.output_path, 'file')])
--- a/devlib/connection.py
+++ b/devlib/connection.py
@@ -1,789 +0,0 @@
 #    Copyright 2024 ARM Limited
 #
 # 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.
 #
 from abc import ABC, abstractmethod
 from contextlib import contextmanager, nullcontext
 from shlex import quote
 import os
 from pathlib import Path
 import signal
 import subprocess
 import threading
 import time
 import logging
 import select
 import fcntl
 from devlib.utils.misc import InitCheckpoint, memoized
 _KILL_TIMEOUT = 3
 def _popen_communicate(bg, popen, input, timeout):
    try:
        stdout, stderr = popen.communicate(input=input, timeout=timeout)
    except subprocess.TimeoutExpired:
        bg.cancel()
        raise
    ret = popen.returncode
    if ret:
        raise subprocess.CalledProcessError(
            ret,
            popen.args,
            stdout,
            stderr,
        )
    else:
        return (stdout, stderr)
 class ConnectionBase(InitCheckpoint):
    """
    Base class for all connections.
    """
    def __init__(
        self,
        poll_transfers=False,
        start_transfer_poll_delay=30,
        total_transfer_timeout=3600,
        transfer_poll_period=30,
    ):
        self._current_bg_cmds = set()
        self._closed = False
        self._close_lock = threading.Lock()
        self.busybox = None
        self.logger = logging.getLogger('Connection')
        self.transfer_manager = TransferManager(
            self,
            start_transfer_poll_delay=start_transfer_poll_delay,
            total_transfer_timeout=total_transfer_timeout,
            transfer_poll_period=transfer_poll_period,
        ) if poll_transfers else NoopTransferManager()
    def cancel_running_command(self):
        bg_cmds = set(self._current_bg_cmds)
        for bg_cmd in bg_cmds:
            bg_cmd.cancel()
    @abstractmethod
    def _close(self):
        """
        Close the connection.
        The public :meth:`close` method makes sure that :meth:`_close` will
        only be called once, and will serialize accesses to it if it happens to
        be called from multiple threads at once.
        """
    def close(self):
        def finish_bg():
            bg_cmds = set(self._current_bg_cmds)
            n = len(bg_cmds)
            if n:
                self.logger.debug(f'Canceling {n} background commands before closing connection')
            for bg_cmd in bg_cmds:
                bg_cmd.cancel()
        # Locking the closing allows any thread to safely call close() as long
        # as the connection can be closed from a thread that is not the one it
        # started its life in.
        with self._close_lock:
            if not self._closed:
                finish_bg()
                self._close()
                self._closed = True
    # Ideally, that should not be relied upon but that will improve the chances
    # of the connection being properly cleaned up when it's not in use anymore.
    def __del__(self):
        # Since __del__ will be called if an exception is raised in __init__
        # (e.g. we cannot connect), we only run close() when we are sure
        # __init__ has completed successfully.
        if self.initialized:
            self.close()
 class BackgroundCommand(ABC):
    """
    Allows managing a running background command using a subset of the
    :class:`subprocess.Popen` API.
    Instances of this class can be used as context managers, with the same
    semantic as :class:`subprocess.Popen`.
    """
    def __init__(self, conn, data_dir, cmd, as_root):
        self.conn = conn
        self._data_dir = data_dir
        self.as_root = as_root
        self.cmd = cmd
        # Poll currently opened background commands on that connection to make
        # them deregister themselves if they are completed. This avoids
        # accumulating terminated commands and therefore leaking associated
        # resources if the user is not careful and does not use the context
        # manager API.
        for bg_cmd in set(conn._current_bg_cmds):
            try:
                bg_cmd.poll()
            # We don't want anything to fail here because of another command
            except Exception:
                pass
        conn._current_bg_cmds.add(self)
    @classmethod
    def from_factory(cls, conn, cmd, as_root, make_init_kwargs):
        cmd, data_dir = cls._with_data_dir(conn, cmd)
        return cls(
            conn=conn,
            data_dir=data_dir,
            cmd=cmd,
            as_root=as_root,
            **make_init_kwargs(cmd),
        )
    def _deregister(self):
        try:
            self.conn._current_bg_cmds.remove(self)
        except KeyError:
            pass
    @property
    def _pid_file(self):
        return str(Path(self._data_dir, 'pid'))
    @property
    @memoized
    def _targeted_pid(self):
        """
        PID of the process pointed at by ``devlib-signal-target`` command.
        """
        path = quote(self._pid_file)
        busybox = quote(self.conn.busybox)
        def execute(cmd):
            return self.conn.execute(cmd, as_root=self.as_root)
        while self.poll() is None:
            try:
                pid = execute(f'{busybox} cat {path}')
            except subprocess.CalledProcessError:
                time.sleep(0.01)
            else:
                if pid.endswith('\n'):
                    return int(pid.strip())
                else:
                    # We got a partial write in the PID file
                    continue
        raise ValueError(f'The background commmand did not use devlib-signal-target wrapper to designate which command should be the target of signals')
    @classmethod
    def _with_data_dir(cls, conn, cmd):
        busybox = quote(conn.busybox)
        data_dir = conn.execute(f'{busybox} mktemp -d').strip()
        cmd = f'_DEVLIB_BG_CMD_DATA_DIR={data_dir} exec {busybox} sh -c {quote(cmd)}'
        return cmd, data_dir
    def _cleanup_data_dir(self):
        path = quote(self._data_dir)
        busybox = quote(self.conn.busybox)
        cmd = f'{busybox} rm -r {path} || true'
        self.conn.execute(cmd, as_root=self.as_root)
    def send_signal(self, sig):
        """
        Send a POSIX signal to the background command's process group ID
        (PGID).
        :param signal: Signal to send.
        :type signal: signal.Signals
        """
        def execute(cmd):
            return self.conn.execute(cmd, as_root=self.as_root)
        def send(sig):
            busybox = quote(self.conn.busybox)
            # If the command has already completed, we don't want to send a
            # signal to another process that might have gotten that PID in the
            # meantime.
            if self.poll() is None:
                if sig in (signal.SIGTERM, signal.SIGQUIT, signal.SIGKILL):
                    # Use -PGID to target a process group rather than just the
                    # process itself. This will work in any condition and will
                    # not require cooperation from the command.
                    execute(f'{busybox} kill -{sig.value} -{self.pid}')
                else:
                    # Other signals require cooperation from the shell command
                    # so that it points to a specific process using
                    # devlib-signal-target
                    pid = self._targeted_pid
                    execute(f'{busybox} kill -{sig.value} {pid}')
        try:
            return send(sig)
        finally:
            # Deregister if the command has finished
            self.poll()
    def kill(self):
        """
        Send SIGKILL to the background command.
        """
        self.send_signal(signal.SIGKILL)
    def cancel(self, kill_timeout=_KILL_TIMEOUT):
        """
        Try to gracefully terminate the process by sending ``SIGTERM``, then
        waiting for ``kill_timeout`` to send ``SIGKILL``.
        """
        try:
            if self.poll() is None:
                return self._cancel(kill_timeout=kill_timeout)
        finally:
            self._deregister()
    @abstractmethod
    def _cancel(self, kill_timeout):
        """
        Method to override in subclasses to implement :meth:`cancel`.
        """
        pass
    @abstractmethod
    def _wait(self):
        pass
    def wait(self):
        """
        Block until the background command completes, and return its exit code.
        """
        try:
            return self._wait()
        finally:
            self._deregister()
    def communicate(self, input=b'', timeout=None):
        """
        Block until the background command completes while reading stdout and stderr.
        Return ``tuple(stdout, stderr)``. If the return code is non-zero,
        raises a :exc:`subprocess.CalledProcessError` exception.
        """
        try:
            return self._communicate(input=input, timeout=timeout)
        finally:
            self.close()
    @abstractmethod
    def _communicate(self, input, timeout):
        pass
    @abstractmethod
    def _poll(self):
        pass
    def poll(self):
        """
        Return exit code if the command has exited, None otherwise.
        """
        retcode = self._poll()
        if retcode is not None:
            self._deregister()
        return retcode
    @property
    @abstractmethod
    def stdin(self):
        """
        File-like object connected to the background's command stdin.
        """
    @property
    @abstractmethod
    def stdout(self):
        """
        File-like object connected to the background's command stdout.
        """
    @property
    @abstractmethod
    def stderr(self):
        """
        File-like object connected to the background's command stderr.
        """
    @property
    @abstractmethod
    def pid(self):
        """
        Process Group ID (PGID) of the background command.
        Since the command is usually wrapped in shell processes for IO
        redirections, sudo etc, the PID cannot be assumed to be the actual PID
        of the command passed by the user. It's is guaranteed to be a PGID
        instead, which means signals sent to it as such will target all
        subprocesses involved in executing that command.
        """
    @abstractmethod
    def _close(self):
        pass
    def close(self):
        """
        Close all opened streams and then wait for command completion.
        :returns: Exit code of the command.
        .. note:: If the command is writing to its stdout/stderr, it might be
            blocked on that and die when the streams are closed.
        """
        try:
            return self._close()
        finally:
            self._deregister()
            self._cleanup_data_dir()
    def __enter__(self):
        return self
    def __exit__(self, *args, **kwargs):
        self.close()
 class PopenBackgroundCommand(BackgroundCommand):
    """
    :class:`subprocess.Popen`-based background command.
    """
    def __init__(self, conn, data_dir, cmd, as_root, popen):
        super().__init__(
            conn=conn,
            data_dir=data_dir,
            cmd=cmd,
            as_root=as_root,
        )
        self.popen = popen
    @property
    def stdin(self):
        return self.popen.stdin
    @property
    def stdout(self):
        return self.popen.stdout
    @property
    def stderr(self):
        return self.popen.stderr
    @property
    def pid(self):
        return self.popen.pid
    def _wait(self):
        return self.popen.wait()
    def _communicate(self, input, timeout):
        return _popen_communicate(self, self.popen, input, timeout)
    def _poll(self):
        return self.popen.poll()
    def _cancel(self, kill_timeout):
        popen = self.popen
        os.killpg(os.getpgid(popen.pid), signal.SIGTERM)
        try:
            popen.wait(timeout=kill_timeout)
        except subprocess.TimeoutExpired:
            os.killpg(os.getpgid(popen.pid), signal.SIGKILL)
    def _close(self):
        self.popen.__exit__(None, None, None)
        return self.popen.returncode
    def __enter__(self):
        super().__enter__()
        self.popen.__enter__()
        return self
 class ParamikoBackgroundCommand(BackgroundCommand):
    """
    :mod:`paramiko`-based background command.
    """
    def __init__(self, conn, data_dir, cmd, as_root, chan, pid, stdin, stdout, stderr, redirect_thread):
        super().__init__(
            conn=conn,
            data_dir=data_dir,
            cmd=cmd,
            as_root=as_root,
        )
        self.chan = chan
        self._pid = pid
        self._stdin = stdin
        self._stdout = stdout
        self._stderr = stderr
        self.redirect_thread = redirect_thread
    @property
    def pid(self):
        return self._pid
    def _wait(self):
        status = self.chan.recv_exit_status()
        # Ensure that the redirection thread is finished copying the content
        # from paramiko to the pipe.
        self.redirect_thread.join()
        return status
    def _communicate(self, input, timeout):
        stdout = self._stdout
        stderr = self._stderr
        stdin = self._stdin
        chan = self.chan
        # For some reason, file descriptors in the read-list of select() can
        # still end up blocking in .read(), so make the non-blocking to avoid a
        # deadlock. Since _communicate() will consume all input and all output
        # until the command dies, we can do whatever we want with the pipe
        # without affecting external users.
        for s in (stdout, stderr):
            fcntl.fcntl(s.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
        out = {stdout: [], stderr: []}
        ret = None
        can_send = True
        select_timeout = 1
        if timeout is not None:
            select_timeout = min(select_timeout, 1)
        def create_out():
            return (
                b''.join(out[stdout]),
                b''.join(out[stderr])
            )
        start = time.monotonic()
        while ret is None:
            # Even if ret is not None anymore, we need to drain the streams
            ret = self.poll()
            if timeout is not None and ret is None and time.monotonic() - start >= timeout:
                self.cancel()
                _stdout, _stderr = create_out()
                raise subprocess.TimeoutExpired(self.cmd, timeout, _stdout, _stderr)
            can_send &= (not chan.closed) & bool(input)
            wlist = [chan] if can_send else []
            if can_send and chan.send_ready():
                try:
                    n = chan.send(input)
                # stdin might have been closed already
                except OSError:
                    can_send = False
                    chan.shutdown_write()
                else:
                    input = input[n:]
                    if not input:
                        # Send EOF on stdin
                        chan.shutdown_write()
            rs, ws, _ = select.select(
                [x for x in (stdout, stderr) if not x.closed],
                wlist,
                [],
                select_timeout,
            )
            for r in rs:
                chunk = r.read()
                if chunk:
                    out[r].append(chunk)
        _stdout, _stderr = create_out()
        if ret:
            raise subprocess.CalledProcessError(
                ret,
                self.cmd,
                _stdout,
                _stderr,
            )
        else:
            return (_stdout, _stderr)
    def _poll(self):
        # Wait for the redirection thread to finish, otherwise we would
        # indicate the caller that the command is finished and that the streams
        # are safe to drain, but actually the redirection thread is not
        # finished yet, which would end up in lost data.
        if self.redirect_thread.is_alive():
            return None
        elif self.chan.exit_status_ready():
            return self.wait()
        else:
            return None
    def _cancel(self, kill_timeout):
        self.send_signal(signal.SIGTERM)
        # Check if the command terminated quickly
        time.sleep(10e-3)
        # Otherwise wait for the full timeout and kill it
        if self.poll() is None:
            time.sleep(kill_timeout)
            self.send_signal(signal.SIGKILL)
            self.wait()
    @property
    def stdin(self):
        return self._stdin
    @property
    def stdout(self):
        return self._stdout
    @property
    def stderr(self):
        return self._stderr
    def _close(self):
        for x in (self.stdin, self.stdout, self.stderr):
            if x is not None:
                x.close()
        exit_code = self.wait()
        thread = self.redirect_thread
        if thread:
            thread.join()
        return exit_code
 class AdbBackgroundCommand(BackgroundCommand):
    """
    ``adb``-based background command.
    """
    def __init__(self, conn, data_dir, cmd, as_root, adb_popen, pid):
        super().__init__(
            conn=conn,
            data_dir=data_dir,
            cmd=cmd,
            as_root=as_root,
        )
        self.adb_popen = adb_popen
        self._pid = pid
    @property
    def stdin(self):
        return self.adb_popen.stdin
    @property
    def stdout(self):
        return self.adb_popen.stdout
    @property
    def stderr(self):
        return self.adb_popen.stderr
    @property
    def pid(self):
        return self._pid
    def _wait(self):
        return self.adb_popen.wait()
    def _communicate(self, input, timeout):
        return _popen_communicate(self, self.adb_popen, input, timeout)
    def _poll(self):
        return self.adb_popen.poll()
    def _cancel(self, kill_timeout):
        self.send_signal(signal.SIGTERM)
        try:
            self.adb_popen.wait(timeout=kill_timeout)
        except subprocess.TimeoutExpired:
            self.send_signal(signal.SIGKILL)
            self.adb_popen.kill()
    def _close(self):
        self.adb_popen.__exit__(None, None, None)
        return self.adb_popen.returncode
    def __enter__(self):
        super().__enter__()
        self.adb_popen.__enter__()
        return self
 class TransferManager:
    def __init__(self, conn, transfer_poll_period=30, start_transfer_poll_delay=30, total_transfer_timeout=3600):
        self.conn = conn
        self.transfer_poll_period = transfer_poll_period
        self.total_transfer_timeout = total_transfer_timeout
        self.start_transfer_poll_delay = start_transfer_poll_delay
        self.logger = logging.getLogger('FileTransfer')
    @contextmanager
    def manage(self, sources, dest, direction, handle):
        excep = None
        stop_thread = threading.Event()
        def monitor():
            nonlocal excep
            def cancel(reason):
                self.logger.warning(
                    f'Cancelling file transfer {sources} -> {dest} due to: {reason}'
                )
                handle.cancel()
            start_t = time.monotonic()
            stop_thread.wait(self.start_transfer_poll_delay)
            while not stop_thread.wait(self.transfer_poll_period):
                if not handle.isactive():
                    cancel(reason='transfer inactive')
                elif time.monotonic() - start_t > self.total_transfer_timeout:
                    cancel(reason='transfer timed out')
                    excep = TimeoutError(f'{direction}: {sources} -> {dest}')
        m_thread = threading.Thread(target=monitor, daemon=True)
        try:
            m_thread.start()
            yield self
        finally:
            stop_thread.set()
            m_thread.join()
            if excep is not None:
                raise excep
 class NoopTransferManager:
    def manage(self, *args, **kwargs):
        return nullcontext(self)
 class TransferHandleBase(ABC):
    def __init__(self, manager):
        self.manager = manager
    @property
    def logger(self):
        return self.manager.logger
    @abstractmethod
    def isactive(self):
        pass
    @abstractmethod
    def cancel(self):
        pass
 class PopenTransferHandle(TransferHandleBase):
    def __init__(self, popen, dest, direction, *args, **kwargs):
        super().__init__(*args, **kwargs)
        if direction == 'push':
            sample_size = self._push_dest_size
        elif direction == 'pull':
            sample_size = self._pull_dest_size
        else:
            raise ValueError(f'Unknown direction: {direction}')
        self.sample_size = lambda: sample_size(dest)
        self.popen = popen
        self.last_sample = 0
    @staticmethod
    def _pull_dest_size(dest):
        if os.path.isdir(dest):
            return sum(
                os.stat(os.path.join(dirpath, f)).st_size
 	            for dirpath, _, fnames in os.walk(dest)
 	            for f in fnames
            )
        else:
            return os.stat(dest).st_size
    def _push_dest_size(self, dest):
        conn = self.manager.conn
        cmd = '{} du -s -- {}'.format(quote(conn.busybox), quote(dest))
        out = conn.execute(cmd)
        return int(out.split()[0])
    def cancel(self):
        self.popen.terminate()
    def isactive(self):
        try:
            curr_size = self.sample_size()
        except Exception as e:
            self.logger.debug(f'File size polling failed: {e}')
            return True
        else:
            self.logger.debug(f'Polled file transfer, destination size: {curr_size}')
            if curr_size:
                active = curr_size > self.last_sample
                self.last_sample = curr_size
                return active
            # If the file is empty it will never grow in size, so we assume
            # everything is going well.
            else:
                return True
 class SSHTransferHandle(TransferHandleBase):
    def __init__(self, handle, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # SFTPClient or SSHClient
        self.handle = handle
        self.progressed = False
        self.transferred = 0
        self.to_transfer = 0
    def cancel(self):
        self.handle.close()
    def isactive(self):
        progressed = self.progressed
        if progressed:
            self.progressed = False
            pc = (self.transferred / self.to_transfer) * 100
            self.logger.debug(
                f'Polled transfer: {pc:.2f}% [{self.transferred}B/{self.to_transfer}B]'
            )
        return progressed
    def progress_cb(self, transferred, to_transfer):
        self.progressed = True
        self.transferred = transferred
        self.to_transfer = to_transfer
--- a/devlib/derived/init.py
+++ b/devlib/derived/init.py
@@ -1,63 +0,0 @@
 #    Copyright 2015-2017 ARM Limited
 #
 # 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.
 #
 from devlib.instrument import MeasurementType, MEASUREMENT_TYPES
 class DerivedMetric(object):
    __slots__ = ['name', 'value', 'measurement_type']
    @property
    def units(self):
        return self.measurement_type.units
    def __init__(self, name, value, measurement_type):
        self.name = name
        self.value = value
        if isinstance(measurement_type, MeasurementType):
            self.measurement_type = measurement_type
        else:
            try:
                self.measurement_type = MEASUREMENT_TYPES[measurement_type]
            except KeyError:
                msg = 'Unknown measurement type:  {}'
                raise ValueError(msg.format(measurement_type))
    def __str__(self):
        if self.units:
            return '{}: {} {}'.format(self.name, self.value, self.units)
        else:
            return '{}: {}'.format(self.name, self.value)
    # pylint: disable=undefined-variable
    def __cmp__(self, other):
        if hasattr(other, 'value'):
            return cmp(self.value, other.value)
        else:
            return cmp(self.value, other)
    __repr__ = __str__
 class DerivedMeasurements(object):
    # pylint: disable=no-self-use,unused-argument
    def process(self, measurements_csv):
        return []
    # pylint: disable=no-self-use
    def process_raw(self, *args):
        return []
--- a/devlib/derived/energy.py
+++ b/devlib/derived/energy.py
@@ -1,97 +0,0 @@
 #    Copyright 2013-2018 ARM Limited
 #
 # 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.
 #
 from collections import defaultdict
 from devlib.derived import DerivedMeasurements, DerivedMetric
 from devlib.instrument import  MEASUREMENT_TYPES
 class DerivedEnergyMeasurements(DerivedMeasurements):
    # pylint: disable=too-many-locals,too-many-branches
    @staticmethod
    def process(measurements_csv):
        should_calculate_energy = []
        use_timestamp = False
        # Determine sites to calculate energy for
        channel_map = defaultdict(list)
        for channel in measurements_csv.channels:
            channel_map[channel.site].append(channel.kind)
            if channel.site == 'timestamp':
                use_timestamp = True
                time_measurment = channel.measurement_type
        for site, kinds in channel_map.items():
            if 'power' in kinds and not 'energy' in kinds:
                should_calculate_energy.append(site)
        if measurements_csv.sample_rate_hz is None and not use_timestamp:
            msg = 'Timestamp data is unavailable, please provide a sample rate'
            raise ValueError(msg)
        if use_timestamp:
            # Find index of timestamp column
            ts_index = [i for i, chan in enumerate(measurements_csv.channels)
                        if chan.site == 'timestamp']
            if len(ts_index) > 1:
                raise ValueError('Multiple timestamps detected')
            ts_index = ts_index[0]
        row_ts = 0
        last_ts = 0
        energy_results = defaultdict(dict)
        power_results = defaultdict(float)
        # Process data
        for count, row in enumerate(measurements_csv.iter_measurements()):
            if use_timestamp:
                last_ts = row_ts
                row_ts = time_measurment.convert(float(row[ts_index].value), 'time')
            for entry in row:
                channel = entry.channel
                site = channel.site
                if channel.kind == 'energy':
                    if count == 0:
                        energy_results[site]['start'] = entry.value
                    else:
                        energy_results[site]['end'] = entry.value
                if channel.kind == 'power':
                    power_results[site] += entry.value
                    if site in should_calculate_energy:
                        if count == 0:
                            energy_results[site]['start'] = 0
                            energy_results[site]['end'] = 0
                        elif use_timestamp:
                            energy_results[site]['end'] += entry.value * (row_ts - last_ts)
                        else:
                            energy_results[site]['end'] += entry.value * (1 /
                                                           measurements_csv.sample_rate_hz)
        # Calculate final measurements
        derived_measurements = []
        for site in energy_results:
            total_energy = energy_results[site]['end'] - energy_results[site]['start']
            name = '{}_total_energy'.format(site)
            derived_measurements.append(DerivedMetric(name, total_energy, MEASUREMENT_TYPES['energy']))
        for site in power_results:
            power = power_results[site] / (count + 1)  #pylint: disable=undefined-loop-variable
            name = '{}_average_power'.format(site)
            derived_measurements.append(DerivedMetric(name, power, MEASUREMENT_TYPES['power']))
        return derived_measurements
--- a/devlib/derived/fps.py
+++ b/devlib/derived/fps.py
@@ -1,235 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import os
 try:
    import pandas as pd
 except ImportError:
    pd = None
 from past.builtins import basestring
 from devlib.derived import DerivedMeasurements, DerivedMetric
 from devlib.exception import HostError
 from devlib.instrument import MeasurementsCsv
 from devlib.utils.csvutil import csvwriter
 from devlib.utils.rendering import gfxinfo_get_last_dump, VSYNC_INTERVAL
 from devlib.utils.types import numeric
 class DerivedFpsStats(DerivedMeasurements):
    def __init__(self, drop_threshold=5, suffix=None, filename=None, outdir=None):
        self.drop_threshold = drop_threshold
        self.suffix = suffix
        self.filename = filename
        self.outdir = outdir
        if (filename is None) and (suffix is None):
            self.suffix = '-fps'
        elif (filename is not None) and (suffix is not None):
            raise ValueError('suffix and filename cannot be specified at the same time.')
        if filename is not None and os.sep in filename:
            raise ValueError('filename cannot be a path (cannot countain "{}"'.format(os.sep))
    # pylint: disable=no-member
    def process(self, measurements_csv):
        if isinstance(measurements_csv, basestring):
            measurements_csv = MeasurementsCsv(measurements_csv)
        if pd is not None:
            return self._process_with_pandas(measurements_csv)
        return self._process_without_pandas(measurements_csv)
    def _get_csv_file_name(self, frames_file):
        outdir = self.outdir or os.path.dirname(frames_file)
        if self.filename:
            return os.path.join(outdir, self.filename)
        frames_basename = os.path.basename(frames_file)
        rest, ext = os.path.splitext(frames_basename)
        csv_basename = rest + self.suffix + ext
        return os.path.join(outdir, csv_basename)
 class DerivedGfxInfoStats(DerivedFpsStats):
    #pylint: disable=arguments-differ
    @staticmethod
    def process_raw(filepath, *args):
        metrics = []
        dump = gfxinfo_get_last_dump(filepath)
        seen_stats = False
        for line in dump.split('\n'):
            if seen_stats and not line.strip():
                break
            elif line.startswith('Janky frames:'):
                text = line.split(': ')[-1]
                val_text, pc_text = text.split('(')
                metrics.append(DerivedMetric('janks', numeric(val_text.strip()), 'count'))
                metrics.append(DerivedMetric('janks_pc', numeric(pc_text[:-3]), 'percent'))
            elif ' percentile: ' in line:
                ptile, val_text = line.split(' percentile: ')
                name = 'render_time_{}_ptile'.format(ptile)
                value = numeric(val_text.strip()[:-2])
                metrics.append(DerivedMetric(name, value, 'time_ms'))
            elif line.startswith('Number '):
                name_text, val_text = line.strip().split(': ')
                name = name_text[7:].lower().replace(' ', '_')
                value = numeric(val_text)
                metrics.append(DerivedMetric(name, value, 'count'))
            else:
                continue
            seen_stats = True
        return metrics
    def _process_without_pandas(self, measurements_csv):
        per_frame_fps = []
        start_vsync, end_vsync = None, None
        frame_count = 0
        for frame_data in measurements_csv.iter_values():
            if frame_data.Flags_flags != 0:
                continue
            frame_count += 1
            if start_vsync is None:
                start_vsync = frame_data.Vsync_time_ns
            end_vsync = frame_data.Vsync_time_ns
            frame_time = frame_data.FrameCompleted_time_ns - frame_data.IntendedVsync_time_ns
            pff = 1e9 / frame_time
            if pff > self.drop_threshold:
                per_frame_fps.append([pff])
        if frame_count:
            duration = end_vsync - start_vsync
            fps = (1e9 * frame_count) / float(duration)
        else:
            duration = 0
            fps = 0
        csv_file = self._get_csv_file_name(measurements_csv.path)
        with csvwriter(csv_file) as writer:
            writer.writerow(['fps'])
            writer.writerows(per_frame_fps)
        return [DerivedMetric('fps', fps, 'fps'),
                DerivedMetric('total_frames', frame_count, 'frames'),
                MeasurementsCsv(csv_file)]
    def _process_with_pandas(self, measurements_csv):
        data = pd.read_csv(measurements_csv.path)
        data = data[data.Flags_flags == 0]
        frame_time = data.FrameCompleted_time_ns - data.IntendedVsync_time_ns
        per_frame_fps = (1e9 / frame_time)
        keep_filter = per_frame_fps > self.drop_threshold
        per_frame_fps = per_frame_fps[keep_filter]
        per_frame_fps.name = 'fps'
        frame_count = data.index.size
        if frame_count > 1:
            duration = data.Vsync_time_ns.iloc[-1] - data.Vsync_time_ns.iloc[0]
            fps = (1e9 * frame_count) / float(duration)
        else:
            duration = 0
            fps = 0
        csv_file = self._get_csv_file_name(measurements_csv.path)
        per_frame_fps.to_csv(csv_file, index=False, header=True)
        return [DerivedMetric('fps', fps, 'fps'),
                DerivedMetric('total_frames', frame_count, 'frames'),
                MeasurementsCsv(csv_file)]
 class DerivedSurfaceFlingerStats(DerivedFpsStats):
    # pylint: disable=too-many-locals
    def _process_with_pandas(self, measurements_csv):
        data = pd.read_csv(measurements_csv.path)
        # fiter out bogus frames.
        bogus_frames_filter = data.actual_present_time_us != 0x7fffffffffffffff
        actual_present_times = data.actual_present_time_us[bogus_frames_filter]
        actual_present_time_deltas = actual_present_times.diff().dropna()
        vsyncs_to_compose = actual_present_time_deltas.div(VSYNC_INTERVAL)
        vsyncs_to_compose.apply(lambda x: int(round(x, 0)))
        # drop values lower than drop_threshold FPS as real in-game frame
        # rate is unlikely to drop below that (except on loading screens
        # etc, which should not be factored in frame rate calculation).
        per_frame_fps = (1.0 / (vsyncs_to_compose.multiply(VSYNC_INTERVAL / 1e9)))
        keep_filter = per_frame_fps > self.drop_threshold
        filtered_vsyncs_to_compose = vsyncs_to_compose[keep_filter]
        per_frame_fps.name = 'fps'
        csv_file = self._get_csv_file_name(measurements_csv.path)
        per_frame_fps.to_csv(csv_file, index=False, header=True)
        if not filtered_vsyncs_to_compose.empty:
            fps = 0
            total_vsyncs = filtered_vsyncs_to_compose.sum()
            frame_count = filtered_vsyncs_to_compose.size
            if total_vsyncs:
                fps = 1e9 * frame_count / (VSYNC_INTERVAL * total_vsyncs)
            janks = self._calc_janks(filtered_vsyncs_to_compose)
            not_at_vsync = self._calc_not_at_vsync(vsyncs_to_compose)
        else:
            fps = 0
            frame_count = 0
            janks = 0
            not_at_vsync = 0
        janks_pc = 0 if frame_count == 0 else janks * 100 / frame_count
        return [DerivedMetric('fps', fps, 'fps'),
                DerivedMetric('total_frames', frame_count, 'frames'),
                MeasurementsCsv(csv_file),
                DerivedMetric('janks', janks, 'count'),
                DerivedMetric('janks_pc', janks_pc, 'percent'),
                DerivedMetric('missed_vsync', not_at_vsync, 'count')]
    # pylint: disable=unused-argument,no-self-use
    def _process_without_pandas(self, measurements_csv):
        # Given that SurfaceFlinger has been deprecated in favor of GfxInfo,
        # it does not seem worth it implementing this.
        raise HostError('Please install "pandas" Python package to process SurfaceFlinger frames')
    @staticmethod
    def _calc_janks(filtered_vsyncs_to_compose):
        """
        Internal method for calculating jank frames.
        """
        pause_latency = 20
        vtc_deltas = filtered_vsyncs_to_compose.diff().dropna()
        vtc_deltas = vtc_deltas.abs()
        janks = vtc_deltas.apply(lambda x: (pause_latency > x > 1.5) and 1 or 0).sum()
        return janks
    @staticmethod
    def _calc_not_at_vsync(vsyncs_to_compose):
        """
        Internal method for calculating the number of frames that did not
        render in a single vsync cycle.
        """
        epsilon = 0.0001
        func = lambda x: (abs(x - 1.0) > epsilon) and 1 or 0
        not_at_vsync = vsyncs_to_compose.apply(func).sum()
        return not_at_vsync
--- a/devlib/exception.py
+++ b/devlib/exception.py
@@ -1,4 +1,4 @@
-#    Copyright 2013-2018 ARM Limited
+#    Copyright 2013-2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,43 +13,12 @@
 # limitations under the License.
 #
-import subprocess
+
 from devlib.utils.misc import TimeoutError  # NOQA pylint: disable=W0611
 class DevlibError(Exception):
-    """Base class for all Devlib exceptions."""
+    """Base class for all Workload Automation exceptions."""
    def __init__(self, *args):
        message = args[0] if args else None
        self._message = message
    @property
    def message(self):
        try:
            msg = self._message
        except AttributeError:
            msg = None
        if msg is None:
            return str(self)
        else:
            return self._message
 class DevlibStableError(DevlibError):
    """Non transient target errors, that are not subject to random variations
    in the environment and can be reliably linked to for example a missing
    feature on a target."""
    pass
 class DevlibTransientError(DevlibError):
    """Exceptions inheriting from ``DevlibTransientError`` represent random
    transient events that are usually related to issues in the environment, as
    opposed to programming errors, for example network failures or
    timeout-related exceptions. When the error could come from
    indistinguishable transient or non-transient issue, it can generally be
    assumed that the configuration is correct and therefore, a transient
    exception is raised."""
    pass
@@ -58,133 +27,14 @@ class TargetError(DevlibError):
    pass
-class TargetTransientError(TargetError, DevlibTransientError):
+class TargetNotRespondingError(DevlibError):
    """Transient target errors that can happen randomly when everything is
    properly configured."""
    pass
 class TargetStableError(TargetError, DevlibStableError):
    """Non-transient target errors that can be linked to a programming error or
    a configuration issue, and is not influenced by non-controllable parameters
    such as network issues."""
    pass
 class TargetCalledProcessError(subprocess.CalledProcessError, TargetError):
    """Exception raised when a command executed on the target fails."""
    def __str__(self):
        msg = super().__str__()
        def decode(s):
            try:
                s = s.decode()
            except AttributeError:
                s = str(s)
            return s.strip()
        if self.stdout is not None and self.stderr is None:
            out = ['OUTPUT: {}'.format(decode(self.output))]
        else:
            out = [
                'STDOUT: {}'.format(decode(self.output)) if self.output is not None else '',
                'STDERR: {}'.format(decode(self.stderr)) if self.stderr is not None else '',
            ]
        return '\n'.join((
            msg,
            *out,
        ))
 class TargetStableCalledProcessError(TargetCalledProcessError, TargetStableError):
    """Variant of :exc:`devlib.exception.TargetCalledProcessError` that indicates a stable error"""
    pass
 class TargetTransientCalledProcessError(TargetCalledProcessError, TargetTransientError):
    """Variant of :exc:`devlib.exception.TargetCalledProcessError` that indicates a transient error"""
    pass
 class TargetNotRespondingError(TargetTransientError):
    """The target is unresponsive."""
-    pass
+
    def __init__(self, target):
        super(TargetNotRespondingError, self).__init__('Target {} is not responding.'.format(target))
 class HostError(DevlibError):
    """An error has occured on the host"""
    pass
 # pylint: disable=redefined-builtin
 class TimeoutError(DevlibTransientError):
    """Raised when a subprocess command times out. This is basically a ``DevlibError``-derived version
    of ``subprocess.CalledProcessError``, the thinking being that while a timeout could be due to
    programming error (e.g. not setting long enough timers), it is often due to some failure in the
    environment, and there fore should be classed as a "user error"."""
    def __init__(self, command, output):
        super(TimeoutError, self).__init__('Timed out: {}'.format(command))
        self.command = command
        self.output = output
    def __str__(self):
        return '\n'.join([self.message, 'OUTPUT:', self.output or ''])
 class WorkerThreadError(DevlibError):
    """
    This should get raised  in the main thread if a non-WAError-derived
    exception occurs on a worker/background thread. If a WAError-derived
    exception is raised in the worker, then it that exception should be
    re-raised on the main thread directly -- the main point of this is to
    preserve the backtrace in the output, and backtrace doesn't get output for
    WAErrors.
    """
    def __init__(self, thread, exc_info):
        self.thread = thread
        self.exc_info = exc_info
        orig = self.exc_info[1]
        orig_name = type(orig).__name__
        message = 'Exception of type {} occured on thread {}:\n'.format(orig_name, thread)
        message += '{}\n{}: {}'.format(get_traceback(self.exc_info), orig_name, orig)
        super(WorkerThreadError, self).__init__(message)
 class KernelConfigKeyError(KeyError, IndexError, DevlibError):
    """
    Exception raised when a kernel config option cannot be found.
    It inherits from :exc:`IndexError` for backward compatibility, and
    :exc:`KeyError` to behave like a regular mapping.
    """
    pass
 def get_traceback(exc=None):
    """
    Returns the string with the traceback for the specifiec exc
    object, or for the current exception exc is not specified.
    """
    import io, traceback, sys  # pylint: disable=multiple-imports
    if exc is None:
        exc = sys.exc_info()
    if not exc:
        return None
    tb = exc[2]
    sio = io.StringIO()
    traceback.print_tb(tb, file=sio)
    del tb  # needs to be done explicitly see: http://docs.python.org/2/library/sys.html#sys.exc_info
    return sio.getvalue()
 class AdbRootError(TargetStableError):
    """
    Exception raised when it is not safe to use ``adb root`` or ``adb unroot``
    because other connections are known to be active, and changing rootness
    requires restarting the server.
    """
--- a/devlib/host.py
+++ b/devlib/host.py
@@ -1,4 +1,4 @@
-#    Copyright 2015-2024 ARM Limited
+#    Copyright 2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,172 +13,63 @@
 # limitations under the License.
 #
 import os
 import signal
 import shutil
 import subprocess
 import logging
 import sys
 from getpass import getpass
 from shlex import quote
-from devlib.exception import (
+from devlib.exception import TargetError
    TargetStableError, TargetTransientCalledProcessError, TargetStableCalledProcessError
 )
 from devlib.utils.misc import check_output
 from devlib.connection import ConnectionBase, PopenBackgroundCommand
 if sys.version_info >= (3, 8):
    def copy_tree(src, dst):
        from shutil import copy, copytree
        copytree(
            src,
            dst,
            # dirs_exist_ok=True only exists in Python >= 3.8
            dirs_exist_ok=True,
            # Do not copy creation and modification time to behave like other
            # targets.
            copy_function=copy
        )
 else:
    def copy_tree(src, dst):
        from distutils.dir_util import copy_tree
        # Mirror the behavior of all other targets which only copy the
        # content without metadata
        copy_tree(src, dst, preserve_mode=False, preserve_times=False)
 PACKAGE_BIN_DIRECTORY = os.path.join(os.path.dirname(__file__), 'bin')
-# pylint: disable=redefined-outer-name
+class LocalConnection(object):
 def kill_children(pid, signal=signal.SIGKILL):
    with open('/proc/{0}/task/{0}/children'.format(pid), 'r') as fd:
        for cpid in map(int, fd.read().strip().split()):
            kill_children(cpid, signal)
            os.kill(cpid, signal)
 class LocalConnection(ConnectionBase):
    name = 'local'
    host = 'localhost'
-    @property
+    def __init__(self, timeout=10, keep_password=True, unrooted=False):
    def connected_as_root(self):
        if self._connected_as_root is None:
            result = self.execute('id', as_root=False)
            self._connected_as_root = 'uid=0(' in result
        return self._connected_as_root
    @connected_as_root.setter
    def connected_as_root(self, state):
        self._connected_as_root = state
    # pylint: disable=unused-argument
    def __init__(self, platform=None, keep_password=True, unrooted=False,
                 password=None, timeout=None):
        super().__init__()
        self._connected_as_root = None
        self.logger = logging.getLogger('local_connection')
        self.timeout = timeout
        self.keep_password = keep_password
        self.unrooted = unrooted
-        self.password = password
+        self.password = None
    def push(self, source, dest, timeout=None, as_root=False):  # pylint: disable=unused-argument
        self.logger.debug('cp {} {}'.format(source, dest))
        shutil.copy(source, dest)
-    def _copy_path(self, source, dest):
+    def pull(self, source, dest, timeout=None, as_root=False): # pylint: disable=unused-argument
-        self.logger.debug('copying {} to {}'.format(source, dest))
+        self.logger.debug('cp {} {}'.format(source, dest))
-        if os.path.isdir(source):
+        shutil.copy(source, dest)
            copy_tree(source, dest)
        else:
            shutil.copy(source, dest)
-    def _copy_paths(self, sources, dest):
+    def execute(self, command, timeout=None, check_exit_code=True, as_root=False):
        for source in sources:
            self._copy_path(source, dest)
    def push(self, sources, dest, timeout=None, as_root=False):  # pylint: disable=unused-argument
        self._copy_paths(sources, dest)
    def pull(self, sources, dest, timeout=None, as_root=False): # pylint: disable=unused-argument
        self._copy_paths(sources, dest)
    # pylint: disable=unused-argument
    def execute(self, command, timeout=None, check_exit_code=True,
                as_root=False, strip_colors=True, will_succeed=False):
        self.logger.debug(command)
-        use_sudo = as_root and not self.connected_as_root
+        if as_root:
        if use_sudo:
            if self.unrooted:
-                raise TargetStableError('unrooted')
+                raise TargetError('unrooted')
            password = self._get_password()
-            # Empty prompt with -p '' to avoid adding a leading space to the
+            command = 'echo \'{}\' | sudo -S '.format(password) + command
            # output.
            command = "echo {} | sudo -k -p '' -S -- sh -c {}".format(quote(password), quote(command))
        ignore = None if check_exit_code else 'all'
        try:
-            stdout, stderr = check_output(command, shell=True, timeout=timeout, ignore=ignore)
+            return check_output(command, shell=True, timeout=timeout, ignore=ignore)[0]
        except subprocess.CalledProcessError as e:
-            cls = TargetTransientCalledProcessError if will_succeed else TargetStableCalledProcessError
+            raise TargetError(e)
            raise cls(
                e.returncode,
                command,
                e.output,
                e.stderr,
            )
        # Remove the one-character prompt of sudo -S -p
        if use_sudo and stderr:
            stderr = stderr[1:]
        return stdout + stderr
    def background(self, command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, as_root=False):
-        if as_root and not self.connected_as_root:
+        if as_root:
            if self.unrooted:
-                raise TargetStableError('unrooted')
+                raise TargetError('unrooted')
            password = self._get_password()
-            # Empty prompt with -p '' to avoid adding a leading space to the
+            command = 'echo \'{}\' | sudo -S '.format(password) + command
-            # output.
+        return subprocess.Popen(command, stdout=stdout, stderr=stderr, shell=True)
            command = "echo {} | sudo -k -p '' -S -- sh -c {}".format(quote(password), quote(command))
-        # Make sure to get a new PGID so PopenBackgroundCommand() can kill
+    def close(self):
        # all sub processes that could be started without troubles.
        def preexec_fn():
            os.setpgrp()
        def make_init_kwargs(command):
            popen = subprocess.Popen(
                command,
                stdout=stdout,
                stderr=stderr,
                stdin=subprocess.PIPE,
                shell=True,
                preexec_fn=preexec_fn,
            )
            return dict(
                popen=popen,
            )
        return PopenBackgroundCommand.from_factory(
            conn=self,
            cmd=command,
            as_root=as_root,
            make_init_kwargs=make_init_kwargs,
        )
    def _close(self):
        pass
    def cancel_running_command(self):
        pass
    def wait_for_device(self, timeout=30):
        return
    def reboot_bootloader(self, timeout=30):
        raise NotImplementedError()
    def _get_password(self):
        if self.password:
            return self.password
@@ -186,3 +77,4 @@ class LocalConnection(ConnectionBase):
        if self.keep_password:
            self.password = password
        return password
--- a/devlib/instrument/init.py
+++ b/devlib/instrument/init.py
@@ -1,4 +1,4 @@
-#    Copyright 2018 ARM Limited
+#    Copyright 2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,14 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 import csv
 import logging
 import collections
 from past.builtins import basestring
 from devlib.utils.csvutil import csvreader
 from devlib.utils.types import numeric
 from devlib.utils.types import identifier
 # Channel modes describe what sort of measurement the instrument supports.
@@ -27,37 +23,29 @@ from devlib.utils.types import identifier
 INSTANTANEOUS = 1
 CONTINUOUS = 2
 MEASUREMENT_TYPES = {}  # populated further down
 class MeasurementType(tuple):
-class MeasurementType(object):
+    __slots__ = []
-    def __init__(self, name, units, category=None, conversions=None):
+    def __new__(cls, name, units, category=None):
-        self.name = name
+        return tuple.__new__(cls, (name, units, category))
        self.units = units
        self.category = category
        self.conversions = {}
        if conversions is not None:
            for key, value in conversions.items():
                if not callable(value):
                    msg = 'Converter must be callable; got {} "{}"'
                    raise ValueError(msg.format(type(value), value))
                self.conversions[key] = value
-    def convert(self, value, to):
+    @property
-        if isinstance(to, basestring) and to in MEASUREMENT_TYPES:
+    def name(self):
-            to = MEASUREMENT_TYPES[to]
+        return tuple.__getitem__(self, 0)
-        if not isinstance(to, MeasurementType):
+
-            msg = 'Unexpected conversion target: "{}"'
+    @property
-            raise ValueError(msg.format(to))
+    def units(self):
-        if to.name == self.name:
+        return tuple.__getitem__(self, 1)
-            return value
+
-        if not to.name in self.conversions:
+    @property
-            msg = 'No conversion from {} to {} available'
+    def category(self):
-            raise ValueError(msg.format(self.name, to.name))
+        return tuple.__getitem__(self, 2)
-        return self.conversions[to.name](value)
+
    def __getitem__(self, item):
        raise TypeError()
    # pylint: disable=undefined-variable
    def __cmp__(self, other):
        if isinstance(other, MeasurementType):
            other = other.name
@@ -66,83 +54,24 @@ class MeasurementType(object):
    def __str__(self):
        return self.name
-    def __repr__(self):
+    __repr__ = __str__
        if self.category:
            text = 'MeasurementType({}, {}, {})'
            return text.format(self.name, self.units, self.category)
        else:
            text = 'MeasurementType({}, {})'
            return text.format(self.name, self.units)
-# Standard measures. In order to make sure that downstream data processing is not tied
+# Standard measures
 # to particular insturments (e.g. a particular method of mearuing power), instruments
 # must, where possible, resport their measurments formatted as on of the standard types
 # defined here.
 _measurement_types = [
-    # For whatever reason, the type of measurement could not be established.
+    MeasurementType('time', 'seconds'),
-    MeasurementType('unknown', None),
+    MeasurementType('temperature', 'degrees'),
    # Generic measurements
    MeasurementType('count', 'count'),
    MeasurementType('percent', 'percent'),
    # Time measurement. While there is typically a single "canonical" unit
    # used for each type of measurmenent, time may be measured to a wide variety
    # of events occuring at a wide range of scales. Forcing everying into a
    # single scale will lead to inefficient and awkward to work with result tables.
    # Coversion functions between the formats are specified, so that downstream
    # processors that expect all times time be at a particular scale can automatically
    # covert without being familar with individual instruments.
    MeasurementType('time', 'seconds', 'time',
        conversions={
            'time_us': lambda x: x * 1e6,
            'time_ms': lambda x: x * 1e3,
            'time_ns': lambda x: x * 1e9,
        }
    ),
    MeasurementType('time_us', 'microseconds', 'time',
        conversions={
            'time': lambda x: x / 1e6,
            'time_ms': lambda x: x / 1e3,
            'time_ns': lambda x: x * 1e3,
        }
    ),
    MeasurementType('time_ms', 'milliseconds', 'time',
        conversions={
            'time': lambda x: x / 1e3,
            'time_us': lambda x: x * 1e3,
            'time_ns': lambda x: x * 1e6,
        }
    ),
    MeasurementType('time_ns', 'nanoseconds', 'time',
    conversions={
        'time': lambda x: x / 1e9,
        'time_ms': lambda x: x / 1e6,
        'time_us': lambda x: x / 1e3,
        }
    ),
    # Measurements related to thermals.
    MeasurementType('temperature', 'degrees', 'thermal'),
    # Measurements related to power end energy consumption.
    MeasurementType('power', 'watts', 'power/energy'),
    MeasurementType('voltage', 'volts', 'power/energy'),
    MeasurementType('current', 'amps', 'power/energy'),
    MeasurementType('energy', 'joules', 'power/energy'),
    # Measurments realted to data transfer, e.g. neworking,
    # memory, or backing storage.
    MeasurementType('tx', 'bytes', 'data transfer'),
    MeasurementType('rx', 'bytes', 'data transfer'),
    MeasurementType('tx/rx', 'bytes', 'data transfer'),
    MeasurementType('fps', 'fps', 'ui render'),
    MeasurementType('frames', 'frames', 'ui render'),
 ]
-for m in _measurement_types:
+MEASUREMENT_TYPES = {m.name: m for m in _measurement_types}
    MEASUREMENT_TYPES[m.name] = m
 class Measurement(object):
@@ -161,9 +90,8 @@ class Measurement(object):
        self.value = value
        self.channel = channel
    # pylint: disable=undefined-variable
    def __cmp__(self, other):
-        if hasattr(other, 'value'):
+        if isinstance(other, Measurement):
            return cmp(self.value, other.value)
        else:
            return cmp(self.value, other)
@@ -179,73 +107,28 @@ class Measurement(object):
 class MeasurementsCsv(object):
-    def __init__(self, path, channels=None, sample_rate_hz=None):
+    def __init__(self, path, channels):
        self.path = path
        self.channels = channels
-        self.sample_rate_hz = sample_rate_hz
+        self._fh = open(path, 'rb')
        if self.channels is None:
            self._load_channels()
        headings = [chan.label for chan in self.channels]
        self.data_tuple = collections.namedtuple('csv_entry',
                                                 map(identifier, headings))
    def measurements(self):
-        return list(self.iter_measurements())
+        return list(self.itermeasurements())
-    def iter_measurements(self):
+    def itermeasurements(self):
-        for row in self._iter_rows():
+        self._fh.seek(0)
        reader = csv.reader(self._fh)
        reader.next()  # headings
        for row in reader:
            values = map(numeric, row)
            yield [Measurement(v, c) for (v, c) in zip(values, self.channels)]
    def values(self):
        return list(self.iter_values())
    def iter_values(self):
        for row in self._iter_rows():
            values = list(map(numeric, row))
            yield self.data_tuple(*values)
    def _load_channels(self):
        header = []
        with csvreader(self.path) as reader:
            header = next(reader)
        self.channels = []
        for entry in header:
            for mt in MEASUREMENT_TYPES:
                suffix = '_{}'.format(mt)
                if entry.endswith(suffix):
                    site = entry[:-len(suffix)]
                    measure = mt
                    break
            else:
                if entry in MEASUREMENT_TYPES:
                    site = None
                    measure = entry
                else:
                    site = entry
                    measure = 'unknown'
            chan = InstrumentChannel(site, measure)
            self.channels.append(chan)
    # pylint: disable=stop-iteration-return
    def _iter_rows(self):
        with csvreader(self.path) as reader:
            next(reader)  # headings
            for row in reader:
                yield row
 class InstrumentChannel(object):
    @property
    def label(self):
-        if self.site is not None:
+        return '{}_{}'.format(self.site, self.kind)
            return '{}_{}'.format(self.site, self.kind)
        return self.kind
    name = label
    @property
    def kind(self):
@@ -255,7 +138,8 @@ class InstrumentChannel(object):
    def units(self):
        return self.measurement_type.units
-    def __init__(self, site, measurement_type, **attrs):
+    def __init__(self, name, site, measurement_type, **attrs):
        self.name = name
        self.site = site
        if isinstance(measurement_type, MeasurementType):
            self.measurement_type = measurement_type
@@ -264,7 +148,7 @@ class InstrumentChannel(object):
                self.measurement_type = MEASUREMENT_TYPES[measurement_type]
            except KeyError:
                raise ValueError('Unknown measurement type:  {}'.format(measurement_type))
-        for atname, atvalue in attrs.items():
+        for atname, atvalue in attrs.iteritems():
            setattr(self, atname, atvalue)
    def __str__(self):
@@ -283,22 +167,23 @@ class Instrument(object):
    def __init__(self, target):
        self.target = target
        self.logger = logging.getLogger(self.__class__.__name__)
-        self.channels = collections.OrderedDict()
+        self.channels = {}
        self.active_channels = []
        self.sample_rate_hz = None
    # channel management
    def list_channels(self):
-        return list(self.channels.values())
+        return self.channels.values()
    def get_channels(self, measure):
        if hasattr(measure, 'name'):
            measure = measure.name
-        return [c for c in self.list_channels() if c.kind == measure]
+        return [c for c in self.channels if c.measure.name == measure]
-    def add_channel(self, site, measure, **attrs):
+    def add_channel(self, site, measure, name=None, **attrs):
-        chan = InstrumentChannel(site, measure, **attrs)
+        if name is None:
            name = '{}_{}'.format(site, measure)
        chan = InstrumentChannel(name, site, measure, **attrs)
        self.channels[chan.label] = chan
    # initialization and teardown
@@ -309,27 +194,19 @@ class Instrument(object):
    def teardown(self):
        pass
-    def reset(self, sites=None, kinds=None, channels=None):
+    def reset(self, sites=None, kinds=None):
-        if channels is not None:
+        if kinds is None and sites is None:
            if sites is not None or kinds is not None:
                raise ValueError('sites and kinds should not be set if channels is set')
            try:
                self.active_channels = [self.channels[ch] for ch in channels]
            except KeyError as e:
                msg = 'Unexpected channel "{}"; must be in {}'
                raise ValueError(msg.format(e, self.channels.keys()))
        elif sites is None and kinds is None:
            self.active_channels = sorted(self.channels.values(), key=lambda x: x.label)
        else:
            if isinstance(sites, basestring):
                sites = [sites]
            if isinstance(kinds, basestring):
                kinds = [kinds]
-
+            self.active_channels = []
-            wanted = lambda ch: ((kinds is None or ch.kind in kinds) and
+            for chan in self.channels.values():
-                                  (sites is None or ch.site in sites))
+                if (kinds is None or chan.kind in kinds) and \
-            self.active_channels = list(filter(wanted, self.channels.values()))
+                   (sites is None or chan.site in sites):
                    self.active_channels.append(chan)
    # instantaneous
@@ -344,9 +221,5 @@ class Instrument(object):
    def stop(self):
        pass
    # pylint: disable=no-self-use
    def get_data(self, outfile):
        pass
    def get_raw(self):
        return []
--- a/devlib/instrument/acmecape.py
+++ b/devlib/instrument/acmecape.py
@@ -1,164 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 #pylint: disable=attribute-defined-outside-init
 import os
 import sys
 import time
 import tempfile
 import shlex
 from fcntl import fcntl, F_GETFL, F_SETFL
 from string import Template
 from subprocess import Popen, PIPE, STDOUT
 from shlex import quote
 from devlib import Instrument, CONTINUOUS, MeasurementsCsv
 from devlib.exception import HostError
 from devlib.utils.csvutil import csvreader, csvwriter
 from devlib.utils.misc import which
 OUTPUT_CAPTURE_FILE = 'acme-cape.csv'
 IIOCAP_CMD_TEMPLATE = Template("""
 ${iio_capture} -n ${host} -b ${buffer_size} -c -f ${outfile} ${iio_device}
 """)
 def _read_nonblock(pipe, size=1024):
    fd = pipe.fileno()
    flags = fcntl(fd, F_GETFL)
    flags |= os.O_NONBLOCK
    fcntl(fd, F_SETFL, flags)
    output = ''
    try:
        while True:
            output += pipe.read(size)
    except IOError:
        pass
    return output
 class AcmeCapeInstrument(Instrument):
    mode = CONTINUOUS
    def __init__(self, target,
                 iio_capture=which('iio-capture'),
                 host='baylibre-acme.local',
                 iio_device='iio:device0',
                 buffer_size=256,
                 keep_raw=False):
        super(AcmeCapeInstrument, self).__init__(target)
        self.iio_capture = iio_capture
        self.host = host
        self.iio_device = iio_device
        self.buffer_size = buffer_size
        self.keep_raw = keep_raw
        self.sample_rate_hz = 100
        if self.iio_capture is None:
            raise HostError('Missing iio-capture binary')
        self.command = None
        self.process = None
        self.add_channel('shunt', 'voltage')
        self.add_channel('bus', 'voltage')
        self.add_channel('device', 'power')
        self.add_channel('device', 'current')
        self.add_channel('timestamp', 'time_ms')
    def __del__(self):
        if self.process and self.process.pid:
            self.logger.warning('killing iio-capture process [{}]...'.format(self.process.pid))
            self.process.kill()
    def reset(self, sites=None, kinds=None, channels=None):
        super(AcmeCapeInstrument, self).reset(sites, kinds, channels)
        self.raw_data_file = tempfile.mkstemp('.csv')[1]
        params = dict(
            iio_capture=self.iio_capture,
            host=self.host,
            # This must be a string for quote()
            buffer_size=str(self.buffer_size),
            iio_device=self.iio_device,
            outfile=self.raw_data_file
        )
        params = {k: quote(v) for k, v in params.items()}
        self.command = IIOCAP_CMD_TEMPLATE.substitute(**params)
        self.logger.debug('ACME cape command: {}'.format(self.command))
    def start(self):
        self.process = Popen(shlex.split(self.command), stdout=PIPE, stderr=STDOUT)
    def stop(self):
        self.process.terminate()
        timeout_secs = 10
        output = ''
        for _ in range(timeout_secs):
            if self.process.poll() is not None:
                break
            time.sleep(1)
        else:
            output += _read_nonblock(self.process.stdout)
            self.process.kill()
            self.logger.error('iio-capture did not terminate gracefully')
            if self.process.poll() is None:
                msg = 'Could not terminate iio-capture:\n{}'
                raise HostError(msg.format(output))
        if self.process.returncode != 15: # iio-capture exits with 15 when killed
            output += self.process.stdout.read().decode(sys.stdout.encoding or 'utf-8', 'replace')
            self.logger.info('ACME instrument encountered an error, '
                             'you may want to try rebooting the ACME device:\n'
                             '  ssh root@{} reboot'.format(self.host))
            raise HostError('iio-capture exited with an error ({}), output:\n{}'
                            .format(self.process.returncode, output))
        if not os.path.isfile(self.raw_data_file):
            raise HostError('Output CSV not generated.')
        self.process = None
    def get_data(self, outfile):
        if os.stat(self.raw_data_file).st_size == 0:
            self.logger.warning('"{}" appears to be empty'.format(self.raw_data_file))
            return
        all_channels = [c.label for c in self.list_channels()]
        active_channels = [c.label for c in self.active_channels]
        active_indexes = [all_channels.index(ac) for ac in active_channels]
        with csvreader(self.raw_data_file, skipinitialspace=True) as reader:
            with csvwriter(outfile) as writer:
                writer.writerow(active_channels)
                header = next(reader)
                ts_index = header.index('timestamp ms')
                for row in reader:
                    output_row = []
                    for i in active_indexes:
                        if i == ts_index:
                            # Leave time in ms
                            output_row.append(float(row[i]))
                        else:
                            # Convert rest into standard units.
                            output_row.append(float(row[i])/1000)
                    writer.writerow(output_row)
        return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz)
    def get_raw(self):
        return [self.raw_data_file]
    def teardown(self):
        if not self.keep_raw:
            if os.path.isfile(self.raw_data_file):
                os.remove(self.raw_data_file)
--- a/devlib/instrument/arm_energy_probe.py
+++ b/devlib/instrument/arm_energy_probe.py
@@ -1,149 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 #    Copyright 2018 Linaro Limited
 #
 # 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.
 #
 # pylint: disable=W0613,E1101,access-member-before-definition,attribute-defined-outside-init
 import os
 import shutil
 import signal
 import tempfile
 import subprocess
 from shlex import quote
 from devlib.instrument import Instrument, CONTINUOUS, MeasurementsCsv
 from devlib.exception import HostError
 from devlib.utils.csvutil import csvreader, csvwriter
 from devlib.utils.misc import which
 from devlib.utils.parse_aep import AepParser
 class ArmEnergyProbeInstrument(Instrument):
    """
    Collects power traces using the ARM Energy Probe.
    This instrument requires ``arm-probe`` utility to be installed on the host and be in the PATH.
    arm-probe is available here:
    ``https://git.linaro.org/tools/arm-probe.git``.
    Details about how to build and use it is available here:
    ``https://git.linaro.org/tools/arm-probe.git/tree/README``
    ARM energy probe (AEP) device can simultaneously collect power from up to 3 power rails and
    arm-probe utility can record data from several AEP devices simultaneously.
    To connect the energy probe on a rail, connect the white wire to the pin that is closer to the
    Voltage source and the black wire to the pin that is closer to the load (the SoC or the device
    you are probing). Between the pins there should be a shunt resistor of known resistance in the
    range of 5 to 500 mOhm but the voltage on the shunt resistor must stay smaller than 165mV.
    The resistance of the shunt resistors is a mandatory parameter to be set in the ``config`` file.
    """
    mode = CONTINUOUS
    MAX_CHANNELS = 12 # 4 Arm Energy Probes
    def __init__(self, target, config_file='./config-aep', keep_raw=False):
        super(ArmEnergyProbeInstrument, self).__init__(target)
        self.arm_probe = which('arm-probe')
        if self.arm_probe is None:
            raise HostError('arm-probe must be installed on the host')
        #todo detect is config file exist
        self.attributes = ['power', 'voltage', 'current']
        self.sample_rate_hz = 10000
        self.config_file = config_file
        self.keep_raw = keep_raw
        self.parser = AepParser()
        #TODO make it generic
        topo = self.parser.topology_from_config(self.config_file)
        for item in topo:
            if item == 'time':
                self.add_channel('timestamp', 'time')
            else:
                self.add_channel(item, 'power')
    def reset(self, sites=None, kinds=None, channels=None):
        super(ArmEnergyProbeInstrument, self).reset(sites, kinds, channels)
        self.output_directory = tempfile.mkdtemp(prefix='energy_probe')
        self.output_file_raw = os.path.join(self.output_directory, 'data_raw')
        self.output_file = os.path.join(self.output_directory, 'data')
        self.output_file_figure = os.path.join(self.output_directory, 'summary.txt')
        self.output_file_error = os.path.join(self.output_directory, 'error.log')
        self.output_fd_error = open(self.output_file_error, 'w')
        self.command = 'arm-probe --config {} > {}'.format(quote(self.config_file), quote(self.output_file_raw))
    def start(self):
        self.logger.debug(self.command)
        self.armprobe = subprocess.Popen(self.command,
                                       stderr=self.output_fd_error,
                                       preexec_fn=os.setpgrp,
                                       shell=True)
    def stop(self):
        self.logger.debug("kill running arm-probe")
        os.killpg(self.armprobe.pid, signal.SIGTERM)
    def get_data(self, outfile):  # pylint: disable=R0914
        self.logger.debug("Parse data and compute consumed energy")
        self.parser.prepare(self.output_file_raw, self.output_file, self.output_file_figure)
        self.parser.parse_aep()
        self.parser.unprepare()
        skip_header = 1
        all_channels = [c.label for c in self.list_channels()]
        active_channels = [c.label for c in self.active_channels]
        active_indexes = [all_channels.index(ac) for ac in active_channels]
        with csvreader(self.output_file, delimiter=' ') as reader:
            with csvwriter(outfile) as writer:
                for row in reader:
                    if skip_header == 1:
                        writer.writerow(active_channels)
                        skip_header = 0
                        continue
                    if len(row) < len(active_channels):
                        continue
                    # all data are in micro (seconds/watt)
                    new = [float(row[i])/1000000 for i in active_indexes]
                    writer.writerow(new)
        self.output_fd_error.close()
        shutil.rmtree(self.output_directory)
        return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz)
    def get_raw(self):
        return [self.output_file_raw]
    def teardown(self):
        if not self.keep_raw:
            if os.path.isfile(self.output_file_raw):
                os.remove(self.output_file_raw)
--- a/devlib/instrument/baylibre_acme.py
+++ b/devlib/instrument/baylibre_acme.py
@@ -1,557 +0,0 @@
 #pylint: disable=attribute-defined-outside-init
 import collections
 import functools
 import re
 import threading
 from past.builtins import basestring
 try:
    import iio
 except ImportError as e:
    iio_import_failed = True
    iio_import_error  = e
 else:
    iio_import_failed = False
 import numpy as np
 import pandas as pd
 from devlib import CONTINUOUS, Instrument, HostError, MeasurementsCsv, TargetError
 from devlib.utils.ssh import SshConnection
 class IIOINA226Channel(object):
    def __init__(self, iio_channel):
        channel_id   = iio_channel.id
        channel_type = iio_channel.attrs['type'].value
        re_measure = r'(?P<measure>\w+)(?P<index>\d*)$'
        re_dtype = r'le:(?P<sign>\w)(?P<width>\d+)/(?P<size>\d+)>>(?P<align>\d+)'
        match_measure = re.search(re_measure, channel_id)
        match_dtype = re.search(re_dtype, channel_type)
        if not match_measure:
            msg = "IIO channel ID '{}' does not match expected RE '{}'"
            raise ValueError(msg.format(channel_id, re_measure))
        if not match_dtype:
            msg = "'IIO channel type '{}' does not match expected RE '{}'"
            raise ValueError(msg.format(channel_type, re_dtype))
        self.measure = match_measure.group('measure')
        self.iio_dtype = 'int{}'.format(match_dtype.group('width'))
        self.iio_channel = iio_channel
        # Data is reported in amps, volts, watts and microseconds:
        self.iio_scale   = (1. if 'scale' not in iio_channel.attrs
                            else float(iio_channel.attrs['scale'].value))
        self.iio_scale /= 1000
        # As calls to iio_store_buffer will be blocking and probably coming
        # from a loop retrieving samples from the ACME, we want to provide
        # consistency in processing timing between iterations i.e. we want
        # iio_store_buffer to be o(1) for every call (can't have that with []):
        self.sample_buffers = collections.deque()
    def iio_store_buffer_samples(self, iio_buffer):
        # IIO buffers receive and store their data as an interlaced array of
        # samples from all the IIO channels of the IIO device. The IIO library
        # provides a reliable function to extract the samples (bytes, actually)
        # corresponding to a channel from the received buffer; in Python, it is
        # iio.Channel.read(iio.Buffer).
        #
        # NB: As this is called in a potentially tightly timed loop, we do as
        #     little work as possible:
        self.sample_buffers.append(self.iio_channel.read(iio_buffer))
    def iio_get_samples(self, absolute_timestamps=False):
        # Up to this point, the data is not interpreted yet i.e. these are
        # bytearrays. Hence the use of np.dtypes.
        buffers = [np.frombuffer(b, dtype=self.iio_dtype)
                   for b in self.sample_buffers]
        must_shift = (self.measure == 'timestamp' and not absolute_timestamps)
        samples = np.concatenate(buffers)
        return (samples - samples[0] if must_shift else samples) * self.iio_scale
    def iio_forget_samples(self):
        self.sample_buffers.clear()
 # Decorators for the attributes of IIOINA226Instrument:
 def only_set_to(valid_values, dynamic=False):
    def validating_wrapper(func):
        @functools.wraps(func)
        def wrapper(self, value):
            values = (valid_values if not dynamic
                      else getattr(self, valid_values))
            if value not in values: 
                msg = '{} is invalid; expected values are {}'
                raise ValueError(msg.format(value, valid_values))
            return func(self, value)
        return wrapper
    return validating_wrapper
 def with_input_as(wanted_type):
    def typecasting_wrapper(func):
        @functools.wraps(func)
        def wrapper(self, value):
            return func(self, wanted_type(value))
        return wrapper
    return typecasting_wrapper
 def _IIODeviceAttr(attr_name, attr_type, writable=False, dyn_vals=None, stat_vals=None):
    def getter(self):
        return attr_type(self.iio_device.attrs[attr_name].value)
    def setter(self, value):
        self.iio_device.attrs[attr_name].value = str(attr_type(value))
    if writable and (dyn_vals or stat_vals):
        vals, dyn = dyn_vals or stat_vals, dyn_vals is not None
        setter = with_input_as(attr_type)(only_set_to(vals, dyn)(setter))
    return property(getter, setter if writable else None)
 def _IIOChannelIntTime(chan_name):
    attr_name, attr_type = 'integration_time', float
    def getter(self):
        ch = self.iio_device.find_channel(chan_name)
        return attr_type(ch.attrs[attr_name].value)
    @only_set_to('INTEGRATION_TIMES_AVAILABLE', dynamic=True)
    @with_input_as(attr_type)
    def setter(self, value):
        ch = self.iio_device.find_channel(chan_name)
        ch.attrs[attr_name].value = str(value)
    return property(getter, setter)
 def _setify(x):
    return {x} if isinstance(x, basestring) else set(x) #Py3: basestring->str
 class IIOINA226Instrument(object):
    IIO_DEVICE_NAME = 'ina226'
    def __init__(self, iio_device):
        if iio_device.name != self.IIO_DEVICE_NAME:
            msg = 'IIO device is {}; expected {}'
            raise TargetError(msg.format(iio_device.name, self.IIO_DEVICE_NAME))
        self.iio_device           = iio_device
        self.absolute_timestamps  = False
        self.high_resolution      = True
        self.buffer_samples_count = None
        self.buffer_is_circular   = False
        self.collector = None
        self.work_done = threading.Event()
        self.collector_exception = None
        self.data = collections.OrderedDict()
        channels = {
                'timestamp': 'timestamp',
                'shunt'    : 'voltage0',
                'voltage'  : 'voltage1', # bus
                'power'    : 'power2',
                'current'  : 'current3',
        }
        self.computable_channels = {'current' : {'shunt'},
                                    'power'   : {'shunt', 'voltage'}}
        self.uncomputable_channels = set(channels) - set(self.computable_channels)
        self.channels = {k: IIOINA226Channel(self.iio_device.find_channel(v))
                         for k, v in channels.items()}
        # We distinguish between "output" channels (as seen by the user of this
        # class) and "hardware" channels (as requested from the INA226).
        # This is necessary because of the 'high_resolution' feature which
        # requires outputting computed channels:
        self.active_channels = set()  # "hardware" channels
        self.wanted_channels = set()  # "output" channels
    # Properties
    OVERSAMPLING_RATIOS_AVAILABLE = (1, 4, 16, 64, 128, 256, 512, 1024)
    INTEGRATION_TIMES_AVAILABLE = _IIODeviceAttr('integration_time_available',
                                                 lambda x: tuple(map(float, x.split())))
    sample_rate_hz     = _IIODeviceAttr('in_sampling_frequency', int)
    shunt_resistor     = _IIODeviceAttr('in_shunt_resistor'    , int, True)
    oversampling_ratio = _IIODeviceAttr('in_oversampling_ratio', int, True,
                                        dyn_vals='OVERSAMPLING_RATIOS_AVAILABLE')
    integration_time_shunt = _IIOChannelIntTime('voltage0')
    integration_time_bus   = _IIOChannelIntTime('voltage1')
    def list_channels(self):
        return self.channels.keys()
    def activate(self, channels=None):
        all_channels = set(self.channels)
        requested_channels = (all_channels if channels is None
                              else _setify(channels))
        unknown = ', '.join(requested_channels - all_channels)
        if unknown:
            raise ValueError('Unknown channel(s): {}'.format(unknown))
        self.wanted_channels |= requested_channels
    def deactivate(self, channels=None):
        unwanted_channels = (self.wanted_channels if channels is None
                             else _setify(channels))
        unknown = ', '.join(unwanted_channels - set(self.channels))
        if unknown:
            raise ValueError('Unknown channel(s): {}'.format(unknown))
        unactive = ', '.join(unwanted_channels - self.wanted_channels)
        if unactive:
            raise ValueError('Already unactive channel(s): {}'.format(unactive))
        self.wanted_channels -= unwanted_channels
    def sample_collector(self):
        class Collector(threading.Thread):
            def run(collector_self):
                for name, ch in self.channels.items():
                    ch.iio_channel.enabled = (name in self.active_channels)
                samples_count = self.buffer_samples_count or self.sample_rate_hz
                iio_buffer = iio.Buffer(self.iio_device, samples_count,
                                        self.buffer_is_circular)
                # NB: This buffer creates a communication pipe to the
                #     BeagleBone (or is it between the BBB and the ACME?)
                #     that locks down any configuration. The IIO drivers
                #     do not limit access when a buffer exists so that
                #     configuring the INA226 (i.e. accessing iio.Device.attrs
                #     or iio.Channel.attrs from iio.Device.channels i.e.
                #     assigning to or reading from any property of this class
                #     or calling its setup or reset methods) will screw up the
                #     whole system and will require rebooting the BBB-ACME board!
                self.collector_exception = None
                try:
                    refilled_once = False
                    while not (refilled_once and self.work_done.is_set()):
                        refilled_once = True
                        iio_buffer.refill()
                        for name in self.active_channels:
                            self.channels[name].iio_store_buffer_samples(iio_buffer)
                except Exception as e:
                    self.collector_exception = e
                finally:
                    del iio_buffer
                    for ch in self.channels.values():
                        ch.enabled = False
        return Collector()
    def start_capturing(self):
        if not self.wanted_channels:
            raise TargetError('No active channel: aborting.')
        self.active_channels = self.wanted_channels.copy()
        if self.high_resolution:
            self.active_channels &= self.uncomputable_channels
            for channel, dependencies in self.computable_channels.items():
                if channel in self.wanted_channels:
                    self.active_channels |= dependencies
        self.work_done.clear()
        self.collector = self.sample_collector()
        self.collector.daemon = True
        self.collector.start()
    def stop_capturing(self):
        self.work_done.set()
        self.collector.join()
        if self.collector_exception:
            raise self.collector_exception
        self.data.clear()
        for channel in self.active_channels:
            ch = self.channels[channel]
            self.data[channel] = ch.iio_get_samples(self.absolute_timestamps)
            ch.iio_forget_samples()
        if self.high_resolution:
            res_ohm = 1e-6 * self.shunt_resistor
            current = self.data['shunt'] / res_ohm
            if 'current' in self.wanted_channels:
                self.data['current'] = current
            if 'power' in self.wanted_channels:
                self.data['power'] = current * self.data['voltage']
            for channel in set(self.data) - self.wanted_channels:
                del self.data[channel]
        self.active_channels.clear()
    def get_data(self):
        return self.data
 class BaylibreAcmeInstrument(Instrument):
    mode = CONTINUOUS
    MINIMAL_ACME_SD_IMAGE_VERSION    = (2, 1, 3)
    MINIMAL_ACME_IIO_DRIVERS_VERSION = (0, 6)
    MINIMAL_HOST_IIO_DRIVERS_VERSION = (0, 15)
    def __init__(self, target=None, iio_context=None,
                 use_base_iio_context=False, probe_names=None):
        if iio_import_failed:
            raise HostError('Could not import "iio": {}'.format(iio_import_error))
        super(BaylibreAcmeInstrument, self).__init__(target)
        if isinstance(probe_names, basestring):
            probe_names = [probe_names]
        self.iio_context = (iio_context if not use_base_iio_context
                            else iio.Context(iio_context))
        self.check_version()
        if probe_names is not None:
            if len(probe_names) != len(set(probe_names)):
                msg = 'Probe names should be unique: {}'
                raise ValueError(msg.format(probe_names))
            if len(probe_names) != len(self.iio_context.devices):
                msg = ('There should be as many probe_names ({}) '
                       'as detected probes ({}).')
                raise ValueError(msg.format(len(probe_names),
                                            len(self.iio_context.devices)))
        probes = [IIOINA226Instrument(d) for d in self.iio_context.devices]
        self.probes = (dict(zip(probe_names, probes)) if probe_names
                       else {p.iio_device.id : p for p in probes})
        self.active_probes = set()
        for probe in self.probes:
            for measure in ['voltage', 'power', 'current']:
                self.add_channel(site=probe, measure=measure)
        self.add_channel('timestamp', 'time_us')
        self.data = pd.DataFrame()
    def check_version(self):
        msg = ('The IIO drivers running on {} ({}) are out-of-date; '
               'devlib requires {} or later.')
        if iio.version[:2] < self.MINIMAL_HOST_IIO_DRIVERS_VERSION:
            ver_str = '.'.join(map(str, iio.version[:2]))
            min_str = '.'.join(map(str, self.MINIMAL_HOST_IIO_DRIVERS_VERSION))
            raise HostError(msg.format('this host', ver_str, min_str))
        if self.version[:2] < self.MINIMAL_ACME_IIO_DRIVERS_VERSION:
            ver_str = '.'.join(map(str, self.version[:2]))
            min_str = '.'.join(map(str, self.MINIMAL_ACME_IIO_DRIVERS_VERSION))
            raise TargetError(msg.format('the BBB', ver_str, min_str))
    # properties
    def probes_unique_property(self, property_name):
        probes = self.active_probes or self.probes
        try:
            # This will fail if there is not exactly one single value:
            (value,) = {getattr(self.probes[p], property_name) for p in probes}
        except ValueError:
            msg = 'Probes have different values for {}.'
            raise ValueError(msg.format(property_name) if probes else 'No probe')
        return value
    @property
    def version(self):
        return self.iio_context.version
    @property
    def OVERSAMPLING_RATIOS_AVAILABLE(self):
        return self.probes_unique_property('OVERSAMPLING_RATIOS_AVAILABLE')
    @property
    def INTEGRATION_TIMES_AVAILABLE(self):
        return self.probes_unique_property('INTEGRATION_TIMES_AVAILABLE')
    @property
    def sample_rate_hz(self):
        return self.probes_unique_property('sample_rate_hz')
    @sample_rate_hz.setter
    # This setter is required for compliance with the inherited methods
    def sample_rate_hz(self, value):
        if value is not None:
            raise AttributeError("can't set attribute")
    # initialization and teardown
    def setup(self, shunt_resistor,
              integration_time_bus,
              integration_time_shunt,
              oversampling_ratio,
              buffer_samples_count=None,
              buffer_is_circular=False,
              absolute_timestamps=False,
              high_resolution=True):
        def pseudo_list(v, i):
            try:
                return v[i]
            except TypeError:
                return v
        for i, p in enumerate(self.probes.values()):
            for attr, val in locals().items():
                if attr != 'self':
                    setattr(p, attr, pseudo_list(val, i))
        self.absolute_timestamps = all(pseudo_list(absolute_timestamps, i)
                                       for i in range(len(self.probes)))
    def reset(self, sites=None, kinds=None, channels=None):
        # populate self.active_channels:
        super(BaylibreAcmeInstrument, self).reset(sites, kinds, channels)
        for ch in self.active_channels:
            if ch.site != 'timestamp':
                self.probes[ch.site].activate(['timestamp', ch.kind])
                self.active_probes.add(ch.site)
    def teardown(self):
        del self.active_channels[:]
        self.active_probes.clear()
    def start(self):
        for p in self.active_probes:
            self.probes[p].start_capturing()
    def stop(self):
        for p in self.active_probes:
            self.probes[p].stop_capturing()
        max_rate_probe = max(self.active_probes,
                             key=lambda p: self.probes[p].sample_rate_hz)
        probes_dataframes = {
                probe: pd.DataFrame.from_dict(self.probes[probe].get_data())
                                   .set_index('timestamp')
                for probe in self.active_probes
        }
        for df in probes_dataframes.values():
            df.set_index(pd.to_datetime(df.index, unit='us'), inplace=True)
        final_index = probes_dataframes[max_rate_probe].index
        df = pd.concat(probes_dataframes, axis=1).sort_index()
        df.columns = ['_'.join(c).strip() for c in df.columns.values]
        self.data = df.interpolate('time').reindex(final_index)
        if not self.absolute_timestamps:
            epoch_index = self.data.index.astype(np.int64) // 1000
            self.data.set_index(epoch_index, inplace=True)
            # self.data.index is in [us]
            # columns are in volts, amps and watts
    def get_data(self, outfile=None, **to_csv_kwargs):
        if outfile is None:
            return self.data
        self.data.to_csv(outfile, **to_csv_kwargs)
        return MeasurementsCsv(outfile, self.active_channels)
 class BaylibreAcmeLocalInstrument(BaylibreAcmeInstrument):
    def __init__(self, target=None, probe_names=None):
        if iio_import_failed:
            raise HostError('Could not import "iio": {}'.format(iio_import_error))
        super(BaylibreAcmeLocalInstrument, self).__init__(
                        target=target,
                        iio_context=iio.LocalContext(),
                        probe_names=probe_names
        )
 class BaylibreAcmeXMLInstrument(BaylibreAcmeInstrument):
    def __init__(self, target=None, xmlfile=None, probe_names=None):
        if iio_import_failed:
            raise HostError('Could not import "iio": {}'.format(iio_import_error))
        super(BaylibreAcmeXMLInstrument, self).__init__(
                        target=target,
                        iio_context=iio.XMLContext(xmlfile),
                        probe_names=probe_names
        )
 class BaylibreAcmeNetworkInstrument(BaylibreAcmeInstrument):
    def __init__(self, target=None, hostname=None, probe_names=None):
        if iio_import_failed:
            raise HostError('Could not import "iio": {}'.format(iio_import_error))
        super(BaylibreAcmeNetworkInstrument, self).__init__(
                        target=target,
                        iio_context=iio.NetworkContext(hostname),
                        probe_names=probe_names
        )
        try:
            self.ssh_connection = SshConnection(hostname, username='root', password=None)
        except TargetError as e:
            msg = 'No SSH connexion could be established to {}: {}'
            self.logger.debug(msg.format(hostname, e))
            self.ssh_connection = None
    def check_version(self):
        super(BaylibreAcmeNetworkInstrument, self).check_version()
        cmd = r"""sed -nr 's/^VERSION_ID="(.+)"$/\1/p' < /etc/os-release"""
        try:
            ver_str = self._ssh(cmd).rstrip()
            ver = tuple(map(int, ver_str.split('.')))
        except Exception as e:
            self.logger.debug('Unable to verify ACME SD image version through SSH: {}'.format(e))
        else:
            if ver < self.MINIMAL_ACME_SD_IMAGE_VERSION:
                min_str = '.'.join(map(str, self.MINIMAL_ACME_SD_IMAGE_VERSION))
                msg = ('The ACME SD image for the BBB (ver. {}) is out-of-date; '
                       'devlib requires {} or later.')
                raise TargetError(msg.format(ver_str, min_str))
    def _ssh(self, cmd=''):
        """Connections are assumed to be rare."""
        if self.ssh_connection is None:
            raise TargetError('No SSH connection; see log.')
        return self.ssh_connection.execute(cmd)
    def _reboot(self):
        """Always delete the object after calling its _reboot method"""
        try:
            self._ssh('reboot')
        except:
            pass
--- a/devlib/instrument/daq.py
+++ b/devlib/instrument/daq.py
@@ -1,37 +1,19 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import os
-import shutil
+import csv
 import tempfile
-import time
+from itertools import chain
 from itertools import chain, zip_longest
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.instrument import Instrument, MeasurementsCsv, CONTINUOUS
 from devlib.exception import HostError
 from devlib.utils.csvutil import csvwriter, create_reader
 from devlib.utils.misc import unique
 try:
-    from daqpower.client import DaqClient
+    from daqpower.client import execute_command, Status
-    from daqpower.config import DeviceConfiguration
+    from daqpower.config import DeviceConfiguration, ServerConfiguration
-except ImportError as e:
+except ImportError, e:
-    DaqClient = None
+    execute_command, Status = None, None
-    DeviceConfiguration = None
+    DeviceConfiguration, ServerConfiguration, ConfigurationError = None, None, None
-    import_error_mesg = e.args[0] if e.args else str(e)
+    import_error_mesg = e.message
 class DaqInstrument(Instrument):
@@ -45,100 +27,64 @@ class DaqInstrument(Instrument):
                 device_id='Dev1',
                 v_range=2.5,
                 dv_range=0.2,
-                 sample_rate_hz=10000,
+                 sampling_rate=10000,
                 channel_map=(0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 20, 21, 22, 23),
                 keep_raw=False,
                 time_as_clock_boottime=True
                 ):
        # pylint: disable=no-member
        super(DaqInstrument, self).__init__(target)
        self.keep_raw = keep_raw
        self._need_reset = True
-        self._raw_files = []
+        if execute_command is None:
        self.tempdir = None
        self.target_boottime_clock_at_start = 0.0
        if DaqClient is None:
            raise HostError('Could not import "daqpower": {}'.format(import_error_mesg))
        if labels is None:
-            labels = ['PORT_{}'.format(i) for i in range(len(resistor_values))]
+            labels = ['PORT_{}'.format(i) for i in xrange(len(resistor_values))]
        if len(labels) != len(resistor_values):
            raise ValueError('"labels" and "resistor_values" must be of the same length')
-        self.daq_client = DaqClient(host, port)
+        self.server_config = ServerConfiguration(host=host,
-        try:
+                                                 port=port)
-            devices = self.daq_client.list_devices()
+        result = self.execute('list_devices')
-            if device_id not in devices:
+        if result.status == Status.OK:
-                msg = 'Device "{}" is not found on the DAQ server. Available devices are: "{}"'
+            if device_id not in result.data:
-                raise ValueError(msg.format(device_id, ', '.join(devices)))
+                raise ValueError('Device "{}" is not found on the DAQ server.'.format(device_id))
-        except Exception as e:
+        elif result.status != Status.OKISH:
-            raise HostError('Problem querying DAQ server: {}'.format(e))
+            raise HostError('Problem querying DAQ server: {}'.format(result.message))
        self.device_config = DeviceConfiguration(device_id=device_id,
                                                 v_range=v_range,
                                                 dv_range=dv_range,
-                                                 sampling_rate=sample_rate_hz,
+                                                 sampling_rate=sampling_rate,
                                                 resistor_values=resistor_values,
                                                 channel_map=channel_map,
                                                 labels=labels)
        self.sample_rate_hz = sample_rate_hz
        self.time_as_clock_boottime = time_as_clock_boottime
        self.add_channel('Time', 'time')
        for label in labels:
            for kind in ['power', 'voltage']:
                self.add_channel(label, kind)
-        if time_as_clock_boottime:
+    def reset(self, sites=None, kinds=None):
-            host_path = os.path.join(PACKAGE_BIN_DIRECTORY, self.target.abi,
+        super(DaqInstrument, self).reset(sites, kinds)
-                                     'get_clock_boottime')
+        self.execute('close')
-            self.clock_boottime_cmd = self.target.install_if_needed(host_path,
+        result = self.execute('configure', config=self.device_config)
-                                                                    search_system_binaries=False)
+        if not result.status == Status.OK:  # pylint: disable=no-member
-
+            raise HostError(result.message)
    def calculate_boottime_offset(self):
        time_before = time.time()
        out = self.target.execute(self.clock_boottime_cmd)
        time_after = time.time()
        remote_clock_boottime = float(out)
        propagation_delay = (time_after - time_before) / 2
        boottime_at_end = remote_clock_boottime + propagation_delay
        return time_after - boottime_at_end
    def reset(self, sites=None, kinds=None, channels=None):
        super(DaqInstrument, self).reset(sites, kinds, channels)
        self.daq_client.close()
        self.daq_client.configure(self.device_config)
        self._need_reset = False
        self._raw_files = []
    def start(self):
        if self._need_reset:
-            # Preserve channel order
+            self.reset()
-            self.reset(channels=self.channels.keys())
+        self.execute('start')
        if self.time_as_clock_boottime:
            target_boottime_offset = self.calculate_boottime_offset()
            time_start = time.time()
        self.daq_client.start()
        if self.time_as_clock_boottime:
            time_end = time.time()
            self.target_boottime_clock_at_start = (time_start + time_end) / 2 - target_boottime_offset
    def stop(self):
-        self.daq_client.stop()
+        self.execute('stop')
        self._need_reset = True
    def get_data(self, outfile):  # pylint: disable=R0914
-        self.tempdir = tempfile.mkdtemp(prefix='daq-raw-')
+        tempdir = tempfile.mkdtemp(prefix='daq-raw-')
-        self.daq_client.get_data(self.tempdir)
+        self.execute('get_data', output_directory=tempdir)
        raw_file_map = {}
-        for entry in os.listdir(self.tempdir):
+        for entry in os.listdir(tempdir):
            site = os.path.splitext(entry)[0]
-            path = os.path.join(self.tempdir, entry)
+            path = os.path.join(tempdir, entry)
            raw_file_map[site] = path
            self._raw_files.append(path)
        active_sites = unique([c.site for c in self.active_channels])
        file_handles = []
@@ -147,47 +93,46 @@ class DaqInstrument(Instrument):
            for site in active_sites:
                try:
                    site_file = raw_file_map[site]
-                    reader, fh = create_reader(site_file)
+                    fh = open(site_file, 'rb')
-                    site_readers[site] = reader
+                    site_readers[site] = csv.reader(fh)
                    file_handles.append(fh)
                except KeyError:
-                    if not site.startswith("Time"):
+                    message = 'Could not get DAQ trace for {}; Obtained traces are in {}'
-                        message = 'Could not get DAQ trace for {}; Obtained traces are in {}'
+                    raise HostError(message.format(site, tempdir))
                        raise HostError(message.format(site, self.tempdir))
            # The first row is the headers
-            channel_order = ['Time_time']
+            channel_order = []
-            for site, reader in site_readers.items():
+            for site, reader in site_readers.iteritems():
                channel_order.extend(['{}_{}'.format(site, kind)
-                                      for kind in next(reader)])
+                                      for kind in reader.next()])
-            def _read_rows():
+            def _read_next_rows():
-                row_iter = zip_longest(*site_readers.values(), fillvalue=(None, None))
+                parts = []
-                for raw_row in row_iter:
+                for reader in site_readers.itervalues():
-                    raw_row = list(chain.from_iterable(raw_row))
+                    try:
-                    raw_row.insert(0, _read_rows.row_time_s)
+                        parts.extend(reader.next())
-                    yield raw_row
+                    except StopIteration:
-                    _read_rows.row_time_s += 1.0 / self.sample_rate_hz
+                        parts.extend([None, None])
                return list(chain(parts))
-            _read_rows.row_time_s = self.target_boottime_clock_at_start
+            with open(outfile, 'wb') as wfh:
            with csvwriter(outfile) as writer:
                field_names = [c.label for c in self.active_channels]
                writer = csv.writer(wfh)
                writer.writerow(field_names)
-                for raw_row in _read_rows():
+                raw_row = _read_next_rows()
                while any(raw_row):
                    row = [raw_row[channel_order.index(f)] for f in field_names]
                    writer.writerow(row)
                    raw_row = _read_next_rows()
-            return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz)
+            return MeasurementsCsv(outfile, self.active_channels)
        finally:
            for fh in file_handles:
                fh.close()
    def get_raw(self):
        return self._raw_files
    def teardown(self):
-        self.daq_client.close()
+        self.execute('close')
-        if not self.keep_raw:
+
-            if self.tempdir and os.path.isdir(self.tempdir):
+    def execute(self, command, **kwargs):
-                shutil.rmtree(self.tempdir)
+        return execute_command(self.server_config, command, **kwargs)
--- a/devlib/instrument/energy_probe.py
+++ b/devlib/instrument/energy_probe.py
@@ -1,4 +1,4 @@
-#    Copyright 2015-2018 ARM Limited
+#    Copyright 2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,17 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 from __future__ import division
 import os
 import csv
 import signal
 import tempfile
 import struct
 import subprocess
-import sys
+
-from shlex import quote
+try:
    import pandas
 except ImportError:
    pandas = None
 from devlib.instrument import Instrument, CONTINUOUS, MeasurementsCsv
 from devlib.exception import HostError
 from devlib.utils.csvutil import csvwriter
 from devlib.utils.misc import which
@@ -33,45 +37,40 @@ class EnergyProbeInstrument(Instrument):
    def __init__(self, target, resistor_values,
                 labels=None,
                 device_entry='/dev/ttyACM0',
                 keep_raw=False
                 ):
        super(EnergyProbeInstrument, self).__init__(target)
        self.resistor_values = resistor_values
        self.keep_raw = keep_raw
        if labels is not None:
            self.labels = labels
        else:
            self.labels = ['PORT_{}'.format(i)
-                           for i in range(len(resistor_values))]
+                           for i in xrange(len(resistor_values))]
        self.device_entry = device_entry
        self.caiman = which('caiman')
        if self.caiman is None:
            raise HostError('caiman must be installed on the host '
                            '(see https://github.com/ARM-software/caiman)')
        if pandas is None:
            self.logger.info("pandas package will significantly speed up this instrument")
            self.logger.info("to install it try: pip install pandas")
        self.attributes_per_sample = 3
        self.bytes_per_sample = self.attributes_per_sample * 4
        self.attributes = ['power', 'voltage', 'current']
        self.command = None
        self.raw_output_directory = None
        self.process = None
        self.sample_rate_hz = 10000 # Determined empirically
        self.raw_data_file = None
        for label in self.labels:
            for kind in self.attributes:
                self.add_channel(label, kind)
-    def reset(self, sites=None, kinds=None, channels=None):
+    def reset(self, sites=None, kinds=None):
-        super(EnergyProbeInstrument, self).reset(sites, kinds, channels)
+        super(EnergyProbeInstrument, self).reset(sites, kinds)
        self.raw_output_directory = tempfile.mkdtemp(prefix='eprobe-caiman-')
        parts = ['-r {}:{} '.format(i, int(1000 * rval))
                 for i, rval in enumerate(self.resistor_values)]
        rstring = ''.join(parts)
-        self.command = '{} -d {} -l {} {}'.format(
+        self.command = '{} -d {} -l {} {}'.format(self.caiman, self.device_entry, rstring, self.raw_output_directory)
            quote(self.caiman), quote(self.device_entry),
            rstring, quote(self.raw_output_directory)
        )
        self.raw_data_file = None
    def start(self):
        self.logger.debug(self.command)
@@ -83,16 +82,7 @@ class EnergyProbeInstrument(Instrument):
                                        shell=True)
    def stop(self):
-        self.process.poll()
+        os.killpg(self.process.pid, signal.SIGTERM)
        if self.process.returncode is not None:
            stdout, stderr = self.process.communicate()
            stdout = stdout.decode(sys.stdout.encoding or 'utf-8', 'replace')
            stderr = stderr.decode(sys.stdout.encoding or 'utf-8', 'replace')
            raise HostError(
                'Energy Probe: Caiman exited unexpectedly with exit code {}.\n'
                'stdout:\n{}\nstderr:\n{}'.format(self.process.returncode,
                                                  stdout, stderr))
        os.killpg(self.process.pid, signal.SIGINT)
    def get_data(self, outfile):  # pylint: disable=R0914
        all_channels = [c.label for c in self.list_channels()]
@@ -102,11 +92,12 @@ class EnergyProbeInstrument(Instrument):
        num_of_ports = len(self.resistor_values)
        struct_format = '{}I'.format(num_of_ports * self.attributes_per_sample)
        not_a_full_row_seen = False
-        self.raw_data_file = os.path.join(self.raw_output_directory, '0000000000')
+        raw_data_file = os.path.join(self.raw_output_directory, '0000000000')
-        self.logger.debug('Parsing raw data file: {}'.format(self.raw_data_file))
+        self.logger.debug('Parsing raw data file: {}'.format(raw_data_file))
-        with open(self.raw_data_file, 'rb') as bfile:
+        with open(raw_data_file, 'rb') as bfile:
-            with csvwriter(outfile) as writer:
+            with open(outfile, 'wb') as wfh:
                writer = csv.writer(wfh)
                writer.writerow(active_channels)
                while True:
                    data = bfile.read(num_of_ports * self.bytes_per_sample)
@@ -118,16 +109,8 @@ class EnergyProbeInstrument(Instrument):
                        writer.writerow(row)
                    except struct.error:
                        if not_a_full_row_seen:
-                            self.logger.warning('possibly missaligned caiman raw data, row contained {} bytes'.format(len(data)))
+                            self.logger.warn('possibly missaligned caiman raw data, row contained {} bytes'.format(len(data)))
                            continue
                        else:
                            not_a_full_row_seen = True
-        return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz)
+        return MeasurementsCsv(outfile, self.active_channels)
    def get_raw(self):
        return [self.raw_data_file]
    def teardown(self):
        if self.keep_raw:
            if os.path.isfile(self.raw_data_file):
                os.remove(self.raw_data_file)
--- a/devlib/instrument/frames.py
+++ b/devlib/instrument/frames.py
@@ -1,104 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import os
 from devlib.instrument import (Instrument, CONTINUOUS,
                               MeasurementsCsv, MeasurementType)
 from devlib.utils.rendering import (GfxinfoFrameCollector,
                                    SurfaceFlingerFrameCollector,
                                    SurfaceFlingerFrame,
                                    read_gfxinfo_columns)
 class FramesInstrument(Instrument):
    mode = CONTINUOUS
    collector_cls = None
    def __init__(self, target, collector_target, period=2, keep_raw=True):
        super(FramesInstrument, self).__init__(target)
        self.collector_target = collector_target
        self.period = period
        self.keep_raw = keep_raw
        self.sample_rate_hz = 1 / self.period
        self.collector = None
        self.header = None
        self._need_reset = True
        self._raw_file = None
        self._init_channels()
    def reset(self, sites=None, kinds=None, channels=None):
        super(FramesInstrument, self).reset(sites, kinds, channels)
        # pylint: disable=not-callable
        self.collector = self.collector_cls(self.target, self.period,
                                            self.collector_target, self.header)
        self._need_reset = False
        self._raw_file = None
    def start(self):
        if self._need_reset:
            self.reset()
        self.collector.start()
    def stop(self):
        self.collector.stop()
        self._need_reset = True
    def get_data(self, outfile):
        if self.keep_raw:
            self._raw_file = outfile + '.raw'
        self.collector.process_frames(self._raw_file)
        active_sites = [chan.label for chan in self.active_channels]
        self.collector.write_frames(outfile, columns=active_sites)
        return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz)
    def get_raw(self):
        return [self._raw_file] if self._raw_file else []
    def _init_channels(self):
        raise NotImplementedError()
    def teardown(self):
        if not self.keep_raw:
            if os.path.isfile(self._raw_file):
                os.remove(self._raw_file)
 class GfxInfoFramesInstrument(FramesInstrument):
    mode = CONTINUOUS
    collector_cls = GfxinfoFrameCollector
    def _init_channels(self):
        columns = read_gfxinfo_columns(self.target)
        for entry in columns:
            if entry == 'Flags':
                self.add_channel('Flags', MeasurementType('flags', 'flags'))
            else:
                self.add_channel(entry, 'time_ns')
        self.header = [chan.label for chan in self.channels.values()]
 class SurfaceFlingerFramesInstrument(FramesInstrument):
    mode = CONTINUOUS
    collector_cls = SurfaceFlingerFrameCollector
    def _init_channels(self):
        for field in SurfaceFlingerFrame._fields:
            # remove the "_time" from filed names to avoid duplication
            self.add_channel(field[:-5], 'time_us')
        self.header = [chan.label for chan in self.channels.values()]
--- a/devlib/instrument/gem5power.py
+++ b/devlib/instrument/gem5power.py
@@ -1,76 +0,0 @@
 #    Copyright 2017-2018 ARM Limited
 #
 # 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.
 from devlib.platform.gem5 import Gem5SimulationPlatform
 from devlib.instrument import Instrument, CONTINUOUS, MeasurementsCsv
 from devlib.exception import TargetStableError
 from devlib.utils.csvutil import csvwriter
 class Gem5PowerInstrument(Instrument):
    '''
    Instrument enabling power monitoring in gem5
    '''
    mode = CONTINUOUS
    roi_label = 'power_instrument'
    site_mapping = {'timestamp': 'sim_seconds'}
    def __init__(self, target, power_sites):
        '''
        Parameter power_sites is a list of gem5 identifiers for power values.
        One example of such a field:
            system.cluster0.cores0.power_model.static_power
        '''
        if not isinstance(target.platform, Gem5SimulationPlatform):
            raise TargetStableError('Gem5PowerInstrument requires a gem5 platform')
        if not target.has('gem5stats'):
            raise TargetStableError('Gem5StatsModule is not loaded')
        super(Gem5PowerInstrument, self).__init__(target)
        # power_sites is assumed to be a list later
        if isinstance(power_sites, list):
            self.power_sites = power_sites
        else:
            self.power_sites = [power_sites]
        self.add_channel('timestamp', 'time')
        for field in self.power_sites:
            self.add_channel(field, 'power')
        self.target.gem5stats.book_roi(self.roi_label)
        self.sample_period_ns = 10000000
        # Sample rate must remain unset as gem5 does not provide samples
        # at regular intervals therefore the reported timestamp should be used.
        self.sample_rate_hz = None
        self.target.gem5stats.start_periodic_dump(0, self.sample_period_ns)
        self._base_stats_dump = 0
    def start(self):
        self.target.gem5stats.roi_start(self.roi_label)
    def stop(self):
        self.target.gem5stats.roi_end(self.roi_label)
    def get_data(self, outfile):
        active_sites = [c.site for c in self.active_channels]
        with csvwriter(outfile) as writer:
            writer.writerow([c.label for c in self.active_channels]) # headers
            sites_to_match = [self.site_mapping.get(s, s) for s in active_sites]
            for rec, _ in self.target.gem5stats.match_iter(sites_to_match,
                    [self.roi_label], self._base_stats_dump):
                writer.writerow([rec[s] for s in sites_to_match])
        return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz)
    def reset(self, sites=None, kinds=None, channels=None):
        super(Gem5PowerInstrument, self).reset(sites, kinds, channels)
        self._base_stats_dump = self.target.gem5stats.next_dump_no()
--- a/devlib/instrument/hwmon.py
+++ b/devlib/instrument/hwmon.py
@@ -1,4 +1,4 @@
-#    Copyright 2015-2017 ARM Limited
+#    Copyright 2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,10 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 from __future__ import division
 import re
 from devlib.instrument import Instrument, Measurement, INSTANTANEOUS
-from devlib.exception import TargetStableError
+from devlib.exception import TargetError
 class HwmonInstrument(Instrument):
@@ -34,7 +35,7 @@ class HwmonInstrument(Instrument):
    def __init__(self, target):
        if not hasattr(target, 'hwmon'):
-            raise TargetStableError('Target does not support HWMON')
+            raise TargetError('Target does not support HWMON')
        super(HwmonInstrument, self).__init__(target)
        self.logger.debug('Discovering available HWMON sensors...')
@@ -44,7 +45,7 @@ class HwmonInstrument(Instrument):
                measure = self.measure_map.get(ts.kind)[0]
                if measure:
                    self.logger.debug('\tAdding sensor {}'.format(ts.name))
-                    self.add_channel(_guess_site(ts), measure, sensor=ts)
+                    self.add_channel(_guess_site(ts), measure, name=ts.name, sensor=ts)
                else:
                    self.logger.debug('\tSkipping sensor {} (unknown kind "{}")'.format(ts.name, ts.kind))
            except ValueError:
--- a/devlib/instrument/monsoon.py
+++ b/devlib/instrument/monsoon.py
@@ -1,152 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import os
 import signal
 import sys
 from subprocess import Popen, PIPE
 from tempfile import NamedTemporaryFile
 from devlib.instrument import Instrument, CONTINUOUS, MeasurementsCsv
 from devlib.exception import HostError
 from devlib.utils.csvutil import csvwriter
 from devlib.utils.misc import which
 INSTALL_INSTRUCTIONS = """
 MonsoonInstrument requires the monsoon.py tool, available from AOSP:
 https://android.googlesource.com/platform/cts/+/master/tools/utils/monsoon.py
 Download this script and put it in your $PATH (or pass it as the monsoon_bin
 parameter to MonsoonInstrument). `pip install python-gflags pyserial` to install
 the dependencies.
 """
 class MonsoonInstrument(Instrument):
    """Instrument for Monsoon Solutions power monitor
    To use this instrument, you need to install the monsoon.py script available
    from the Android Open Source Project. As of May 2017 this is under the CTS
    repository:
    https://android.googlesource.com/platform/cts/+/master/tools/utils/monsoon.py
    Collects power measurements only, from a selection of two channels, the USB
    passthrough channel and the main output channel.
    :param target: Ignored
    :param monsoon_bin: Path to monsoon.py executable. If not provided,
                        ``$PATH`` is searched.
    :param tty_device: TTY device to use to communicate with the Power
                       Monitor. If not provided, a sane default is used.
    """
    mode = CONTINUOUS
    def __init__(self, target, monsoon_bin=None, tty_device=None):
        super(MonsoonInstrument, self).__init__(target)
        self.monsoon_bin = monsoon_bin or which('monsoon.py')
        if not self.monsoon_bin:
            raise HostError(INSTALL_INSTRUCTIONS)
        self.tty_device = tty_device
        self.process = None
        self.output = None
        self.buffer_file = None
        self.sample_rate_hz = 500
        self.add_channel('output', 'power')
        self.add_channel('USB', 'power')
    def reset(self, sites=None, kinds=None, channels=None):
        super(MonsoonInstrument, self).reset(sites, kinds)
    def start(self):
        if self.process:
            self.process.kill()
        cmd = [self.monsoon_bin,
               '--hz', str(self.sample_rate_hz),
               '--samples', '-1', # -1 means sample indefinitely
               '--includeusb']
        if self.tty_device:
            cmd += ['--device', self.tty_device]
        self.logger.debug(' '.join(cmd))
        self.buffer_file = NamedTemporaryFile(prefix='monsoon', delete=False)
        self.process = Popen(cmd, stdout=self.buffer_file, stderr=PIPE)
    def stop(self):
        process = self.process
        self.process = None
        if not process:
            raise RuntimeError('Monsoon script not started')
        process.poll()
        if process.returncode is not None:
            stdout, stderr = process.communicate()
            stdout = stdout.encode(sys.stdout.encoding or 'utf-8')
            stderr = stderr.encode(sys.stdout.encoding or 'utf-8')
            raise HostError(
                'Monsoon script exited unexpectedly with exit code {}.\n'
                'stdout:\n{}\nstderr:\n{}'.format(process.returncode,
                                                  stdout, stderr))
        process.send_signal(signal.SIGINT)
        stderr = process.stderr.read()
        self.buffer_file.close()
        with open(self.buffer_file.name) as f:
            stdout = f.read()
        os.remove(self.buffer_file.name)
        self.buffer_file = None
        self.output = (stdout, stderr)
    def get_data(self, outfile):
        if self.process:
            raise RuntimeError('`get_data` called before `stop`')
        stdout, _ = self.output
        with csvwriter(outfile) as writer:
            active_sites = [c.site for c in self.active_channels]
            # Write column headers
            row = []
            if 'output' in active_sites:
                row.append('output_power')
            if 'USB' in active_sites:
                row.append('USB_power')
            writer.writerow(row)
            # Write data
            for line in stdout.splitlines():
                # Each output line is a main_output, usb_output measurement pair.
                # (If our user only requested one channel we still collect both,
                # and just ignore one of them)
                output, usb = line.split()
                row = []
                if 'output' in active_sites:
                    row.append(output)
                if 'USB' in active_sites:
                    row.append(usb)
                writer.writerow(row)
        return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz)
--- a/devlib/instrument/netstats/init.py
+++ b/devlib/instrument/netstats/init.py
@@ -1,29 +1,14 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import os
 import re
 import csv
 import tempfile
 from datetime import datetime
 from collections import defaultdict
-from itertools import zip_longest
+from itertools import izip_longest
 from devlib.instrument import Instrument, MeasurementsCsv, CONTINUOUS
-from devlib.exception import TargetStableError, HostError
+from devlib.exception import TargetError, HostError
 from devlib.utils.android import ApkInfo
 from devlib.utils.csvutil import csvwriter
 THIS_DIR = os.path.dirname(__file__)
@@ -61,9 +46,10 @@ def netstats_to_measurements(netstats):
 def write_measurements_csv(measurements, filepath):
    headers = sorted(measurements.keys())
    columns = [measurements[h] for h in headers]
-    with csvwriter(filepath) as writer:
+    with open(filepath, 'wb') as wfh:
        writer = csv.writer(wfh)
        writer.writerow(headers)
-        writer.writerows(zip_longest(*columns))
+        writer.writerows(izip_longest(*columns))
 class NetstatsInstrument(Instrument):
@@ -83,7 +69,7 @@ class NetstatsInstrument(Instrument):
        """
        if target.os != 'android':
-            raise TargetStableError('netstats instrument only supports Android targets')
+            raise TargetError('netstats insturment only supports Android targets')
        if apk is None:
            apk = os.path.join(THIS_DIR, 'netstats.apk')
        if not os.path.isfile(apk):
@@ -100,7 +86,6 @@ class NetstatsInstrument(Instrument):
            self.add_channel(package, 'tx')
            self.add_channel(package, 'rx')
    # pylint: disable=keyword-arg-before-vararg,arguments-differ
    def setup(self, force=False, *args, **kwargs):
        if self.target.package_is_installed(self.package):
            if force:
@@ -113,8 +98,8 @@ class NetstatsInstrument(Instrument):
            self.logger.debug('Deploying {} to target'.format(self.package))
            self.target.install(self.apk)
-    def reset(self, sites=None, kinds=None, channels=None, period=None):  # pylint: disable=arguments-differ
+    def reset(self, sites=None, kinds=None, period=None):  # pylint: disable=arguments-differ
-        super(NetstatsInstrument, self).reset(sites, kinds, channels)
+        super(NetstatsInstrument, self).reset(sites, kinds)
        period_arg, packages_arg = '', ''
        self.tag = 'netstats-{}'.format(datetime.now().strftime('%Y%m%d%H%M%s'))
        tag_arg = ' --es tag {}'.format(self.tag)
--- a/devlib/module/init.py
+++ b/devlib/module/init.py
@@ -1,4 +1,4 @@
-#    Copyright 2014-2018 ARM Limited
+#    Copyright 2014-2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,30 +15,14 @@
 import logging
 from inspect import isclass
 from devlib.exception import TargetStableError
 from devlib.utils.types import identifier
 from devlib.utils.misc import walk_modules
-
+from devlib.utils.types import identifier
 _module_registry = {}
 def register_module(mod):
    if not issubclass(mod, Module):
        raise ValueError('A module must subclass devlib.Module')
    if mod.name is None:
        raise ValueError('A module must define a name')
    try:
        existing = _module_registry[mod.name]
    except KeyError:
        pass
    else:
        if existing is not mod:
            raise ValueError(f'Module "{mod.name}" already exists')
    _module_registry[mod.name] = mod
-class Module:
+__module_cache = {}
 class Module(object):
    name = None
    kind = None
@@ -51,9 +35,6 @@ class Module:
    #             serial).
    #  'connected' -- installed when a connection to to the target has been
    #                 established. This is the default.
    #   'setup' -- installed after initial setup of the device has been performed.
    #              This allows the module to utilize assets deployed during the
    #              setup stage for example 'Busybox'.
    stage = 'connected'
    @staticmethod
@@ -62,49 +43,23 @@ class Module:
    @classmethod
    def install(cls, target, **params):
-        attr_name = cls.attr_name
+        if cls.kind is not None:
-        installed = target._installed_modules
+            attr_name = identifier(cls.kind)
        try:
            mod = installed[attr_name]
        except KeyError:
            mod = cls(target, **params)
            mod.logger.debug(f'Installing module {cls.name}')
            if mod.probe(target):
                for name in (
                    attr_name,
                    identifier(cls.name),
                    identifier(cls.kind) if cls.kind else None,
                ):
                    if name is not None:
                        installed[name] = mod
                target._modules[cls.name] = params
                return mod
            else:
                raise TargetStableError(f'Module "{cls.name}" is not supported by the target')
        else:
-            raise ValueError(
+            attr_name = identifier(cls.name)
-                f'Attempting to install module "{cls.name}" but a module is already installed as attribute "{attr_name}": {mod}'
+        if hasattr(target, attr_name):
-            )
+            existing_module = getattr(target, attr_name)
            existing_name = getattr(existing_module, 'name', str(existing_module))
            message = 'Attempting to install module "{}" which already exists (new: {}, existing: {})'
            raise ValueError(message.format(attr_name, cls.name, existing_name))
        setattr(target, attr_name, cls(target, **params))
    def __init__(self, target):
        self.target = target
-        self.logger = logging.getLogger(self.name)
+        self.logger = logging.getLogger(self.__class__.__name__)
-    def __init_subclass__(cls, *args, **kwargs):
+class HardRestModule(Module):  # pylint: disable=R0921
        super().__init_subclass__(*args, **kwargs)
        attr_name = cls.kind or cls.name
        cls.attr_name = identifier(attr_name) if attr_name else None
        if cls.name is not None:
            register_module(cls)
 class HardRestModule(Module):
    kind = 'hard_reset'
@@ -112,7 +67,7 @@ class HardRestModule(Module):
        raise NotImplementedError()
-class BootModule(Module):
+class BootModule(Module):  # pylint: disable=R0921
    kind = 'boot'
@@ -120,7 +75,7 @@ class BootModule(Module):
        raise NotImplementedError()
    def update(self, **kwargs):
-        for name, value in kwargs.items():
+        for name, value in kwargs.iteritems():
            if not hasattr(self, name):
                raise ValueError('Unknown parameter "{}" for {}'.format(name, self.name))
            self.logger.debug('Updating "{}" to "{}"'.format(name, value))
@@ -131,30 +86,37 @@ class FlashModule(Module):
    kind = 'flash'
-    def __call__(self, image_bundle=None, images=None, boot_config=None, connect=True):
+    def __call__(self, image_bundle=None, images=None, boot_config=None):
        raise NotImplementedError()
 def get_module(mod):
-    def from_registry(mod):
+    if not __module_cache:
        __load_cache()
    if isinstance(mod, basestring):
        try:
-            return _module_registry[mod]
+            return __module_cache[mod]
        except KeyError:
            raise ValueError('Module "{}" does not exist'.format(mod))
    if isinstance(mod, str):
        try:
            return from_registry(mod)
        except ValueError:
            # If the lookup failed, we may have simply not imported Modules
            # from the devlib.module package. The former module loading
            # implementation was also pre-importing modules, so we need to
            # replicate that behavior since users are currently not expected to
            # have imported the module prior to trying to use it.
            walk_modules('devlib.module')
            return from_registry(mod)
    elif issubclass(mod, Module):
        return mod
    else:
        raise ValueError('Not a valid module: {}'.format(mod))
 def register_module(mod):
    if not issubclass(mod, Module):
        raise ValueError('A module must subclass devlib.Module')
    if mod.name is None:
        raise ValueError('A module must define a name')
    if mod.name in __module_cache:
        raise ValueError('Module {} already exists'.format(mod.name))
    __module_cache[mod.name] = mod
 def __load_cache():
    for module in walk_modules('devlib.module'):
        for obj in vars(module).itervalues():
            if isclass(obj) and issubclass(obj, Module) and obj.name:
                register_module(obj)
--- a/devlib/module/android.py
+++ b/devlib/module/android.py
@@ -1,4 +1,4 @@
-#    Copyright 2014-2018 ARM Limited
+#    Copyright 2014-2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,7 +22,7 @@ import tempfile
 from devlib.module import FlashModule
 from devlib.exception import HostError
 from devlib.utils.android import fastboot_flash_partition, fastboot_command
-from devlib.utils.misc import merge_dicts, safe_extract
+from devlib.utils.misc import merge_dicts
 class FastbootFlashModule(FlashModule):
@@ -54,7 +54,7 @@ class FastbootFlashModule(FlashModule):
    def probe(target):
        return target.os == 'android'
-    def __call__(self, image_bundle=None, images=None, bootargs=None, connect=True):
+    def __call__(self, image_bundle=None, images=None, bootargs=None):
        if bootargs:
            raise ValueError('{} does not support boot configuration'.format(self.name))
        self.prelude_done = False
@@ -63,12 +63,11 @@ class FastbootFlashModule(FlashModule):
            image_bundle = expand_path(image_bundle)
            to_flash = self._bundle_to_images(image_bundle)
        to_flash = merge_dicts(to_flash, images or {}, should_normalize=False)
-        for partition, image_path in to_flash.items():
+        for partition, image_path in to_flash.iteritems():
            self.logger.debug('flashing {}'.format(partition))
            self._flash_image(self.target, partition, expand_path(image_path))
        fastboot_command('reboot')
-        if connect:
+        self.target.connect(timeout=180)
            self.target.connect(timeout=180)
    def _validate_image_bundle(self, image_bundle):
        if not tarfile.is_tarfile(image_bundle):
@@ -86,7 +85,7 @@ class FastbootFlashModule(FlashModule):
        self._validate_image_bundle(image_bundle)
        extract_dir = tempfile.mkdtemp()
        with tarfile.open(image_bundle) as tar:
-            safe_extract(tar, path=extract_dir)
+            tar.extractall(path=extract_dir)
            files = [tf.name for tf in tar.getmembers()]
            if self.partitions_file_name not in files:
                extract_dir = os.path.join(extract_dir, files[0])
@@ -126,3 +125,4 @@ def get_mapping(base_dir, partition_file):
                HostError('file {} was not found in the bundle or was misplaced'.format(pair[1]))
            mapping[pair[0]] = image_path
    return mapping
--- a/devlib/module/biglittle.py
+++ b/devlib/module/biglittle.py
@@ -1,18 +1,3 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 from devlib.module import Module
@@ -59,151 +44,79 @@ class BigLittleModule(Module):
    # cpufreq
    def list_bigs_frequencies(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.list_frequencies(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.list_frequencies(bigs_online[0])
    def list_bigs_governors(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.list_governors(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.list_governors(bigs_online[0])
    def list_bigs_governor_tunables(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.list_governor_tunables(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.list_governor_tunables(bigs_online[0])
    def list_littles_frequencies(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.list_frequencies(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.list_frequencies(littles_online[0])
    def list_littles_governors(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.list_governors(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.list_governors(littles_online[0])
    def list_littles_governor_tunables(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.list_governor_tunables(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.list_governor_tunables(littles_online[0])
    def get_bigs_governor(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.get_governor(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.get_governor(bigs_online[0])
    def get_bigs_governor_tunables(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.get_governor_tunables(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.get_governor_tunables(bigs_online[0])
    def get_bigs_frequency(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.get_frequency(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.get_frequency(bigs_online[0])
    def get_bigs_min_frequency(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.get_min_frequency(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.get_min_frequency(bigs_online[0])
    def get_bigs_max_frequency(self):
-        bigs_online = self.bigs_online
+        return self.target.cpufreq.get_max_frequency(self.bigs_online[0])
        if bigs_online:
            return self.target.cpufreq.get_max_frequency(bigs_online[0])
    def get_littles_governor(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.get_governor(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.get_governor(littles_online[0])
    def get_littles_governor_tunables(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.get_governor_tunables(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.get_governor_tunables(littles_online[0])
    def get_littles_frequency(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.get_frequency(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.get_frequency(littles_online[0])
    def get_littles_min_frequency(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.get_min_frequency(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.get_min_frequency(littles_online[0])
    def get_littles_max_frequency(self):
-        littles_online = self.littles_online
+        return self.target.cpufreq.get_max_frequency(self.littles_online[0])
        if littles_online:
            return self.target.cpufreq.get_max_frequency(littles_online[0])
    def set_bigs_governor(self, governor, **kwargs):
-        bigs_online = self.bigs_online
+        self.target.cpufreq.set_governor(self.bigs_online[0], governor, **kwargs)
        if bigs_online:
            self.target.cpufreq.set_governor(bigs_online[0], governor, **kwargs)
        else:
            raise ValueError("All bigs appear to be offline")
    def set_bigs_governor_tunables(self, governor, **kwargs):
-        bigs_online = self.bigs_online
+        self.target.cpufreq.set_governor_tunables(self.bigs_online[0], governor, **kwargs)
        if bigs_online:
            self.target.cpufreq.set_governor_tunables(bigs_online[0], governor, **kwargs)
        else:
            raise ValueError("All bigs appear to be offline")
    def set_bigs_frequency(self, frequency, exact=True):
-        bigs_online = self.bigs_online
+        self.target.cpufreq.set_frequency(self.bigs_online[0], frequency, exact)
        if bigs_online:
            self.target.cpufreq.set_frequency(bigs_online[0], frequency, exact)
        else:
            raise ValueError("All bigs appear to be offline")
    def set_bigs_min_frequency(self, frequency, exact=True):
-        bigs_online = self.bigs_online
+        self.target.cpufreq.set_min_frequency(self.bigs_online[0], frequency, exact)
        if bigs_online:
            self.target.cpufreq.set_min_frequency(bigs_online[0], frequency, exact)
        else:
            raise ValueError("All bigs appear to be offline")
    def set_bigs_max_frequency(self, frequency, exact=True):
-        bigs_online = self.bigs_online
+        self.target.cpufreq.set_max_frequency(self.bigs_online[0], frequency, exact)
        if bigs_online:
            self.target.cpufreq.set_max_frequency(bigs_online[0], frequency, exact)
        else:
            raise ValueError("All bigs appear to be offline")
    def set_littles_governor(self, governor, **kwargs):
-        littles_online = self.littles_online
+        self.target.cpufreq.set_governor(self.littles_online[0], governor, **kwargs)
        if littles_online:
            self.target.cpufreq.set_governor(littles_online[0], governor, **kwargs)
        else:
            raise ValueError("All littles appear to be offline")
    def set_littles_governor_tunables(self, governor, **kwargs):
-        littles_online = self.littles_online
+        self.target.cpufreq.set_governor_tunables(self.littles_online[0], governor, **kwargs)
        if littles_online:
            self.target.cpufreq.set_governor_tunables(littles_online[0], governor, **kwargs)
        else:
            raise ValueError("All littles appear to be offline")
    def set_littles_frequency(self, frequency, exact=True):
-        littles_online = self.littles_online
+        self.target.cpufreq.set_frequency(self.littles_online[0], frequency, exact)
        if littles_online:
            self.target.cpufreq.set_frequency(littles_online[0], frequency, exact)
        else:
            raise ValueError("All littles appear to be offline")
    def set_littles_min_frequency(self, frequency, exact=True):
-        littles_online = self.littles_online
+        self.target.cpufreq.set_min_frequency(self.littles_online[0], frequency, exact)
        if littles_online:
            self.target.cpufreq.set_min_frequency(littles_online[0], frequency, exact)
        else:
            raise ValueError("All littles appear to be offline")
    def set_littles_max_frequency(self, frequency, exact=True):
-        littles_online = self.littles_online
+        self.target.cpufreq.set_max_frequency(self.littles_online[0], frequency, exact)
        if littles_online:
            self.target.cpufreq.set_max_frequency(littles_online[0], frequency, exact)
        else:
            raise ValueError("All littles appear to be offline")
--- a/devlib/module/cgroups.py
+++ b/devlib/module/cgroups.py
@@ -1,4 +1,4 @@
-#    Copyright 2014-2018 ARM Limited
+#    Copyright 2014-2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,50 +14,40 @@
 #
 # pylint: disable=attribute-defined-outside-init
 import logging
 import re
 from collections import namedtuple
 from shlex import quote
 import itertools
 import warnings
 from devlib.module import Module
-from devlib.exception import TargetStableError
+from devlib.exception import TargetError
 from devlib.utils.misc import list_to_ranges, isiterable
 from devlib.utils.types import boolean
 from devlib.utils.asyn import asyncf, run
 class Controller(object):
-    def __init__(self, kind, hid, clist):
+    def __new__(cls, arg):
-        """
+        if isinstance(arg, cls):
-        Initialize a controller given the hierarchy it belongs to.
+            return arg
        else:
            return object.__new__(cls, arg)
-        :param kind: the name of the controller
+    def __init__(self, kind):
-        :type kind: str
+        self.mount_name = 'devlib_'+kind
        :param hid: the Hierarchy ID this controller is mounted on
        :type hid: int
        :param clist: the list of controller mounted in the same hierarchy
        :type clist: list(str)
        """
        self.mount_name = 'devlib_cgh{}'.format(hid)
        self.kind = kind
        self.hid = hid
        self.clist = clist
        self.target = None
        self._noprefix = False
        self.logger = logging.getLogger('CGroup.'+self.kind)
        self.logger.debug('Initialized [%s, %d, %s]',
                          self.kind, self.hid, self.clist)
        self.logger = logging.getLogger('cgroups.'+self.kind)
        self.mount_point = None
        self._cgroups = {}
-    @asyncf
+    def probe(self, target):
-    async def mount(self, target, mount_root):
+        try:
            exists = target.execute('{} grep {} /proc/cgroups'\
                    .format(target.busybox, self.kind))
        except TargetError:
            return False
        return True
    def mount(self, target, mount_root):
        mounted = target.list_file_systems()
        if self.mount_name in [e.device for e in mounted]:
@@ -70,23 +60,16 @@ class Controller(object):
        else:
            # Mount the controller if not already in use
            self.mount_point = target.path.join(mount_root, self.mount_name)
-            await target.execute.asyn('mkdir -p {} 2>/dev/null'\
+            target.execute('mkdir -p {} 2>/dev/null'\
                    .format(self.mount_point), as_root=True)
-            await target.execute.asyn('mount -t cgroup -o {} {} {}'\
+            target.execute('mount -t cgroup -o {} {} {}'\
-                    .format(','.join(self.clist),
+                    .format(self.kind,
                            self.mount_name,
                            self.mount_point),
                            as_root=True)
-        # Check if this controller uses "noprefix" option
+        self.logger.info('Controller %s mounted under: %s',
-        output = await target.execute.asyn('mount | grep "{} "'.format(self.mount_name))
+            self.kind, self.mount_point)
        if 'noprefix' in output:
            self._noprefix = True
            # self.logger.debug('Controller %s using "noprefix" option',
            #                   self.kind)
        self.logger.debug('Controller %s mounted under: %s (noprefix=%s)',
            self.kind, self.mount_point, self._noprefix)
        # Mark this contoller as available
        self.target = target
@@ -108,15 +91,14 @@ class Controller(object):
                    .format(self.kind))
        if name not in self._cgroups:
            self._cgroups[name] = CGroup(self, name, create=False)
-        return self._cgroups[name].exists()
+        return self._cgroups[name].existe()
    def list_all(self):
        self.logger.debug('Listing groups for %s controller', self.kind)
        output = self.target.execute('{} find {} -type d'\
-                .format(self.target.busybox, self.mount_point),
+                .format(self.target.busybox, self.mount_point))
                as_root=True)
        cgroups = []
-        for cg in output.splitlines():
+        for cg in output.split('\n'):
            cg = cg.replace(self.mount_point + '/', '/')
            cg = cg.replace(self.mount_point, '/')
            cg = cg.strip()
@@ -126,144 +108,24 @@ class Controller(object):
            cgroups.append(cg)
        return cgroups
-    def move_tasks(self, source, dest, exclude=None):
+    def move_tasks(self, source, dest):
-        if isinstance(exclude, str):
+        try:
-            warnings.warn("Controller.move_tasks() takes needs a _list_ of exclude patterns, not a string", DeprecationWarning)
+            srcg = self._cgroups[source]
-            exclude = [exclude]
+            dstg = self._cgroups[dest]
            command = 'for task in $(cat {}); do echo $task>{}; done'
            self.target.execute(command.format(srcg.tasks_file, dstg.tasks_file),
                                # this will always fail as some of the tasks
                                # are kthreads that cannot be migrated, but we
                                # don't care about those, so don't check exit
                                # code.
                                check_exit_code=False, as_root=True)
        except KeyError as e:
            raise ValueError('Unkown group: {}'.format(e))
-        if exclude is None:
+    def move_all_tasks_to(self, dest):
-            exclude = []
+        for cgroup in self._cgroups:
        exclude = ' '.join(
            itertools.chain.from_iterable(
                ('-e', quote(pattern))
                for pattern in exclude
            )
        )
        srcg = self.cgroup(source)
        dstg = self.cgroup(dest)
        self.target._execute_util(  # pylint: disable=protected-access
            'cgroups_tasks_move {src} {dst} {exclude}'.format(
                src=quote(srcg.directory),
                dst=quote(dstg.directory),
                exclude=exclude,
            ),
            as_root=True,
        )
    def move_all_tasks_to(self, dest, exclude=None):
        """
        Move all the tasks to the specified CGroup
        Tasks are moved from all their original CGroup the the specified on.
        The tasks which name matches one of the string in exclude are moved
        instead in the root CGroup for the controller.
        The name of a tasks to exclude must be a substring of the task named as
        reported by the "ps" command. Indeed, this list will be translated into
        a: "ps | grep -e name1 -e name2..." in order to obtain the PID of these
        tasks.
        :param exclude: list of commands to keep in the root CGroup
        :type exclude: list(str)
        """
        if exclude is None:
            exclude = []
        if isinstance(exclude, str):
            exclude = [exclude]
        if not isinstance(exclude, list):
            raise ValueError('wrong type for "exclude" parameter, '
                             'it must be a str or a list')
        self.logger.debug('Moving all tasks into %s', dest)
        # Build list of tasks to exclude
        self.logger.debug('   using grep filter: %s', exclude)
        for cgroup in self.list_all():
            if cgroup != dest:
-                self.move_tasks(cgroup, dest, exclude)
+                self.move_tasks(cgroup, dest)
    # pylint: disable=too-many-locals
    def tasks(self, cgroup,
              filter_tid='',
              filter_tname='',
              filter_tcmdline=''):
        """
        Report the tasks that are included in a cgroup. The tasks can be
        filtered by their tid, tname or tcmdline if filter_tid, filter_tname or
        filter_tcmdline are defined respectively. In this case, the reported
        tasks are the ones in the cgroup that match these patterns.
        Example of tasks format:
        TID,tname,tcmdline
        903,cameraserver,/system/bin/cameraserver
        :params filter_tid: regexp pattern to filter by TID
        :type filter_tid: str
        :params filter_tname: regexp pattern to filter by tname
        :type filter_tname: str
        :params filter_tcmdline: regexp pattern to filter by tcmdline
        :type filter_tcmdline: str
        :returns: a dictionary in the form: {tid:(tname, tcmdline)}
        """
        if not isinstance(filter_tid, str):
            raise TypeError('filter_tid should be a str')
        if not isinstance(filter_tname, str):
            raise TypeError('filter_tname should be a str')
        if not isinstance(filter_tcmdline, str):
            raise TypeError('filter_tcmdline should be a str')
        try:
            cg = self._cgroups[cgroup]
        except KeyError as e:
            raise ValueError('Unknown group: {}'.format(e))
        output = self.target._execute_util(  # pylint: disable=protected-access
                    'cgroups_tasks_in {}'.format(cg.directory),
                    as_root=True)
        entries = output.splitlines()
        tasks = {}
        for task in entries:
            fields = task.split(',', 2)
            nr_fields = len(fields)
            if nr_fields < 2:
                continue
            elif nr_fields == 2:
                tid_str, tname = fields
                tcmdline = ''
            else:
                tid_str, tname, tcmdline = fields
            if not re.search(filter_tid, tid_str):
                continue
            if not re.search(filter_tname, tname):
                continue
            if not re.search(filter_tcmdline, tcmdline):
                continue
            tasks[int(tid_str)] = (tname, tcmdline)
        return tasks
    def tasks_count(self, cgroup):
        try:
            cg = self._cgroups[cgroup]
        except KeyError as e:
            raise ValueError('Unknown group: {}'.format(e))
        output = self.target.execute(
                    '{} wc -l {}/tasks'.format(
                    self.target.busybox, cg.directory),
                    as_root=True)
        return int(output.split()[0])
    def tasks_per_group(self):
        tasks = {}
        for cg in self.list_all():
            tasks[cg] = self.tasks_count(cg)
        return tasks
 class CGroup(object):
@@ -275,9 +137,8 @@ class CGroup(object):
        # Control cgroup path
        self.directory = controller.mount_point
        if name != '/':
-            self.directory = self.target.path.join(controller.mount_point, name.strip('/'))
+            self.directory = self.target.path.join(controller.mount_point, name[1:])
        # Setup path for tasks file
        self.tasks_file = self.target.path.join(self.directory, 'tasks')
@@ -286,28 +147,33 @@ class CGroup(object):
        if not create:
            return
-        self.logger.debug('Creating cgroup %s', self.directory)
+        self.logger.info('Creating cgroup %s', self.directory)
        self.target.execute('[ -d {0} ] || mkdir -p {0}'\
                .format(self.directory), as_root=True)
    def exists(self):
        try:
            self.target.execute('[ -d {0} ]'\
-                .format(self.directory), as_root=True)
+                .format(self.directory))
            return True
-        except TargetStableError:
+        except TargetError:
            return False
    def get(self):
        conf = {}
-        self.logger.debug('Reading %s attributes from:', self.controller.kind)
+        logging.debug('Reading %s attributes from:',
-        self.logger.debug('  %s', self.directory)
+                self.controller.kind)
-        output = self.target._execute_util(  # pylint: disable=protected-access
+        logging.debug('  %s',
-                    'cgroups_get_attributes {} {}'.format(
+                self.directory)
-                    self.directory, self.controller.kind),
+        output = self.target.execute('{} grep \'\' {}/{}.*'.format(
-                    as_root=True)
+                    self.target.busybox,
-        for res in output.splitlines():
+                    self.directory,
                    self.controller.kind))
        for res in output.split('\n'):
            if res.find(self.controller.kind) < 0:
                continue
            res = res.split('.')[1]
            attr = res.split(':')[0]
            value = res.split(':')[1]
            conf[attr] = value
@@ -319,30 +185,19 @@ class CGroup(object):
            if isiterable(attrs[idx]):
                attrs[idx] = list_to_ranges(attrs[idx])
            # Build attribute path
-            if self.controller._noprefix:  # pylint: disable=protected-access
+            path = '{}.{}'.format(self.controller.kind, idx)
-                attr_name = '{}'.format(idx)
+            path = self.target.path.join(self.directory, path)
            else:
                attr_name = '{}.{}'.format(self.controller.kind, idx)
            path = self.target.path.join(self.directory, attr_name)
            self.logger.debug('Set attribute [%s] to: %s"',
                    path, attrs[idx])
            # Set the attribute value
-            try:
+            self.target.write_value(path, attrs[idx])
                self.target.write_value(path, attrs[idx])
            except TargetStableError:
                # Check if the error is due to a non-existing attribute
                attrs = self.get()
                if idx not in attrs:
                    raise ValueError('Controller [{}] does not provide attribute [{}]'\
                                     .format(self.controller.kind, attr_name))
                raise
    def get_tasks(self):
        task_ids = self.target.read_value(self.tasks_file).split()
-        self.logger.debug('Tasks: %s', task_ids)
+        logging.debug('Tasks: %s', task_ids)
-        return list(map(int, task_ids))
+        return map(int, task_ids)
    def add_task(self, tid):
        self.target.write_value(self.tasks_file, tid, verify=False)
@@ -359,70 +214,56 @@ CgroupSubsystemEntry = namedtuple('CgroupSubsystemEntry', 'name hierarchy num_cg
 class CgroupsModule(Module):
    name = 'cgroups'
-    stage = 'setup'
+    cgroup_root = '/sys/fs/cgroup'
    @staticmethod
    def probe(target):
-        if not target.is_rooted:
+        return target.config.has('cgroups') and target.is_rooted
            return False
        if target.file_exists('/proc/cgroups'):
            return True
        return target.config.has('cgroups')
    def __init__(self, target):
        super(CgroupsModule, self).__init__(target)
        self.logger = logging.getLogger('CGroups')
-        # Set Devlib's CGroups mount point
+        # Initialize controllers mount point
-        self.cgroup_root = target.path.join(
+        mounted = self.target.list_file_systems()
-            target.working_directory, 'cgroups')
+        if self.cgroup_root not in [e.mount_point for e in mounted]:
            self.target.execute('mount -t tmpfs {} {}'\
                    .format('cgroup_root',
                            self.cgroup_root),
                            as_root=True)
        else:
            self.logger.debug('cgroup_root already mounted at %s',
                    self.cgroup_root)
-        # Get the list of the available controllers
+        # Load list of available controllers
        controllers = []
        subsys = self.list_subsystems()
-        if not subsys:
+        for (n, h, c, e) in subsys:
-            self.logger.warning('No CGroups controller available')
+            controllers.append(n)
-            return
+        self.logger.info('Available controllers: %s', controllers)
        # Map hierarchy IDs into a list of controllers
        hierarchy = {}
        for ss in subsys:
            try:
                hierarchy[ss.hierarchy].append(ss.name)
            except KeyError:
                hierarchy[ss.hierarchy] = [ss.name]
        self.logger.debug('Available hierarchies: %s', hierarchy)
        # Initialize controllers
        self.logger.info('Available controllers:')
        self.controllers = {}
-
+        for idx in controllers:
-        async def register_controller(ss):
+            controller = Controller(idx)
-            hid = ss.hierarchy
+            self.logger.debug('Init %s controller...', controller.kind)
-            controller = Controller(ss.name, hid, hierarchy[hid])
+            if not controller.probe(self.target):
                continue
            try:
-                await controller.mount.asyn(self.target, self.cgroup_root)
+                controller.mount(self.target, self.cgroup_root)
-            except TargetStableError:
+            except TargetError:
-                message = 'Failed to mount "{}" controller'
+                message = 'cgroups {} controller is not supported by the target'
-                raise TargetStableError(message.format(controller.kind))
+                raise TargetError(message.format(controller.kind))
-            self.logger.info('  %-12s : %s', controller.kind,
+            self.logger.debug('Controller %s enabled', controller.kind)
-                             controller.mount_point)
+            self.controllers[idx] = controller
            self.controllers[ss.name] = controller
        run(
            target.async_manager.map_concurrently(
                register_controller,
                subsys,
            )
        )
    def list_subsystems(self):
        subsystems = []
        for line in self.target.execute('{} cat /proc/cgroups'\
-                .format(self.target.busybox), as_root=self.target.is_rooted).splitlines()[1:]:
+                .format(self.target.busybox)).split('\n')[1:]:
            line = line.strip()
-            if not line or line.startswith('#') or line.endswith('0'):
+            if not line or line.startswith('#'):
                continue
            name, hierarchy, num_cgroups, enabled = line.split()
            subsystems.append(CgroupSubsystemEntry(name,
@@ -438,130 +279,3 @@ class CgroupsModule(Module):
            return None
        return self.controllers[kind]
    def run_into_cmd(self, cgroup, cmdline):
        """
        Get the command to run a command into a given cgroup
        :param cmdline: Commdand to be run into cgroup
        :param cgroup: Name of cgroup to run command into
        :returns: A command to run `cmdline` into `cgroup`
        """
        if not cgroup.startswith('/'):
            message = 'cgroup name "{}" must start with "/"'.format(cgroup)
            raise ValueError(message)
        return 'CGMOUNT={} {} cgroups_run_into {} {}'\
                .format(self.cgroup_root, self.target.shutils,
                        cgroup, cmdline)
    def run_into(self, cgroup, cmdline, as_root=None):
        """
        Run the specified command into the specified CGroup
        :param cmdline: Command to be run into cgroup
        :param cgroup: Name of cgroup to run command into
        :param as_root: Specify whether to run the command as root, if not
                        specified will default to whether the target is rooted.
        :returns: Output of command.
        """
        if as_root is None:
            as_root = self.target.is_rooted
        cmd = self.run_into_cmd(cgroup, cmdline)
        raw_output = self.target.execute(cmd, as_root=as_root)
        # First line of output comes from shutils; strip it out.
        return raw_output.split('\n', 1)[1]
    def cgroups_tasks_move(self, srcg, dstg, exclude=''):
        """
        Move all the tasks from the srcg CGroup to the dstg one.
        A regexps of tasks names can be used to defined tasks which should not
        be moved.
        """
        return self.target._execute_util(  # pylint: disable=protected-access
            'cgroups_tasks_move {} {} {}'.format(srcg, dstg, exclude),
            as_root=True)
    def isolate(self, cpus, exclude=None):
        """
        Remove all userspace tasks from specified CPUs.
        A list of CPUs can be specified where we do not want userspace tasks
        running. This functions creates a sandbox cpuset CGroup where all
        user-space tasks and not-pinned kernel-space tasks are moved into.
        This should allows to isolate the specified CPUs which will not get
        tasks running unless explicitely moved into the isolated group.
        :param cpus: the list of CPUs to isolate
        :type cpus: list(int)
        :return: the (sandbox, isolated) tuple, where:
                 sandbox is the CGroup of sandboxed CPUs
                 isolated is the CGroup of isolated CPUs
        """
        if exclude is None:
            exclude = []
        all_cpus = set(range(self.target.number_of_cpus))
        sbox_cpus = list(all_cpus - set(cpus))
        isol_cpus = list(all_cpus - set(sbox_cpus))
        # Create Sandbox and Isolated cpuset CGroups
        cpuset = self.controller('cpuset')
        sbox_cg = cpuset.cgroup('/DEVLIB_SBOX')
        isol_cg = cpuset.cgroup('/DEVLIB_ISOL')
        # Set CPUs for Sandbox and Isolated CGroups
        sbox_cg.set(cpus=sbox_cpus, mems=0)
        isol_cg.set(cpus=isol_cpus, mems=0)
        # Move all currently running tasks to the Sandbox CGroup
        cpuset.move_all_tasks_to('/DEVLIB_SBOX', exclude)
        return sbox_cg, isol_cg
    def freeze(self, exclude=None, thaw=False):
        """
        Freeze all user-space tasks but the specified ones
        A freezer cgroup is used to stop all the tasks in the target system but
        the ones which name match one of the path specified by the exclude
        paramater. The name of a tasks to exclude must be a substring of the
        task named as reported by the "ps" command. Indeed, this list will be
        translated into a: "ps | grep -e name1 -e name2..." in order to obtain
        the PID of these tasks.
        :param exclude: list of commands paths to exclude from freezer
        :type exclude: list(str)
        :param thaw: if true thaw tasks instead
        :type thaw: bool
        """
        if exclude is None:
            exclude = []
        # Create Freezer CGroup
        freezer = self.controller('freezer')
        if freezer is None:
            raise RuntimeError('freezer cgroup controller not present')
        freezer_cg = freezer.cgroup('/DEVLIB_FREEZER')
        cmd = 'cgroups_freezer_set_state {{}} {}'.format(freezer_cg.directory)
        if thaw:
            # Restart frozen tasks
            # pylint: disable=protected-access
            freezer.target._execute_util(cmd.format('THAWED'), as_root=True)
            # Remove all tasks from freezer
            freezer.move_all_tasks_to('/')
            return
        # Move all tasks into the freezer group
        freezer.move_all_tasks_to('/DEVLIB_FREEZER', exclude)
        # Get list of not frozen tasks, which is reported as output
        tasks = freezer.tasks('/')
        # Freeze all tasks
        # pylint: disable=protected-access
        freezer.target._execute_util(cmd.format('FROZEN'), as_root=True)
        return tasks
--- a/devlib/module/cgroups2.py
+++ b/devlib/module/cgroups2.py
--- a/devlib/module/cooling.py
+++ b/devlib/module/cooling.py
@@ -37,14 +37,12 @@ class MbedFanActiveCoolingModule(Module):
        with open_serial_connection(timeout=self.timeout,
                                    port=self.port,
                                    baudrate=self.baud) as target:
            # pylint: disable=no-member
            target.sendline('motor_{}_1'.format(self.fan_pin))
    def stop(self):
        with open_serial_connection(timeout=self.timeout,
                                    port=self.port,
                                    baudrate=self.baud) as target:
            # pylint: disable=no-member
            target.sendline('motor_{}_0'.format(self.fan_pin))
--- a/devlib/module/cpufreq.py
+++ b/devlib/module/cpufreq.py
@@ -1,4 +1,4 @@
-#    Copyright 2014-2024 ARM Limited
+#    Copyright 2014-2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,11 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 from devlib.module import Module
-from devlib.exception import TargetStableError
+from devlib.exception import TargetError
 from devlib.utils.misc import memoized
 import devlib.utils.asyn as asyn
 # a dict of governor name and a list of it tunables that can't be read
@@ -30,52 +28,44 @@ class CpufreqModule(Module):
    name = 'cpufreq'
    @staticmethod
-    @asyn.asyncf
+    def probe(target):
    async def probe(target):
        paths = [
            # x86 with Intel P-State driver
            (target.abi == 'x86_64', '/sys/devices/system/cpu/intel_pstate'),
            # Generic CPUFreq support (single policy)
            (True, '/sys/devices/system/cpu/cpufreq/policy0'),
            # Generic CPUFreq support (per CPU policy)
            (True, '/sys/devices/system/cpu/cpu0/cpufreq'),
        ]
        paths = [
            path[1] for path in paths
            if path[0]
        ]
-        exists = await target.async_manager.map_concurrently(
+        # x86 with Intel P-State driver
-            target.file_exists.asyn,
+        if target.abi == 'x86_64':
-            paths,
+            path = '/sys/devices/system/cpu/intel_pstate'
-        )
+            if target.file_exists(path):
                return True
-        return any(exists.values())
+        # Generic CPUFreq support (single policy)
        path = '/sys/devices/system/cpu/cpufreq'
        if target.file_exists(path):
            return True
        # Generic CPUFreq support (per CPU policy)
        path = '/sys/devices/system/cpu/cpu0/cpufreq'
        return target.file_exists(path)
    def __init__(self, target):
        super(CpufreqModule, self).__init__(target)
        self._governor_tunables = {}
-    @asyn.asyncf
+    @memoized
-    @asyn.memoized_method
+    def list_governors(self, cpu):
    async def list_governors(self, cpu):
        """Returns a list of governors supported by the cpu."""
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_available_governors'.format(cpu)
-        output = await self.target.read_value.asyn(sysfile)
+        output = self.target.read_value(sysfile)
        return output.strip().split()
-    @asyn.asyncf
+    def get_governor(self, cpu):
    async def get_governor(self, cpu):
        """Returns the governor currently set for the specified CPU."""
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_governor'.format(cpu)
-        return await self.target.read_value.asyn(sysfile)
+        return self.target.read_value(sysfile)
-    @asyn.asyncf
+    def set_governor(self, cpu, governor, **kwargs):
    async def set_governor(self, cpu, governor, **kwargs):
        """
        Set the governor for the specified CPU.
        See https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt
@@ -92,254 +82,107 @@ class CpufreqModule(Module):
               Setting the governor on any core in a cluster will also set it on all
               other cores in that cluster.
-        :raises: TargetStableError if governor is not supported by the CPU, or if,
+        :raises: TargetError if governor is not supported by the CPU, or if,
                 for some reason, the governor could not be set.
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
-        supported = await self.list_governors.asyn(cpu)
+        supported = self.list_governors(cpu)
        if governor not in supported:
-            raise TargetStableError('Governor {} not supported for cpu {}'.format(governor, cpu))
+            raise TargetError('Governor {} not supported for cpu {}'.format(governor, cpu))
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_governor'.format(cpu)
-        await self.target.write_value.asyn(sysfile, governor)
+        self.target.write_value(sysfile, governor)
-        await self.set_governor_tunables.asyn(cpu, governor, **kwargs)
+        self.set_governor_tunables(cpu, governor, **kwargs)
-    @asyn.asynccontextmanager
+    def list_governor_tunables(self, cpu):
    async def use_governor(self, governor, cpus=None, **kwargs):
        """
        Use a given governor, then restore previous governor(s)
        :param governor: Governor to use on all targeted CPUs (see :meth:`set_governor`)
        :type governor: str
        :param cpus: CPUs affected by the governor change (all by default)
        :type cpus: list
        :Keyword Arguments: Governor tunables, See :meth:`set_governor_tunables`
        """
        if not cpus:
            cpus = await self.target.list_online_cpus.asyn()
        async def get_cpu_info(cpu):
            return await self.target.async_manager.concurrently((
                self.get_affected_cpus.asyn(cpu),
                self.get_governor.asyn(cpu),
                self.get_governor_tunables.asyn(cpu),
                # We won't always use the frequency, but it's much quicker to
                # do concurrently anyway so do it now
                self.get_frequency.asyn(cpu),
            ))
        cpus_infos = await self.target.async_manager.map_concurrently(get_cpu_info, cpus)
        # Setting a governor & tunables for a cpu will set them for all cpus in
        # the same cpufreq policy, so only manipulating one cpu per domain is
        # enough
        domains = set(
            info[0][0]
            for info in cpus_infos.values()
        )
        await self.target.async_manager.concurrently(
            self.set_governor.asyn(cpu, governor, **kwargs)
            for cpu in domains
        )
        try:
            yield
        finally:
            async def set_per_cpu_tunables(cpu):
                domain, prev_gov, tunables, freq = cpus_infos[cpu]
                # Per-cpu tunables are safe to set concurrently
                await self.set_governor_tunables.asyn(cpu, prev_gov, per_cpu=True, **tunables)
                # Special case for userspace, frequency is not seen as a tunable
                if prev_gov == "userspace":
                    await self.set_frequency.asyn(cpu, freq)
            per_cpu_tunables = self.target.async_manager.concurrently(
                set_per_cpu_tunables(cpu)
                for cpu in domains
            )
            per_cpu_tunables.__qualname__ = 'CpufreqModule.use_governor.<locals>.per_cpu_tunables'
            # Non-per-cpu tunables have to be set one after the other, for each
            # governor that we had to deal with.
            global_tunables = {
                prev_gov: (cpu, tunables)
                for cpu, (domain, prev_gov, tunables, freq) in cpus_infos.items()
            }
            global_tunables = self.target.async_manager.concurrently(
                self.set_governor_tunables.asyn(cpu, gov, per_cpu=False, **tunables)
                for gov, (cpu, tunables) in global_tunables.items()
            )
            global_tunables.__qualname__ = 'CpufreqModule.use_governor.<locals>.global_tunables'
            # Set the governor first
            await self.target.async_manager.concurrently(
                self.set_governor.asyn(cpu, cpus_infos[cpu][1])
                for cpu in domains
            )
            # And then set all the tunables concurrently. Each task has a
            # specific and non-overlapping set of file to write.
            await self.target.async_manager.concurrently(
                (per_cpu_tunables, global_tunables)
            )
    @asyn.asyncf
    async def _list_governor_tunables(self, cpu, governor=None):
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        if governor is None:
            governor = await self.get_governor.asyn(cpu)
        try:
            return self._governor_tunables[governor]
        except KeyError:
            for per_cpu, path in (
                (True, '/sys/devices/system/cpu/{}/cpufreq/{}'.format(cpu, governor)),
                # On old kernels
                (False, '/sys/devices/system/cpu/cpufreq/{}'.format(governor)),
            ):
                try:
                    tunables = await self.target.list_directory.asyn(path)
                except TargetStableError:
                    continue
                else:
                    break
            else:
                per_cpu = False
                tunables = []
            data = (governor, per_cpu, tunables)
            self._governor_tunables[governor] = data
            return data
    @asyn.asyncf
    async def list_governor_tunables(self, cpu):
        """Returns a list of tunables available for the governor on the specified CPU."""
        _, _, tunables = await self._list_governor_tunables.asyn(cpu)
        return tunables
    @asyn.asyncf
    async def get_governor_tunables(self, cpu):
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
-        governor, _, tunable_list = await self._list_governor_tunables.asyn(cpu)
+        governor = self.get_governor(cpu)
-
+        if governor not in self._governor_tunables:
        write_only = set(WRITE_ONLY_TUNABLES.get(governor, []))
        tunable_list = [
            tunable
            for tunable in tunable_list
            if tunable not in write_only
        ]
        tunables = {}
        async def get_tunable(tunable):
            try:
-                path = '/sys/devices/system/cpu/{}/cpufreq/{}/{}'.format(cpu, governor, tunable)
+                tunables_path = '/sys/devices/system/cpu/{}/cpufreq/{}'.format(cpu, governor)
-                x = await self.target.read_value.asyn(path)
+                self._governor_tunables[governor] = self.target.list_directory(tunables_path)
-            except TargetStableError:  # May be an older kernel
+            except TargetError:  # probably an older kernel
-                path = '/sys/devices/system/cpu/cpufreq/{}/{}'.format(governor, tunable)
+                try:
-                x = await self.target.read_value.asyn(path)
+                    tunables_path = '/sys/devices/system/cpu/cpufreq/{}'.format(governor)
-            return x
+                    self._governor_tunables[governor] = self.target.list_directory(tunables_path)
                except TargetError:  # governor does not support tunables
                    self._governor_tunables[governor] = []
        return self._governor_tunables[governor]
-        tunables = await self.target.async_manager.map_concurrently(get_tunable, tunable_list)
+    def get_governor_tunables(self, cpu):
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        governor = self.get_governor(cpu)
        tunables = {}
        for tunable in self.list_governor_tunables(cpu):
            if tunable not in WRITE_ONLY_TUNABLES.get(governor, []):
                try:
                    path = '/sys/devices/system/cpu/{}/cpufreq/{}/{}'.format(cpu, governor, tunable)
                    tunables[tunable] = self.target.read_value(path)
                except TargetError:  # May be an older kernel
                    path = '/sys/devices/system/cpu/cpufreq/{}/{}'.format(governor, tunable)
                    tunables[tunable] = self.target.read_value(path)
        return tunables
-    @asyn.asyncf
+    def set_governor_tunables(self, cpu, governor=None, **kwargs):
    async def set_governor_tunables(self, cpu, governor=None, per_cpu=None, **kwargs):
        """
        Set tunables for the specified governor. Tunables should be specified as
        keyword arguments. Which tunables and values are valid depends on the
        governor.
-        :param cpu: The cpu for which the governor will be set. ``int`` or
+        :param cpu: The cpu for which the governor will be set. This must be the
                    full cpu name as it appears in sysfs, e.g. ``cpu0``.
        :param governor: The name of the governor. Must be all lower case.
        :param per_cpu: If ``None``, both per-cpu and global governor tunables
            will be set. If ``True``, only per-CPU tunables will be set and if
            ``False``, only global tunables will be set.
        The rest should be keyword parameters mapping tunable name onto the value to
        be set for it.
-        :raises: TargetStableError if governor specified is not a valid governor name, or if
+        :raises: TargetError if governor specified is not a valid governor name, or if
                 a tunable specified is not valid for the governor, or if could not set
                 tunable.
        """
        if not kwargs:
            return
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
-
+        if governor is None:
-        governor, gov_per_cpu, valid_tunables = await self._list_governor_tunables.asyn(cpu, governor=governor)
+            governor = self.get_governor(cpu)
-        for tunable, value in kwargs.items():
+        valid_tunables = self.list_governor_tunables(cpu)
        for tunable, value in kwargs.iteritems():
            if tunable in valid_tunables:
-                if per_cpu is not None and gov_per_cpu != per_cpu:
+                try:
                    continue
                if gov_per_cpu:
                    path = '/sys/devices/system/cpu/{}/cpufreq/{}/{}'.format(cpu, governor, tunable)
-                else:
+                    self.target.write_value(path, value)
                except TargetError:  # May be an older kernel
                    path = '/sys/devices/system/cpu/cpufreq/{}/{}'.format(governor, tunable)
-
+                    self.target.write_value(path, value)
                await self.target.write_value.asyn(path, value)
            else:
                message = 'Unexpected tunable {} for governor {} on {}.\n'.format(tunable, governor, cpu)
                message += 'Available tunables are: {}'.format(valid_tunables)
-                raise TargetStableError(message)
+                raise TargetError(message)
-    @asyn.asyncf
+    @memoized
-    @asyn.memoized_method
+    def list_frequencies(self, cpu):
-    async def list_frequencies(self, cpu):
+        """Returns a list of frequencies supported by the cpu or an empty list
        """Returns a sorted list of frequencies supported by the cpu or an empty list
        if not could be found."""
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        try:
            cmd = 'cat /sys/devices/system/cpu/{}/cpufreq/scaling_available_frequencies'.format(cpu)
-            output = await self.target.execute.asyn(cmd)
+            output = self.target.execute(cmd)
-            available_frequencies = list(map(int, output.strip().split()))  # pylint: disable=E1103
+            available_frequencies = map(int, output.strip().split())  # pylint: disable=E1103
-        except TargetStableError:
+        except TargetError:
            # On some devices scaling_frequencies  is not generated.
            # http://adrynalyne-teachtofish.blogspot.co.uk/2011/11/how-to-enable-scalingavailablefrequenci.html
            # Fall back to parsing stats/time_in_state
-            path = '/sys/devices/system/cpu/{}/cpufreq/stats/time_in_state'.format(cpu)
+            cmd = 'cat /sys/devices/system/cpu/{}/cpufreq/stats/time_in_state'.format(cpu)
-            try:
+            out_iter = iter(self.target.execute(cmd).strip().split())
-                out_iter = (await self.target.read_value.asyn(path)).split()
+            available_frequencies = map(int, reversed([f for f, _ in zip(out_iter, out_iter)]))
-            except TargetStableError:
+        return available_frequencies
                if not self.target.file_exists(path):
                    # Probably intel_pstate. Can't get available freqs.
                    return []
                raise
-            available_frequencies = list(map(int, reversed([f for f, _ in zip(out_iter, out_iter)])))
+    def get_min_frequency(self, cpu):
        return sorted(available_frequencies)
    @memoized
    def get_max_available_frequency(self, cpu):
        """
        Returns the maximum available frequency for a given core or None if
        could not be found.
        """
        freqs = self.list_frequencies(cpu)
        return max(freqs) if freqs else None
    @memoized
    def get_min_available_frequency(self, cpu):
        """
        Returns the minimum available frequency for a given core or None if
        could not be found.
        """
        freqs = self.list_frequencies(cpu)
        return min(freqs) if freqs else None
    @asyn.asyncf
    async def get_min_frequency(self, cpu):
        """
        Returns the min frequency currently set for the specified CPU.
@@ -347,16 +190,15 @@ class CpufreqModule(Module):
        try to read the minimum frequency and the following exception will be
        raised ::
-        :raises: TargetStableError if for some reason the frequency could not be read.
+        :raises: TargetError if for some reason the frequency could not be read.
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_min_freq'.format(cpu)
-        return await self.target.read_int.asyn(sysfile)
+        return self.target.read_int(sysfile)
-    @asyn.asyncf
+    def set_min_frequency(self, cpu, frequency, exact=True):
    async def set_min_frequency(self, cpu, frequency, exact=True):
        """
        Set's the minimum value for CPU frequency. Actual frequency will
        depend on the Governor used and may vary during execution. The value should be
@@ -368,27 +210,26 @@ class CpufreqModule(Module):
        on the device.
-        :raises: TargetStableError if the frequency is not supported by the CPU, or if, for
+        :raises: TargetError if the frequency is not supported by the CPU, or if, for
                 some reason, frequency could not be set.
        :raises: ValueError if ``frequency`` is not an integer.
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
-        available_frequencies = await self.list_frequencies.asyn(cpu)
+        available_frequencies = self.list_frequencies(cpu)
        try:
            value = int(frequency)
            if exact and available_frequencies and value not in available_frequencies:
-                raise TargetStableError('Can\'t set {} frequency to {}\nmust be in {}'.format(cpu,
+                raise TargetError('Can\'t set {} frequency to {}\nmust be in {}'.format(cpu,
                                                                                        value,
                                                                                        available_frequencies))
            sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_min_freq'.format(cpu)
-            await self.target.write_value.asyn(sysfile, value)
+            self.target.write_value(sysfile, value)
        except ValueError:
            raise ValueError('Frequency must be an integer; got: "{}"'.format(frequency))
-    @asyn.asyncf
+    def get_frequency(self, cpu):
    async def get_frequency(self, cpu, cpuinfo=False):
        """
        Returns the current frequency currently set for the specified CPU.
@@ -396,22 +237,15 @@ class CpufreqModule(Module):
        try to read the current frequency and the following exception will be
        raised ::
-        :param cpuinfo: Read the value in the cpuinfo interface that reflects
+        :raises: TargetError if for some reason the frequency could not be read.
                        the actual running frequency.
        :raises: TargetStableError if for some reason the frequency could not be read.
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_cur_freq'.format(cpu)
        return self.target.read_int(sysfile)
-        sysfile = '/sys/devices/system/cpu/{}/cpufreq/{}'.format(
+    def set_frequency(self, cpu, frequency, exact=True):
                cpu,
                'cpuinfo_cur_freq' if cpuinfo else 'scaling_cur_freq')
        return await self.target.read_int.asyn(sysfile)
    @asyn.asyncf
    async def set_frequency(self, cpu, frequency, exact=True):
        """
        Set's the minimum value for CPU frequency. Actual frequency will
        depend on the Governor used and may vary during execution. The value should be
@@ -425,7 +259,7 @@ class CpufreqModule(Module):
        on the device (if it exists).
-        :raises: TargetStableError if the frequency is not supported by the CPU, or if, for
+        :raises: TargetError if the frequency is not supported by the CPU, or if, for
                 some reason, frequency could not be set.
        :raises: ValueError if ``frequency`` is not an integer.
@@ -435,24 +269,19 @@ class CpufreqModule(Module):
        try:
            value = int(frequency)
            if exact:
-                available_frequencies = await self.list_frequencies.asyn(cpu)
+                available_frequencies = self.list_frequencies(cpu)
                if available_frequencies and value not in available_frequencies:
-                    raise TargetStableError('Can\'t set {} frequency to {}\nmust be in {}'.format(cpu,
+                    raise TargetError('Can\'t set {} frequency to {}\nmust be in {}'.format(cpu,
                                                                                            value,
                                                                                            available_frequencies))
-            if await self.get_governor.asyn(cpu) != 'userspace':
+            if self.get_governor(cpu) != 'userspace':
-                raise TargetStableError('Can\'t set {} frequency; governor must be "userspace"'.format(cpu))
+                raise TargetError('Can\'t set {} frequency; governor must be "userspace"'.format(cpu))
            sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_setspeed'.format(cpu)
-            await self.target.write_value.asyn(sysfile, value, verify=False)
+            self.target.write_value(sysfile, value, verify=False)
            cpuinfo = await self.get_frequency.asyn(cpu, cpuinfo=True)
            if cpuinfo != value:
                self.logger.warning(
                    'The cpufreq value has not been applied properly cpuinfo={} request={}'.format(cpuinfo, value))
        except ValueError:
            raise ValueError('Frequency must be an integer; got: "{}"'.format(frequency))
-    @asyn.asyncf
+    def get_max_frequency(self, cpu):
    async def get_max_frequency(self, cpu):
        """
        Returns the max frequency currently set for the specified CPU.
@@ -460,15 +289,14 @@ class CpufreqModule(Module):
        try to read the maximum frequency and the following exception will be
        raised ::
-        :raises: TargetStableError if for some reason the frequency could not be read.
+        :raises: TargetError if for some reason the frequency could not be read.
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_max_freq'.format(cpu)
-        return await self.target.read_int.asyn(sysfile)
+        return self.target.read_int(sysfile)
-    @asyn.asyncf
+    def set_max_frequency(self, cpu, frequency, exact=True):
    async def set_max_frequency(self, cpu, frequency, exact=True):
        """
        Set's the minimum value for CPU frequency. Actual frequency will
        depend on the Governor used and may vary during execution. The value should be
@@ -480,169 +308,58 @@ class CpufreqModule(Module):
        on the device.
-        :raises: TargetStableError if the frequency is not supported by the CPU, or if, for
+        :raises: TargetError if the frequency is not supported by the CPU, or if, for
                 some reason, frequency could not be set.
        :raises: ValueError if ``frequency`` is not an integer.
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
-        available_frequencies = await self.list_frequencies.asyn(cpu)
+        available_frequencies = self.list_frequencies(cpu)
        try:
            value = int(frequency)
            if exact and available_frequencies and value not in available_frequencies:
-                raise TargetStableError('Can\'t set {} frequency to {}\nmust be in {}'.format(cpu,
+                raise TargetError('Can\'t set {} frequency to {}\nmust be in {}'.format(cpu,
                                                                                        value,
                                                                                        available_frequencies))
            sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_max_freq'.format(cpu)
-            await self.target.write_value.asyn(sysfile, value)
+            self.target.write_value(sysfile, value)
        except ValueError:
            raise ValueError('Frequency must be an integer; got: "{}"'.format(frequency))
-    @asyn.asyncf
+    def set_governor_for_cpus(self, cpus, governor, **kwargs):
    async def set_governor_for_cpus(self, cpus, governor, **kwargs):
        """
        Set the governor for the specified list of CPUs.
        See https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt
        :param cpus: The list of CPU for which the governor is to be set.
        """
-        await self.target.async_manager.map_concurrently(
+        online_cpus = self.target.list_online_cpus()
-            self.set_governor(cpu, governor, **kwargs)
+        for cpu in online_cpus:
-            for cpu in sorted(set(cpus))
+            self.set_governor(cpu, governor, kwargs)
        )
-    @asyn.asyncf
+    def set_frequency_for_cpus(self, cpus, freq, exact=False):
    async def set_frequency_for_cpus(self, cpus, freq, exact=False):
        """
        Set the frequency for the specified list of CPUs.
        See https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt
        :param cpus: The list of CPU for which the frequency has to be set.
        """
-        await self.target.async_manager.map_concurrently(
+        online_cpus = self.target.list_online_cpus()
        for cpu in online_cpus:
            self.set_frequency(cpu, freq, exact)
            for cpu in sorted(set(cpus))
        )
-    @asyn.asyncf
+    def set_all_frequencies(self, freq, exact=False):
-    async def set_all_frequencies(self, freq):
+        self.target.execute(
-        """
+                "for CPU in /sys/devices/system/cpu/cpu[0-9]*; do "\
-        Set the specified (minimum) frequency for all the (online) CPUs
+                        "echo {} > $CPU/cpufreq/scaling_cur_freq; "\
-        """
+                "done"\
-        # pylint: disable=protected-access
+                .format(freq), as_root=True)
        return await self.target._execute_util.asyn(
                'cpufreq_set_all_frequencies {}'.format(freq),
                as_root=True)
-    @asyn.asyncf
+    def set_all_governors(self, governor):
-    async def get_all_frequencies(self):
+        self.target.execute(
-        """
+                "for CPU in /sys/devices/system/cpu/cpu[0-9]*; do "\
-        Get the current frequency for all the (online) CPUs
+                        "echo {} > $CPU/cpufreq/scaling_governor; "\
-        """
+                "done"\
-        # pylint: disable=protected-access
+                .format(governor), as_root=True)
        output = await self.target._execute_util.asyn(
                'cpufreq_get_all_frequencies', as_root=True)
        frequencies = {}
        for x in output.splitlines():
            kv = x.split(' ')
            if kv[0] == '':
                break
            frequencies[kv[0]] = kv[1]
        return frequencies
    @asyn.asyncf
    async def set_all_governors(self, governor):
        """
        Set the specified governor for all the (online) CPUs
        """
        try:
            # pylint: disable=protected-access
            return await self.target._execute_util.asyn(
                'cpufreq_set_all_governors {}'.format(governor),
                as_root=True)
        except TargetStableError as e:
            if ("echo: I/O error" in str(e) or
                "write error: Invalid argument" in str(e)):
                cpus_unsupported = [c for c in await self.target.list_online_cpus.asyn()
                                    if governor not in await self.list_governors.asyn(c)]
                raise TargetStableError("Governor {} unsupported for CPUs {}".format(
                    governor, cpus_unsupported))
            else:
                raise
    @asyn.asyncf
    async def get_all_governors(self):
        """
        Get the current governor for all the (online) CPUs
        """
        # pylint: disable=protected-access
        output = await self.target._execute_util.asyn(
                'cpufreq_get_all_governors', as_root=True)
        governors = {}
        for x in output.splitlines():
            kv = x.split(' ')
            if kv[0] == '':
                break
            governors[kv[0]] = kv[1]
        return governors
    @asyn.asyncf
    async def trace_frequencies(self):
        """
        Report current frequencies on trace file
        """
        # pylint: disable=protected-access
        return await self.target._execute_util.asyn('cpufreq_trace_all_frequencies', as_root=True)
    @asyn.asyncf
    async def get_affected_cpus(self, cpu):
        """
        Get the online CPUs that share a frequency domain with the given CPU
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/affected_cpus'.format(cpu)
        content = await self.target.read_value.asyn(sysfile)
        return [int(c) for c in content.split()]
    @asyn.asyncf
    @asyn.memoized_method
    async def get_related_cpus(self, cpu):
        """
        Get the CPUs that share a frequency domain with the given CPU
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/related_cpus'.format(cpu)
        return [int(c) for c in (await self.target.read_value.asyn(sysfile)).split()]
    @asyn.asyncf
    @asyn.memoized_method
    async def get_driver(self, cpu):
        """
        Get the name of the driver used by this cpufreq policy.
        """
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
        sysfile = '/sys/devices/system/cpu/{}/cpufreq/scaling_driver'.format(cpu)
        return (await self.target.read_value.asyn(sysfile)).strip()
    @asyn.asyncf
    async def iter_domains(self):
        """
        Iterate over the frequency domains in the system
        """
        cpus = set(range(self.target.number_of_cpus))
        while cpus:
            cpu = next(iter(cpus))  # pylint: disable=stop-iteration-return
            domain = await self.target.cpufreq.get_related_cpus.asyn(cpu)
            yield domain
            cpus = cpus.difference(domain)
--- a/devlib/module/cpuidle.py
+++ b/devlib/module/cpuidle.py
@@ -1,4 +1,4 @@
-#    Copyright 2014-2018 ARM Limited
+#    Copyright 2014-2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,16 +13,9 @@
 # limitations under the License.
 #
 # pylint: disable=attribute-defined-outside-init
 from past.builtins import basestring
 from operator import attrgetter
 from pprint import pformat
 from devlib.module import Module
 from devlib.exception import TargetStableError
 from devlib.utils.types import integer, boolean
 from devlib.utils.misc import memoized
-import devlib.utils.asyn as asyn
+from devlib.utils.types import integer, boolean
 class CpuidleState(object):
@@ -48,35 +41,30 @@ class CpuidleState(object):
                raise ValueError('invalid idle state name: "{}"'.format(self.id))
        return int(self.id[i:])
-    def __init__(self, target, index, path, name, desc, power, latency, residency):
+    def __init__(self, target, index, path):
        self.target = target
        self.index = index
        self.path = path
        self.name = name
        self.desc = desc
        self.power = power
        self.latency = latency
        self.residency = residency
        self.id = self.target.path.basename(self.path)
        self.cpu = self.target.path.basename(self.target.path.dirname(path))
        self.desc = self.get('desc')
        self.name = self.get('name')
        self.latency = self.get('latency')
        self.power = self.get('power')
-    @asyn.asyncf
+    def enable(self):
-    async def enable(self):
+        self.set('disable', 0)
        await self.set.asyn('disable', 0)
-    @asyn.asyncf
+    def disable(self):
-    async def disable(self):
+        self.set('disable', 1)
        await self.set.asyn('disable', 1)
-    @asyn.asyncf
+    def get(self, prop):
    async def get(self, prop):
        property_path = self.target.path.join(self.path, prop)
-        return await self.target.read_value.asyn(property_path)
+        return self.target.read_value(property_path)
-    @asyn.asyncf
+    def set(self, prop, value):
    async def set(self, prop, value):
        property_path = self.target.path.join(self.path, prop)
-        await self.target.write_value.asyn(property_path, value)
+        self.target.write_value(property_path, value)
    def __eq__(self, other):
        if isinstance(other, CpuidleState):
@@ -101,51 +89,31 @@ class Cpuidle(Module):
    root_path = '/sys/devices/system/cpu/cpuidle'
    @staticmethod
-    @asyn.asyncf
+    def probe(target):
-    async def probe(target):
+        return target.file_exists(Cpuidle.root_path)
        return await target.file_exists.asyn(Cpuidle.root_path)
-    def __init__(self, target):
+    def get_driver(self):
-        super(Cpuidle, self).__init__(target)
+        return self.target.read_value(self.target.path.join(self.root_path, 'current_driver'))
-        basepath = '/sys/devices/system/cpu/'
+    def get_governor(self):
-        values_tree = self.target.read_tree_values(basepath, depth=4, check_exit_code=False)
+        return self.target.read_value(self.target.path.join(self.root_path, 'current_governor_ro'))
        self._states = {
            cpu_name: sorted(
                (
                    CpuidleState(
                        self.target,
                        # state_name is formatted as "state42"
                        index=int(state_name[len('state'):]),
                        path=self.target.path.join(basepath, cpu_name, 'cpuidle', state_name),
                        name=state_node['name'],
                        desc=state_node['desc'],
                        power=int(state_node['power']),
                        latency=int(state_node['latency']),
                        residency=int(state_node['residency']) if 'residency' in state_node else None,
                    )
                    for state_name, state_node in cpu_node['cpuidle'].items()
                    if state_name.startswith('state')
                ),
                key=attrgetter('index'),
            )
            for cpu_name, cpu_node in values_tree.items()
            if cpu_name.startswith('cpu') and 'cpuidle' in cpu_node
        }
        self.logger.debug('Adding cpuidle states:\n{}'.format(pformat(self._states)))
    @memoized
    def get_states(self, cpu=0):
        if isinstance(cpu, int):
            cpu = 'cpu{}'.format(cpu)
-        return self._states.get(cpu, [])
+        states_dir = self.target.path.join(self.target.path.dirname(self.root_path), cpu, 'cpuidle')
        idle_states = []
        for state in self.target.list_directory(states_dir):
            if state.startswith('state'):
                index = int(state[5:])
                idle_states.append(CpuidleState(self.target, index, self.target.path.join(states_dir, state)))
        return idle_states
    def get_state(self, state, cpu=0):
        if isinstance(state, int):
            try:
-                return self.get_states(cpu)[state]
+                self.get_states(cpu)[state].enable()
            except IndexError:
                raise ValueError('Cpuidle state {} does not exist'.format(state))
        else:  # assume string-like
@@ -154,67 +122,17 @@ class Cpuidle(Module):
                    return s
            raise ValueError('Cpuidle state {} does not exist'.format(state))
-    @asyn.asyncf
+    def enable(self, state, cpu=0):
-    async def enable(self, state, cpu=0):
+        self.get_state(state, cpu).enable()
        await self.get_state(state, cpu).enable.asyn()
-    @asyn.asyncf
+    def disable(self, state, cpu=0):
-    async def disable(self, state, cpu=0):
+        self.get_state(state, cpu).disable()
        await self.get_state(state, cpu).disable.asyn()
-    @asyn.asyncf
+    def enable_all(self, cpu=0):
-    async def enable_all(self, cpu=0):
+        for state in self.get_states(cpu):
-        await self.target.async_manager.concurrently(
+            state.enable()
            state.enable.asyn()
            for state in self.get_states(cpu)
        )
-    @asyn.asyncf
+    def disable_all(self, cpu=0):
-    async def disable_all(self, cpu=0):
+        for state in self.get_states(cpu):
-        await self.target.async_manager.concurrently(
+            state.disable()
            state.disable.asyn()
            for state in self.get_states(cpu)
        )
    @asyn.asyncf
    async def perturb_cpus(self):
        """
        Momentarily wake each CPU. Ensures cpu_idle events in trace file.
        """
        # pylint: disable=protected-access
        await self.target._execute_util.asyn('cpuidle_wake_all_cpus')
    @asyn.asyncf
    async def get_driver(self):
        return await self.target.read_value.asyn(self.target.path.join(self.root_path, 'current_driver'))
    @memoized
    def list_governors(self):
        """Returns a list of supported idle governors."""
        sysfile = self.target.path.join(self.root_path, 'available_governors')
        output = self.target.read_value(sysfile)
        return output.strip().split()
    @asyn.asyncf
    async def get_governor(self):
        """Returns the currently selected idle governor."""
        path = self.target.path.join(self.root_path, 'current_governor_ro')
        if not await self.target.file_exists.asyn(path):
            path = self.target.path.join(self.root_path, 'current_governor')
        return await self.target.read_value.asyn(path)
    def set_governor(self, governor):
        """
        Set the idle governor for the system.
        :param governor: The name of the governor to be used. This must be
        supported by the specific device.
        :raises TargetStableError if governor is not supported by the CPU, or
        if, for some reason, the governor could not be set.
        """
        supported = self.list_governors()
        if governor not in supported:
            raise TargetStableError('Governor {} not supported'.format(governor))
        sysfile = self.target.path.join(self.root_path, 'current_governor')
        self.target.write_value(sysfile, governor)
--- a/devlib/module/devfreq.py
+++ b/devlib/module/devfreq.py
@@ -1,260 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 from devlib.module import Module
 from devlib.exception import TargetStableError
 from devlib.utils.misc import memoized
 class DevfreqModule(Module):
    name = 'devfreq'
    @staticmethod
    def probe(target):
        path = '/sys/class/devfreq/'
        if not target.file_exists(path):
            return False
        # Check that at least one policy is implemented
        if not target.list_directory(path):
            return False
        return True
    @memoized
    def list_devices(self):
        """Returns a list of devfreq devices supported by the target platform."""
        sysfile = '/sys/class/devfreq/'
        return self.target.list_directory(sysfile)
    @memoized
    def list_governors(self, device):
        """Returns a list of governors supported by the device."""
        sysfile = '/sys/class/devfreq/{}/available_governors'.format(device)
        output = self.target.read_value(sysfile)
        return output.strip().split()
    def get_governor(self, device):
        """Returns the governor currently set for the specified device."""
        if isinstance(device, int):
            device = 'device{}'.format(device)
        sysfile = '/sys/class/devfreq/{}/governor'.format(device)
        return self.target.read_value(sysfile)
    def set_governor(self, device, governor):
        """
        Set the governor for the specified device.
        :param device: The device for which the governor is to be set. This must be
                    the full name as it appears in sysfs, e.g. "e82c0000.mali".
        :param governor: The name of the governor to be used. This must be
                         supported by the specific device.
        Additional keyword arguments can be used to specify governor tunables for
        governors that support them.
        :raises: TargetStableError if governor is not supported by the device, or if,
                 for some reason, the governor could not be set.
        """
        supported = self.list_governors(device)
        if governor not in supported:
            raise TargetStableError('Governor {} not supported for device {}'.format(governor, device))
        sysfile = '/sys/class/devfreq/{}/governor'.format(device)
        self.target.write_value(sysfile, governor)
    @memoized
    def list_frequencies(self, device):
        """
        Returns a list of frequencies supported by the device or an empty list
        if could not be found.
        """
        cmd = 'cat /sys/class/devfreq/{}/available_frequencies'.format(device)
        output = self.target.execute(cmd)
        available_frequencies = [int(freq) for freq in output.strip().split()]
        return available_frequencies
    def get_min_frequency(self, device):
        """
        Returns the min frequency currently set for the specified device.
        Warning, this method does not check if the device is present or not. It
        will try to read the minimum frequency and the following exception will
        be raised ::
        :raises: TargetStableError if for some reason the frequency could not be read.
        """
        sysfile = '/sys/class/devfreq/{}/min_freq'.format(device)
        return self.target.read_int(sysfile)
    def set_min_frequency(self, device, frequency, exact=True):
        """
        Sets the minimum value for device frequency. Actual frequency will
        depend on the thermal governor used and may vary during execution. The
        value should be either an int or a string representing an integer. The
        Value must also be supported by the device. The available frequencies
        can be obtained by calling list_frequencies() or examining
        /sys/class/devfreq/<device_name>/available_frequencies
        on the device.
        :raises: TargetStableError if the frequency is not supported by the device, or if, for
                 some reason, frequency could not be set.
        :raises: ValueError if ``frequency`` is not an integer.
        """
        available_frequencies = self.list_frequencies(device)
        try:
            value = int(frequency)
            if exact and available_frequencies and value not in available_frequencies:
                raise TargetStableError('Can\'t set {} frequency to {}\nmust be in {}'.format(device,
                                                                                        value,
                                                                                        available_frequencies))
            sysfile = '/sys/class/devfreq/{}/min_freq'.format(device)
            self.target.write_value(sysfile, value)
        except ValueError:
            raise ValueError('Frequency must be an integer; got: "{}"'.format(frequency))
    def get_frequency(self, device):
        """
        Returns the current frequency currently set for the specified device.
        Warning, this method does not check if the device is present or not. It
        will try to read the current frequency and the following exception will
        be raised ::
        :raises: TargetStableError if for some reason the frequency could not be read.
        """
        sysfile = '/sys/class/devfreq/{}/cur_freq'.format(device)
        return self.target.read_int(sysfile)
    def get_max_frequency(self, device):
        """
        Returns the max frequency currently set for the specified device.
        Warning, this method does not check if the device is online or not. It will
        try to read the maximum frequency and the following exception will be
        raised ::
        :raises: TargetStableError if for some reason the frequency could not be read.
        """
        sysfile = '/sys/class/devfreq/{}/max_freq'.format(device)
        return self.target.read_int(sysfile)
    def set_max_frequency(self, device, frequency, exact=True):
        """
        Sets the maximum value for device frequency. Actual frequency will
        depend on the Governor used and may vary during execution. The value
        should be either an int or a string representing an integer. The Value
        must also be supported by the device. The available frequencies can be
        obtained by calling get_frequencies() or examining
        /sys/class/devfreq/<device_name>/available_frequencies
        on the device.
        :raises: TargetStableError if the frequency is not supported by the device, or
                 if, for some reason, frequency could not be set.
        :raises: ValueError if ``frequency`` is not an integer.
        """
        available_frequencies = self.list_frequencies(device)
        try:
            value = int(frequency)
        except ValueError:
            raise ValueError('Frequency must be an integer; got: "{}"'.format(frequency))
        if exact and value not in available_frequencies:
            raise TargetStableError('Can\'t set {} frequency to {}\nmust be in {}'.format(device,
                                                                                    value,
                                                                                    available_frequencies))
        sysfile = '/sys/class/devfreq/{}/max_freq'.format(device)
        self.target.write_value(sysfile, value)
    def set_governor_for_devices(self, devices, governor):
        """
        Set the governor for the specified list of devices.
        :param devices: The list of device for which the governor is to be set.
        """
        for device in devices:
            self.set_governor(device, governor)
    def set_all_governors(self, governor):
        """
        Set the specified governor for all the (available) devices
        """
        try:
            return self.target._execute_util(  # pylint: disable=protected-access
                'devfreq_set_all_governors {}'.format(governor), as_root=True)
        except TargetStableError as e:
            if ("echo: I/O error" in str(e) or
                "write error: Invalid argument" in str(e)):
                devs_unsupported = [d for d in self.target.list_devices()
                                    if governor not in self.list_governors(d)]
                raise TargetStableError("Governor {} unsupported for devices {}".format(
                    governor, devs_unsupported))
            else:
                raise
    def get_all_governors(self):
        """
        Get the current governor for all the (online) CPUs
        """
        output = self.target._execute_util(  # pylint: disable=protected-access
                'devfreq_get_all_governors', as_root=True)
        governors = {}
        for x in output.splitlines():
            kv = x.split(' ')
            if kv[0] == '':
                break
            governors[kv[0]] = kv[1]
        return governors
    def set_frequency_for_devices(self, devices, freq, exact=False):
        """
        Set the frequency for the specified list of devices.
        :param devices: The list of device for which the frequency has to be set.
        """
        for device in devices:
            self.set_max_frequency(device, freq, exact)
            self.set_min_frequency(device, freq, exact)
    def set_all_frequencies(self, freq):
        """
        Set the specified (minimum) frequency for all the (available) devices
        """
        return self.target._execute_util(  # pylint: disable=protected-access
                'devfreq_set_all_frequencies {}'.format(freq),
                as_root=True)
    def get_all_frequencies(self):
        """
        Get the current frequency for all the (available) devices
        """
        output = self.target._execute_util(  # pylint: disable=protected-access
                'devfreq_get_all_frequencies', as_root=True)
        frequencies = {}
        for x in output.splitlines():
            kv = x.split(' ')
            if kv[0] == '':
                break
            frequencies[kv[0]] = kv[1]
        return frequencies
--- a/devlib/module/gem5stats.py
+++ b/devlib/module/gem5stats.py
@@ -1,250 +0,0 @@
 #    Copyright 2017-2018 ARM Limited
 #
 # 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.
 import re
 import sys
 import os.path
 from collections import defaultdict
 from devlib.exception import TargetStableError, HostError
 from devlib.module import Module
 from devlib.platform.gem5 import Gem5SimulationPlatform
 from devlib.utils.gem5 import iter_statistics_dump, GEM5STATS_ROI_NUMBER
 class Gem5ROI:
    def __init__(self, number, target):
        self.target = target
        self.number = number
        self.running = False
        self.field = 'ROI::{}'.format(number)
    def start(self):
        if self.running:
            return False
        self.target.execute('m5 roistart {}'.format(self.number))
        self.running = True
        return True
    def stop(self):
        if not self.running:
            return False
        self.target.execute('m5 roiend {}'.format(self.number))
        self.running = False
        return True
 class Gem5StatsModule(Module):
    '''
    Module controlling Region of Interest (ROIs) markers, satistics dump
    frequency and parsing statistics log file when using gem5 platforms.
    ROIs are identified by user-defined labels and need to be booked prior to
    use. The translation of labels into gem5 ROI numbers will be performed
    internally in order to avoid conflicts between multiple clients.
    '''
    name = 'gem5stats'
    @staticmethod
    def probe(target):
        return isinstance(target.platform, Gem5SimulationPlatform)
    def __init__(self, target):
        super(Gem5StatsModule, self).__init__(target)
        self._current_origin = 0
        self._stats_file_path = os.path.join(target.platform.gem5_out_dir,
                                            'stats.txt')
        self.rois = {}
        self._dump_pos_cache = {0: 0}
    def book_roi(self, label):
        if label in self.rois:
            raise KeyError('ROI label {} already used'.format(label))
        if len(self.rois) >= GEM5STATS_ROI_NUMBER:
            raise RuntimeError('Too many ROIs reserved')
        all_rois = set(range(GEM5STATS_ROI_NUMBER))
        used_rois = set([roi.number for roi in self.rois.values()])
        avail_rois = all_rois - used_rois
        self.rois[label] = Gem5ROI(list(avail_rois)[0], self.target)
    def free_roi(self, label):
        if label not in self.rois:
            raise KeyError('ROI label {} not reserved yet'.format(label))
        self.rois[label].stop()
        del self.rois[label]
    def roi_start(self, label):
        if label not in self.rois:
            raise KeyError('Incorrect ROI label: {}'.format(label))
        if not self.rois[label].start():
            raise TargetStableError('ROI {} was already running'.format(label))
    def roi_end(self, label):
        if label not in self.rois:
            raise KeyError('Incorrect ROI label: {}'.format(label))
        if not self.rois[label].stop():
            raise TargetStableError('ROI {} was not running'.format(label))
    def start_periodic_dump(self, delay_ns=0, period_ns=10000000):
        # Default period is 10ms because it's roughly what's needed to have
        # accurate power estimations
        if delay_ns < 0 or period_ns < 0:
            msg = 'Delay ({}) and period ({}) for periodic dumps must be positive'
            raise ValueError(msg.format(delay_ns, period_ns))
        self.target.execute('m5 dumpresetstats {} {}'.format(delay_ns, period_ns))
    def match(self, keys, rois_labels, base_dump=0):
        '''
        Extract specific values from the statistics log file of gem5
        :param keys: a list of key name or regular expression patterns that
            will be matched in the fields of the statistics file. ``match()``
            returns only the values of fields matching at least one these
            keys.
        :type keys: list
        :param rois_labels: list of ROIs labels. ``match()`` returns the
            values of the specified fields only during dumps spanned by at
            least one of these ROIs.
        :type rois_label: list
        :param base_dump: dump number from which ``match()`` should operate. By
            specifying a non-zero dump number, one can virtually truncate
            the head of the stats file and ignore all dumps before a specific
            instant. The value of ``base_dump`` will typically (but not
            necessarily) be the result of a previous call to ``next_dump_no``.
            Default value is 0.
        :type base_dump: int
        :returns: a dict indexed by key parameters containing a dict indexed by
        ROI labels containing an in-order list of records for the key under
        consideration during the active intervals of the ROI.
        Example of return value:
         * Result of match(['sim_'],['roi_1']):
            {
                'sim_inst':
                {
                    'roi_1': [265300176, 267975881]
                }
                'sim_ops':
                {
                    'roi_1': [324395787, 327699419]
                }
                'sim_seconds':
                {
                    'roi_1': [0.199960, 0.199897]
                }
                'sim_freq':
                {
                    'roi_1': [1000000000000, 1000000000000]
                }
                'sim_ticks':
                {
                    'roi_1': [199960234227, 199896897330]
                }
            }
        '''
        records = defaultdict(lambda: defaultdict(list))
        for record, active_rois in self.match_iter(keys, rois_labels, base_dump):
            for key in record:
                for roi_label in active_rois:
                    records[key][roi_label].append(record[key])
        return records
    def match_iter(self, keys, rois_labels, base_dump=0):
        '''
        Yield specific values dump-by-dump from the statistics log file of gem5
        :param keys: same as ``match()``
        :param rois_labels: same as ``match()``
        :param base_dump: same as ``match()``
        :returns: a pair containing:
            1. a dict storing the values corresponding to each of the found keys
            2. the list of currently active ROIs among those passed as parameters
        Example of return value:
         * Result of match_iter(['sim_'],['roi_1', 'roi_2']).next()
            (
                {
                    'sim_inst': 265300176,
                    'sim_ops': 324395787,
                    'sim_seconds': 0.199960,
                    'sim_freq': 1000000000000,
                    'sim_ticks': 199960234227,
                },
                [ 'roi_1 ' ]
            )
        '''
        for label in rois_labels:
            if label not in self.rois:
                raise KeyError('Impossible to match ROI label {}'.format(label))
            if self.rois[label].running:
                self.logger.warning('Trying to match records in statistics file'
                        ' while ROI {} is running'.format(label))
        # Construct one large regex that concatenates all keys because
        # matching one large expression is more efficient than several smaller
        all_keys_re = re.compile('|'.join(keys))
        def roi_active(roi_label, dump):
            roi = self.rois[roi_label]
            return (roi.field in dump) and (int(dump[roi.field]) == 1)
        with open(self._stats_file_path, 'r') as stats_file:
            self._goto_dump(stats_file, base_dump)
            for dump in iter_statistics_dump(stats_file):
                active_rois = [l for l in rois_labels if roi_active(l, dump)]
                if active_rois:
                    rec = {k: dump[k] for k in dump if all_keys_re.search(k)}
                    yield (rec, active_rois)
    def next_dump_no(self):
        '''
        Returns the number of the next dump to be written to the stats file.
        For example, if next_dump_no is called while there are 5 (0 to 4) full
        dumps in the stats file, it will return 5. This will be usefull to know
        from which dump one should match() in the future to get only data from
        now on.
        '''
        with open(self._stats_file_path, 'r') as stats_file:
            # _goto_dump reach EOF and returns the total number of dumps + 1
            return self._goto_dump(stats_file, sys.maxsize)
    def _goto_dump(self, stats_file, target_dump):
        if target_dump < 0:
            raise HostError('Cannot go to dump {}'.format(target_dump))
        # Go to required dump quickly if it was visited before
        if target_dump in self._dump_pos_cache:
            stats_file.seek(self._dump_pos_cache[target_dump])
            return target_dump
        # Or start from the closest dump already visited before the required one
        prev_dumps = filter(lambda x: x < target_dump, self._dump_pos_cache.keys())
        curr_dump = max(prev_dumps)
        curr_pos = self._dump_pos_cache[curr_dump]
        stats_file.seek(curr_pos)
        # And iterate until target_dump
        dump_iterator = iter_statistics_dump(stats_file)
        while curr_dump < target_dump:
            try:
                next(dump_iterator)
            except StopIteration:
                break
            # End of passed dump is beginning og next one
            curr_pos = stats_file.tell()
            curr_dump += 1
        self._dump_pos_cache[curr_dump] = curr_pos
        return curr_dump
--- a/devlib/module/gpufreq.py
+++ b/devlib/module/gpufreq.py
@@ -1,89 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 #    Copyright 2017 Google, ARM Limited
 #
 # 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.
 import re
 from devlib.module import Module
 from devlib.exception import TargetStableError
 from devlib.utils.misc import memoized
 class GpufreqModule(Module):
    name = 'gpufreq'
    path = ''
    def __init__(self, target):
        super(GpufreqModule, self).__init__(target)
        frequencies_str = self.target.read_value("/sys/kernel/gpu/gpu_freq_table")
        self.frequencies = list(map(int, frequencies_str.split(" ")))
        self.frequencies.sort()
        self.governors = self.target.read_value("/sys/kernel/gpu/gpu_available_governor").split(" ")
    @staticmethod
    def probe(target):
        # kgsl/Adreno
        probe_path = '/sys/kernel/gpu/'
        if target.file_exists(probe_path):
            model = target.read_value(probe_path + "gpu_model")
            if re.search('adreno', model, re.IGNORECASE):
                return True
        return False
    def set_governor(self, governor):
        if governor not in self.governors:
            raise TargetStableError('Governor {} not supported for gpu'.format(governor))
        self.target.write_value("/sys/kernel/gpu/gpu_governor", governor)
    def get_frequencies(self):
        """
        Returns the list of frequencies that the GPU can have
        """
        return self.frequencies
    def get_current_frequency(self):
        """
        Returns the current frequency currently set for the GPU.
        Warning, this method does not check if the gpu is online or not. It will
        try to read the current frequency and the following exception will be
        raised ::
        :raises: TargetStableError if for some reason the frequency could not be read.
        """
        return int(self.target.read_value("/sys/kernel/gpu/gpu_clock"))
    @memoized
    def get_model_name(self):
        """
        Returns the model name reported by the GPU.
        """
        try:
            return self.target.read_value("/sys/kernel/gpu/gpu_model")
        except:  # pylint: disable=bare-except
            return "unknown"
--- a/devlib/module/hotplug.py
+++ b/devlib/module/hotplug.py
@@ -1,20 +1,4 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 from devlib.module import Module
 from devlib.exception import TargetTransientError
 class HotplugModule(Module):
@@ -36,17 +20,8 @@ class HotplugModule(Module):
            cpu = 'cpu{}'.format(cpu)
        return target.path.join(cls.base_path, cpu, 'online')
-    def list_hotpluggable_cpus(self):
+    def online_all(self):
-        return [cpu for cpu in range(self.target.number_of_cpus)
+        self.online(*range(self.target.number_of_cpus))
                if self.target.file_exists(self._cpu_path(self.target, cpu))]
    def online_all(self, verify=True):
        self.target._execute_util('hotplug_online_all',  # pylint: disable=protected-access
                                  as_root=self.target.is_rooted)
        if verify:
            offline = set(self.target.list_offline_cpus())
            if offline:
                raise TargetTransientError('The following CPUs failed to come back online: {}'.format(offline))
    def online(self, *args):
        for cpu in args:
@@ -63,22 +38,3 @@ class HotplugModule(Module):
        value = 1 if online else 0
        self.target.write_value(path, value)
    def _get_path(self, path):
        return self.target.path.join(self.base_path,
            path)
    def fail(self, cpu, state):
        path = self._get_path('cpu{}/hotplug/fail'.format(cpu))
        return self.target.write_value(path, state)
    def get_state(self, cpu):
        path = self._get_path('cpu{}/hotplug/state'.format(cpu))
        return self.target.read_value(path)
    def get_states(self):
        path = self._get_path('hotplug/states')
        states_string = self.target.read_value(path)
        return dict(
                map(str.strip, string.split(':', 1))
                for string in states_string.strip().splitlines()
        )
--- a/devlib/module/hwmon.py
+++ b/devlib/module/hwmon.py
@@ -1,4 +1,4 @@
-#    Copyright 2015-2018 ARM Limited
+#    Copyright 2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,7 +15,6 @@
 import re
 from collections import defaultdict
 from devlib import TargetStableError
 from devlib.module import Module
 from devlib.utils.types import integer
@@ -74,19 +73,19 @@ class HwmonDevice(object):
    @property
    def sensors(self):
        all_sensors = []
-        for sensors_of_kind in self._sensors.values():
+        for sensors_of_kind in self._sensors.itervalues():
-            all_sensors.extend(list(sensors_of_kind.values()))
+            all_sensors.extend(sensors_of_kind.values())
        return all_sensors
-    def __init__(self, target, path, name, fields):
+    def __init__(self, target, path):
        self.target = target
        self.path = path
-        self.name = name
+        self.name = self.target.read_value(self.target.path.join(self.path, 'name'))
        self._sensors = defaultdict(dict)
        path = self.path
        if not path.endswith(self.target.path.sep):
            path += self.target.path.sep
-        for entry in fields:
+        for entry in self.target.list_directory(path):
            match = HWMON_FILE_REGEX.search(entry)
            if match:
                kind = match.group('kind')
@@ -99,7 +98,7 @@ class HwmonDevice(object):
    def get(self, kind, number=None):
        if number is None:
-            return [s for _, s in sorted(self._sensors[kind].items(),
+            return [s for _, s in sorted(self._sensors[kind].iteritems(),
                                         key=lambda x: x[0])]
        else:
            return self._sensors[kind].get(number)
@@ -116,12 +115,7 @@ class HwmonModule(Module):
    @staticmethod
    def probe(target):
-        try:
+        return target.file_exists(HWMON_ROOT)
            target.list_directory(HWMON_ROOT, as_root=target.is_rooted)
        except TargetStableError:
            # Doesn't exist or no permissions
            return False
        return True
    @property
    def sensors(self):
@@ -137,12 +131,10 @@ class HwmonModule(Module):
        self.scan()
    def scan(self):
-        values_tree = self.target.read_tree_values(self.root, depth=3, tar=True)
+        for entry in self.target.list_directory(self.root):
-        for entry_id, fields in values_tree.items():
+            if entry.startswith('hwmon'):
-            path = self.target.path.join(self.root, entry_id)
+                entry_path = self.target.path.join(self.root, entry)
-            name = fields.pop('name', None)
+                if self.target.file_exists(self.target.path.join(entry_path, 'name')):
-            if name is None:
+                    device = HwmonDevice(self.target, entry_path)
-                continue
+                    self.devices.append(device)
-            self.logger.debug('Adding device {}'.format(name))
+
            device = HwmonDevice(self.target, path, name, fields)
            self.devices.append(device)
--- a/devlib/module/sched.py
+++ b/devlib/module/sched.py
@@ -1,612 +0,0 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import logging
 import re
 from past.builtins import basestring
 from devlib.module import Module
 from devlib.utils.misc import memoized
 from devlib.utils.types import boolean
 from devlib.exception import TargetStableError
 class SchedProcFSNode(object):
    """
    Represents a sched_domain procfs node
    :param nodes: Dictionnary view of the underlying procfs nodes
        (as returned by devlib.read_tree_values())
    :type nodes: dict
    Say you want to represent this path/data:
    $ cat /proc/sys/kernel/sched_domain/cpu0/domain*/name
    MC
    DIE
    Taking cpu0 as a root, this can be defined as:
    >>> data = {"domain0" : {"name" : "MC"}, "domain1" : {"name" : "DIE"}}
    >>> repr = SchedProcFSNode(data)
    >>> print repr.domains[0].name
    MC
    The "raw" dict remains available under the `procfs` field:
    >>> print repr.procfs["domain0"]["name"]
    MC
    """
    _re_procfs_node = re.compile(r"(?P<name>.*\D)(?P<digits>\d+)$")
    PACKABLE_ENTRIES = [
        "cpu",
        "domain",
        "group"
    ]
    @staticmethod
    def _ends_with_digits(node):
        if not isinstance(node, basestring):
            return False
        return re.search(SchedProcFSNode._re_procfs_node, node) != None
    @staticmethod
    def _node_digits(node):
        """
        :returns: The ending digits of the procfs node
        """
        return int(re.search(SchedProcFSNode._re_procfs_node, node).group("digits"))
    @staticmethod
    def _node_name(node):
        """
        :returns: The name of the procfs node
        """
        match = re.search(SchedProcFSNode._re_procfs_node, node)
        if match:
            return match.group("name")
        return node
    @classmethod
    def _packable(cls, node):
        """
        :returns: Whether it makes sense to pack a node into a common entry
        """
        return (SchedProcFSNode._ends_with_digits(node) and
                SchedProcFSNode._node_name(node) in cls.PACKABLE_ENTRIES)
    @staticmethod
    def _build_directory(node_name, node_data):
        if node_name.startswith("domain"):
            return SchedDomain(node_data)
        else:
            return SchedProcFSNode(node_data)
    @staticmethod
    def _build_entry(node_data):
        value = node_data
        # Most nodes just contain numerical data, try to convert
        try:
            value = int(value)
        except ValueError:
            pass
        return value
    @staticmethod
    def _build_node(node_name, node_data):
        if isinstance(node_data, dict):
            return SchedProcFSNode._build_directory(node_name, node_data)
        else:
            return SchedProcFSNode._build_entry(node_data)
    def __getattr__(self, name):
        return self._dyn_attrs[name]
    def __init__(self, nodes):
        self.procfs = nodes
        # First, reduce the procs fields by packing them if possible
        # Find which entries can be packed into a common entry
        packables = {
            node : SchedProcFSNode._node_name(node) + "s"
            for node in list(nodes.keys()) if SchedProcFSNode._packable(node)
        }
        self._dyn_attrs = {}
        for dest in set(packables.values()):
            self._dyn_attrs[dest] = {}
        # Pack common entries
        for key, dest in packables.items():
            i = SchedProcFSNode._node_digits(key)
            self._dyn_attrs[dest][i] = self._build_node(key, nodes[key])
        # Build the other nodes
        for key in nodes.keys():
            if key in packables:
                continue
            self._dyn_attrs[key] = self._build_node(key, nodes[key])
 class _SchedDomainFlag:
    """
    Backward-compatible emulation of the former :class:`enum.Enum` that will
    work on recent kernels with dynamic sched domain flags name and no value
    exposed.
    """
    _INSTANCES = {}
    """
    Dictionary storing the instances so that they can be compared with ``is``
    operator.
    """
    def __new__(cls, name, value, doc=None):
        self = super().__new__(cls)
        self.name = name
        self._value = value
        self.__doc__ = doc
        return cls._INSTANCES.setdefault(self, self)
    def __eq__(self, other):
        # We *have to* check for "value" as well, otherwise it will be
        # impossible to keep in the same set 2 instances with differing values.
        return self.name == other.name and self._value == other._value
    def __hash__(self):
        return hash((self.name, self._value))
    @property
    def value(self):
        value = self._value
        if value is None:
            raise AttributeError('The kernel does not expose the sched domain flag values')
        else:
            return value
    @staticmethod
    def check_version(target, logger):
        """
        Check the target and see if its kernel version matches our view of the world
        """
        parts = target.kernel_version.parts
        # Checked to be valid from v4.4
        # Not saved as a class attribute else it'll be converted to an enum
        ref_parts = (4, 4, 0)
        if parts < ref_parts:
            logger.warn(
                "Sched domain flags are defined for kernels v{} and up, "
                "but target is running v{}".format(ref_parts, parts)
            )
    def __str__(self):
        return self.name
    def __repr__(self):
        return '<SchedDomainFlag: {}>'.format(self.name)
 class _SchedDomainFlagMeta(type):
    """
    Metaclass of :class:`SchedDomainFlag`.
    Provides some level of emulation of :class:`enum.Enum` behavior for
    backward compatibility.
    """
    @property
    def _flags(self):
        return [
            attr
            for name, attr in self.__dict__.items()
            if name.startswith('SD_')
        ]
    def __getitem__(self, i):
        return self._flags[i]
    def __len__(self):
        return len(self._flags)
    # These would be provided by collections.abc.Sequence, but using it on a
    # metaclass seems to have issues around __init_subclass__
    def __iter__(self):
        return iter(self._flags)
    def __reversed__(self):
        return reversed(self._flags)
    def __contains__(self, x):
        return x in self._flags
    @property
    def __members__(self):
        return {flag.name: flag for flag in self._flags}
 class SchedDomainFlag(_SchedDomainFlag, metaclass=_SchedDomainFlagMeta):
    """
    Represents a sched domain flag.
    .. note:: ``SD_*`` class attributes are deprecated, new code should never
        test a given flag against one of these attributes with ``is`` (.e.g ``x
        is SchedDomainFlag.SD_LOAD_BALANCE``. This is because the
        ``SD_LOAD_BALANCE`` flag exists in two flavors that are not equal: one
        with a value (the class attribute) and one without (dynamically created
        when parsing flags for new kernels). Old code ran on old kernels should
        work fine though.
    """
    # pylint: disable=bad-whitespace
    # Domain flags obtained from include/linux/sched/topology.h on v4.17
    # https://kernel.googlesource.com/pub/scm/linux/kernel/git/torvalds/linux/+/v4.17/include/linux/sched/topology.h#20
    SD_LOAD_BALANCE =        _SchedDomainFlag("SD_LOAD_BALANCE", 0x0001, "Do load balancing on this domain")
    SD_BALANCE_NEWIDLE =     _SchedDomainFlag("SD_BALANCE_NEWIDLE", 0x0002, "Balance when about to become idle")
    SD_BALANCE_EXEC =        _SchedDomainFlag("SD_BALANCE_EXEC", 0x0004, "Balance on exec")
    SD_BALANCE_FORK =        _SchedDomainFlag("SD_BALANCE_FORK", 0x0008, "Balance on fork, clone")
    SD_BALANCE_WAKE =        _SchedDomainFlag("SD_BALANCE_WAKE", 0x0010, "Balance on wakeup")
    SD_WAKE_AFFINE =         _SchedDomainFlag("SD_WAKE_AFFINE", 0x0020, "Wake task to waking CPU")
    SD_ASYM_CPUCAPACITY =    _SchedDomainFlag("SD_ASYM_CPUCAPACITY", 0x0040, "Groups have different max cpu capacities")
    SD_SHARE_CPUCAPACITY =   _SchedDomainFlag("SD_SHARE_CPUCAPACITY", 0x0080, "Domain members share cpu capacity")
    SD_SHARE_POWERDOMAIN =   _SchedDomainFlag("SD_SHARE_POWERDOMAIN", 0x0100, "Domain members share power domain")
    SD_SHARE_PKG_RESOURCES = _SchedDomainFlag("SD_SHARE_PKG_RESOURCES", 0x0200, "Domain members share cpu pkg resources")
    SD_SERIALIZE =           _SchedDomainFlag("SD_SERIALIZE", 0x0400, "Only a single load balancing instance")
    SD_ASYM_PACKING =        _SchedDomainFlag("SD_ASYM_PACKING", 0x0800, "Place busy groups earlier in the domain")
    SD_PREFER_SIBLING =      _SchedDomainFlag("SD_PREFER_SIBLING", 0x1000, "Prefer to place tasks in a sibling domain")
    SD_OVERLAP =             _SchedDomainFlag("SD_OVERLAP", 0x2000, "Sched_domains of this level overlap")
    SD_NUMA =                _SchedDomainFlag("SD_NUMA", 0x4000, "Cross-node balancing")
    # Only defined in Android
    # https://android.googlesource.com/kernel/common/+/android-4.14/include/linux/sched/topology.h#29
    SD_SHARE_CAP_STATES =    _SchedDomainFlag("SD_SHARE_CAP_STATES", 0x8000, "(Android only) Domain members share capacity state")
 class SchedDomain(SchedProcFSNode):
    """
    Represents a sched domain as seen through procfs
    """
    def __init__(self, nodes):
        super().__init__(nodes)
        flags = self.flags
        # Recent kernels now have a space-separated list of flags instead of a
        # packed bitfield
        if isinstance(flags, str):
            flags = {
                _SchedDomainFlag(name=name, value=None)
                for name in flags.split()
            }
        else:
            def has_flag(flags, flag):
                return flags & flag.value == flag.value
            flags = {
                flag
                for flag in SchedDomainFlag
                if has_flag(flags, flag)
            }
        self.flags = flags
 def _select_path(target, paths, name):
    for p in paths:
        if target.file_exists(p):
            return p
    raise TargetStableError('No {} found. Tried: {}'.format(name, ', '.join(paths)))
 class SchedProcFSData(SchedProcFSNode):
    """
    Root class for creating & storing SchedProcFSNode instances
    """
    _read_depth = 6
    @classmethod
    def get_data_root(cls, target):
        # Location differs depending on kernel version
        paths = ['/sys/kernel/debug/sched/domains/', '/proc/sys/kernel/sched_domain']
        return _select_path(target, paths, "sched_domain debug directory")
    @staticmethod
    def available(target):
        try:
            path = SchedProcFSData.get_data_root(target)
        except TargetStableError:
            return False
        cpus = target.list_directory(path, as_root=target.is_rooted)
        if not cpus:
            return False
        # Even if we have a CPU entry, it can be empty (e.g. hotplugged out)
        # Make sure some data is there
        for cpu in cpus:
            if target.file_exists(target.path.join(path, cpu, "domain0", "flags")):
                return True
        return False
    def __init__(self, target, path=None):
        if path is None:
            path = SchedProcFSData.get_data_root(target)
        procfs = target.read_tree_values(path, depth=self._read_depth)
        super(SchedProcFSData, self).__init__(procfs)
 class SchedModule(Module):
    name = 'sched'
    cpu_sysfs_root = '/sys/devices/system/cpu'
    @staticmethod
    def probe(target):
        logger = logging.getLogger(SchedModule.name)
        SchedDomainFlag.check_version(target, logger)
        # It makes sense to load this module if at least one of those
        # functionalities is enabled
        schedproc = SchedProcFSData.available(target)
        debug = SchedModule.target_has_debug(target)
        dmips = any([target.file_exists(SchedModule.cpu_dmips_capacity_path(target, cpu))
                     for cpu in target.list_online_cpus()])
        logger.info("Scheduler sched_domain procfs entries %s",
                    "found" if schedproc else "not found")
        logger.info("Detected kernel compiled with SCHED_DEBUG=%s",
                    "y" if debug else "n")
        logger.info("CPU capacity sysfs entries %s",
                    "found" if dmips else "not found")
        return schedproc or debug or dmips
    def __init__(self, target):
        super().__init__(target)
    @classmethod
    def get_sched_features_path(cls, target):
        # Location differs depending on kernel version
        paths = ['/sys/kernel/debug/sched/features', '/sys/kernel/debug/sched_features']
        return _select_path(target, paths, "sched_features file")
    def get_kernel_attributes(self, matching=None, check_exit_code=True):
        """
        Get the value of scheduler attributes.
        :param matching: an (optional) substring to filter the scheduler
        attributes to be returned.
        The scheduler exposes a list of tunable attributes under:
            /proc/sys/kernel
        all starting with the "sched_" prefix.
        This method returns a dictionary of all the "sched_" attributes exposed
        by the target kernel, within the prefix removed.
        It's possible to restrict the list of attributes by specifying a
        substring to be matched.
        returns: a dictionary of scheduler tunables
        """
        command = 'sched_get_kernel_attributes {}'.format(
            matching if matching else ''
        )
        output = self.target._execute_util(command, as_root=self.target.is_rooted,
                                           check_exit_code=check_exit_code)
        result = {}
        for entry in output.strip().split('\n'):
            if ':' not in entry:
                continue
            path, value = entry.strip().split(':', 1)
            if value in ['0', '1']:
                value = bool(int(value))
            elif value.isdigit():
                value = int(value)
            result[path] = value
        return result
    def set_kernel_attribute(self, attr, value, verify=True):
        """
        Set the value of a scheduler attribute.
        :param attr: the attribute to set, without the "sched_" prefix
        :param value: the value to set
        :param verify: true to check that the requested value has been set
        :raise TargetError: if the attribute cannot be set
        """
        if isinstance(value, bool):
            value = '1' if value else '0'
        elif isinstance(value, int):
            value = str(value)
        path = '/proc/sys/kernel/sched_' + attr
        self.target.write_value(path, value, verify)
    @classmethod
    def target_has_debug(cls, target):
        if target.config.get('SCHED_DEBUG') != 'y':
            return False
        try:
            cls.get_sched_features_path(target)
            return True
        except TargetStableError:
            return False
    def get_features(self):
        """
        Get the status of each sched feature
        :returns: a dictionary of features and their "is enabled" status
        """
        feats = self.target.read_value(self.get_sched_features_path(self.target))
        features = {}
        for feat in feats.split():
            value = True
            if feat.startswith('NO'):
                feat = feat.replace('NO_', '', 1)
                value = False
            features[feat] = value
        return features
    def set_feature(self, feature, enable, verify=True):
        """
        Set the status of a specified scheduler feature
        :param feature: the feature name to set
        :param enable: true to enable the feature, false otherwise
        :raise ValueError: if the specified enable value is not bool
        :raise RuntimeError: if the specified feature cannot be set
        """
        feature = feature.upper()
        feat_value = feature
        if not boolean(enable):
            feat_value = 'NO_' + feat_value
        self.target.write_value(self.get_sched_features_path(self.target),
                                feat_value, verify=False)
        if not verify:
            return
        msg = 'Failed to set {}, feature not supported?'.format(feat_value)
        features = self.get_features()
        feat_value = features.get(feature, not enable)
        if feat_value != enable:
            raise RuntimeError(msg)
    def get_cpu_sd_info(self, cpu):
        """
        :returns: An object view of the sched_domain debug directory of 'cpu'
        """
        path = self.target.path.join(
            SchedProcFSData.get_data_root(self.target),
            "cpu{}".format(cpu)
        )
        return SchedProcFSData(self.target, path)
    def get_sd_info(self):
        """
        :returns: An object view of the entire sched_domain debug directory
        """
        return SchedProcFSData(self.target)
    def get_capacity(self, cpu):
        """
        :returns: The capacity of 'cpu'
        """
        return self.get_capacities()[cpu]
    @memoized
    def has_em(self, cpu, sd=None):
        """
        :returns: Whether energy model data is available for 'cpu'
        """
        if not sd:
            sd = self.get_cpu_sd_info(cpu)
        return sd.procfs["domain0"].get("group0", {}).get("energy", {}).get("cap_states") != None
    @classmethod
    def cpu_dmips_capacity_path(cls, target, cpu):
        """
        :returns: The target sysfs path where the dmips capacity data should be
        """
        return target.path.join(
            cls.cpu_sysfs_root,
            'cpu{}/cpu_capacity'.format(cpu))
    @memoized
    def has_dmips_capacity(self, cpu):
        """
        :returns: Whether dmips capacity data is available for 'cpu'
        """
        return self.target.file_exists(
            self.cpu_dmips_capacity_path(self.target, cpu)
        )
    @memoized
    def get_em_capacity(self, cpu, sd=None):
        """
        :returns: The maximum capacity value exposed by the EAS energy model
        """
        if not sd:
            sd = self.get_cpu_sd_info(cpu)
        cap_states = sd.domains[0].groups[0].energy.cap_states
        cap_states_list = cap_states.split('\t')
        num_cap_states = sd.domains[0].groups[0].energy.nr_cap_states
        max_cap_index = -1 * int(len(cap_states_list) / num_cap_states)
        return int(cap_states_list[max_cap_index])
    @memoized
    def get_dmips_capacity(self, cpu):
        """
        :returns: The capacity value generated from the capacity-dmips-mhz DT entry
        """
        return self.target.read_value(
            self.cpu_dmips_capacity_path(self.target, cpu), int
        )
    def get_capacities(self, default=None):
        """
        :param default: Default capacity value to find if no data is
        found in procfs
        :returns: a dictionnary of the shape {cpu : capacity}
        :raises RuntimeError: Raised when no capacity information is
        found and 'default' is None
        """
        cpus = self.target.list_online_cpus()
        capacities = {}
        for cpu in cpus:
            if self.has_dmips_capacity(cpu):
                capacities[cpu] = self.get_dmips_capacity(cpu)
        missing_cpus = set(cpus).difference(capacities.keys())
        if not missing_cpus:
            return capacities
        if not SchedProcFSData.available(self.target):
            if default != None:
                capacities.update({cpu : default for cpu in missing_cpus})
                return capacities
            else:
                raise RuntimeError(
                    'No capacity data for cpus {}'.format(sorted(missing_cpus)))
        sd_info = self.get_sd_info()
        for cpu in missing_cpus:
            if self.has_em(cpu, sd_info.cpus[cpu]):
                capacities[cpu] = self.get_em_capacity(cpu, sd_info.cpus[cpu])
            else:
                if default != None:
                    capacities[cpu] = default
                else:
                    raise RuntimeError('No capacity data for cpu{}'.format(cpu))
        return capacities
    @memoized
    def get_hz(self):
        """
        :returns: The scheduler tick frequency on the target
        """
        return int(self.target.config.get('CONFIG_HZ', strict=True))
--- a/devlib/module/thermal.py
+++ b/devlib/module/thermal.py
@@ -1,197 +0,0 @@
 #    Copyright 2015-2018 ARM Limited
 #
 # 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.
 import re
 import logging
 import devlib.utils.asyn as asyn
 from devlib.module import Module
 from devlib.exception import TargetStableCalledProcessError
 class TripPoint(object):
    def __init__(self, zone, _id):
        self._id = _id
        self.zone = zone
        self.temp_node = 'trip_point_' + _id + '_temp'
        self.type_node = 'trip_point_' + _id + '_type'
    @property
    def target(self):
        return self.zone.target
    @asyn.asyncf
    async def get_temperature(self):
        """Returns the currently configured temperature of the trip point"""
        temp_file = self.target.path.join(self.zone.path, self.temp_node)
        return await self.target.read_int.asyn(temp_file)
    @asyn.asyncf
    async def set_temperature(self, temperature):
        temp_file = self.target.path.join(self.zone.path, self.temp_node)
        await self.target.write_value.asyn(temp_file, temperature)
    @asyn.asyncf
    async def get_type(self):
        """Returns the type of trip point"""
        type_file = self.target.path.join(self.zone.path, self.type_node)
        return await self.target.read_value.asyn(type_file)
 class ThermalZone(object):
    def __init__(self, target, root, _id):
        self.target = target
        self.name = 'thermal_zone' + _id
        self.path = target.path.join(root, self.name)
        self.trip_points = {}
        self.type = self.target.read_value(self.target.path.join(self.path, 'type'))
        for entry in self.target.list_directory(self.path, as_root=target.is_rooted):
            re_match = re.match('^trip_point_([0-9]+)_temp', entry)
            if re_match is not None:
                self._add_trip_point(re_match.group(1))
    def _add_trip_point(self, _id):
        self.trip_points[int(_id)] = TripPoint(self, _id)
    @asyn.asyncf
    async def is_enabled(self):
        """Returns a boolean representing the 'mode' of the thermal zone"""
        value = await self.target.read_value.asyn(self.target.path.join(self.path, 'mode'))
        return value == 'enabled'
    @asyn.asyncf
    async def set_enabled(self, enabled=True):
        value = 'enabled' if enabled else 'disabled'
        await self.target.write_value.asyn(self.target.path.join(self.path, 'mode'), value)
    @asyn.asyncf
    async def get_temperature(self):
        """Returns the temperature of the thermal zone"""
        sysfs_temperature_file = self.target.path.join(self.path, 'temp')
        return await self.target.read_int.asyn(sysfs_temperature_file)
    @asyn.asyncf
    async def get_policy(self):
        """Returns the policy of the thermal zone"""
        temp_file = self.target.path.join(self.path, 'policy')
        return await self.target.read_value.asyn(temp_file)
    @asyn.asyncf
    async def set_policy(self, policy):
        """
        Sets the policy of the thermal zone
        :params policy: Thermal governor name
        :type policy: str
        """
        await self.target.write_value.asyn(self.target.path.join(self.path, 'policy'), policy)
    @asyn.asyncf
    async def get_offset(self):
        """Returns the temperature offset of the thermal zone"""
        offset_file = self.target.path.join(self.path, 'offset')
        return await self.target.read_value.asyn(offset_file)
    @asyn.asyncf
    async def set_offset(self, offset):
        """
        Sets the temperature offset in milli-degrees of the thermal zone
        :params offset: Temperature offset in milli-degrees
        :type policy: int
        """
        await self.target.write_value.asyn(self.target.path.join(self.path, 'offset'), policy)
    @asyn.asyncf
    async def set_emul_temp(self, offset):
        """
        Sets the emulated temperature in milli-degrees of the thermal zone
        :params offset: Emulated temperature in milli-degrees
        :type policy: int
        """
        await self.target.write_value.asyn(self.target.path.join(self.path, 'emul_temp'), policy)
    @asyn.asyncf
    async def get_available_policies(self):
        """Returns the policies available for the thermal zone"""
        temp_file = self.target.path.join(self.path, 'available_policies')
        return await self.target.read_value.asyn(temp_file)
 class ThermalModule(Module):
    name = 'thermal'
    thermal_root = '/sys/class/thermal'
    @staticmethod
    def probe(target):
        if target.file_exists(ThermalModule.thermal_root):
            return True
    def __init__(self, target):
        super(ThermalModule, self).__init__(target)
        self.logger = logging.getLogger(self.name)
        self.logger.debug('Initialized [%s] module', self.name)
        self.zones = {}
        self.cdevs = []
        for entry in target.list_directory(self.thermal_root):
            re_match = re.match('^(thermal_zone|cooling_device)([0-9]+)', entry)
            if not re_match:
                self.logger.warning('unknown thermal entry: %s', entry)
                continue
            if re_match.group(1) == 'thermal_zone':
                self._add_thermal_zone(re_match.group(2))
            elif re_match.group(1) == 'cooling_device':
                # TODO
                pass
    def _add_thermal_zone(self, _id):
        self.zones[int(_id)] = ThermalZone(self.target, self.thermal_root, _id)
    def disable_all_zones(self):
        """Disables all the thermal zones in the target"""
        for zone in self.zones.values():
            zone.set_enabled(False)
    @asyn.asyncf
    async def get_all_temperatures(self, error='raise'):
        """
        Returns dictionary with current reading of all thermal zones.
        :params error: Sensor read error handling (raise or ignore)
        :type error: str
        :returns: a dictionary in the form: {tz_type:temperature}
        """
        async def get_temperature_noexcep(item):
            tzid, tz = item
            try:
                temperature = await tz.get_temperature.asyn()
            except TargetStableCalledProcessError as e:
                if error == 'raise':
                    raise e
                elif error == 'ignore':
                    self.logger.warning(f'Skipping thermal_zone_id={tzid} thermal_zone_type={tz.type} error="{e}"')
                    return None
                else:
                    raise ValueError(f'Unknown error parameter value: {error}')
            return temperature
        tz_temps = await self.target.async_manager.map_concurrently(get_temperature_noexcep, self.zones.items())
        return {tz.type: temperature for (tzid, tz), temperature in tz_temps.items() if temperature is not None}
--- a/devlib/module/vexpress.py
+++ b/devlib/module/vexpress.py
@@ -1,5 +1,5 @@
 #
-#    Copyright 2015-2018 ARM Limited
+#    Copyright 2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,18 +17,15 @@ import os
 import time
 import tarfile
 import shutil
 from subprocess import CalledProcessError
 from devlib.module import HardRestModule, BootModule, FlashModule
-from devlib.exception import TargetError, TargetStableError, HostError
+from devlib.exception import TargetError, HostError
 from devlib.utils.misc import safe_extract
 from devlib.utils.serial_port import open_serial_connection, pulse_dtr, write_characters
 from devlib.utils.uefi import UefiMenu, UefiConfig
 from devlib.utils.uboot import UbootMenu
-OLD_AUTOSTART_MESSAGE = 'Press Enter to stop auto boot...'
+AUTOSTART_MESSAGE = 'Press Enter to stop auto boot...'
 AUTOSTART_MESSAGE = 'Hit any key to stop autoboot:'
 POWERUP_MESSAGE = 'Powering up system...'
 DEFAULT_MCC_PROMPT = 'Cmd>'
@@ -54,7 +51,7 @@ class VexpressDtrHardReset(HardRestModule):
        try:
            if self.target.is_connected:
                self.target.execute('sync')
-        except (TargetError, CalledProcessError):
+        except TargetError:
            pass
        with open_serial_connection(port=self.port,
                                    baudrate=self.baudrate,
@@ -90,7 +87,7 @@ class VexpressReboottxtHardReset(HardRestModule):
        try:
            if self.target.is_connected:
                self.target.execute('sync')
-        except (TargetError, CalledProcessError):
+        except TargetError:
            pass
        if not os.path.exists(self.path):
@@ -131,7 +128,7 @@ class VexpressBootModule(BootModule):
                                    init_dtr=0) as tty:
            self.get_through_early_boot(tty)
            self.perform_boot_sequence(tty)
-            self.wait_for_shell_prompt(tty)
+            self.wait_for_android_prompt(tty)
    def perform_boot_sequence(self, tty):
        raise NotImplementedError()
@@ -139,20 +136,18 @@ class VexpressBootModule(BootModule):
    def get_through_early_boot(self, tty):
        self.logger.debug('Establishing initial state...')
        tty.sendline('')
-        i = tty.expect([AUTOSTART_MESSAGE, OLD_AUTOSTART_MESSAGE, POWERUP_MESSAGE, self.mcc_prompt])
+        i = tty.expect([AUTOSTART_MESSAGE, POWERUP_MESSAGE, self.mcc_prompt])
-        if i == 3:
+        if i == 2:
            self.logger.debug('Saw MCC prompt.')
            time.sleep(self.short_delay)
            tty.sendline('reboot')
-        elif i == 2:
+        elif i == 1:
            self.logger.debug('Saw powering up message (assuming soft reboot).')
        else:
            self.logger.debug('Saw auto boot message.')
            tty.sendline('')
            time.sleep(self.short_delay)
            # could be either depending on where in the boot we are
            tty.sendline('reboot')
            tty.sendline('reset')
    def get_uefi_menu(self, tty):
        menu = UefiMenu(tty)
@@ -160,8 +155,8 @@ class VexpressBootModule(BootModule):
        menu.wait(timeout=self.timeout)
        return menu
-    def wait_for_shell_prompt(self, tty):
+    def wait_for_android_prompt(self, tty):
-        self.logger.debug('Waiting for the shell prompt.')
+        self.logger.debug('Waiting for the Android prompt.')
        tty.expect(self.target.shell_prompt, timeout=self.timeout)
        # This delay is needed to allow the platform some time to finish
        # initilizing; querying the ip address too early from connect() may
@@ -210,7 +205,6 @@ class VexpressUefiShellBoot(VexpressBootModule):
    name = 'vexpress-uefi-shell'
    # pylint: disable=keyword-arg-before-vararg
    def __init__(self, target, uefi_entry='^Shell$',
                 efi_shell_prompt='Shell>',
                 image='kernel', bootargs=None,
@@ -226,7 +220,7 @@ class VexpressUefiShellBoot(VexpressBootModule):
        try:
            menu.select(self.uefi_entry)
        except LookupError:
-            raise TargetStableError('Did not see "{}" UEFI entry.'.format(self.uefi_entry))
+            raise TargetError('Did not see "{}" UEFI entry.'.format(self.uefi_entry))
        tty.expect(self.efi_shell_prompt, timeout=self.timeout)
        if self.bootargs:
            tty.sendline('')  # stop default boot
@@ -241,7 +235,6 @@ class VexpressUBoot(VexpressBootModule):
    name = 'vexpress-u-boot'
    # pylint: disable=keyword-arg-before-vararg
    def __init__(self, target, env=None,
                 *args, **kwargs):
        super(VexpressUBoot, self).__init__(target, *args, **kwargs)
@@ -254,7 +247,7 @@ class VexpressUBoot(VexpressBootModule):
        menu = UbootMenu(tty)
        self.logger.debug('Waiting for U-Boot prompt...')
        menu.open(timeout=120)
-        for var, value in self.env.items():
+        for var, value in self.env.iteritems():
            menu.setenv(var, value)
        menu.boot()
@@ -263,7 +256,6 @@ class VexpressBootmon(VexpressBootModule):
    name = 'vexpress-bootmon'
    # pylint: disable=keyword-arg-before-vararg
    def __init__(self, target,
                 image, fdt, initrd, bootargs,
                 uses_bootscript=False,
@@ -286,11 +278,11 @@ class VexpressBootmon(VexpressBootModule):
        with open_serial_connection(port=self.port,
                                    baudrate=self.baudrate,
                                    timeout=self.timeout,
-                                    init_dtr=0) as tty_conn:
+                                    init_dtr=0) as tty:
-            write_characters(tty_conn, 'fl linux fdt {}'.format(self.fdt))
+            write_characters(tty, 'fl linux fdt {}'.format(self.fdt))
-            write_characters(tty_conn, 'fl linux initrd {}'.format(self.initrd))
+            write_characters(tty, 'fl linux initrd {}'.format(self.initrd))
-            write_characters(tty_conn, 'fl linux boot {} {}'.format(self.image,
+            write_characters(tty, 'fl linux boot {} {}'.format(self.image,
-                                                                    self.bootargs))
+                                                               self.bootargs))
 class VersatileExpressFlashModule(FlashModule):
@@ -326,16 +318,15 @@ class VersatileExpressFlashModule(FlashModule):
        self.timeout = timeout
        self.short_delay = short_delay
-    def __call__(self, image_bundle=None, images=None, bootargs=None, connect=True):
+    def __call__(self, image_bundle=None, images=None, bootargs=None):
        self.target.hard_reset()
        with open_serial_connection(port=self.target.platform.serial_port,
                                    baudrate=self.target.platform.baudrate,
                                    timeout=self.timeout,
                                    init_dtr=0) as tty:
-            # pylint: disable=no-member
+            i = tty.expect([self.mcc_prompt, AUTOSTART_MESSAGE])
            i = tty.expect([self.mcc_prompt, AUTOSTART_MESSAGE, OLD_AUTOSTART_MESSAGE])
            if i:
-                tty.sendline('')  # pylint: disable=no-member
+                tty.sendline('')
            wait_for_vemsd(self.vemsd_mount, tty, self.mcc_prompt, self.short_delay)
        try:
            if image_bundle:
@@ -343,22 +334,21 @@ class VersatileExpressFlashModule(FlashModule):
            if images:
                self._overlay_images(images)
            os.system('sync')
-        except (IOError, OSError) as e:
+        except (IOError, OSError), e:
            msg = 'Could not deploy images to {}; got: {}'
-            raise TargetStableError(msg.format(self.vemsd_mount, e))
+            raise TargetError(msg.format(self.vemsd_mount, e))
        self.target.boot()
-        if connect:
+        self.target.connect(timeout=30)
            self.target.connect(timeout=30)
    def _deploy_image_bundle(self, bundle):
        self.logger.debug('Validating {}'.format(bundle))
        validate_image_bundle(bundle)
        self.logger.debug('Extracting {} into {}...'.format(bundle, self.vemsd_mount))
        with tarfile.open(bundle) as tar:
-            safe_extract(tar, self.vemsd_mount)
+            tar.extractall(self.vemsd_mount)
    def _overlay_images(self, images):
-        for dest, src in images.items():
+        for dest, src in images.iteritems():
            dest = os.path.join(self.vemsd_mount, dest)
            self.logger.debug('Copying {} to {}'.format(src, dest))
            shutil.copy(src, dest)
@@ -385,11 +375,12 @@ def wait_for_vemsd(vemsd_mount, tty, mcc_prompt=DEFAULT_MCC_PROMPT, short_delay=
    path = os.path.join(vemsd_mount, 'config.txt')
    if os.path.exists(path):
        return
-    for _ in range(attempts):
+    for _ in xrange(attempts):
        tty.sendline('')  # clear any garbage
        tty.expect(mcc_prompt, timeout=short_delay)
        tty.sendline('usb_on')
        time.sleep(short_delay * 3)
        if os.path.exists(path):
            return
-    raise TargetStableError('Could not mount {}'.format(vemsd_mount))
+    raise TargetError('Could not mount {}'.format(vemsd_mount))
--- a/devlib/platform/init.py
+++ b/devlib/platform/init.py
@@ -1,24 +1,6 @@
 #    Copyright 2018 ARM Limited
 #
 # 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.
 #
 import logging
 BIG_CPUS = ['A15', 'A57', 'A72', 'A73']
 class Platform(object):
    @property
@@ -43,6 +25,7 @@ class Platform(object):
        self.logger = logging.getLogger(self.name)
        if not self.core_clusters and self.core_names:
            self._set_core_clusters_from_core_names()
        self._validate()
    def init_target_connection(self, target):
        # May be ovewritten by subclasses to provide target-specific
@@ -54,7 +37,8 @@ class Platform(object):
            self.core_names = target.cpuinfo.cpu_names
            self._set_core_clusters_from_core_names()
        if not self.big_core and self.number_of_clusters == 2:
-            self.big_core = self._identify_big_core()
+            big_idx = self.core_clusters.index(max(self.core_clusters))
            self.big_core = self.core_names[big_idx]
        if not self.core_clusters and self.core_names:
            self._set_core_clusters_from_core_names()
        if not self.model:
@@ -63,11 +47,6 @@ class Platform(object):
            self.name = self.model
        self._validate()
    def setup(self, target):
        # May be overwritten by subclasses to provide platform-specific
        # setup procedures.
        pass
    def _set_core_clusters_from_core_names(self):
        self.core_clusters = []
        clusters = []
@@ -78,16 +57,7 @@ class Platform(object):
    def _set_model_from_target(self, target):
        if target.os == 'android':
-            try:
+            self.model = target.getprop('ro.product.model')
                self.model = target.getprop(prop='ro.product.device')
            except KeyError:
                self.model = target.getprop('ro.product.model')
        elif target.file_exists("/proc/device-tree/model"):
            # There is currently no better way to do this cross platform.
            # ARM does not have dmidecode
            raw_model = target.execute("cat /proc/device-tree/model")
            device_model_to_return = '_'.join(raw_model.split()[:2])
            return device_model_to_return.rstrip(' \t\r\n\0')
        elif target.is_rooted:
            try:
                self.model = target.execute('dmidecode -s system-version',
@@ -95,13 +65,6 @@ class Platform(object):
            except Exception:  # pylint: disable=broad-except
                pass  # this is best-effort
    def _identify_big_core(self):
        for core in self.core_names:
            if core.upper() in BIG_CPUS:
                return core
        big_idx = self.core_clusters.index(max(self.core_clusters))
        return self.core_names[big_idx]
    def _validate(self):
        if len(self.core_names) != len(self.core_clusters):
            raise ValueError('core_names and core_clusters are of different lengths.')
@@ -113,7 +76,6 @@ class Platform(object):
            raise ValueError(message.format(self.big_core,
                                            ', '.join(set(self.core_names))))
        if self.big_core:
-            for core in self.core_names:
+            little_idx = self.core_clusters.index(min(self.core_clusters))
-                if core != self.big_core:
+            self.little_core = self.core_names[little_idx]
-                    self.little_core = core
+
                    break
--- a/devlib/platform/arm.py
+++ b/devlib/platform/arm.py
@@ -1,4 +1,4 @@
-#    Copyright 2015-2024 ARM Limited
+#    Copyright 2015 ARM Limited
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,17 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 from __future__ import division
 import os
 import tempfile
 import csv
 import time
 import pexpect
 from devlib.exception import HostError, TargetTransientError
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.instrument import (Instrument, InstrumentChannel, MeasurementsCsv,
                               Measurement, CONTINUOUS, INSTANTANEOUS)
 from devlib.platform import Platform
-from devlib.utils.csvutil import csvreader, csvwriter
+from devlib.instrument import Instrument, InstrumentChannel, MeasurementsCsv, CONTINUOUS
 from devlib.exception import TargetError, HostError
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.utils.serial_port import open_serial_connection
@@ -33,7 +33,6 @@ class VersatileExpressPlatform(Platform):
                 core_names=None,
                 core_clusters=None,
                 big_core=None,
                 model=None,
                 modules=None,
                 # serial settings
@@ -62,7 +61,6 @@ class VersatileExpressPlatform(Platform):
                                                       core_names,
                                                       core_clusters,
                                                       big_core,
                                                       model,
                                                       modules)
        self.serial_port = serial_port
        self.baudrate = baudrate
@@ -95,32 +93,27 @@ class VersatileExpressPlatform(Platform):
            addr = self._get_target_ip_address(target)
            target.connection_settings['host'] = addr
    # pylint: disable=no-member
    def _get_target_ip_address(self, target):
        with open_serial_connection(port=self.serial_port,
                                    baudrate=self.baudrate,
                                    timeout=30,
                                    init_dtr=0) as tty:
-            tty.sendline('su')  # this is, apprently, required to query network device
+            tty.sendline('')
-                                # info by name on recent Juno builds...
+            self.logger.debug('Waiting for the Android shell prompt.')
            self.logger.debug('Waiting for the shell prompt.')
            tty.expect(target.shell_prompt)
            self.logger.debug('Waiting for IP address...')
            wait_start_time = time.time()
-            try:
+            while True:
-                while True:
+                tty.sendline('ip addr list eth0')
-                    tty.sendline('ip addr list eth0')
+                time.sleep(1)
-                    time.sleep(1)
+                try:
-                    try:
+                    tty.expect(r'inet ([1-9]\d*.\d+.\d+.\d+)', timeout=10)
-                        tty.expect(r'inet ([1-9]\d*.\d+.\d+.\d+)', timeout=10)
+                    return tty.match.group(1)
-                        return tty.match.group(1).decode('utf-8')
+                except pexpect.TIMEOUT:
-                    except pexpect.TIMEOUT:
+                    pass  # We have our own timeout -- see below.
-                        pass  # We have our own timeout -- see below.
+                if (time.time() - wait_start_time) > self.ready_timeout:
-                    if (time.time() - wait_start_time) > self.ready_timeout:
+                    raise TargetError('Could not acquire IP address.')
                        raise TargetTransientError('Could not acquire IP address.')
            finally:
                tty.sendline('exit')  # exit shell created by "su" call at the start
    def _set_hard_reset_method(self, hard_reset_method):
        if hard_reset_method == 'dtr':
@@ -152,12 +145,9 @@ class VersatileExpressPlatform(Platform):
                                                         'bootargs': self.bootargs,
                                                         }})
        elif self.bootloader == 'u-boot':
            uboot_env = None
            if self.bootargs:
                uboot_env = {'bootargs': self.bootargs}
            self.modules.append({'vexpress-u-boot': {'port': self.serial_port,
                                                     'baudrate': self.baudrate,
-                                                     'env': uboot_env,
+                                                     'env': {'bootargs': self.bootargs},
                                                     }})
        elif self.bootloader == 'bootmon':
            self.modules.append({'vexpress-bootmon': {'port': self.serial_port,
@@ -214,25 +204,25 @@ class TC2(VersatileExpressPlatform):
 class JunoEnergyInstrument(Instrument):
    binname = 'readenergy'
-    mode = CONTINUOUS | INSTANTANEOUS
+    mode = CONTINUOUS
    _channels = [
-        InstrumentChannel('sys', 'current'),
+        InstrumentChannel('sys_curr', 'sys', 'current'),
-        InstrumentChannel('a57', 'current'),
+        InstrumentChannel('a57_curr', 'a57', 'current'),
-        InstrumentChannel('a53', 'current'),
+        InstrumentChannel('a53_curr', 'a53', 'current'),
-        InstrumentChannel('gpu', 'current'),
+        InstrumentChannel('gpu_curr', 'gpu', 'current'),
-        InstrumentChannel('sys', 'voltage'),
+        InstrumentChannel('sys_volt', 'sys', 'voltage'),
-        InstrumentChannel('a57', 'voltage'),
+        InstrumentChannel('a57_volt', 'a57', 'voltage'),
-        InstrumentChannel('a53', 'voltage'),
+        InstrumentChannel('a53_volt', 'a53', 'voltage'),
-        InstrumentChannel('gpu', 'voltage'),
+        InstrumentChannel('gpu_volt', 'gpu', 'voltage'),
-        InstrumentChannel('sys', 'power'),
+        InstrumentChannel('sys_pow', 'sys', 'power'),
-        InstrumentChannel('a57', 'power'),
+        InstrumentChannel('a57_pow', 'a57', 'power'),
-        InstrumentChannel('a53', 'power'),
+        InstrumentChannel('a53_pow', 'a53', 'power'),
-        InstrumentChannel('gpu', 'power'),
+        InstrumentChannel('gpu_pow', 'gpu', 'power'),
-        InstrumentChannel('sys', 'energy'),
+        InstrumentChannel('sys_cenr', 'sys', 'energy'),
-        InstrumentChannel('a57', 'energy'),
+        InstrumentChannel('a57_cenr', 'a57', 'energy'),
-        InstrumentChannel('a53', 'energy'),
+        InstrumentChannel('a53_cenr', 'a53', 'energy'),
-        InstrumentChannel('gpu', 'energy'),
+        InstrumentChannel('gpu_cenr', 'gpu', 'energy'),
    ]
    def __init__(self, target):
@@ -243,18 +233,14 @@ class JunoEnergyInstrument(Instrument):
        for chan in self._channels:
            self.channels[chan.name] = chan
        self.on_target_file = self.target.tempfile('energy', '.csv')
        self.sample_rate_hz = 10 # DEFAULT_PERIOD is 100[ms] in readenergy.c
        self.command = '{} -o {}'.format(self.binary, self.on_target_file)
        self.command2 = '{}'.format(self.binary)
-    def setup(self):  # pylint: disable=arguments-differ
+    def setup(self):
        self.binary = self.target.install(os.path.join(PACKAGE_BIN_DIRECTORY,
                                                       self.target.abi, self.binname))
        self.command = '{} -o {}'.format(self.binary, self.on_target_file)
        self.command2 = '{}'.format(self.binary)
-    def reset(self, sites=None, kinds=None, channels=None):
+    def reset(self, sites=None, kinds=None):
-        super(JunoEnergyInstrument, self).reset(sites, kinds, channels)
+        super(JunoEnergyInstrument, self).reset(sites, kinds)
        self.target.killall(self.binname, as_root=True)
    def start(self):
@@ -263,14 +249,14 @@ class JunoEnergyInstrument(Instrument):
    def stop(self):
        self.target.killall(self.binname, signal='TERM', as_root=True)
    # pylint: disable=arguments-differ
    def get_data(self, output_file):
        temp_file = tempfile.mktemp()
        self.target.pull(self.on_target_file, temp_file)
        self.target.remove(self.on_target_file)
-        with csvreader(temp_file) as reader:
+        with open(temp_file, 'rb') as fh:
-            headings = next(reader)
+            reader = csv.reader(fh)
            headings = reader.next()
            # Figure out which columns from the collected csv we actually want
            select_columns = []
@@ -280,23 +266,15 @@ class JunoEnergyInstrument(Instrument):
                except ValueError:
                    raise HostError('Channel "{}" is not in {}'.format(chan.name, temp_file))
-            with csvwriter(output_file) as writer:
+            with open(output_file, 'wb') as wfh:
                write_headings = ['{}_{}'.format(c.site, c.kind)
                                  for c in self.active_channels]
                writer = csv.writer(wfh)
                writer.writerow(write_headings)
                for row in reader:
                    write_row = [row[c] for c in select_columns]
                    writer.writerow(write_row)
-        return MeasurementsCsv(output_file, self.active_channels, sample_rate_hz=10)
+        return MeasurementsCsv(output_file, self.active_channels)
    def take_measurement(self):
        result = []
        output = self.target.execute(self.command2).split()
        with csvreader(output) as reader:
            headings = next(reader)
            values = next(reader)
            for chan in self.active_channels:
                value = values[headings.index(chan.name)]
                result.append(Measurement(value, chan))
        return result
--- a/devlib/platform/gem5.py
+++ b/devlib/platform/gem5.py
@@ -1,303 +0,0 @@
 #    Copyright 2016-2018 ARM Limited
 #
 # 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.
 import os
 import re
 import subprocess
 import shutil
 import time
 import types
 import shlex
 from shlex import quote
 from devlib.exception import TargetStableError
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.platform import Platform
 from devlib.utils.ssh import AndroidGem5Connection, LinuxGem5Connection
 class Gem5SimulationPlatform(Platform):
    def __init__(self, name,
                 host_output_dir,
                 gem5_bin,
                 gem5_args,
                 gem5_virtio,
                 core_names=None,
                 core_clusters=None,
                 big_core=None,
                 model=None,
                 modules=None,
                 gem5_telnet_port=None):
        # First call the parent class
        super(Gem5SimulationPlatform, self).__init__(name, core_names, core_clusters,
                                                     big_core, model, modules)
        # Start setting up the gem5 parameters/directories
        # The gem5 subprocess
        self.gem5 = None
        self.gem5_port = gem5_telnet_port or None
        self.stats_directory = host_output_dir
        self.gem5_out_dir = os.path.join(self.stats_directory, "gem5")
        self.gem5_interact_dir = '/tmp' # Host directory
        self.executable_dir = None # Device directory
        self.working_dir = None # Device directory
        self.stdout_file = None
        self.stderr_file = None
        self.stderr_filename = None
        if self.gem5_port is None:  # pylint: disable=simplifiable-if-statement
            # Allows devlib to pick up already running simulations
            self.start_gem5_simulation = True
        else:
            self.start_gem5_simulation = False
        # Find the first one that does not exist. Ensures that we do not re-use
        # the directory used by someone else.
        i = 0
        directory = os.path.join(self.gem5_interact_dir, "wa_{}".format(i))
        while os.path.exists(directory):
            i += 1
            directory = os.path.join(self.gem5_interact_dir, "wa_{}".format(i))
        self.gem5_interact_dir = directory
        self.logger.debug("Using {} as the temporary directory."
                          .format(self.gem5_interact_dir))
        # Parameters passed onto gem5
        self.gem5args_binary = gem5_bin
        self.gem5args_args = gem5_args
        self.gem5args_virtio = gem5_virtio
        self._check_gem5_command()
        # Start the interaction with gem5
        self._start_interaction_gem5()
    def _check_gem5_command(self):
        """
        Check if the command to start gem5 makes sense
        """
        if self.gem5args_binary is None:
            raise TargetStableError('Please specify a gem5 binary.')
        if self.gem5args_args is None:
            raise TargetStableError('Please specify the arguments passed on to gem5.')
        self.gem5args_virtio = str(self.gem5args_virtio).format(self.gem5_interact_dir)
        if self.gem5args_virtio is None:
            raise TargetStableError('Please specify arguments needed for virtIO.')
    def _start_interaction_gem5(self):
        """
        Starts the interaction of devlib with gem5.
        """
        # First create the input and output directories for gem5
        if self.start_gem5_simulation:
            # Create the directory to send data to/from gem5 system
            self.logger.info("Creating temporary directory for interaction "
                             " with gem5 via virtIO: {}"
                             .format(self.gem5_interact_dir))
            os.mkdir(self.gem5_interact_dir)
            # Create the directory for gem5 output (stats files etc)
            if not os.path.exists(self.stats_directory):
                os.mkdir(self.stats_directory)
            if os.path.exists(self.gem5_out_dir):
                raise TargetStableError("The gem5 stats directory {} already "
                                  "exists.".format(self.gem5_out_dir))
            else:
                os.mkdir(self.gem5_out_dir)
            # We need to redirect the standard output and standard error for the
            # gem5 process to a file so that we can debug when things go wrong.
            f = os.path.join(self.gem5_out_dir, 'stdout')
            self.stdout_file = open(f, 'w')
            f = os.path.join(self.gem5_out_dir, 'stderr')
            self.stderr_file = open(f, 'w')
            # We need to keep this so we can check which port to use for the
            # telnet connection.
            self.stderr_filename = f
            # Start gem5 simulation
            self.logger.info("Starting the gem5 simulator")
            command_line = "{} --outdir={} {} {}".format(self.gem5args_binary,
                                                         quote(self.gem5_out_dir),
                                                         self.gem5args_args,
                                                         self.gem5args_virtio)
            self.logger.debug("gem5 command line: {}".format(command_line))
            self.gem5 = subprocess.Popen(shlex.split(command_line),
                                         stdout=self.stdout_file,
                                         stderr=self.stderr_file)
        else:
            # The simulation should already be running
            # Need to dig up the (1) gem5 simulation in question (2) its input
            # and output directories (3) virtio setting
            self._intercept_existing_gem5()
        # As the gem5 simulation is running now or was already running
        # we now need to find out which telnet port it uses
        self._intercept_telnet_port()
    def _intercept_existing_gem5(self):
        """
        Intercept the information about a running gem5 simulation
        e.g. pid, input directory etc
        """
        self.logger("This functionality is not yet implemented")
        raise TargetStableError()
    def _intercept_telnet_port(self):
        """
        Intercept the telnet port of a running gem5 simulation
        """
        if self.gem5 is None:
            raise TargetStableError('The platform has no gem5 simulation! '
                              'Something went wrong')
        while self.gem5_port is None:
            # Check that gem5 is running!
            if self.gem5.poll():
                message = "The gem5 process has crashed with error code {}!\n\tPlease see {} for details."
                raise TargetStableError(message.format(self.gem5.poll(), self.stderr_file.name))
            # Open the stderr file
            with open(self.stderr_filename, 'r') as f:
                for line in f:
                    # Look for two different strings, exact wording depends on
                    # version of gem5
                    m = re.search(r"Listening for system connection on port (?P<port>\d+)", line)
                    if not m:
                        m = re.search(r"Listening for connections on port (?P<port>\d+)", line)
                    if m:
                        port = int(m.group('port'))
                        if port >= 3456 and port < 5900:
                            self.gem5_port = port
                            break
                    # Check if the sockets are not disabled
                    m = re.search(r"Sockets disabled, not accepting terminal connections", line)
                    if m:
                        raise TargetStableError("The sockets have been disabled!"
                                          "Pass --listener-mode=on to gem5")
                else:
                    time.sleep(1)
    def init_target_connection(self, target):
        """
        Update the type of connection in the target from here
        """
        if target.os == 'linux':
            target.conn_cls = LinuxGem5Connection
        else:
            target.conn_cls = AndroidGem5Connection
    def setup(self, target):
        """
        Deploy m5 if not yet installed
        """
        m5_path = self._deploy_m5(target)
        target.conn.m5_path = m5_path
        # Set the terminal settings for the connection to gem5
        self._resize_shell(target)
    def update_from_target(self, target):
        """
        Set the m5 path and if not yet installed, deploy m5
        Overwrite certain methods in the target that either can be done
        more efficiently by gem5 or don't exist in gem5
        """
        m5_path = target.get_installed('m5')
        if m5_path is None:
            m5_path = self._deploy_m5(target)
        target.conn.m5_path = m5_path
        # Overwrite the following methods (monkey-patching)
        self.logger.debug("Overwriting the 'capture_screen' method in target")
        # Housekeeping to prevent recursion
        setattr(target, 'target_impl_capture_screen', target.capture_screen)
        target.capture_screen = types.MethodType(_overwritten_capture_screen, target)
        self.logger.debug("Overwriting the 'reset' method in target")
        target.reset = types.MethodType(_overwritten_reset, target)
        self.logger.debug("Overwriting the 'reboot' method in target")
        target.reboot = types.MethodType(_overwritten_reboot, target)
        # Call the general update_from_target implementation
        super(Gem5SimulationPlatform, self).update_from_target(target)
    def gem5_capture_screen(self, filepath):
        file_list = os.listdir(self.gem5_out_dir)
        screen_caps = []
        for f in file_list:
            if '.bmp' in f:
                screen_caps.append(f)
        if '{ts}' in filepath:
            cmd = '{} date -u -Iseconds'
            # pylint: disable=no-member
            ts = self.target.execute(cmd.format(self.target.busybox)).strip()
            filepath = filepath.format(ts=ts)
        successful_capture = False
        if len(screen_caps) == 1:
            # Bail out if we do not have image, and resort to the slower, built
            # in method.
            try:
                import Image
                gem5_image = os.path.join(self.gem5_out_dir, screen_caps[0])
                temp_image = os.path.join(self.gem5_out_dir, "file.png")
                im = Image.open(gem5_image)
                im.save(temp_image, "PNG")
                shutil.copy(temp_image, filepath)
                os.remove(temp_image)
                # pylint: disable=undefined-variable
                gem5_logger.info("capture_screen: using gem5 screencap")
                successful_capture = True
            except (shutil.Error, ImportError, IOError):
                pass
        return successful_capture
    # pylint: disable=no-self-use
    def _deploy_m5(self, target):
        # m5 is not yet installed so install it
        host_executable = os.path.join(PACKAGE_BIN_DIRECTORY,
                                       target.abi, 'm5')
        return target.install(host_executable)
    # pylint: disable=no-self-use
    def _resize_shell(self, target):
        """
        Resize the shell to avoid line wrapping issues.
        """
        # Try and avoid line wrapping as much as possible.
        target.execute('{} stty columns 1024'.format(target.busybox))
        target.execute('reset', check_exit_code=False)
 # Methods that will be monkey-patched onto the target
 def _overwritten_reset(self):  # pylint: disable=unused-argument
    raise TargetStableError('Resetting is not allowed on gem5 platforms!')
 def _overwritten_reboot(self):  # pylint: disable=unused-argument
    raise TargetStableError('Rebooting is not allowed on gem5 platforms!')
 def _overwritten_capture_screen(self, filepath):
    connection_screencapped = self.platform.gem5_capture_screen(filepath)
    if not connection_screencapped:
        # The connection was not able to capture the screen so use the target
        # implementation
        self.logger.debug('{} was not able to screen cap, using the original target implementation'.format(self.platform.__class__.__name__))
        self.target_impl_capture_screen(filepath)
--- a/devlib/target.py
+++ b/devlib/target.py
--- a/devlib/trace/init.py
+++ b/devlib/trace/init.py
@@ -0,0 +1,20 @@
 import logging
 class TraceCollector(object):
    def __init__(self, target):
        self.target = target
        self.logger = logging.getLogger(self.__class__.__name__)
    def reset(self):
        pass
    def start(self):
        pass
    def stop(self):
        pass
    def get_trace(self, outfile):
        pass
--- a/devlib/trace/ftrace.py
+++ b/devlib/trace/ftrace.py
@@ -0,0 +1,199 @@
 #    Copyright 2015 ARM Limited
 #
 # 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.
 #
 from __future__ import division
 import os
 import time
 import subprocess
 from devlib.trace import TraceCollector
 from devlib.host import PACKAGE_BIN_DIRECTORY
 from devlib.exception import TargetError, HostError
 from devlib.utils.misc import check_output, which
 TRACE_MARKER_START = 'TRACE_MARKER_START'
 TRACE_MARKER_STOP = 'TRACE_MARKER_STOP'
 OUTPUT_TRACE_FILE = 'trace.dat'
 DEFAULT_EVENTS = [
    'cpu_frequency',
    'cpu_idle',
    'sched_migrate_task',
    'sched_process_exec',
    'sched_process_fork',
    'sched_stat_iowait',
    'sched_switch',
    'sched_wakeup',
    'sched_wakeup_new',
 ]
 TIMEOUT = 180
 class FtraceCollector(TraceCollector):
    def __init__(self, target,
                 events=None,
                 buffer_size=None,
                 buffer_size_step=1000,
                 buffer_size_file='/sys/kernel/debug/tracing/buffer_size_kb',
                 marker_file='/sys/kernel/debug/tracing/trace_marker',
                 automark=True,
                 autoreport=True,
                 autoview=False,
                 no_install=False,
                 ):
        super(FtraceCollector, self).__init__(target)
        self.events = events if events is not None else DEFAULT_EVENTS
        self.buffer_size = buffer_size
        self.buffer_size_step = buffer_size_step
        self.buffer_size_file = buffer_size_file
        self.marker_file = marker_file
        self.automark = automark
        self.autoreport = autoreport
        self.autoview = autoview
        self.target_output_file = os.path.join(self.target.working_directory, OUTPUT_TRACE_FILE)
        self.target_binary = None
        self.host_binary = None
        self.start_time = None
        self.stop_time = None
        self.event_string = _build_trace_events(self.events)
        self._reset_needed = True
        self.host_binary = which('trace-cmd')
        self.kernelshark = which('kernelshark')
        if not self.target.is_rooted:
            raise TargetError('trace-cmd instrument cannot be used on an unrooted device.')
        if self.autoreport and self.host_binary is None:
            raise HostError('trace-cmd binary must be installed on the host if autoreport=True.')
        if self.autoview and self.kernelshark is None:
            raise HostError('kernelshark binary must be installed on the host if autoview=True.')
        if not no_install:
            host_file = os.path.join(PACKAGE_BIN_DIRECTORY, self.target.abi, 'trace-cmd')
            self.target_binary = self.target.install(host_file)
        else:
            if not self.target.is_installed('trace-cmd'):
                raise TargetError('No trace-cmd found on device and no_install=True is specified.')
            self.target_binary = 'trace-cmd'
    def reset(self):
        if self.buffer_size:
            self._set_buffer_size()
        self.target.execute('{} reset'.format(self.target_binary), as_root=True, timeout=TIMEOUT)
        self._reset_needed = False
    def start(self):
        self.start_time = time.time()
        if self._reset_needed:
            self.reset()
        if self.automark:
            self.mark_start()
        self.target.execute('{} start {}'.format(self.target_binary, self.event_string), as_root=True)
    def stop(self):
        self.stop_time = time.time()
        if self.automark:
            self.mark_stop()
        self.target.execute('{} stop'.format(self.target_binary), timeout=TIMEOUT, as_root=True)
        self._reset_needed = True
    def get_trace(self, outfile):
        if os.path.isdir(outfile):
            outfile = os.path.join(outfile, os.path.dirname(self.target_output_file))
        self.target.execute('{} extract -o {}'.format(self.target_binary, self.target_output_file),
                            timeout=TIMEOUT, as_root=True)
        # The size of trace.dat will depend on how long trace-cmd was running.
        # Therefore timout for the pull command must also be adjusted
        # accordingly.
        pull_timeout = self.stop_time - self.start_time
        self.target.pull(self.target_output_file, outfile, timeout=pull_timeout)
        if not os.path.isfile(outfile):
            self.logger.warning('Binary trace not pulled from device.')
        else:
            if self.autoreport:
                textfile = os.path.splitext(outfile)[0] + '.txt'
                self.report(outfile, textfile)
            if self.autoview:
                self.view(outfile)
    def report(self, binfile, destfile):
        # To get the output of trace.dat, trace-cmd must be installed
        # This is done host-side because the generated file is very large
        try:
            command = '{} report {} > {}'.format(self.host_binary, binfile, destfile)
            self.logger.debug(command)
            process = subprocess.Popen(command, stderr=subprocess.PIPE, shell=True)
            _, error = process.communicate()
            if process.returncode:
                raise TargetError('trace-cmd returned non-zero exit code {}'.format(process.returncode))
            if error:
                # logged at debug level, as trace-cmd always outputs some
                # errors that seem benign.
                self.logger.debug(error)
            if os.path.isfile(destfile):
                self.logger.debug('Verifying traces.')
                with open(destfile) as fh:
                    for line in fh:
                        if 'EVENTS DROPPED' in line:
                            self.logger.warning('Dropped events detected.')
                            break
                    else:
                        self.logger.debug('Trace verified.')
            else:
                self.logger.warning('Could not generate trace.txt.')
        except OSError:
            raise HostError('Could not find trace-cmd. Please make sure it is installed and is in PATH.')
    def view(self, binfile):
        check_output('{} {}'.format(self.kernelshark, binfile), shell=True)
    def teardown(self):
        self.target.remove(self.target.path.join(self.target.working_directory, OUTPUT_TRACE_FILE))
    def mark_start(self):
        self.target.write_value(self.marker_file, TRACE_MARKER_START, verify=False)
    def mark_stop(self):
        self.target.write_value(self.marker_file, TRACE_MARKER_STOP, verify=False)
    def _set_buffer_size(self):
        target_buffer_size = self.buffer_size
        attempt_buffer_size = target_buffer_size
        buffer_size = 0
        floor = 1000 if target_buffer_size > 1000 else target_buffer_size
        while attempt_buffer_size >= floor:
            self.target.write_value(self.buffer_size_file, attempt_buffer_size, verify=False)
            buffer_size = self.target.read_int(self.buffer_size_file)
            if buffer_size == attempt_buffer_size:
                break
            else:
                attempt_buffer_size -= self.buffer_size_step
        if buffer_size == target_buffer_size:
            return
        while attempt_buffer_size < target_buffer_size:
            attempt_buffer_size += self.buffer_size_step
            self.target.write_value(self.buffer_size_file, attempt_buffer_size, verify=False)
            buffer_size = self.target.read_int(self.buffer_size_file)
            if attempt_buffer_size != buffer_size:
                message = 'Failed to set trace buffer size to {}, value set was {}'
                self.logger.warning(message.format(target_buffer_size, buffer_size))
                break
 def _build_trace_events(events):
    event_string = ' '.join(['-e {}'.format(e) for e in events])
    return event_string
--- a/devlib/utils/init.py
+++ b/devlib/utils/init.py
@@ -12,3 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
--- a/devlib/utils/android.py
+++ b/devlib/utils/android.py
--- a/devlib/utils/asyn.py
+++ b/devlib/utils/asyn.py
@@ -1,994 +0,0 @@
 #    Copyright 2013-2018 ARM Limited
 #
 # 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.
 #
 """
 Async-related utilities
 """
 import abc
 import asyncio
 import contextvars
 import functools
 import itertools
 import contextlib
 import pathlib
 import queue
 import os.path
 import inspect
 import sys
 import threading
 from concurrent.futures import ThreadPoolExecutor
 from weakref import WeakSet, WeakKeyDictionary
 from greenlet import greenlet
 def create_task(awaitable, name=None):
    if isinstance(awaitable, asyncio.Task):
        task = awaitable
    else:
        task = asyncio.create_task(awaitable)
    if name is None:
        name = getattr(awaitable, '__qualname__', None)
    task.name = name
    return task
 def _close_loop(loop):
    if loop is not None:
        try:
            loop.run_until_complete(loop.shutdown_asyncgens())
            try:
                shutdown_default_executor = loop.shutdown_default_executor
            except AttributeError:
                pass
            else:
                loop.run_until_complete(shutdown_default_executor())
        finally:
            loop.close()
 class AsyncManager:
    def __init__(self):
        self.task_tree = dict()
        self.resources = dict()
    def track_access(self, access):
        """
        Register the given ``access`` to have been handled by the current
        async task.
        :param access: Access that were done.
        :type access: ConcurrentAccessBase
        This allows :func:`concurrently` to check that concurrent tasks did not
        step on each other's toes.
        """
        try:
            task = asyncio.current_task()
        except RuntimeError:
            pass
        else:
            self.resources.setdefault(task, set()).add(access)
    async def concurrently(self, awaitables):
        """
        Await concurrently for the given awaitables, and cancel them as soon as
        one raises an exception.
        """
        awaitables = list(awaitables)
        # Avoid creating asyncio.Tasks when it's not necessary, as it will
        # disable a the blocking path optimization of Target._execute_async()
        # that uses blocking calls as long as there is only one asyncio.Task
        # running on the event loop.
        if len(awaitables) == 1:
            return [await awaitables[0]]
        tasks = list(map(create_task, awaitables))
        current_task = asyncio.current_task()
        task_tree = self.task_tree
        try:
            node = task_tree[current_task]
        except KeyError:
            is_root_task = True
            node = set()
        else:
            is_root_task = False
        task_tree[current_task] = node
        task_tree.update({
            child: set()
            for child in tasks
        })
        node.update(tasks)
        try:
            return await asyncio.gather(*tasks)
        except BaseException:
            for task in tasks:
                task.cancel()
                try:
                    await task
                except asyncio.CancelledError:
                    pass
            raise
        finally:
            def get_children(task):
                immediate_children = task_tree[task]
                return frozenset(
                    itertools.chain(
                        [task],
                        immediate_children,
                        itertools.chain.from_iterable(
                            map(get_children, immediate_children)
                        )
                    )
                )
            # Get the resources created during the execution of each subtask
            # (directly or indirectly)
            resources = {
                task: frozenset(
                    itertools.chain.from_iterable(
                        self.resources.get(child, [])
                        for child in get_children(task)
                    )
                )
                for task in tasks
            }
            for (task1, resources1), (task2, resources2) in itertools.combinations(resources.items(), 2):
                for res1, res2 in itertools.product(resources1, resources2):
                    if issubclass(res2.__class__, res1.__class__) and res1.overlap_with(res2):
                        raise RuntimeError(
                            'Overlapping resources manipulated in concurrent async tasks: {} (task {}) and {} (task {})'.format(res1, task1.name, res2, task2.name)
                        )
            if is_root_task:
                self.resources.clear()
                task_tree.clear()
    async def map_concurrently(self, f, keys):
        """
        Similar to :meth:`concurrently`,
        but maps the given function ``f`` on the given ``keys``.
        :return: A dictionary with ``keys`` as keys, and function result as
            values.
        """
        keys = list(keys)
        return dict(zip(
            keys,
            await self.concurrently(map(f, keys))
        ))
 def compose(*coros):
    """
    Compose coroutines, feeding the output of each as the input of the next
    one.
    ``await compose(f, g)(x)`` is equivalent to ``await f(await g(x))``
    .. note:: In Haskell, ``compose f g h`` would be equivalent to ``f <=< g <=< h``
    """
    async def f(*args, **kwargs):
        empty_dict = {}
        for coro in reversed(coros):
            x = coro(*args, **kwargs)
            # Allow mixing corountines and regular functions
            if asyncio.isfuture(x):
                x = await x
            args = [x]
            kwargs = empty_dict
        return x
    return f
 class _AsyncPolymorphicFunction:
    """
    A callable that allows exposing both a synchronous and asynchronous API.
    When called, the blocking synchronous operation is called. The ```asyn``
    attribute gives access to the asynchronous version of the function, and all
    the other attribute access will be redirected to the async function.
    """
    def __init__(self, asyn, blocking):
        self.asyn = asyn
        self.blocking = blocking
        functools.update_wrapper(self, asyn)
    def __get__(self, *args, **kwargs):
        return self.__class__(
            asyn=self.asyn.__get__(*args, **kwargs),
            blocking=self.blocking.__get__(*args, **kwargs),
        )
    # Ensure inspect.iscoroutinefunction() does not detect us as being async,
    # since __call__ is not.
    @property
    def __code__(self):
        return self.__call__.__code__
    def __call__(self, *args, **kwargs):
        return self.blocking(*args, **kwargs)
    def __getattr__(self, attr):
        return getattr(self.asyn, attr)
 class memoized_method:
    """
    Decorator to memmoize a method.
    It works for:
        * async methods (coroutine functions)
        * non-async methods
        * method already decorated with :func:`devlib.asyn.asyncf`.
    .. note:: This decorator does not rely on hacks to hash unhashable data. If
        such input is required, it will either have to be coerced to a hashable
        first (e.g. converting a list to a tuple), or the code of
        :func:`devlib.asyn.memoized_method` will have to be updated to do so.
    """
    def __init__(self, f):
        memo = self
        sig = inspect.signature(f)
        def bind(self, *args, **kwargs):
            bound = sig.bind(self, *args, **kwargs)
            bound.apply_defaults()
            key = (bound.args[1:], tuple(sorted(bound.kwargs.items())))
            return (key, bound.args, bound.kwargs)
        def get_cache(self):
            try:
                cache = self.__dict__[memo.name]
            except KeyError:
                cache = {}
                self.__dict__[memo.name] = cache
            return cache
        if inspect.iscoroutinefunction(f):
            @functools.wraps(f)
            async def wrapper(self, *args, **kwargs):
                cache = get_cache(self)
                key, args, kwargs = bind(self, *args, **kwargs)
                try:
                    return cache[key]
                except KeyError:
                    x = await f(*args, **kwargs)
                    cache[key] = x
                    return x
        else:
            @functools.wraps(f)
            def wrapper(self, *args, **kwargs):
                cache = get_cache(self)
                key, args, kwargs = bind(self, *args, **kwargs)
                try:
                    return cache[key]
                except KeyError:
                    x = f(*args, **kwargs)
                    cache[key] = x
                    return x
        self.f = wrapper
        self._name = f.__name__
    @property
    def name(self):
        return '__memoization_cache_of_' + self._name
    def __call__(self, *args, **kwargs):
        return self.f(*args, **kwargs)
    def __get__(self, obj, owner=None):
        return self.f.__get__(obj, owner)
    def __set__(self, obj, value):
        raise RuntimeError("Cannot monkey-patch a memoized function")
    def __set_name__(self, owner, name):
        self._name = name
 class _Genlet(greenlet):
    """
    Generator-like object based on ``greenlets``. It allows nested :class:`_Genlet`
    to make their parent yield on their behalf, as if callees could decide to
    be annotated ``yield from`` without modifying the caller.
    """
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Forward the context variables to the greenlet, which will not happen
        # by default:
        # https://greenlet.readthedocs.io/en/latest/contextvars.html
        self.gr_context = contextvars.copy_context()
    @classmethod
    def from_coro(cls, coro):
        """
        Create a :class:`_Genlet` from a given coroutine, treating it as a
        generator.
        """
        f = lambda value: self.consume_coro(coro, value)
        self = cls(f)
        return self
    def consume_coro(self, coro, value):
        """
        Send ``value`` to ``coro`` then consume the coroutine, passing all its
        yielded actions to the enclosing :class:`_Genlet`. This allows crossing
        blocking calls layers as if they were async calls with `await`.
        """
        excep = None
        while True:
            try:
                if excep is None:
                    future = coro.send(value)
                else:
                    future = coro.throw(excep)
            except StopIteration as e:
                return e.value
            else:
                parent = self.parent
                # Switch back to the consumer that returns the values via
                # send()
                try:
                    value = parent.switch(future)
                except BaseException as e:
                    excep = e
                    value = None
                else:
                    excep = None
    @classmethod
    def get_enclosing(cls):
        """
        Get the immediately enclosing :class:`_Genlet` in the callstack or
        ``None``.
        """
        g = greenlet.getcurrent()
        while not (isinstance(g, cls) or g is None):
            g = g.parent
        return g
    def _send_throw(self, value, excep):
        self.parent = greenlet.getcurrent()
        # Switch back to the function yielding values
        if excep is None:
            result = self.switch(value)
        else:
            result = self.throw(excep)
        if self:
            return result
        else:
            raise StopIteration(result)
    def gen_send(self, x):
        """
        Similar to generators' ``send`` method.
        """
        return self._send_throw(x, None)
    def gen_throw(self, x):
        """
        Similar to generators' ``throw`` method.
        """
        return self._send_throw(None, x)
 class _AwaitableGenlet:
    """
    Wrap a coroutine with a :class:`_Genlet` and wrap that to be awaitable.
    """
    @classmethod
    def wrap_coro(cls, coro):
        async def coro_f():
            # Make sure every new task will be instrumented since a task cannot
            # yield futures on behalf of another task. If that were to happen,
            # the task B trying to do a nested yield would switch back to task
            # A, asking to yield on its behalf. Since the event loop would be
            # currently handling task B, nothing would handle task A trying to
            # yield on behalf of B, leading to a deadlock.
            loop = asyncio.get_running_loop()
            _install_task_factory(loop)
            # Create a top-level _AwaitableGenlet that all nested runs will use
            # to yield their futures
            _coro = cls(coro)
            return await _coro
        return coro_f()
    def __init__(self, coro):
        self._coro = coro
    def __await__(self):
        coro = self._coro
        is_started = inspect.iscoroutine(coro) and coro.cr_running
        def genf():
            gen = _Genlet.from_coro(coro)
            value = None
            excep = None
            # The coroutine is already started, so we need to dispatch the
            # value from the upcoming send() to the gen without running
            # gen first.
            if is_started:
                try:
                    value = yield
                except BaseException as e:
                    excep = e
            while True:
                try:
                    if excep is None:
                        future = gen.gen_send(value)
                    else:
                        future = gen.gen_throw(excep)
                except StopIteration as e:
                    return e.value
                finally:
                    _set_current_context(gen.gr_context)
                try:
                    value = yield future
                except BaseException as e:
                    excep = e
                    value = None
                else:
                    excep = None
        gen = genf()
        if is_started:
            # Start the generator so it waits at the first yield point
            gen.gen_send(None)
        return gen
 def _allow_nested_run(coro):
    if _Genlet.get_enclosing() is None:
        return _AwaitableGenlet.wrap_coro(coro)
    else:
        return coro
 def allow_nested_run(coro):
    """
    Wrap the coroutine ``coro`` such that nested calls to :func:`run` will be
    allowed.
    .. warning:: The coroutine needs to be consumed in the same OS thread it
        was created in.
    """
    return _allow_nested_run(coro)
 # This thread runs coroutines that cannot be ran on the event loop in the
 # current thread. Instead, they are scheduled in a separate thread where
 # another event loop has been setup, so we can wrap coroutines before
 # dispatching them there.
 _CORO_THREAD_EXECUTOR = ThreadPoolExecutor(
    # Allow for a ridiculously large number so that we will never end up
    # queuing one job after another. This is critical as we could otherwise end
    # up in deadlock, if a job triggers another job and waits for it.
    max_workers=2**64,
 )
 def _check_executor_alive(executor):
    try:
        executor.submit(lambda: None)
    except RuntimeError:
        return False
    else:
        return True
 _PATCHED_LOOP_LOCK = threading.Lock()
 _PATCHED_LOOP = WeakSet()
 def _install_task_factory(loop):
    """
    Install a task factory on the given event ``loop`` so that top-level
    coroutines are wrapped using :func:`allow_nested_run`. This ensures that
    the nested :func:`run` infrastructure will be available.
    """
    def install(loop):
        if sys.version_info >= (3, 11):
            def default_factory(loop, coro, context=None):
                return asyncio.Task(coro, loop=loop, context=context)
        else:
            def default_factory(loop, coro, context=None):
                return asyncio.Task(coro, loop=loop)
        make_task = loop.get_task_factory() or default_factory
        def factory(loop, coro, context=None):
            # Make sure each Task will be able to yield on behalf of its nested
            # await beneath blocking layers
            coro = _AwaitableGenlet.wrap_coro(coro)
            return make_task(loop, coro, context=context)
        loop.set_task_factory(factory)
    with _PATCHED_LOOP_LOCK:
        if loop in _PATCHED_LOOP:
            return
        else:
            install(loop)
            _PATCHED_LOOP.add(loop)
 def _set_current_context(ctx):
    """
    Get all the variable from the passed ``ctx`` and set them in the current
    context.
    """
    for var, val in ctx.items():
        var.set(val)
 class _CoroRunner(abc.ABC):
    """
    ABC for an object that can execute multiple coroutines in a given
    environment.
    This allows running coroutines for which it might be an assumption, such as
    the awaitables yielded by an async generator that are all attached to a
    single event loop.
    """
    @abc.abstractmethod
    def _run(self, coro):
        pass
    def run(self, coro):
        # Ensure we have a fresh coroutine. inspect.getcoroutinestate() does not
        # work on all objects that asyncio creates on some version of Python, such
        # as iterable_coroutine
        assert not (inspect.iscoroutine(coro) and coro.cr_running)
        return self._run(coro)
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_value, tb):
        pass
 class _ThreadCoroRunner(_CoroRunner):
    """
    Run the coroutines on a thread picked from a
    :class:`concurrent.futures.ThreadPoolExecutor`.
    Critically, this allows running multiple coroutines out of the same thread,
    which will be reserved until the runner ``__exit__`` method is called.
    """
    def __init__(self, future, jobq, resq):
        self._future = future
        self._jobq = jobq
        self._resq = resq
    @staticmethod
    def _thread_f(jobq, resq):
        def handle_jobs(runner):
            while True:
                job = jobq.get()
                if job is None:
                    return
                else:
                    ctx, coro = job
                    try:
                        value = ctx.run(runner.run, coro)
                    except BaseException as e:
                        value = None
                        excep = e
                    else:
                        excep = None
                    resq.put((ctx, excep, value))
        with _LoopCoroRunner(None) as runner:
            handle_jobs(runner)
    @classmethod
    def from_executor(cls, executor):
        jobq = queue.SimpleQueue()
        resq = queue.SimpleQueue()
        try:
            future = executor.submit(cls._thread_f, jobq, resq)
        except RuntimeError as e:
            if _check_executor_alive(executor):
                raise e
            else:
                raise RuntimeError('Devlib relies on nested asyncio implementation requiring threads. These threads are not available while shutting down the interpreter.')
        return cls(
            jobq=jobq,
            resq=resq,
            future=future,
        )
    def _run(self, coro):
        ctx = contextvars.copy_context()
        self._jobq.put((ctx, coro))
        ctx, excep, value = self._resq.get()
        _set_current_context(ctx)
        if excep is None:
            return value
        else:
            raise excep
    def __exit__(self, *args, **kwargs):
        self._jobq.put(None)
        self._future.result()
 class _LoopCoroRunner(_CoroRunner):
    """
    Run a coroutine on the given event loop.
    The passed event loop is assumed to not be running. If ``None`` is passed,
    a new event loop will be created in ``__enter__`` and closed in
    ``__exit__``.
    """
    def __init__(self, loop):
        self.loop = loop
        self._owned = False
    def _run(self, coro):
        loop = self.loop
        # Back-propagate the contextvars that could have been modified by the
        # coroutine. This could be handled by asyncio.Runner().run(...,
        # context=...) or loop.create_task(..., context=...) but these APIs are
        # only available since Python 3.11
        ctx = None
        async def capture_ctx():
            nonlocal ctx
            try:
                return await _allow_nested_run(coro)
            finally:
                ctx = contextvars.copy_context()
        try:
            return loop.run_until_complete(capture_ctx())
        finally:
            _set_current_context(ctx)
    def __enter__(self):
        loop = self.loop
        if loop is None:
            owned = True
            loop = asyncio.new_event_loop()
        else:
            owned = False
        asyncio.set_event_loop(loop)
        self.loop = loop
        self._owned = owned
        return self
    def __exit__(self, *args, **kwargs):
        if self._owned:
            asyncio.set_event_loop(None)
            _close_loop(self.loop)
 class _GenletCoroRunner(_CoroRunner):
    """
    Run a coroutine assuming one of the parent coroutines was wrapped with
    :func:`allow_nested_run`.
    """
    def __init__(self, g):
        self._g = g
    def _run(self, coro):
        return self._g.consume_coro(coro, None)
 def _get_runner():
    executor = _CORO_THREAD_EXECUTOR
    g = _Genlet.get_enclosing()
    try:
        loop = asyncio.get_running_loop()
    except RuntimeError:
        loop = None
    # We have an coroutine wrapped with allow_nested_run() higher in the
    # callstack, that we will be able to use as a conduit to yield the
    # futures.
    if g is not None:
        return _GenletCoroRunner(g)
    # No event loop setup, so we can just make our own
    elif loop is None:
        return _LoopCoroRunner(None)
    # There is an event loop setup, but it is not currently running so we
    # can just re-use it.
    #
    # TODO: for now, this path is dead since asyncio.get_running_loop() will
    # always raise a RuntimeError if the loop is not running, even if
    # asyncio.set_event_loop() was used.
    elif not loop.is_running():
        return _LoopCoroRunner(loop)
    # There is an event loop currently running in our thread, so we cannot
    # just create another event loop and install it since asyncio forbids
    # that. The only choice is doing this in a separate thread that we
    # fully control.
    else:
        return _ThreadCoroRunner.from_executor(executor)
 def run(coro):
    """
    Similar to :func:`asyncio.run` but can be called while an event loop is
    running if a coroutine higher in the callstack has been wrapped using
    :func:`allow_nested_run`.
    Note that context variables from :mod:`contextvars` will be available in
    the coroutine, and unlike with :func:`asyncio.run`, any update to them will
    be reflected in the context of the caller. This allows context variable
    updates to cross an arbitrary number of run layers, as if all those layers
    were just part of the same coroutine.
    """
    runner = _get_runner()
    with runner as runner:
        return runner.run(coro)
 def asyncf(f):
    """
    Decorator used to turn a coroutine into a blocking function, with an
    optional asynchronous API.
    **Example**::
        @asyncf
        async def foo(x):
            await do_some_async_things(x)
            return x
        # Blocking call, just as if the function was synchronous, except it may
        # use asynchronous code inside, e.g. to do concurrent operations.
        foo(42)
        # Asynchronous API, foo.asyn being a corountine
        await foo.asyn(42)
    This allows the same implementation to be both used as blocking for ease of
    use and backward compatibility, or exposed as a corountine for callers that
    can deal with awaitables.
    """
    @functools.wraps(f)
    def blocking(*args, **kwargs):
        # Since run() needs a corountine, make sure we provide one
        async def wrapper():
            x = f(*args, **kwargs)
            # Async generators have to be consumed and accumulated in a list
            # before crossing a blocking boundary.
            if inspect.isasyncgen(x):
                def genf():
                    asyncgen = x.__aiter__()
                    while True:
                        try:
                            yield run(asyncgen.__anext__())
                        except StopAsyncIteration:
                            return
                return genf()
            else:
                return await x
        return run(wrapper())
    return _AsyncPolymorphicFunction(
        asyn=f,
        blocking=blocking,
    )
 class _AsyncPolymorphicCMState:
    def __init__(self):
        self.nesting = 0
        self.runner = None
    def _update_nesting(self, n):
        x = self.nesting
        assert x >= 0
        x = x + n
        self.nesting = x
        return bool(x)
    def _get_runner(self):
        runner = self.runner
        if runner is None:
            assert not self.nesting
            runner = _get_runner()
            runner.__enter__()
        self.runner = runner
        return runner
    def _cleanup_runner(self, force=False):
        def cleanup():
            self.runner = None
            if runner is not None:
                runner.__exit__(None, None, None)
        runner = self.runner
        if force:
            cleanup()
        else:
            assert runner is not None
            if not self._update_nesting(0):
                cleanup()
 class _AsyncPolymorphicCM:
    """
    Wrap an async context manager such that it exposes a synchronous API as
    well for backward compatibility.
    """
    def __init__(self, async_cm):
        self.cm = async_cm
        self._state = threading.local()
    def _get_state(self):
        try:
            return self._state.x
        except AttributeError:
            state = _AsyncPolymorphicCMState()
            self._state.x = state
            return state
    def _delete_state(self):
        try:
            del self._state.x
        except AttributeError:
            pass
    def __aenter__(self, *args, **kwargs):
        return self.cm.__aenter__(*args, **kwargs)
    def __aexit__(self, *args, **kwargs):
        return self.cm.__aexit__(*args, **kwargs)
    @staticmethod
    def _exit(state):
        state._update_nesting(-1)
        state._cleanup_runner()
    def __enter__(self, *args, **kwargs):
        state = self._get_state()
        runner = state._get_runner()
        # Increase the nesting count _before_ we start running the
        # coroutine, in case it is a recursive context manager
        state._update_nesting(1)
        try:
            coro = self.cm.__aenter__(*args, **kwargs)
            return runner.run(coro)
        except BaseException:
            self._exit(state)
            raise
    def __exit__(self, *args, **kwargs):
        coro = self.cm.__aexit__(*args, **kwargs)
        state = self._get_state()
        runner = state._get_runner()
        try:
            return runner.run(coro)
        finally:
            self._exit(state)
    def __del__(self):
        self._get_state()._cleanup_runner(force=True)
 def asynccontextmanager(f):
    """
    Same as :func:`contextlib.asynccontextmanager` except that it can also be
    used with a regular ``with`` statement for backward compatibility.
    """
    f = contextlib.asynccontextmanager(f)
    @functools.wraps(f)
    def wrapper(*args, **kwargs):
        cm = f(*args, **kwargs)
        return _AsyncPolymorphicCM(cm)
    return wrapper
 class ConcurrentAccessBase(abc.ABC):
    """
    Abstract Base Class for resources tracked by :func:`concurrently`.
    """
    @abc.abstractmethod
    def overlap_with(self, other):
        """
        Return ``True`` if the resource overlaps with the given one.
        :param other: Resources that should not overlap with ``self``.
        :type other: devlib.utils.asym.ConcurrentAccessBase
        .. note:: It is guaranteed that ``other`` will be a subclass of our
            class.
        """
 class PathAccess(ConcurrentAccessBase):
    """
    Concurrent resource representing a file access.
    :param namespace: Identifier of the namespace of the path. One of "target" or "host".
    :type namespace: str
    :param path: Normalized path to the file.
    :type path: str
    :param mode: Opening mode of the file. Can be ``"r"`` for read and ``"w"``
        for writing.
    :type mode: str
    """
    def __init__(self, namespace, path, mode):
        assert namespace in ('host', 'target')
        self.namespace = namespace
        assert mode in ('r', 'w')
        self.mode = mode
        self.path = os.path.abspath(path) if namespace == 'host' else os.path.normpath(path)
    def overlap_with(self, other):
        path1 = pathlib.Path(self.path).resolve()
        path2 = pathlib.Path(other.path).resolve()
        return (
            self.namespace == other.namespace and
            'w' in (self.mode, other.mode) and
            (
                path1 == path2 or
                path1 in path2.parents or
                path2 in path1.parents
            )
        )
    def __str__(self):
        mode = {
            'r': 'read',
            'w': 'write',
        }[self.mode]
        return '{} ({})'.format(self.path, mode)
--- a/Show More
+++ b/Show More