build

#!/usr/bin/env python3

import re
import os

import cli_function
import collections
import common
import copy
import itertools
import math
import subprocess
import shell_helpers
from shell_helpers import LF

import lkmc

class _Component:
    '''
    Yes, we are re-inventing a crappy dependency resolution system,
    reminiscent of scons or apt or Buildroot. I can't believe it.

    The hard part is that we have optional dependencies as well...
    e.g. Buildroot optionally depends on m5 to put m5 in the root filesystem,
    and Buildroot optionally depends on QEMU to build the qcow2 version
    of the image.
    '''
    def __init__(
        self,
        build_callback=None,
        supported_archs=None,
        dependencies=None,
        apt_get_pkgs=None,
        apt_build_deps=None,
        submodules=None,
        submodules_shallow=None,
        python2_pkgs=None,
        python3_pkgs=None,
        ruby_pkgs=None,
    ):
        self.build_callback = build_callback
        self.supported_archs = supported_archs
        self.dependencies = dependencies or set()
        self.apt_get_pkgs = apt_get_pkgs or set()
        self.apt_build_deps = apt_build_deps or set()
        self.submodules = submodules or set()
        self.submodules_shallow = submodules_shallow or set()
        self.python2_pkgs = python2_pkgs or set()
        self.python3_pkgs = python3_pkgs or set()
        self.ruby_pkgs = ruby_pkgs or set()

    def build(self, arch):
        if (
            (self.build_callback is not None) and
            (self.supported_archs is None or arch in self.supported_archs)
        ):
            self.build_callback()

submodule_extra_remotes = {
    'binutils-gdb': {
        'up': 'git://sourceware.org/git/binutils-gdb.git',
    },
    'buildroot': {
        'up': 'https://gem5.googlesource.com/public/gem5',
    },
    'crosstool-ng': {
        'up': 'https://github.com/crosstool-ng/crosstool-ng',
    },
    'gcc': {
        'up': 'git://gcc.gnu.org/git/gcc.git',
    },
    'gem5': {
        'up': 'https://gem5.googlesource.com/public/gem5',
    },
    'glibc': {
        'up': 'git://sourceware.org/git/glibc.git',
    },
    'linux': {
        # https://cirosantilli.com/linux-kernel-module-cheat#gem5-arm-linux-kernel-patches
        'gem5-arm': 'https://gem5.googlesource.com/arm/linux',
        'up': 'git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git',
    },
    'qemu': {
        'up': 'https://git.qemu.org/git/qemu.git',
    },
    'xen': {
        'up': 'git://xenbits.xen.org/xen.git',
    },
}

