runqemu: refactor it and remove machine knowledge
Previously, runqemu had hard coded machine knowledge, which limited its
usage, for example, qemu can boot genericx86, but runqemu can't, we need
edit runqemu/runqemu-internal a lot if we want to boot genericx86.
Now bsp conf files can set vars to make it can be boot by runqemu, and
qemuboot.bbclass will save these info to DEPLOY_DIR_IMAGE/qemuboot.conf.
Please see qemuboot.bbclass' comments on how to set the vars.
* Re-write it in python3, which can reduce lines from 1239 to about 750
lines
* All the machine knowledges are gone
* All of the TUN_ARCH knowledge are gone
* All the previous options are preserved, and there is a new way to run
runqemu: (it doesn't need run "bitake -e" in such a case)
$ runqemu tmp/deploy/images/qemux86
or:
$ runqemu tmp/deploy/images/qemuarm/<image>.ext4
or:
$ runqemu tmp/deploy/images/qemuarm/qemuboot.conf
* Fixed audio support, not limited on x86 or x86_64
* Fix SLIRP mode, add help message, avoid mixing with tap
* Fix NFS boot, it will extract <image>.tar.bz2 or tar.gz to
DEPLOY_DIR_IMAGE/<image>-nfsroot when no NFS_DIR, and remove it after
stop.
* More bsps can be boot, such as genericx86 and genericx86-64.
* The patch for qemuzynq, qemuzynqmp, qemumicroblaze has been sent to
meta-xilinx' mailing list.
* I can't find any qemush4 bsp or how to build it, so it is not
considered atm.
[YOCTO #1018]
[YOCTO #4827]
[YOCTO #7459]
[YOCTO #7887]
(From OE-Core rev: 60ca8a8d899b90a4693fd62b6ec97d0c76a9f6c5)
Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2016-08-25 14:41:05 +00:00
|
|
|
#!/usr/bin/env python3
|
|
|
|
|
2011-04-21 11:26:25 +00:00
|
|
|
# Handle running OE images standalone with QEMU
|
2007-01-16 12:23:08 +00:00
|
|
|
#
|
2011-04-21 11:26:25 +00:00
|
|
|
# Copyright (C) 2006-2011 Linux Foundation
|
runqemu: refactor it and remove machine knowledge
Previously, runqemu had hard coded machine knowledge, which limited its
usage, for example, qemu can boot genericx86, but runqemu can't, we need
edit runqemu/runqemu-internal a lot if we want to boot genericx86.
Now bsp conf files can set vars to make it can be boot by runqemu, and
qemuboot.bbclass will save these info to DEPLOY_DIR_IMAGE/qemuboot.conf.
Please see qemuboot.bbclass' comments on how to set the vars.
* Re-write it in python3, which can reduce lines from 1239 to about 750
lines
* All the machine knowledges are gone
* All of the TUN_ARCH knowledge are gone
* All the previous options are preserved, and there is a new way to run
runqemu: (it doesn't need run "bitake -e" in such a case)
$ runqemu tmp/deploy/images/qemux86
or:
$ runqemu tmp/deploy/images/qemuarm/<image>.ext4
or:
$ runqemu tmp/deploy/images/qemuarm/qemuboot.conf
* Fixed audio support, not limited on x86 or x86_64
* Fix SLIRP mode, add help message, avoid mixing with tap
* Fix NFS boot, it will extract <image>.tar.bz2 or tar.gz to
DEPLOY_DIR_IMAGE/<image>-nfsroot when no NFS_DIR, and remove it after
stop.
* More bsps can be boot, such as genericx86 and genericx86-64.
* The patch for qemuzynq, qemuzynqmp, qemumicroblaze has been sent to
meta-xilinx' mailing list.
* I can't find any qemush4 bsp or how to build it, so it is not
considered atm.
[YOCTO #1018]
[YOCTO #4827]
[YOCTO #7459]
[YOCTO #7887]
(From OE-Core rev: 60ca8a8d899b90a4693fd62b6ec97d0c76a9f6c5)
Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2016-08-25 14:41:05 +00:00
|
|
|
# Copyright (c) 2016 Wind River Systems, Inc.
|
2007-01-16 12:23:08 +00:00
|
|
|
#
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
|
|
# it under the terms of the GNU General Public License version 2 as
|
|
|
|
# published by the Free Software Foundation.
|
|
|
|
#
|
|
|
|
# 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2007-05-16 13:48:29 +00:00
|
|
|
|
runqemu: refactor it and remove machine knowledge
Previously, runqemu had hard coded machine knowledge, which limited its
usage, for example, qemu can boot genericx86, but runqemu can't, we need
edit runqemu/runqemu-internal a lot if we want to boot genericx86.
Now bsp conf files can set vars to make it can be boot by runqemu, and
qemuboot.bbclass will save these info to DEPLOY_DIR_IMAGE/qemuboot.conf.
Please see qemuboot.bbclass' comments on how to set the vars.
* Re-write it in python3, which can reduce lines from 1239 to about 750
lines
* All the machine knowledges are gone
* All of the TUN_ARCH knowledge are gone
* All the previous options are preserved, and there is a new way to run
runqemu: (it doesn't need run "bitake -e" in such a case)
$ runqemu tmp/deploy/images/qemux86
or:
$ runqemu tmp/deploy/images/qemuarm/<image>.ext4
or:
$ runqemu tmp/deploy/images/qemuarm/qemuboot.conf
* Fixed audio support, not limited on x86 or x86_64
* Fix SLIRP mode, add help message, avoid mixing with tap
* Fix NFS boot, it will extract <image>.tar.bz2 or tar.gz to
DEPLOY_DIR_IMAGE/<image>-nfsroot when no NFS_DIR, and remove it after
stop.
* More bsps can be boot, such as genericx86 and genericx86-64.
* The patch for qemuzynq, qemuzynqmp, qemumicroblaze has been sent to
meta-xilinx' mailing list.
* I can't find any qemush4 bsp or how to build it, so it is not
considered atm.
[YOCTO #1018]
[YOCTO #4827]
[YOCTO #7459]
[YOCTO #7887]
(From OE-Core rev: 60ca8a8d899b90a4693fd62b6ec97d0c76a9f6c5)
Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2016-08-25 14:41:05 +00:00
|
|
|
import os
|
|
|
|
import sys
|
|
|
|
import logging
|
|
|
|
import subprocess
|
|
|
|
import re
|
|
|
|
import fcntl
|
|
|
|
import shutil
|
|
|
|
import glob
|
|
|
|
import configparser
|
|
|
|
|
|
|
|
def create_logger():
|
|
|
|
logger = logging.getLogger('runqemu')
|
|
|
|
logger.setLevel(logging.INFO)
|
|
|
|
|
|
|
|
# create console handler and set level to debug
|
|
|
|
ch = logging.StreamHandler()
|
|
|
|
ch.setLevel(logging.INFO)
|
|
|
|
|
|
|
|
# create formatter
|
|
|
|
formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
|
|
|
|
|
|
|
|
# add formatter to ch
|
|
|
|
ch.setFormatter(formatter)
|
|
|
|
|
|
|
|
# add ch to logger
|
|
|
|
logger.addHandler(ch)
|
|
|
|
|
|
|
|
return logger
|
|
|
|
|
|
|
|
logger = create_logger()
|
2016-02-26 02:06:26 +00:00
|
|
|
|
runqemu: refactor it and remove machine knowledge
Previously, runqemu had hard coded machine knowledge, which limited its
usage, for example, qemu can boot genericx86, but runqemu can't, we need
edit runqemu/runqemu-internal a lot if we want to boot genericx86.
Now bsp conf files can set vars to make it can be boot by runqemu, and
qemuboot.bbclass will save these info to DEPLOY_DIR_IMAGE/qemuboot.conf.
Please see qemuboot.bbclass' comments on how to set the vars.
* Re-write it in python3, which can reduce lines from 1239 to about 750
lines
* All the machine knowledges are gone
* All of the TUN_ARCH knowledge are gone
* All the previous options are preserved, and there is a new way to run
runqemu: (it doesn't need run "bitake -e" in such a case)
$ runqemu tmp/deploy/images/qemux86
or:
$ runqemu tmp/deploy/images/qemuarm/<image>.ext4
or:
$ runqemu tmp/deploy/images/qemuarm/qemuboot.conf
* Fixed audio support, not limited on x86 or x86_64
* Fix SLIRP mode, add help message, avoid mixing with tap
* Fix NFS boot, it will extract <image>.tar.bz2 or tar.gz to
DEPLOY_DIR_IMAGE/<image>-nfsroot when no NFS_DIR, and remove it after
stop.
* More bsps can be boot, such as genericx86 and genericx86-64.
* The patch for qemuzynq, qemuzynqmp, qemumicroblaze has been sent to
meta-xilinx' mailing list.
* I can't find any qemush4 bsp or how to build it, so it is not
considered atm.
[YOCTO #1018]
[YOCTO #4827]
[YOCTO #7459]
[YOCTO #7887]
(From OE-Core rev: 60ca8a8d899b90a4693fd62b6ec97d0c76a9f6c5)
Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2016-08-25 14:41:05 +00:00
|
|
|
def print_usage():
|
|
|
|
print("""
|
2016-02-26 02:06:26 +00:00
|
|
|
Usage: you can run this script with any valid combination
|
|
|
|
of the following environment variables (in any order):
|
|
|
|
KERNEL - the kernel image file to use
|
|
|
|
ROOTFS - the rootfs image file or nfsroot directory to use
|
|
|
|
MACHINE - the machine name (optional, autodetected from KERNEL filename if unspecified)
|
|
|
|
Simplified QEMU command-line options can be passed with:
|
runqemu: refactor it and remove machine knowledge
Previously, runqemu had hard coded machine knowledge, which limited its
usage, for example, qemu can boot genericx86, but runqemu can't, we need
edit runqemu/runqemu-internal a lot if we want to boot genericx86.
Now bsp conf files can set vars to make it can be boot by runqemu, and
qemuboot.bbclass will save these info to DEPLOY_DIR_IMAGE/qemuboot.conf.
Please see qemuboot.bbclass' comments on how to set the vars.
* Re-write it in python3, which can reduce lines from 1239 to about 750
lines
* All the machine knowledges are gone
* All of the TUN_ARCH knowledge are gone
* All the previous options are preserved, and there is a new way to run
runqemu: (it doesn't need run "bitake -e" in such a case)
$ runqemu tmp/deploy/images/qemux86
or:
$ runqemu tmp/deploy/images/qemuarm/<image>.ext4
or:
$ runqemu tmp/deploy/images/qemuarm/qemuboot.conf
* Fixed audio support, not limited on x86 or x86_64
* Fix SLIRP mode, add help message, avoid mixing with tap
* Fix NFS boot, it will extract <image>.tar.bz2 or tar.gz to
DEPLOY_DIR_IMAGE/<image>-nfsroot when no NFS_DIR, and remove it after
stop.
* More bsps can be boot, such as genericx86 and genericx86-64.
* The patch for qemuzynq, qemuzynqmp, qemumicroblaze has been sent to
meta-xilinx' mailing list.
* I can't find any qemush4 bsp or how to build it, so it is not
considered atm.
[YOCTO #1018]
[YOCTO #4827]
[YOCTO #7459]
[YOCTO #7887]
(From OE-Core rev: 60ca8a8d899b90a4693fd62b6ec97d0c76a9f6c5)
Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2016-08-25 14:41:05 +00:00
|
|
|
nographic - disable video console
|
|
|
|
serial - enable a serial console on /dev/ttyS0
|
|
|
|
slirp - enable user networking, no root privileges is required
|
|
|
|
kvm - enable KVM when running x86/x86_64 (VT-capable CPU required)
|
|
|
|
kvm-vhost - enable KVM with vhost when running x86/x86_64 (VT-capable CPU required)
|
2016-02-26 02:06:26 +00:00
|
|
|
publicvnc - enable a VNC server open to all hosts
|
runqemu: refactor it and remove machine knowledge
Previously, runqemu had hard coded machine knowledge, which limited its
usage, for example, qemu can boot genericx86, but runqemu can't, we need
edit runqemu/runqemu-internal a lot if we want to boot genericx86.
Now bsp conf files can set vars to make it can be boot by runqemu, and
qemuboot.bbclass will save these info to DEPLOY_DIR_IMAGE/qemuboot.conf.
Please see qemuboot.bbclass' comments on how to set the vars.
* Re-write it in python3, which can reduce lines from 1239 to about 750
lines
* All the machine knowledges are gone
* All of the TUN_ARCH knowledge are gone
* All the previous options are preserved, and there is a new way to run
runqemu: (it doesn't need run "bitake -e" in such a case)
$ runqemu tmp/deploy/images/qemux86
or:
$ runqemu tmp/deploy/images/qemuarm/<image>.ext4
or:
$ runqemu tmp/deploy/images/qemuarm/qemuboot.conf
* Fixed audio support, not limited on x86 or x86_64
* Fix SLIRP mode, add help message, avoid mixing with tap
* Fix NFS boot, it will extract <image>.tar.bz2 or tar.gz to
DEPLOY_DIR_IMAGE/<image>-nfsroot when no NFS_DIR, and remove it after
stop.
* More bsps can be boot, such as genericx86 and genericx86-64.
* The patch for qemuzynq, qemuzynqmp, qemumicroblaze has been sent to
meta-xilinx' mailing list.
* I can't find any qemush4 bsp or how to build it, so it is not
considered atm.
[YOCTO #1018]
[YOCTO #4827]
[YOCTO #7459]
[YOCTO #7887]
(From OE-Core rev: 60ca8a8d899b90a4693fd62b6ec97d0c76a9f6c5)
Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2016-08-25 14:41:05 +00:00
|
|
|
audio - enable audio
|
|
|
|
tcpserial=<port> - specify tcp serial port number
|
|
|
|
biosdir=<dir> - specify custom bios dir
|
|
|
|
biosfilename=<filename> - specify bios filename
|
|
|
|
qemuparams=<xyz> - specify custom parameters to QEMU
|
|
|
|
bootparams=<xyz> - specify custom kernel parameters during boot
|
|
|
|
help: print this text
|
2016-02-26 02:06:26 +00:00
|
|
|
|
|
|
|
Examples:
|
runqemu: refactor it and remove machine knowledge
Previously, runqemu had hard coded machine knowledge, which limited its
usage, for example, qemu can boot genericx86, but runqemu can't, we need
edit runqemu/runqemu-internal a lot if we want to boot genericx86.
Now bsp conf files can set vars to make it can be boot by runqemu, and
qemuboot.bbclass will save these info to DEPLOY_DIR_IMAGE/qemuboot.conf.
Please see qemuboot.bbclass' comments on how to set the vars.
* Re-write it in python3, which can reduce lines from 1239 to about 750
lines
* All the machine knowledges are gone
* All of the TUN_ARCH knowledge are gone
* All the previous options are preserved, and there is a new way to run
runqemu: (it doesn't need run "bitake -e" in such a case)
$ runqemu tmp/deploy/images/qemux86
or:
$ runqemu tmp/deploy/images/qemuarm/<image>.ext4
or:
$ runqemu tmp/deploy/images/qemuarm/qemuboot.conf
* Fixed audio support, not limited on x86 or x86_64
* Fix SLIRP mode, add help message, avoid mixing with tap
* Fix NFS boot, it will extract <image>.tar.bz2 or tar.gz to
DEPLOY_DIR_IMAGE/<image>-nfsroot when no NFS_DIR, and remove it after
stop.
* More bsps can be boot, such as genericx86 and genericx86-64.
* The patch for qemuzynq, qemuzynqmp, qemumicroblaze has been sent to
meta-xilinx' mailing list.
* I can't find any qemush4 bsp or how to build it, so it is not
considered atm.
[YOCTO #1018]
[YOCTO #4827]
[YOCTO #7459]
[YOCTO #7887]
(From OE-Core rev: 60ca8a8d899b90a4693fd62b6ec97d0c76a9f6c5)
Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2016-08-25 14:41:05 +00:00
|
|
|
runqemu qemuarm
|
|
|
|
runqemu tmp/deploy/images/qemuarm
|
|
|
|
runqemu tmp/deploy/images/qemux86/.qemuboot.conf
|
|
|
|
runqemu qemux86-64 core-image-sato ext4
|
|
|
|
runqemu qemux86-64 wic-image-minimal wic
|
|
|
|
runqemu path/to/bzImage-qemux86.bin path/to/nfsrootdir/ serial
|
|
|
|
runqemu qemux86 iso/hddimg/vmdk/qcow2/vdi/ramfs/cpio.gz...
|
|
|
|
runqemu qemux86 qemuparams="-m 256"
|
|
|
|
runqemu qemux86 bootparams="psplash=false"
|
|
|
|
runqemu path/to/<image>-<machine>.vmdk
|
|
|
|
runqemu path/to/<image>-<machine>.wic
|
|
|
|
""")
|
|
|
|
|
|
|
|
def check_tun():
|
|
|
|
"""Check /dev/net/run"""
|
|
|
|
dev_tun = '/dev/net/tun'
|
|
|
|
if not os.path.exists(dev_tun):
|
|
|
|
raise Exception("TUN control device %s is unavailable; you may need to enable TUN (e.g. sudo modprobe tun)" % dev_tun)
|
|
|
|
|
|
|
|
if not os.access(dev_tun, os.W_OK):
|
|
|
|
raise Exception("TUN control device %s is not writable, please fix (e.g. sudo chmod 666 %s)" % (dev_tun, dev_tun))
|
|
|
|
|
|
|
|
def check_libgl(qemu_bin):
|
|
|
|
cmd = 'ldd %s' % qemu_bin
|
|
|
|
logger.info('Running %s...' % cmd)
|
|
|
|
need_gl = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
|
|
|
|
if re.search('libGLU', need_gl):
|
|
|
|
# We can't run without a libGL.so
|
|
|
|
libgl = False
|
|
|
|
check_files = (('/usr/lib/libGL.so', '/usr/lib/libGLU.so'), \
|
|
|
|
('/usr/lib64/libGL.so', '/usr/lib64/libGLU.so'), \
|
|
|
|
('/usr/lib/*-linux-gnu/libGL.so', '/usr/lib/*-linux-gnu/libGLU.so'))
|
|
|
|
|
|
|
|
for (f1, f2) in check_files:
|
|
|
|
if re.search('\*', f1):
|
|
|
|
for g1 in glob.glob(f1):
|
|
|
|
if libgl:
|
|
|
|
break
|
|
|
|
if os.path.exists(g1):
|
|
|
|
for g2 in glob.glob(f2):
|
|
|
|
if os.path.exists(g2):
|
|
|
|
libgl = True
|
|
|
|
break
|
|
|
|
if libgl:
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
if os.path.exists(f1) and os.path.exists(f2):
|
|
|
|
libgl = True
|
|
|
|
break
|
|
|
|
if not libgl:
|
|
|
|
logger.error("You need libGL.so and libGLU.so to exist in your library path to run the QEMU emulator.")
|
|
|
|
logger.error("Ubuntu package names are: libgl1-mesa-dev and libglu1-mesa-dev.")
|
|
|
|
logger.error("Fedora package names are: mesa-libGL-devel mesa-libGLU-devel.")
|
|
|
|
raise Exception('%s requires libGLU, but not found' % qemu_bin)
|
|
|
|
|
|
|
|
class BaseConfig(object):
|
|
|
|
def __init__(self):
|
|
|
|
# Vars can be merged with .qemuboot.conf, use a dict to manage them.
|
|
|
|
self.d = {
|
|
|
|
'MACHINE': '',
|
|
|
|
'DEPLOY_DIR_IMAGE': '',
|
|
|
|
'QB_KERNEL_ROOT': '/dev/vda',
|
|
|
|
}
|
|
|
|
|
|
|
|
self.qemu_opt = ''
|
|
|
|
self.qemu_opt_script = ''
|
|
|
|
self.nfs_dir = ''
|
|
|
|
self.clean_nfs_dir = False
|
|
|
|
self.nfs_server = ''
|
|
|
|
self.rootfs = ''
|
|
|
|
self.qemuboot = ''
|
|
|
|
self.kernel = ''
|
|
|
|
self.kernel_cmdline = ''
|
|
|
|
self.kernel_cmdline_script = ''
|
|
|
|
self.fstype = ''
|
|
|
|
self.kvm_enabled = False
|
|
|
|
self.vhost_enabled = False
|
|
|
|
self.slirp_enabled = False
|
|
|
|
self.nfs_instance = 0
|
|
|
|
self.nfs_running = False
|
|
|
|
self.serialstdio = False
|
|
|
|
self.cleantap = False
|
|
|
|
self.saved_stty = ''
|
|
|
|
self.audio_enabled = False
|
|
|
|
self.tcpserial_portnum = ''
|
|
|
|
self.custombiosdir = ''
|
|
|
|
self.lock = ''
|
|
|
|
self.lock_descriptor = ''
|
|
|
|
self.bitbake_e = ''
|
|
|
|
self.fstypes = ('ext2', 'ext3', 'ext4', 'jffs2', 'nfs', 'btrfs', 'cpio.gz', 'cpio', 'ramfs')
|
|
|
|
self.vmtypes = ('hddimg', 'hdddirect', 'wic', 'vmdk', 'qcow2', 'vdi', 'iso')
|
|
|
|
|
|
|
|
def acquire_lock(self):
|
|
|
|
logger.info("Acquiring lockfile %s..." % self.lock)
|
|
|
|
lock_descriptor = open(self.lock, 'w')
|
|
|
|
try:
|
|
|
|
fcntl.flock(lock_descriptor, fcntl.LOCK_EX|fcntl.LOCK_NB)
|
|
|
|
except Exception as e:
|
|
|
|
logger.info("Acquiring lockfile %s failed: %s" % (self.lock, e))
|
|
|
|
lock_descriptor.close()
|
|
|
|
return False
|
|
|
|
self.lock_descriptor = lock_descriptor
|
|
|
|
return True
|
|
|
|
|
|
|
|
def release_lock(self):
|
|
|
|
fcntl.flock(self.lock_descriptor, fcntl.LOCK_UN)
|
|
|
|
self.lock_descriptor.close()
|
|
|
|
os.remove(self.lock)
|
|
|
|
|
|
|
|
def get(self, key):
|
|
|
|
if key in self.d:
|
|
|
|
return self.d.get(key)
|
|
|
|
else:
|
|
|
|
return ''
|
|
|
|
|
|
|
|
def set(self, key, value):
|
|
|
|
self.d[key] = value
|
|
|
|
|
|
|
|
def is_deploy_dir_image(self, p):
|
|
|
|
if os.path.isdir(p):
|
|
|
|
if not re.search('.qemuboot.conf$', '\n'.join(os.listdir(p)), re.M):
|
|
|
|
logger.info("Can't find required qemuboot.conf in %s" % p)
|
|
|
|
return False
|
|
|
|
if not re.search('-image-', '\n'.join(os.listdir(p))):
|
|
|
|
logger.info("Can't find *-image-* in %s" % p)
|
|
|
|
return False
|
|
|
|
return True
|
|
|
|
else:
|
|
|
|
return False
|
|
|
|
|
|
|
|
def check_arg_fstype(self, fst):
|
|
|
|
"""Check and set FSTYPE"""
|
|
|
|
if fst not in self.fstypes + self.vmtypes:
|
|
|
|
logger.warn("Maybe unsupported FSTYPE: %s" % fst)
|
|
|
|
if not self.fstype or self.fstype == fst:
|
|
|
|
if fst == 'ramfs':
|
|
|
|
fst = 'cpio.gz'
|
|
|
|
self.fstype = fst
|
|
|
|
else:
|
|
|
|
raise Exception("Conflicting: FSTYPE %s and %s" % (self.fstype, fst))
|
|
|
|
|
|
|
|
def set_machine_deploy_dir(self, machine, deploy_dir_image):
|
|
|
|
"""Set MACHINE and DEPLOY_DIR_IMAGE"""
|
|
|
|
logger.info('MACHINE: %s' % machine)
|
|
|
|
self.set("MACHINE", machine)
|
|
|
|
logger.info('DEPLOY_DIR_IMAGE: %s' % deploy_dir_image)
|
|
|
|
self.set("DEPLOY_DIR_IMAGE", deploy_dir_image)
|
|
|
|
|
|
|
|
def check_arg_nfs(self, p):
|
|
|
|
if os.path.isdir(p):
|
|
|
|
self.nfs_dir = p
|
|
|
|
else:
|
|
|
|
m = re.match('(.*):(.*)', p)
|
|
|
|
self.nfs_server = m.group(1)
|
|
|
|
self.nfs_dir = m.group(2)
|
|
|
|
self.rootfs = ""
|
|
|
|
self.check_arg_fstype('nfs')
|
|
|
|
|
|
|
|
def check_arg_path(self, p):
|
|
|
|
"""
|
|
|
|
- Check whether it is <image>.qemuboot.conf or contains <image>.qemuboot.conf
|
|
|
|
- Check whether is a kernel file
|
|
|
|
- Check whether is a image file
|
|
|
|
- Check whether it is a nfs dir
|
|
|
|
"""
|
|
|
|
if p.endswith('.qemuboot.conf'):
|
|
|
|
self.qemuboot = p
|
|
|
|
elif re.search('\.bin$', p) or re.search('bzImage', p) or \
|
|
|
|
re.search('zImage', p) or re.search('vmlinux', p) or \
|
|
|
|
re.search('fitImage', p) or re.search('uImage', p):
|
|
|
|
self.kernel = p
|
|
|
|
elif os.path.exists(p) and (not os.path.isdir(p)) and re.search('-image-', os.path.basename(p)):
|
|
|
|
self.rootfs = p
|
|
|
|
dirpath = os.path.dirname(p)
|
|
|
|
m = re.search('(.*)\.(.*)$', p)
|
|
|
|
if m:
|
|
|
|
qb = '%s%s' % (re.sub('\.rootfs$', '', m.group(1)), '.qemuboot.conf')
|
|
|
|
if os.path.exists(qb):
|
|
|
|
self.qemuboot = qb
|
|
|
|
else:
|
|
|
|
logger.warn("%s doesn't exist" % qb)
|
|
|
|
fst = m.group(2)
|
|
|
|
self.check_arg_fstype(fst)
|
|
|
|
else:
|
|
|
|
raise Exception("Can't find FSTYPE from: %s" % p)
|
|
|
|
elif os.path.isdir(p) or re.search(':', arg) and re.search('/', arg):
|
|
|
|
if self.is_deploy_dir_image(p):
|
|
|
|
logger.info('DEPLOY_DIR_IMAGE: %s' % p)
|
|
|
|
self.set("DEPLOY_DIR_IMAGE", p)
|
|
|
|
else:
|
|
|
|
logger.info("Assuming %s is an nfs rootfs" % p)
|
|
|
|
self.check_arg_nfs(p)
|
|
|
|
else:
|
|
|
|
raise Exception("Unknown path arg %s" % p)
|
|
|
|
|
|
|
|
def check_arg_machine(self, arg):
|
|
|
|
"""Check whether it is a machine"""
|
|
|
|
if self.get('MACHINE') and self.get('MACHINE') != arg or re.search('/', arg):
|
|
|
|
raise Exception("Unknown arg: %s" % arg)
|
|
|
|
elif self.get('MACHINE') == arg:
|
|
|
|
return
|
|
|
|
logger.info('Assuming MACHINE = %s' % arg)
|
|
|
|
cmd = 'MACHINE=%s bitbake -e' % arg
|
|
|
|
logger.info('Running %s...' % cmd)
|
|
|
|
self.bitbake_e = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
|
|
|
|
# bitbake -e doesn't report invalid MACHINE as an error, so
|
|
|
|
# let's check DEPLOY_DIR_IMAGE to make sure that it is a valid
|
|
|
|
# MACHINE.
|
|
|
|
s = re.search('^DEPLOY_DIR_IMAGE="(.*)"', self.bitbake_e, re.M)
|
|
|
|
if s:
|
|
|
|
deploy_dir_image = s.group(1)
|
|
|
|
else:
|
|
|
|
raise Exception("bitbake -e %s" % self.bitbake_e)
|
|
|
|
if self.is_deploy_dir_image(deploy_dir_image):
|
|
|
|
self.set_machine_deploy_dir(arg, deploy_dir_image)
|
|
|
|
else:
|
|
|
|
logger.error("%s not a directory valid DEPLOY_DIR_IMAGE" % deploy_dir_image)
|
|
|
|
raise Exception("Failed to set MACHINE to %s. Unknown arg: %s" % (arg, arg))
|
|
|
|
|
|
|
|
def check_args(self):
|
|
|
|
unknown_arg = ""
|
|
|
|
for arg in sys.argv[1:]:
|
|
|
|
if arg in self.fstypes + self.vmtypes:
|
|
|
|
self.check_arg_fstype(arg)
|
|
|
|
elif arg == 'nographic':
|
|
|
|
self.qemu_opt_script += ' -nographic'
|
|
|
|
self.kernel_cmdline_script += ' console=ttyS0'
|
|
|
|
elif arg == 'serial':
|
|
|
|
self.kernel_cmdline_script += ' console=ttyS0'
|
|
|
|
self.serialstdio = True
|
|
|
|
elif arg == 'audio':
|
|
|
|
logger.info("Enabling audio in qemu")
|
|
|
|
logger.info("Please install sound drivers in linux host")
|
|
|
|
self.audio_enabled = True
|
|
|
|
elif arg == 'kvm':
|
|
|
|
self.kvm_enabled = True
|
|
|
|
elif arg == 'kvm-vhost':
|
|
|
|
self.vhost_enabled = True
|
|
|
|
elif arg == 'slirp':
|
|
|
|
self.slirp_enabled = True
|
|
|
|
elif arg == 'publicvnc':
|
|
|
|
self.qemu_opt_script += ' -vnc :0'
|
|
|
|
elif arg.startswith('tcpserial='):
|
|
|
|
self.tcpserial_portnum = arg[len('tcpserial='):]
|
|
|
|
elif arg.startswith('biosdir='):
|
|
|
|
self.custombiosdir = arg[len('biosdir='):]
|
|
|
|
elif arg.startswith('biosfilename='):
|
|
|
|
self.qemu_opt_script += ' -bios %s' % arg[len('biosfilename='):]
|
|
|
|
elif arg.startswith('qemuparams='):
|
|
|
|
self.qemu_opt_script += ' %s' % arg[len('qemuparams='):]
|
|
|
|
elif arg.startswith('bootparams='):
|
|
|
|
self.kernel_cmdline_script += ' %s' % arg[len('bootparams='):]
|
|
|
|
elif os.path.exists(arg) or (re.search(':', arg) and re.search('/', arg)):
|
|
|
|
self.check_arg_path(os.path.abspath(arg))
|
|
|
|
elif re.search('-image-', arg):
|
|
|
|
# Lazy rootfs
|
|
|
|
self.rootfs = arg
|
|
|
|
else:
|
|
|
|
# At last, assume is it the MACHINE
|
|
|
|
if (not unknown_arg) or unknown_arg == arg:
|
|
|
|
unknown_arg = arg
|
|
|
|
else:
|
|
|
|
raise Exception("Can't handle two unknown args: %s %s" % (unknown_arg, arg))
|
|
|
|
# Check to make sure it is a valid machine
|
|
|
|
if unknown_arg:
|
|
|
|
if self.get('MACHINE') == unknown_arg:
|
|
|
|
return
|
|
|
|
if not self.get('DEPLOY_DIR_IMAGE'):
|
|
|
|
# Trying to get DEPLOY_DIR_IMAGE from env.
|
|
|
|
p = os.getenv('DEPLOY_DIR_IMAGE')
|
|
|
|
if p and self.is_deploy_dir_image(p):
|
|
|
|
machine = os.path.basename(p)
|
|
|
|
if unknown_arg == machine:
|
|
|
|
self.set_machine_deploy_dir(machine, p)
|
|
|
|
return
|
|
|
|
else:
|
|
|
|
logger.info('DEPLOY_DIR_IMAGE: %s' % p)
|
|
|
|
self.set("DEPLOY_DIR_IMAGE", p)
|
|
|
|
self.check_arg_machine(unknown_arg)
|
|
|
|
|
|
|
|
def check_kvm(self):
|
|
|
|
"""Check kvm and kvm-host"""
|
|
|
|
if not (self.kvm_enabled or self.vhost_enabled):
|
|
|
|
self.qemu_opt_script += ' %s %s' % (self.get('QB_MACHINE'), self.get('QB_CPU'))
|
|
|
|
return
|
|
|
|
|
|
|
|
if not self.get('QB_CPU_KVM'):
|
|
|
|
raise Exception("QB_CPU_KVM is NULL, this board doesn't support kvm")
|
|
|
|
|
|
|
|
self.qemu_opt_script += ' %s %s' % (self.get('QB_MACHINE'), self.get('QB_CPU_KVM'))
|
|
|
|
yocto_kvm_wiki = "https://wiki.yoctoproject.org/wiki/How_to_enable_KVM_for_Poky_qemu"
|
|
|
|
yocto_paravirt_kvm_wiki = "https://wiki.yoctoproject.org/wiki/Running_an_x86_Yocto_Linux_image_under_QEMU_KVM"
|
|
|
|
dev_kvm = '/dev/kvm'
|
|
|
|
dev_vhost = '/dev/vhost-net'
|
|
|
|
with open('/proc/cpuinfo', 'r') as f:
|
|
|
|
kvm_cap = re.search('vmx|svm', "".join(f.readlines()))
|
|
|
|
if not kvm_cap:
|
|
|
|
logger.error("You are trying to enable KVM on a cpu without VT support.")
|
|
|
|
logger.error("Remove kvm from the command-line, or refer:")
|
|
|
|
raise Exception(yocto_kvm_wiki)
|
|
|
|
|
|
|
|
if not os.path.exists(dev_kvm):
|
|
|
|
logger.error("Missing KVM device. Have you inserted kvm modules?")
|
|
|
|
logger.error("For further help see:")
|
|
|
|
raise Exception(yocto_kvm_wiki)
|
|
|
|
|
|
|
|
if os.access(dev_kvm, os.W_OK|os.R_OK):
|
|
|
|
self.qemu_opt_script += ' -enable-kvm'
|
|
|
|
else:
|
|
|
|
logger.error("You have no read or write permission on /dev/kvm.")
|
|
|
|
logger.error("Please change the ownership of this file as described at:")
|
|
|
|
raise Exception(yocto_kvm_wiki)
|
|
|
|
|
|
|
|
if self.vhost_enabled:
|
|
|
|
if not os.path.exists(dev_vhost):
|
|
|
|
logger.error("Missing virtio net device. Have you inserted vhost-net module?")
|
|
|
|
logger.error("For further help see:")
|
|
|
|
raise Exception(yocto_paravirt_kvm_wiki)
|
|
|
|
|
|
|
|
if not os.access(dev_kvm, os.W_OK|os.R_OK):
|
|
|
|
logger.error("You have no read or write permission on /dev/vhost-net.")
|
|
|
|
logger.error("Please change the ownership of this file as described at:")
|
|
|
|
raise Exception(yocto_kvm_wiki)
|
|
|
|
|
|
|
|
def check_fstype(self):
|
|
|
|
"""Check and setup FSTYPE"""
|
|
|
|
if not self.fstype:
|
|
|
|
fstype = self.get('QB_DEFAULT_FSTYPE')
|
|
|
|
if fstype:
|
|
|
|
self.fstype = fstype
|
|
|
|
else:
|
|
|
|
raise Exception("FSTYPE is NULL!")
|
|
|
|
|
|
|
|
def check_rootfs(self):
|
|
|
|
"""Check and set rootfs"""
|
|
|
|
|
|
|
|
if self.fstype == 'nfs':
|
|
|
|
return
|
|
|
|
|
|
|
|
if self.rootfs and not os.path.exists(self.rootfs):
|
|
|
|
# Lazy rootfs
|
|
|
|
self.rootfs = "%s/%s-%s.%s" % (self.get('DEPLOY_DIR_IMAGE'),
|
|
|
|
self.rootfs, self.get('MACHINE'),
|
|
|
|
self.fstype)
|
|
|
|
elif not self.rootfs:
|
|
|
|
cmd = '%s/%s*.%s' % (self.get('DEPLOY_DIR_IMAGE'), self.get('IMAGE_NAME'), self.fstype)
|
|
|
|
all_files = glob.glob(cmd)
|
|
|
|
if all_files:
|
|
|
|
self.rootfs = all_files[0]
|
|
|
|
else:
|
|
|
|
raise Exception("Failed to find rootfs: %s" % cmd)
|
|
|
|
|
|
|
|
if not os.path.exists(self.rootfs):
|
|
|
|
raise Exception("Can't find rootfs: %s" % self.rootfs)
|
|
|
|
|
|
|
|
def check_kernel(self):
|
|
|
|
"""Check and set kernel, dtb"""
|
|
|
|
# The vm image doesn't need a kernel
|
|
|
|
if self.fstype in self.vmtypes:
|
|
|
|
return
|
|
|
|
kernel = self.kernel
|
|
|
|
if not kernel:
|
|
|
|
kernel = "%s/%s" % (self.get('DEPLOY_DIR_IMAGE'), self.get('QB_DEFAULT_KERNEL'))
|
|
|
|
|
|
|
|
if os.path.exists(kernel):
|
|
|
|
self.kernel = kernel
|
|
|
|
else:
|
|
|
|
raise Exception("KERNEL %s not found" % kernel)
|
|
|
|
|
|
|
|
dtb = self.get('QB_DTB')
|
|
|
|
if dtb:
|
|
|
|
dtb = "%s/%s" % (self.get('DEPLOY_DIR_IMAGE'), dtb)
|
|
|
|
if os.path.exists(dtb):
|
|
|
|
self.set('QB_DTB', '-dtb %s' % dtb)
|
|
|
|
else:
|
|
|
|
raise Exception("DTB %s not found" % dtb)
|
|
|
|
|
|
|
|
|
|
|
|
def check_biosdir(self):
|
|
|
|
"""Check custombiosdir"""
|
|
|
|
if not self.custombiosdir:
|
|
|
|
return
|
|
|
|
|
|
|
|
biosdir = ""
|
|
|
|
biosdir_native = "%s/%s" % (self.get('STAGING_DIR_NATIVE'), self.custombiosdir)
|
|
|
|
biosdir_host = "%s/%s" % (self.get('STAGING_DIR_HOST'), self.custombiosdir)
|
|
|
|
for i in (self.custombiosdir, biosdir_native, biosdir_host):
|
|
|
|
if os.path.isdir(i):
|
|
|
|
biosdir = i
|
|
|
|
break
|
|
|
|
|
|
|
|
if biosdir:
|
|
|
|
logger.info("Assuming biosdir is: %s" % biosdir)
|
|
|
|
self.qemu_opt_script += ' -L %s' % biosdir
|
|
|
|
else:
|
|
|
|
logger.error("Custom BIOS directory not found. Tried: %s, %s, and %s" % (self.custombiosdir, biosdir_native, biosdir_host))
|
|
|
|
raise Exception("Invalid custombiosdir: %s" % self.custombiosdir)
|
|
|
|
|
|
|
|
def check_mem(self):
|
|
|
|
s = re.search('-m +([0-9]+)', self.qemu_opt_script)
|
|
|
|
if s:
|
|
|
|
self.set('QB_MEM', '-m %s' % s.group(1))
|
|
|
|
elif not self.get('QB_MEM'):
|
|
|
|
logger.info('QB_MEM is not set, use 512M by default')
|
|
|
|
self.set('QB_MEM', '-m 512')
|
|
|
|
|
|
|
|
self.kernel_cmdline_script += ' mem=%s' % self.get('QB_MEM').replace('-m','').strip() + 'M'
|
|
|
|
self.qemu_opt_script += ' %s' % self.get('QB_MEM')
|
|
|
|
|
|
|
|
def check_tcpserial(self):
|
|
|
|
if self.tcpserial_portnum:
|
|
|
|
if self.get('QB_TCPSERIAL_OPT'):
|
|
|
|
self.qemu_opt_script += ' ' + self.get('QB_TCPSERIAL_OPT').replace('@PORT@', self.tcpserial_portnum)
|
|
|
|
else:
|
|
|
|
self.qemu_opt_script += ' -serial tcp:127.0.0.1:%s' % self.tcpserial_portnum
|
|
|
|
|
|
|
|
def check_and_set(self):
|
|
|
|
"""Check configs sanity and set when needed"""
|
|
|
|
check_tun()
|
|
|
|
# Check audio
|
|
|
|
if self.audio_enabled:
|
|
|
|
if not self.get('QB_AUDIO_DRV'):
|
|
|
|
raise Exception("QB_AUDIO_DRV is NULL, this board doesn't support audio")
|
|
|
|
if not self.get('QB_AUDIO_OPT'):
|
|
|
|
logger.warn('QB_AUDIO_OPT is NULL, you may need define it to make audio work')
|
|
|
|
else:
|
|
|
|
self.qemu_opt_script += ' %s' % self.get('QB_AUDIO_OPT')
|
|
|
|
os.putenv('QEMU_AUDIO_DRV', self.get('QB_AUDIO_DRV'))
|
|
|
|
else:
|
|
|
|
os.putenv('QEMU_AUDIO_DRV', 'none')
|
|
|
|
|
|
|
|
self.check_kvm()
|
|
|
|
self.check_fstype()
|
|
|
|
self.check_rootfs()
|
|
|
|
self.check_kernel()
|
|
|
|
self.check_biosdir()
|
|
|
|
self.check_mem()
|
|
|
|
self.check_tcpserial()
|
|
|
|
|
|
|
|
def read_qemuboot(self):
|
|
|
|
if not self.qemuboot:
|
|
|
|
if self.get('DEPLOY_DIR_IMAGE'):
|
|
|
|
deploy_dir_image = self.get('DEPLOY_DIR_IMAGE')
|
|
|
|
elif os.getenv('DEPLOY_DIR_IMAGE'):
|
|
|
|
deploy_dir_image = os.getenv('DEPLOY_DIR_IMAGE')
|
|
|
|
else:
|
|
|
|
raise Exception("DEPLOY_DIR_IMAGE is NULL!")
|
|
|
|
|
|
|
|
if self.rootfs and not os.path.exists(self.rootfs):
|
|
|
|
# Lazy rootfs
|
|
|
|
machine = self.get('MACHINE')
|
|
|
|
if not machine:
|
|
|
|
machine = os.path.basename(deploy_dir_image)
|
|
|
|
self.qemuboot = "%s/%s-%s.qemuboot.conf" % (deploy_dir_image,
|
|
|
|
self.rootfs, machine)
|
|
|
|
else:
|
|
|
|
cmd = 'ls -t %s/*.qemuboot.conf' % deploy_dir_image
|
|
|
|
logger.info('Running %s...' % cmd)
|
|
|
|
qbs = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
|
|
|
|
if qbs:
|
|
|
|
self.qemuboot = qbs.split()[0]
|
|
|
|
|
|
|
|
if not os.path.exists(self.qemuboot):
|
|
|
|
raise Exception("Failed to find <image>.qemuboot.conf!")
|
|
|
|
|
|
|
|
logger.info('CONFFILE: %s' % self.qemuboot)
|
|
|
|
|
|
|
|
cf = configparser.ConfigParser()
|
|
|
|
cf.read(self.qemuboot)
|
|
|
|
for k, v in cf.items('config_bsp'):
|
|
|
|
k_upper = k.upper()
|
|
|
|
self.set(k_upper, v)
|
|
|
|
|
|
|
|
def print_config(self):
|
|
|
|
logger.info('Continuing with the following parameters:\n')
|
|
|
|
if not self.fstype in self.vmtypes:
|
|
|
|
print('KERNEL: [%s]' % self.kernel)
|
|
|
|
print('MACHINE: [%s]' % self.get('MACHINE'))
|
|
|
|
print('FSTYPE: [%s]' % self.fstype)
|
|
|
|
if self.fstype == 'nfs':
|
|
|
|
print('NFS_DIR: [%s]' % self.nfs_dir)
|
|
|
|
else:
|
|
|
|
print('ROOTFS: [%s]' % self.rootfs)
|
|
|
|
print('CONFFILE: [%s]' % self.qemuboot)
|
|
|
|
print('')
|
|
|
|
|
|
|
|
def setup_nfs(self):
|
|
|
|
if not self.nfs_server:
|
|
|
|
if self.slirp_enabled:
|
|
|
|
self.nfs_server = '10.0.2.2'
|
|
|
|
else:
|
|
|
|
self.nfs_server = '192.168.7.1'
|
|
|
|
|
|
|
|
nfs_instance = int(self.nfs_instance)
|
|
|
|
|
|
|
|
mountd_rpcport = 21111 + nfs_instance
|
|
|
|
nfsd_rpcport = 11111 + nfs_instance
|
|
|
|
nfsd_port = 3049 + 2 * nfs_instance
|
|
|
|
mountd_port = 3048 + 2 * nfs_instance
|
|
|
|
unfs_opts="nfsvers=3,port=%s,mountprog=%s,nfsprog=%s,udp,mountport=%s" % (nfsd_port, mountd_rpcport, nfsd_rpcport, mountd_port)
|
|
|
|
self.unfs_opts = unfs_opts
|
|
|
|
|
|
|
|
p = '%s/.runqemu-sdk/pseudo' % os.getenv('HOME')
|
|
|
|
os.putenv('PSEUDO_LOCALSTATEDIR', p)
|
|
|
|
|
|
|
|
# Extract .tar.bz2 or .tar.bz if no self.nfs_dir
|
|
|
|
if not self.nfs_dir:
|
|
|
|
src_prefix = '%s/%s' % (self.get('DEPLOY_DIR_IMAGE'), self.get('IMAGE_LINK_NAME'))
|
|
|
|
dest = "%s-nfsroot" % src_prefix
|
|
|
|
if os.path.exists('%s.pseudo_state' % dest):
|
|
|
|
logger.info('Use %s as NFS_DIR' % dest)
|
|
|
|
self.nfs_dir = dest
|
|
|
|
else:
|
|
|
|
src = ""
|
|
|
|
src1 = '%s.tar.bz2' % src_prefix
|
|
|
|
src2 = '%s.tar.gz' % src_prefix
|
|
|
|
if os.path.exists(src1):
|
|
|
|
src = src1
|
|
|
|
elif os.path.exists(src2):
|
|
|
|
src = src2
|
|
|
|
if not src:
|
|
|
|
raise Exception("No NFS_DIR is set but can't find %s or %s to extract" % (src1, src2))
|
|
|
|
logger.info('NFS_DIR not found, extracting %s to %s' % (src, dest))
|
|
|
|
cmd = 'runqemu-extract-sdk %s %s' % (src, dest)
|
|
|
|
logger.info('Running %s...' % cmd)
|
|
|
|
if subprocess.call(cmd, shell=True) != 0:
|
|
|
|
raise Exception('Failed to run %s' % cmd)
|
|
|
|
self.clean_nfs_dir = True
|
|
|
|
self.nfs_dir = dest
|
|
|
|
|
|
|
|
# Start the userspace NFS server
|
|
|
|
cmd = 'runqemu-export-rootfs restart %s' % self.nfs_dir
|
|
|
|
logger.info('Running %s...' % cmd)
|
|
|
|
if subprocess.call(cmd, shell=True) != 0:
|
|
|
|
raise Exception('Failed to run %s' % cmd)
|
|
|
|
|
|
|
|
self.nfs_running = True
|
|
|
|
|
|
|
|
|
|
|
|
def setup_slirp(self):
|
|
|
|
if self.fstype == 'nfs':
|
|
|
|
self.setup_nfs()
|
|
|
|
self.kernel_cmdline_script += ' ip=dhcp'
|
|
|
|
self.set('NETWORK_CMD', self.get('QB_SLIRP_OPT'))
|
|
|
|
|
|
|
|
def setup_tap(self):
|
|
|
|
"""Setup tap"""
|
|
|
|
|
|
|
|
# This file is created when runqemu-gen-tapdevs creates a bank of tap
|
|
|
|
# devices, indicating that the user should not bring up new ones using
|
|
|
|
# sudo.
|
|
|
|
nosudo_flag = '/etc/runqemu-nosudo'
|
|
|
|
self.qemuifup = shutil.which('runqemu-ifup')
|
|
|
|
self.qemuifdown = shutil.which('runqemu-ifdown')
|
|
|
|
ip = shutil.which('ip')
|
|
|
|
lockdir = "/tmp/qemu-tap-locks"
|
|
|
|
|
|
|
|
if not (self.qemuifup and self.qemuifdown and ip):
|
|
|
|
raise Exception("runqemu-ifup, runqemu-ifdown or ip not found")
|
|
|
|
|
|
|
|
if not os.path.exists(lockdir):
|
|
|
|
os.mkdir(lockdir)
|
|
|
|
|
|
|
|
cmd = '%s link' % ip
|
|
|
|
logger.info('Running %s...' % cmd)
|
|
|
|
ip_link = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
|
|
|
|
# Matches line like: 6: tap0: <foo>
|
|
|
|
possibles = re.findall('^[1-9]+: +(tap[0-9]+): <.*', ip_link, re.M)
|
|
|
|
tap = ""
|
|
|
|
for p in possibles:
|
|
|
|
lockfile = os.path.join(lockdir, p)
|
|
|
|
if os.path.exists('%s.skip' % lockfile):
|
|
|
|
logger.info('Found %s.skip, skipping %s' % (lockfile, p))
|
|
|
|
continue
|
|
|
|
self.lock = lockfile + '.lock'
|
|
|
|
if self.acquire_lock():
|
|
|
|
tap = p
|
|
|
|
logger.info("Using preconfigured tap device %s" % tap)
|
|
|
|
logger.info("If this is not intended, touch %s.skip to make runqemu skip %s." %(lockfile, tap))
|
|
|
|
break
|
|
|
|
|
|
|
|
if not tap:
|
|
|
|
if os.path.exists(nosudo_flag):
|
|
|
|
logger.error("Error: There are no available tap devices to use for networking,")
|
|
|
|
logger.error("and I see %s exists, so I am not going to try creating" % nosudo_flag)
|
|
|
|
raise Exception("a new one with sudo.")
|
|
|
|
|
|
|
|
gid = os.getgid()
|
|
|
|
uid = os.getuid()
|
|
|
|
logger.info("Setting up tap interface under sudo")
|
|
|
|
cmd = 'sudo %s %s %s %s' % (self.qemuifup, uid, gid, self.get('STAGING_DIR_NATIVE'))
|
|
|
|
tap = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8').rstrip('\n')
|
|
|
|
lockfile = os.path.join(lockdir, tap)
|
|
|
|
self.lock = lockfile + '.lock'
|
|
|
|
self.acquire_lock()
|
|
|
|
self.cleantap = True
|
|
|
|
logger.info('Created tap: %s' % tap)
|
|
|
|
|
|
|
|
self.tap = tap
|
|
|
|
n0 = tap[3:]
|
|
|
|
n1 = int(n0) * 2 + 1
|
|
|
|
n2 = n1 + 1
|
|
|
|
self.nfs_instance = n0
|
|
|
|
if self.fstype == 'nfs':
|
|
|
|
self.setup_nfs()
|
|
|
|
self.kernel_cmdline_script += " ip=192.168.7.%s::192.168.7.%s:255.255.255.0" % (n2, n1)
|
|
|
|
qb_tap_opt = self.get('QB_TAP_OPT')
|
|
|
|
if qb_tap_opt:
|
|
|
|
qemu_tap_opt = qb_tap_opt.replace('@TAP@', tap)
|
|
|
|
else:
|
|
|
|
qemu_tap_opt = "-net nic,model=virtio -net tap,vlan=0,ifname=%s,script=no,downscript=no" % self.tap
|
|
|
|
|
|
|
|
if self.vhost_enabled:
|
|
|
|
qemu_tap_opt += ',vhost=on'
|
|
|
|
|
|
|
|
self.set('NETWORK_CMD', qemu_tap_opt)
|
|
|
|
|
|
|
|
def setup_network(self):
|
|
|
|
cmd = "stty -g"
|
|
|
|
self.saved_stty = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
|
|
|
|
if self.slirp_enabled:
|
|
|
|
self.setup_slirp()
|
|
|
|
else:
|
|
|
|
self.setup_tap()
|
|
|
|
|
|
|
|
qb_rootfs_opt = self.get('QB_ROOTFS_OPT')
|
|
|
|
if qb_rootfs_opt:
|
|
|
|
self.rootfs_options = qb_rootfs_opt.replace('@ROOTFS@', self.rootfs)
|
|
|
|
else:
|
|
|
|
self.rootfs_options = '-drive file=%s,if=virtio,format=raw' % self.rootfs
|
|
|
|
|
|
|
|
if self.fstype in ('cpio.gz', 'cpio'):
|
|
|
|
self.set('NETWORK_CMD', '')
|
|
|
|
self.kernel_cmdline = 'root=/dev/ram0 rw debugshell'
|
|
|
|
self.rootfs_options = '-initrd %s' % self.rootfs
|
|
|
|
else:
|
|
|
|
if self.fstype in self.vmtypes:
|
|
|
|
if self.fstype == 'iso':
|
|
|
|
vm_drive = '-cdrom %s' % self.rootfs
|
|
|
|
else:
|
|
|
|
cmd1 = "grep -q 'root=/dev/sd' %s" % self.rootfs
|
|
|
|
cmd2 = "grep -q 'root=/dev/hd' %s" % self.rootfs
|
|
|
|
if subprocess.call(cmd1, shell=True) == 0:
|
|
|
|
logger.info('Using scsi drive')
|
|
|
|
vm_drive = '-drive if=none,id=hd,file=%s -device virtio-scsi-pci,id=scsi -device scsi-hd,drive=hd' % self.rootfs
|
|
|
|
elif subprocess.call(cmd2, shell=True) == 0:
|
|
|
|
logger.info('Using scsi drive')
|
|
|
|
vm_drive = self.rootfs
|
|
|
|
else:
|
|
|
|
logger.warn("Can't detect drive type %s" % self.rootfs)
|
|
|
|
logger.warn('Tring to use virtio block drive')
|
|
|
|
vm_drive = '-drive if=virtio,file=%s' % self.rootfs
|
|
|
|
self.rootfs_options = '%s -no-reboot' % vm_drive
|
|
|
|
self.kernel_cmdline = 'root=%s rw highres=off' % (self.get('QB_KERNEL_ROOT'))
|
|
|
|
|
|
|
|
if self.fstype == 'nfs':
|
|
|
|
self.rootfs_options = ''
|
|
|
|
k_root = '/dev/nfs nfsroot=%s:%s,%s' % (self.nfs_server, self.nfs_dir, self.unfs_opts)
|
|
|
|
self.kernel_cmdline = 'root=%s rw highres=off' % k_root
|
|
|
|
|
|
|
|
self.set('ROOTFS_OPTIONS', self.rootfs_options)
|
|
|
|
|
|
|
|
def setup_final(self):
|
|
|
|
qemu_system = self.get('QB_SYSTEM_NAME')
|
|
|
|
if not qemu_system:
|
|
|
|
raise Exception("Failed to boot, QB_SYSTEM_NAME is NULL!")
|
|
|
|
|
|
|
|
qemu_bin = '%s/%s' % (self.get('STAGING_BINDIR_NATIVE'), qemu_system)
|
|
|
|
if not os.access(qemu_bin, os.X_OK):
|
|
|
|
raise Exception("No QEMU binary '%s' could be found" % qemu_bin)
|
|
|
|
|
|
|
|
check_libgl(qemu_bin)
|
|
|
|
|
|
|
|
self.qemu_opt = "%s %s %s %s %s %s" % (qemu_bin, self.get('NETWORK_CMD'), self.qemu_opt_script, self.get('ROOTFS_OPTIONS'), self.get('QB_DTB'), self.get('QB_OPT_APPEND'))
|
|
|
|
|
|
|
|
if self.serialstdio:
|
|
|
|
logger.info("Interrupt character is '^]'")
|
|
|
|
cmd = "stty intr ^]"
|
|
|
|
subprocess.call(cmd, shell=True)
|
|
|
|
|
|
|
|
first_serial = ""
|
|
|
|
if not re.search("-nographic", self.qemu_opt):
|
|
|
|
first_serial = "-serial mon:vc"
|
|
|
|
# We always want a ttyS1. Since qemu by default adds a serial
|
|
|
|
# port when nodefaults is not specified, it seems that all that
|
|
|
|
# would be needed is to make sure a "-serial" is there. However,
|
|
|
|
# it appears that when "-serial" is specified, it ignores the
|
|
|
|
# default serial port that is normally added. So here we make
|
|
|
|
# sure to add two -serial if there are none. And only one if
|
|
|
|
# there is one -serial already.
|
|
|
|
serial_num = len(re.findall("-serial", self.qemu_opt))
|
|
|
|
if serial_num == 0:
|
|
|
|
self.qemu_opt += " %s %s" % (first_serial, self.get("QB_SERIAL_OPT"))
|
|
|
|
elif serial_num == 1:
|
|
|
|
self.qemu_opt += " %s" % self.get("QB_SERIAL_OPT")
|
|
|
|
|
|
|
|
def start_qemu(self):
|
|
|
|
if self.kernel:
|
|
|
|
kernel_opts = "-kernel %s -append '%s %s %s'" % (self.kernel, self.kernel_cmdline, self.kernel_cmdline_script, self.get('QB_KERNEL_CMDLINE_APPEND'))
|
|
|
|
else:
|
|
|
|
kernel_opts = ""
|
|
|
|
cmd = "%s %s" % (self.qemu_opt, kernel_opts)
|
|
|
|
logger.info('Running %s' % cmd)
|
|
|
|
if subprocess.call(cmd, shell=True) != 0:
|
|
|
|
raise Exception('Failed to run %s' % cmd)
|
|
|
|
|
|
|
|
def cleanup(self):
|
|
|
|
if self.cleantap:
|
|
|
|
cmd = 'sudo %s %s %s' % (self.qemuifdown, self.tap, self.get('STAGING_DIR_NATIVE'))
|
|
|
|
logger.info('Running %s' % cmd)
|
|
|
|
subprocess.call(cmd, shell=True)
|
|
|
|
if self.lock_descriptor:
|
|
|
|
logger.info("Releasing lockfile for tap device '%s'" % self.tap)
|
|
|
|
self.release_lock()
|
|
|
|
|
|
|
|
if self.nfs_running:
|
|
|
|
logger.info("Shutting down the userspace NFS server...")
|
|
|
|
cmd = "runqemu-export-rootfs stop %s" % self.nfs_dir
|
|
|
|
logger.info('Running %s' % cmd)
|
|
|
|
subprocess.call(cmd, shell=True)
|
|
|
|
|
|
|
|
if self.saved_stty:
|
|
|
|
cmd = "stty %s" % self.saved_stty
|
|
|
|
subprocess.call(cmd, shell=True)
|
|
|
|
|
|
|
|
if self.clean_nfs_dir:
|
|
|
|
logger.info('Removing %s' % self.nfs_dir)
|
|
|
|
shutil.rmtree(self.nfs_dir)
|
|
|
|
shutil.rmtree('%s.pseudo_state' % self.nfs_dir)
|
|
|
|
|
|
|
|
def main():
|
|
|
|
if len(sys.argv) == 1 or "help" in sys.argv:
|
|
|
|
print_usage()
|
|
|
|
return 0
|
|
|
|
config = BaseConfig()
|
|
|
|
try:
|
|
|
|
config.check_args()
|
|
|
|
except Exception as esc:
|
|
|
|
logger.error(esc)
|
|
|
|
logger.error("Try 'runqemu help' on how to use it")
|
|
|
|
return 1
|
|
|
|
config.read_qemuboot()
|
|
|
|
config.check_and_set()
|
|
|
|
config.print_config()
|
|
|
|
try:
|
|
|
|
config.setup_network()
|
|
|
|
config.setup_final()
|
|
|
|
config.start_qemu()
|
|
|
|
finally:
|
|
|
|
config.cleanup()
|
|
|
|
return 0
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
try:
|
|
|
|
ret = main()
|
|
|
|
except Exception as esc:
|
|
|
|
ret = 1
|
|
|
|
import traceback
|
|
|
|
traceback.print_exc()
|
|
|
|
sys.exit(ret)
|