launch

#!/usr/bin/env python3

import argparse
import os
import os.path
import subprocess
import signal
import sys

from launcher import *


TMUX_CONF = './.tmux.conf'


def TestRun(sim, uarts):
    sim.run()
    for uart in uarts:
        uart.run()

    try:
        Launchable.wait_any([sim] + uarts)
    except KeyboardInterrupt:
        pass

    for uart in reversed(uarts):
        uart.stop()
    sim.stop()


def DevelRun(sim, dbg, uarts):
    from libtmux import Server, Session

    subprocess.run(['tmux', '-f', TMUX_CONF, '-L', 'mimiker', 'start-server'])

    server = Server(config_file=TMUX_CONF, socket_name='mimiker')

    if server.has_session('mimiker'):
        server.kill_session('mimiker')

    session = server.new_session(session_name='mimiker', attach=False,
                                 window_name=':0', window_command='sleep 1')

    try:
        sim.start(session)
        for uart in uarts:
            uart.start(session)
        if dbg:
            dbg.start(session)

        session.kill_window(':0')
        session.select_window(dbg.name if dbg else '/dev/cons')
        session.attach_session()
    finally:
        server.kill_server()

        # Give QEMU a chance to exit gracefully
        sim.stop()


def sigterm_handler(_signo, _stack_frame):
    sys.exit(1)


if __name__ == '__main__':
    signal.signal(signal.SIGTERM, sigterm_handler)
    signal.signal(signal.SIGINT, sigterm_handler)
    signal.signal(signal.SIGHUP, sigterm_handler)

    parser = argparse.ArgumentParser(
        description='Launch kernel in Malta board simulator.')
    parser.add_argument('args', metavar='ARGS', type=str,
                        nargs=argparse.REMAINDER, help='Kernel arguments.')
    parser.add_argument('-D', '--debugger', metavar='DEBUGGER', type=str,
                        choices=Debuggers.keys(), default='gdb',
                        help=('Run debugging sesion with selected debugger. '
                              'Available options: %s. Default: %s.' %
                              (', '.join(sorted(Debuggers.keys())), 'gdb')))
    parser.add_argument('-d', '--debug', action='store_true',
                        help='Start debugging session with selected debugger.')
    parser.add_argument('-t', '--test-run', action='store_true',
                        help='Test-run mode: simulator output goes to stdout.')
    parser.add_argument('-g', '--graphics', action='store_true',
                        help='Enable VGA output.')
    parser.add_argument('-p', '--port', metavar='PORT', type=int,
                        help='Run gdbserver on specified localhost port.')
    parser.add_argument('-b', '--board', default='malta',
                        choices=['malta', 'rpi3'], help='Emulated board.')
    args = parser.parse_args()

    # Used by tmux to override ./.tmux.conf with ./.tmux.conf.local
    os.environ['MIMIKER_REPO'] = os.path.dirname(os.path.realpath(sys.argv[0]))

    if args.port:
        port = int(args.port)
    else:
        port = RandomPort()

    setboard(args.board)
    setvar('config.debug', args.debug)
    setvar('config.graphics', args.graphics)
    setvar('config.args', args.args)
    setvar('config.gdbport', port)

    # Check if the kernel file is available
    if not os.path.isfile(getvar('config.kernel')):
        raise SystemExit('%s: file does not exist!' % getvar('config.kernel'))

    sim = QEMU()

    if args.debug:
        kernel_args = {}
        for arg in args.args:
            try:
                key, val = arg.split('=', 1)
                kernel_args[key] = val
            except ValueError:
                pass

        if 'test' in kernel_args:
            host_path = "sysroot/bin/utest.dbg"
        elif 'init' in kernel_args:
            host_path = f"sysroot{kernel_args['init']}.dbg"
        else:
            host_path = None

        if host_path is not None:
            extra = getvar('gdb.extra-options')
            extra.append(f'-ex=add-symbol-file {host_path} 0x400000')

        dbg = Debuggers[args.debugger]()
    else:
        dbg = None

    uarts = [SOCAT(uart['name'], uart['port'], uart.get('raw', False))
             for uart in getvar('qemu.uarts')]

    if args.test_run:
        TestRun(sim, uarts)
    else:
        DevelRun(sim, dbg, uarts)