class Main(common.LkmcCliFunction):

    def __init__(self):
        super().__init__(
            description='''\
Build a component and all its dependencies.

Our build-* scripts don't build any dependencies to make iterative
development fast and more predictable.

It is currently not possible to configure individual components from the command line
when you build with this script. TODO.

Without any args, build only what is necessary for:
https://cirosantilli.com/linux-kernel-module-cheat#qemu-buildroot-setup

....
./%(prog)s
....

This is equivalent to:

....
./%(prog)s --arch x86_64 qemu-buildroot
....

Another important target is `all`:

....
./%(prog)s all
....

This does not truly build ALL configurations: that would be impractical.
But more precisely: build the reference configuration of each major component.

So e.g.: one config of Linux kernel, Buildroot, gem5 and QEMU.
Don't do for example all possible gem5 configs: debug, opt and fast,
as that would be huge. This ensures that every piece of software
builds in at least one config.

TODO looping over emulators is not currently supported by this script, e.g.:

....
./%(prog)s --arch x86_64 --arch aarch64 all
....

Instead, for the targets that are emulator dependent, you must select the
taret version for the desired emulator, e.g.:

....
./build --arch aarch64 baremetal-qemu baremetal-gem5
....

The reason is that some targets depend on emulator, while others don't,
so looping over all of them would waste time.
''',
        )
        buildroot_component = _Component(
            self._build_file('build-buildroot'),
            submodules_shallow = {
                'buildroot',
                'binutils-gdb',
                'gcc',
                'glibc',
            },
            # https://buildroot.org/downloads/manual/manual.html#requirement
            apt_get_pkgs={
                'bash',
                'bc',
                'binutils',
                'build-essential',
                'bzip2',
                'cpio',
                'g++',
                'gcc',
                'graphviz',
                'gzip',
                'make',
                'patch',
                'perl',
                'python-matplotlib',
                'python3',
                'rsync',
                'sed',
                'tar',
                'unzip',
            },
        )
        buildroot_overlay_qemu_component = copy.copy(buildroot_component)
        # We need to build QEMU before the final Buildroot to get qemu-img.
        buildroot_overlay_qemu_component.dependencies = ['overlay', 'qemu']
        buildroot_overlay_gem5_component = copy.copy(buildroot_component)
        buildroot_overlay_gem5_component.dependencies = ['overlay-gem5']
        gem5_deps = {
            # TODO test it out on Docker and answer that question properly:
            # https://askubuntu.com/questions/350475/how-can-i-install-gem5
            'apt_get_pkgs': {
                'device-tree-compiler',
                'diod',
                'libgoogle-perftools-dev',
                'libboost-all-dev',
                'm4',
                'protobuf-compiler',
                'python-dev',
                'python-pip',
                # For prebuilt qcow2 unpack.
                'qemu-utils',
                'scons',
                'zlib1g-dev',
            },
            'python2_pkgs': {
                # Generate graphs of config.ini under m5out.
                'pydot',
            },
            'submodules_shallow': {'gem5'},
        }
        self.name_to_component_map = {
            'all': _Component(dependencies=[
                'qemu-gem5-buildroot',
                'all-baremetal',
                'user-mode-qemu',
                'doc',
            ]),
            'all-baremetal': _Component(dependencies=[
                    'qemu-baremetal',
                    'gem5-baremetal',
                    'baremetal-gem5-pbx',
                ],
                supported_archs=common.consts['crosstool_ng_supported_archs'],
            ),
            'baremetal': _Component(dependencies=[
                'baremetal-gem5',
                'baremetal-qemu',
            ]),
            'baremetal-qemu': _Component(
                self._build_file('build-baremetal', emulators=['qemu']),
                supported_archs=common.consts['crosstool_ng_supported_archs'],
                dependencies=['crosstool-ng'],
            ),
            'baremetal-gem5': _Component(
                self._build_file('build-baremetal', emulators=['gem5']),
                supported_archs=common.consts['crosstool_ng_supported_archs'],
                dependencies=['crosstool-ng'],
            ),
            'baremetal-gem5-pbx': _Component(
                self._build_file('build-baremetal', emulators=['gem5'], machine='RealViewPBX'),
                supported_archs=common.consts['crosstool_ng_supported_archs'],
                dependencies=['crosstool-ng'],
            ),
            'buildroot': buildroot_component,
            # We need those to avoid circular dependencies, since we need to run Buildroot
            # twice: once to get the toolchain, and a second time to put the overlay into
            # the root filesystem.
            'buildroot-overlay-qemu': buildroot_overlay_qemu_component,
            'buildroot-overlay-gem5': buildroot_overlay_gem5_component,
            'copy-overlay': _Component(
                self._build_file('copy-overlay'),
            ),
            'crosstool-ng': _Component(
                self._build_file('build-crosstool-ng'),
                supported_archs=common.consts['crosstool_ng_supported_archs'],
                # http://crosstool-ng.github.io/docs/os-setup/
                apt_get_pkgs={
                    'bison',
                    'docbook2x',
                    'flex',
                    'gawk',
                    'gcc',
                    'gperf',
                    'help2man',
                    'libncurses5-dev',
                    'libtool-bin',
                    'make',
                    'python-dev',
                    'texinfo',
                },
                submodules_shallow={'crosstool-ng'},
            ),
            'doc': _Component(
                self._build_file('build-doc'),
                ruby_pkgs={
                    'asciidoctor',
                },
            ),
            'gem5': _Component(
                self._build_file('build-gem5'),
                **gem5_deps
            ),
            'gem5-baremetal': _Component(dependencies=[
                'gem5',
                'baremetal-gem5',
            ]),
            'gem5-buildroot': _Component(dependencies=[
                'buildroot-overlay-gem5',
                'linux',
                'gem5',
            ]),
            'gem5-debug': _Component(
                self._build_file('build-gem5', gem5_build_type='debug'),
                **gem5_deps
            ),
            'gem5-fast': _Component(
                self._build_file('build-gem5', gem5_build_type='fast'),
                **gem5_deps
            ),
            'linux': _Component(
                self._build_file('build-linux'),
                dependencies={'buildroot'},
                submodules_shallow={'linux'},
                apt_get_pkgs={
                    'bison',
                    'flex',
                    # Without this started failing in kernel 4.15 with:
                    # Makefile:932: *** "Cannot generate ORC metadata for CONFIG_UNWINDER_ORC=y, please install libelf-dev, libelf-devel or elfutils-libelf-devel".  Stop.
                    'libelf-dev',
                },
            ),
            'modules': _Component(
                self._build_file('build-modules'),
                dependencies=['buildroot', 'linux'],
            ),
            'm5': _Component(
                self._build_file('build-m5'),
                dependencies=['buildroot'],
                submodules_shallow={'gem5'},
            ),
            'overlay': _Component(dependencies=[
                'copy-overlay',
                'modules',
                'userland',
            ]),
            'overlay-gem5': _Component(dependencies=[
                'm5',
                'overlay',
            ]),
            'parsec-benchmark': _Component(
                submodules_shallow={'parsec-benchmark'},
                dependencies=['buildroot'],
            ),
            'qemu': _Component(
                self._build_file('build-qemu'),
                apt_build_deps={'qemu'},
                apt_get_pkgs={'libsdl2-dev'},
                submodules={'qemu'},
            ),
            'qemu-baremetal': _Component(dependencies=[
                'qemu',
                'baremetal-qemu',
            ]),
            'qemu-buildroot': _Component(dependencies=[
                'buildroot-overlay-qemu',
                'linux',
            ]),
            'qemu-gem5-buildroot': _Component(dependencies=[
                'qemu',
                'gem5-buildroot',
            ]),
            'qemu-user': _Component(
                self._build_file('build-qemu', mode='userland'),
                apt_build_deps = {'qemu'},
                apt_get_pkgs={'libsdl2-dev'},
                submodules={'qemu'},
            ),
            'release': _Component(dependencies=[
                'baremetal-qemu',
                'qemu-buildroot',
                'doc',
            ]),
            'test-gdb': _Component(dependencies=[
                    'all-baremetal',
                    'userland',
                ],
            ),
            'test-executables-userland': _Component(dependencies=[
                'test-executables-userland-qemu',
                'test-executables-userland-gem5',
            ]),
            'test-executables-userland-qemu': _Component(dependencies=[
                'user-mode-qemu',
                'userland',
            ]),
            'test-executables-userland-gem5': _Component(dependencies=[
                'gem5',
                'userland-gem5',
            ]),
            'user-mode-qemu': _Component(
                dependencies=['qemu-user', 'userland'],
            ),
            'userland': _Component(
                self._build_file('build-userland'),
                dependencies=['buildroot'],
            ),
            'userland-host': _Component(
                self._build_file('build-userland-in-tree'),
                apt_get_pkgs={
                    'libboost-all-dev',
                    'libdrm-dev',
                    'libeigen3-dev',
                    'libopenblas-dev',
                },
            ),
            'userland-gem5': _Component(
                self._build_file('build-userland', static=True, userland_build_id='static'),
                dependencies=['buildroot'],
            ),
        }
        self.component_to_name_map = {self.name_to_component_map[key]:key for key in self.name_to_component_map}

        self.add_argument(
            '--apt',
            default=True,
            help='''\
Don't run any apt-get commands. To make it easier to use with other archs:
https://cirosantilli.com/linux-kernel-module-cheat#supported-hosts
'''
        )
        self.add_argument(
            '--download-dependencies',
            default=False,
            help='''\
Also download all dependencies required for a given build: Ubuntu packages,
Python packages and git submodules.
'''
        )
        self.add_argument(
            '--print-components',
            default=False,
            help='''\
Print the components that would be built, including dependencies, but don't
build them, nor show the build commands.
'''
        )
        self.add_argument(
            '--travis',
            default=False,
            help='''\
Extra args to pass to all scripts.
'''
        )
        self.add_argument(
            'components',
            choices=list(self.name_to_component_map.keys()) + [[]],
            default=[],
            nargs='*',
            help='''\
Which components to build. Default: qemu-buildroot
'''
        )

    def _build_file(self, component_file, **extra_args):
        '''
        Build something based on a component file that defines a Main class.
        '''
        def f():
            args = self.get_common_args()
            args.update(extra_args)
            args['show_time'] = False
            lkmc.import_path.import_path_main(component_file)(**args)
        return f

    def timed_main(self):
        self.sh = shell_helpers.ShellHelpers(dry_run=self.env['dry_run'])

        # Decide components.
        components = self.env['components']
        if components == []:
            components = ['qemu-buildroot']
        selected_components = []
        for component_name in components:
            todo = [component_name]
            while todo:
                current_name = todo.pop(0)
                component = self.name_to_component_map[current_name]
                selected_components.insert(0, component)
                todo.extend(component.dependencies)
        # Remove duplicates, keep only the first one of each.
        # https://stackoverflow.com/questions/7961363/removing-duplicates-in-lists/7961390#7961390
        selected_components = collections.OrderedDict.fromkeys(selected_components)

        if self.env['download_dependencies']:
            apt_get_pkgs = {
                # Core requirements for this repo.
                'git',
                'moreutils', # ts
                'python3-pip',
                'rr',
                'tmux',
                'vinagre',
                'wget',
            }
            # E.g. on an ARM host, the package gcc-arm-linux-gnueabihf
            # is called just gcc.
            processor = self.env['host_arch']
            if processor != 'arm':
                apt_get_pkgs.update({
                    'gcc-arm-linux-gnueabihf',
                    'g++-arm-linux-gnueabihf',
                })
            if processor != 'aarch64':
                apt_get_pkgs.update({
                    'gcc-aarch64-linux-gnu',
                    'g++-aarch64-linux-gnu',
                })
            apt_build_deps = set()
            submodules = set()
            submodules_shallow = set()
            python2_pkgs = set()
            python3_pkgs = {
                'pexpect==4.6.0',
            }
            ruby_pkgs = set()
            for component in selected_components:
                apt_get_pkgs.update(component.apt_get_pkgs)
                apt_build_deps.update(component.apt_build_deps)
                submodules.update(component.submodules)
                submodules_shallow.update(component.submodules_shallow)
                python2_pkgs.update(component.python2_pkgs)
                python3_pkgs.update(component.python3_pkgs)
                python3_pkgs.update(component.python3_pkgs)
                ruby_pkgs.update(component.ruby_pkgs)
            if ruby_pkgs:
                apt_get_pkgs.add('ruby')
            if apt_get_pkgs or apt_build_deps:
                if self.env['travis']:
                    interacive_pkgs = {
                        'libsdl2-dev',
                    }
                    apt_get_pkgs.difference_update(interacive_pkgs)
                if common.consts['in_docker']:
                    sudo = []
                    # https://askubuntu.com/questions/909277/avoiding-user-interaction-with-tzdata-when-installing-certbot-in-a-docker-contai
                    os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
                    # https://askubuntu.com/questions/496549/error-you-must-put-some-source-uris-in-your-sources-list
                    sources_path = os.path.join('/etc', 'apt', 'sources.list')
                    with open(sources_path, 'r') as f:
                        sources_txt = f.read()
                    sources_txt = re.sub('^# deb-src ', 'deb-src ', sources_txt, flags=re.MULTILINE)
                    with open(sources_path, 'w') as f:
                        f.write(sources_txt)
                else:
                    sudo = ['sudo']
                if common.consts['in_docker'] or self.env['travis']:
                    y = ['-y']
                else:
                    y = []
                if self.env['apt']:
                    self.sh.run_cmd(
                        sudo + ['apt-get', 'update', LF]
                    )
                    if apt_get_pkgs:
                        self.sh.run_cmd(
                            sudo + ['apt-get', 'install'] + y + [LF] +
                            self.sh.add_newlines(sorted(apt_get_pkgs))
                        )
                    if apt_build_deps:
                        self.sh.run_cmd(
                            sudo +
                            ['apt-get', 'build-dep'] + y + [LF] +
                            self.sh.add_newlines(sorted(apt_build_deps))
                        )
            if python2_pkgs:
                self.sh.run_cmd(
                    ['python', '-m', 'pip', 'install', '--user', LF] +
                    self.sh.add_newlines(sorted(python2_pkgs))
                )
            if python3_pkgs:
                # Not with pip executable directly:
                # https://stackoverflow.com/questions/49836676/error-after-upgrading-pip-cannot-import-name-main/51846054#51846054
                self.sh.run_cmd(
                    ['python3', '-m', 'pip', 'install', '--user', LF] +
                    self.sh.add_newlines(sorted(python3_pkgs))
                )
            if ruby_pkgs:
                # The right thing to do would be to use RVM and avoid sudo,
                # but we felt it was too much boilerplate for now.
                #
                # --user-install does work here, but we still need to add
                # the binary to PATH which is a pain:
                # https://stackoverflow.com/questions/31596273/install-gem-in-local-folder
                self.sh.run_cmd(['sudo', 'gem', 'install', 'bundler', LF])
                # No ones knows how to do this without sudo:
                # https://stackoverflow.com/questions/16376995/bundler-cannot-install-any-gems-without-sudo/27677094
                self.sh.run_cmd([
                    'sudo', LF,
                    'bundle', LF,
                    'install', LF,
                    '--gemfile', os.path.join(self.env['root_dir'], 'Gemfile'), LF,
                ])
            git_cmd_common = [
                'git', LF,
                'submodule', LF,
                'update', LF,
                '--init', LF,
                '--recursive', LF,
            ]
            if self.env['dry_run']:
                git_version_tuple = (math.inf, math.inf, math.inf)
            else:
                git_version_tuple = tuple(
                    int(x) for x in self.sh.check_output(['git', '--version']) \
                            .decode().split(' ')[-1].split('.')[:3]
                )
                if git_version_tuple >= (2, 9, 0):
                    # https://stackoverflow.com/questions/26957237/how-to-make-git-clone-faster-with-multiple-threads/52327638#52327638
                    git_cmd_common.extend(['--jobs', str(len(os.sched_getaffinity(0))), LF])
                if git_version_tuple >= (2, 10, 0):
                    # * https://stackoverflow.com/questions/32944468/how-to-show-progress-for-submodule-fetching
                    # * https://stackoverflow.com/questions/4640020/progress-indicator-for-git-clone
                    git_cmd_common.extend(['--progress', LF])
            def submodule_ids_to_cmd(submodules):
                return self.sh.add_newlines([os.path.join(common.consts['submodules_dir'], x) for x in sorted(submodules)])
            if submodules:
                self.sh.run_cmd(git_cmd_common + ['--', LF] + submodule_ids_to_cmd(submodules))
            if submodules_shallow:
                # TODO Ideally we should shallow clone --depth 1 all of them.
                #
                # However, most git servers out there are crap or craply configured
                # and don't allow shallow cloning except for branches.
                #
                # So for now I'm keeping all mirrors in my GitHub.
                # and always have a lkmc-* branch pointint to it.
                #
                # However, QEMU has a bunch of submodules itself, and I'm not in the mood
                # to mirror all of them...
                #
                # See also:
                #
                # * https://stackoverflow.com/questions/3489173/how-to-clone-git-repository-with-specific-revision-changeset
                # * https://stackoverflow.com/questions/2144406/git-shallow-submodules/47374702#47374702
                # * https://unix.stackexchange.com/questions/338578/why-is-the-git-clone-of-the-linux-kernel-source-code-much-larger-than-the-extrac
                cmd = git_cmd_common.copy()
                if git_version_tuple > (2, 7, 4):
                    # Then there is a bug in Ubuntu 16.04 git 2.7.4 where --depth 1 fails...
                    # OMG git submodules implementation sucks:
                    # * https://stackoverflow.com/questions/2155887/git-submodule-head-reference-is-not-a-tree-error/25875273#25875273
                    # * https://github.com/boostorg/boost/issues/245
                    cmd.extend(['--depth', '1', LF])
                else:
                    self.log_warn('your git is too old for git submodule update --depth 1')
                    self.log_warn('update to git 2.17 or newer and you will save clone time')
                    self.log_warn('see: https://github.com/cirosantilli/linux-kernel-module-cheat/issues/44')
                self.sh.run_cmd(cmd + ['--', LF] + submodule_ids_to_cmd(submodules_shallow))
            for submodule_name in submodule_extra_remotes:
                submodule = submodule_extra_remotes[submodule_name]
                for remote_name in submodule:
                    self.sh.run_cmd(
                        [
                            'git', LF,
                            '-C', os.path.join(common.consts['submodules_dir'], submodule_name), LF,
                            'remote', LF,
                            'add', LF,
                            remote_name, LF,
                            submodule[remote_name], LF,
                        ],
                        # In case the remote already exists.
                        raise_on_failure=False
                    )

        # Do the build.
        for component in selected_components:
            if self.env['print_components']:
                print(self.component_to_name_map[component])
            else:
                component.build(self.env['arch'])

if __name__ == '__main__':
    Main().cli()