diff options
Diffstat (limited to 'scripts/runqemu')
| -rwxr-xr-x | scripts/runqemu | 595 |
1 files changed, 458 insertions, 137 deletions
diff --git a/scripts/runqemu b/scripts/runqemu index 9af13f3360..f0ddeea1bf 100755 --- a/scripts/runqemu +++ b/scripts/runqemu @@ -28,6 +28,16 @@ import shutil import glob import configparser +class OEPathError(Exception): + """Custom Exception to give better guidance on missing binaries""" + def __init__(self, message): + self.message = "In order for this script to dynamically infer paths\n \ +kernels or filesystem images, you either need bitbake in your PATH\n \ +or to source oe-init-build-env before running this script.\n\n \ +Dynamic path inference can be avoided by passing a *.qemuboot.conf to\n \ +runqemu, i.e. `runqemu /path/to/my-image-name.qemuboot.conf`\n\n %s" % message + + def create_logger(): logger = logging.getLogger('runqemu') logger.setLevel(logging.INFO) @@ -64,17 +74,19 @@ of the following environment variables (in any order): kvm-vhost - enable KVM with vhost when running x86/x86_64 (VT-capable CPU required) publicvnc - enable a VNC server open to all hosts audio - enable audio + [*/]ovmf* - OVMF firmware file or base name for booting with UEFI 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 + help, -h, --help: print this text Examples: + runqemu runqemu qemuarm runqemu tmp/deploy/images/qemuarm - runqemu tmp/deploy/images/qemux86/.qemuboot.conf + 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 @@ -86,7 +98,7 @@ Examples: """) def check_tun(): - """Check /dev/net/run""" + """Check /dev/net/tun""" 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) @@ -127,26 +139,63 @@ def check_libgl(qemu_bin): logger.error("Fedora package names are: mesa-libGL-devel mesa-libGLU-devel.") raise Exception('%s requires libGLU, but not found' % qemu_bin) +def get_first_file(cmds): + """Return first file found in wildcard cmds""" + for cmd in cmds: + all_files = glob.glob(cmd) + if all_files: + for f in all_files: + if not os.path.isdir(f): + return f + return '' + +def check_free_port(host, port): + """ Check whether the port is free or not """ + import socket + from contextlib import closing + + with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock: + if sock.connect_ex((host, port)) == 0: + # Port is open, so not free + return False + else: + # Port is not open, so free + return True + 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', - } + # The self.d saved vars from self.set(), part of them are from qemuboot.conf + self.d = {'QB_KERNEL_ROOT': '/dev/vda'} + + # Supported env vars, add it here if a var can be got from env, + # and don't use os.getenv in the code. + self.env_vars = ('MACHINE', + 'ROOTFS', + 'KERNEL', + 'DEPLOY_DIR_IMAGE', + 'OE_TMPDIR', + 'OECORE_NATIVE_SYSROOT', + ) self.qemu_opt = '' self.qemu_opt_script = '' - self.nfs_dir = '' self.clean_nfs_dir = False self.nfs_server = '' self.rootfs = '' + # File name(s) of a OVMF firmware file or variable store, + # to be added with -drive if=pflash. + # Found in the same places as the rootfs, with or without one of + # these suffices: qcow2, bin. + # Setting one also adds "-vga std" because that is all that + # OVMF supports. + self.ovmf_bios = [] self.qemuboot = '' self.qbconfload = False self.kernel = '' self.kernel_cmdline = '' self.kernel_cmdline_script = '' + self.bootparams = '' + self.dtb = '' self.fstype = '' self.kvm_enabled = False self.vhost_enabled = False @@ -165,17 +214,26 @@ class BaseConfig(object): self.snapshot = False self.fstypes = ('ext2', 'ext3', 'ext4', 'jffs2', 'nfs', 'btrfs', 'cpio.gz', 'cpio', 'ramfs') self.vmtypes = ('hddimg', 'hdddirect', 'wic', 'vmdk', 'qcow2', 'vdi', 'iso') + self.network_device = "-device e1000,netdev=net0,mac=@MAC@" + # Use different mac section for tap and slirp to avoid + # conflicts, e.g., when one is running with tap, the other is + # running with slirp. + # The last section is dynamic, which is for avoiding conflicts, + # when multiple qemus are running, e.g., when multiple tap or + # slirp qemus are running. + self.mac_tap = "52:54:00:12:34:" + self.mac_slirp = "52:54:00:12:35:" 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) + self.lock_descriptor = open(self.lock, 'w') + fcntl.flock(self.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() + if self.lock_descriptor: + self.lock_descriptor.close() return False - self.lock_descriptor = lock_descriptor return True def release_lock(self): @@ -186,6 +244,8 @@ class BaseConfig(object): def get(self, key): if key in self.d: return self.d.get(key) + elif os.getenv(key): + return os.getenv(key) else: return '' @@ -195,9 +255,9 @@ class BaseConfig(object): 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) + logger.info("Can't find required *.qemuboot.conf in %s" % p) return False - if not re.search('-image-', '\n'.join(os.listdir(p))): + if not any(map(lambda name: '-image-' in name, os.listdir(p))): logger.info("Can't find *-image-* in %s" % p) return False return True @@ -224,12 +284,11 @@ class BaseConfig(object): def check_arg_nfs(self, p): if os.path.isdir(p): - self.nfs_dir = p + self.rootfs = p else: m = re.match('(.*):(.*)', p) self.nfs_server = m.group(1) - self.nfs_dir = m.group(2) - self.rootfs = "" + self.rootfs = m.group(2) self.check_arg_fstype('nfs') def check_arg_path(self, p): @@ -238,6 +297,7 @@ class BaseConfig(object): - Check whether is a kernel file - Check whether is a image file - Check whether it is a nfs dir + - Check whether it is a OVMF flash file """ if p.endswith('.qemuboot.conf'): self.qemuboot = p @@ -246,37 +306,52 @@ class BaseConfig(object): 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)): + elif os.path.exists(p) and (not os.path.isdir(p)) and '-image-' in 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') + # Check filename against self.fstypes can hanlde <file>.cpio.gz, + # otherwise, its type would be "gz", which is incorrect. + fst = "" + for t in self.fstypes: + if p.endswith(t): + fst = t + break + if not fst: + m = re.search('.*\.(.*)$', self.rootfs) + if m: + fst = m.group(1) + if fst: + self.check_arg_fstype(fst) + qb = re.sub('\.' + fst + "$", '', self.rootfs) + qb = '%s%s' % (re.sub('\.rootfs$', '', qb), '.qemuboot.conf') if os.path.exists(qb): self.qemuboot = qb self.qbconfload = True 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): + + elif os.path.isdir(p) or re.search(':', p) and re.search('/', p): 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) + elif os.path.basename(p).startswith('ovmf'): + self.ovmf_bios.append(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: + if self.get('MACHINE') == arg: return + elif self.get('MACHINE') and self.get('MACHINE') != arg: + raise Exception("Maybe conflicted MACHINE: %s vs %s" % (self.get('MACHINE'), arg)) + elif re.search('/', arg): + raise Exception("Unknown arg: %s" % arg) + logger.info('Assuming MACHINE = %s' % arg) # if we're running under testimage, or similarly as a child @@ -285,11 +360,16 @@ class BaseConfig(object): # FIXME: testimage.bbclass exports these two variables into env, # are there other scenarios in which we need to support being # invoked by bitbake? - deploy = os.environ.get('DEPLOY_DIR_IMAGE', None) - bbchild = deploy and os.environ.get('OE_TMPDIR', None) + deploy = self.get('DEPLOY_DIR_IMAGE') + bbchild = deploy and self.get('OE_TMPDIR') if bbchild: self.set_machine_deploy_dir(arg, deploy) return + # also check whether we're running under a sourced toolchain + # environment file + if self.get('OECORE_NATIVE_SYSROOT'): + self.set("MACHINE", arg) + return cmd = 'MACHINE=%s bitbake -e' % arg logger.info('Running %s...' % cmd) @@ -306,7 +386,7 @@ class BaseConfig(object): 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)) + self.set("MACHINE", arg) def check_args(self): unknown_arg = "" @@ -342,14 +422,16 @@ class BaseConfig(object): elif arg.startswith('qemuparams='): self.qemu_opt_script += ' %s' % arg[len('qemuparams='):] elif arg.startswith('bootparams='): - self.kernel_cmdline_script += ' %s' % arg[len('bootparams='):] + self.bootparams = 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): + elif re.search(r'-image-|-image$', arg): # Lazy rootfs self.rootfs = arg + elif arg.startswith('ovmf'): + self.ovmf_bios.append(arg) else: - # At last, assume is it the MACHINE + # At last, assume it is the MACHINE if (not unknown_arg) or unknown_arg == arg: unknown_arg = arg else: @@ -358,19 +440,20 @@ class BaseConfig(object): 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) + if self.get('DEPLOY_DIR_IMAGE'): + machine = os.path.basename(self.get('DEPLOY_DIR_IMAGE')) + if unknown_arg == machine: + self.set("MACHINE", machine) + return + self.check_arg_machine(unknown_arg) + if not self.get('DEPLOY_DIR_IMAGE'): + self.load_bitbake_env() + s = re.search('^DEPLOY_DIR_IMAGE="(.*)"', self.bitbake_e, re.M) + if s: + self.set("DEPLOY_DIR_IMAGE", s.group(1)) + def check_kvm(self): """Check kvm and kvm-host""" if not (self.kvm_enabled or self.vhost_enabled): @@ -427,6 +510,15 @@ class BaseConfig(object): def check_rootfs(self): """Check and set rootfs""" + if self.fstype == "none": + return + + if self.get('ROOTFS'): + if not self.rootfs: + self.rootfs = self.get('ROOTFS') + elif self.get('ROOTFS') != self.rootfs: + raise Exception("Maybe conflicted ROOTFS: %s vs %s" % (self.get('ROOTFS'), self.rootfs)) + if self.fstype == 'nfs': return @@ -436,38 +528,65 @@ class BaseConfig(object): 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) + cmd_name = '%s/%s*.%s' % (self.get('DEPLOY_DIR_IMAGE'), self.get('IMAGE_NAME'), self.fstype) + cmd_link = '%s/%s*.%s' % (self.get('DEPLOY_DIR_IMAGE'), self.get('IMAGE_LINK_NAME'), self.fstype) + cmds = (cmd_name, cmd_link) + self.rootfs = get_first_file(cmds) + if not self.rootfs: + raise Exception("Failed to find rootfs: %s or %s" % cmds) if not os.path.exists(self.rootfs): raise Exception("Can't find rootfs: %s" % self.rootfs) + def check_ovmf(self): + """Check and set full path for OVMF firmware and variable file(s).""" + + for index, ovmf in enumerate(self.ovmf_bios): + if os.path.exists(ovmf): + continue + for suffix in ('qcow2', 'bin'): + path = '%s/%s.%s' % (self.get('DEPLOY_DIR_IMAGE'), ovmf, suffix) + if os.path.exists(path): + self.ovmf_bios[index] = path + break + else: + raise Exception("Can't find OVMF firmware: %s" % ovmf) + 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) + # QB_DEFAULT_KERNEL is always a full file path + kernel_name = os.path.basename(self.get('QB_DEFAULT_KERNEL')) + + # The user didn't want a kernel to be loaded + if kernel_name == "none": + return + + deploy_dir_image = self.get('DEPLOY_DIR_IMAGE') + if not self.kernel: + kernel_match_name = "%s/%s" % (deploy_dir_image, kernel_name) + kernel_match_link = "%s/%s" % (deploy_dir_image, self.get('KERNEL_IMAGETYPE')) + kernel_startswith = "%s/%s*" % (deploy_dir_image, self.get('KERNEL_IMAGETYPE')) + cmds = (kernel_match_name, kernel_match_link, kernel_startswith) + self.kernel = get_first_file(cmds) + if not self.kernel: + raise Exception('KERNEL not found: %s, %s or %s' % cmds) + + if not os.path.exists(self.kernel): + raise Exception("KERNEL %s not found" % self.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) - + cmd_match = "%s/%s" % (deploy_dir_image, dtb) + cmd_startswith = "%s/%s*" % (deploy_dir_image, dtb) + cmd_wild = "%s/*.dtb" % deploy_dir_image + cmds = (cmd_match, cmd_startswith, cmd_wild) + self.dtb = get_first_file(cmds) + if not os.path.exists(self.dtb): + raise Exception('DTB not found: %s, %s or %s' % cmds) def check_biosdir(self): """Check custombiosdir""" @@ -509,7 +628,9 @@ class BaseConfig(object): def check_and_set(self): """Check configs sanity and set when needed""" - check_tun() + self.validate_paths() + if not self.slirp_enabled: + check_tun() # Check audio if self.audio_enabled: if not self.get('QB_AUDIO_DRV'): @@ -525,6 +646,7 @@ class BaseConfig(object): self.check_kvm() self.check_fstype() self.check_rootfs() + self.check_ovmf() self.check_kernel() self.check_biosdir() self.check_mem() @@ -534,10 +656,9 @@ class BaseConfig(object): 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!") + logger.info("Can't find qemuboot conf file, DEPLOY_DIR_IMAGE is NULL!") + return if self.rootfs and not os.path.exists(self.rootfs): # Lazy rootfs @@ -551,11 +672,24 @@ class BaseConfig(object): 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] + for qb in qbs.split(): + # Don't use initramfs when other choices unless fstype is ramfs + if '-initramfs-' in os.path.basename(qb) and self.fstype != 'cpio.gz': + continue + self.qemuboot = qb + break + if not self.qemuboot: + # Use the first one when no choice + self.qemuboot = qbs.split()[0] self.qbconfload = True + if not self.qemuboot: + # If we haven't found a .qemuboot.conf at this point it probably + # doesn't exist, continue without + return + if not os.path.exists(self.qemuboot): - raise Exception("Failed to find <image>.qemuboot.conf!") + raise Exception("Failed to find %s (wrong image name or BSP does not support running under qemu?)." % self.qemuboot) logger.info('CONFFILE: %s' % self.qemuboot) @@ -565,12 +699,14 @@ class BaseConfig(object): k_upper = k.upper() self.set(k_upper, v) + def validate_paths(self): + """Ensure all relevant path variables are set""" # When we're started with a *.qemuboot.conf arg assume that image # artefacts are relative to that file, rather than in whatever # directory DEPLOY_DIR_IMAGE in the conf file points to. if self.qbconfload: - imgdir = os.path.dirname(self.qemuboot) - if imgdir != self.get('DEPLOY_DIR_IMAGE'): + imgdir = os.path.realpath(os.path.dirname(self.qemuboot)) + if imgdir != os.path.realpath(self.get('DEPLOY_DIR_IMAGE')): logger.info('Setting DEPLOY_DIR_IMAGE to folder containing %s (%s)' % (self.qemuboot, imgdir)) self.set('DEPLOY_DIR_IMAGE', imgdir) @@ -585,7 +721,7 @@ class BaseConfig(object): self.load_bitbake_env() if self.bitbake_e: - native_vars = ['STAGING_DIR_NATIVE', 'STAGING_BINDIR_NATIVE'] + native_vars = ['STAGING_DIR_NATIVE'] for nv in native_vars: s = re.search('^%s="(.*)"' % nv, self.bitbake_e, re.M) if s and s.group(1) != self.get(nv): @@ -593,29 +729,40 @@ class BaseConfig(object): self.set(nv, s.group(1)) else: # when we're invoked from a running bitbake instance we won't - # be able to call `bitbake -e` but should have OE_TMPDIR set in - # the environment and can guess paths based on it - tmpdir = os.environ.get('OE_TMPDIR', None) + # be able to call `bitbake -e`, then try: + # - get OE_TMPDIR from environment and guess paths based on it + # - get OECORE_NATIVE_SYSROOT from environment (for sdk) + tmpdir = self.get('OE_TMPDIR') + oecore_native_sysroot = self.get('OECORE_NATIVE_SYSROOT') if tmpdir: logger.info('Setting STAGING_DIR_NATIVE and STAGING_BINDIR_NATIVE relative to OE_TMPDIR (%s)' % tmpdir) hostos, _, _, _, machine = os.uname() buildsys = '%s-%s' % (machine, hostos.lower()) staging_dir_native = '%s/sysroots/%s' % (tmpdir, buildsys) self.set('STAGING_DIR_NATIVE', staging_dir_native) + elif oecore_native_sysroot: + logger.info('Setting STAGING_DIR_NATIVE to OECORE_NATIVE_SYSROOT (%s)' % oecore_native_sysroot) + self.set('STAGING_DIR_NATIVE', oecore_native_sysroot) + if self.get('STAGING_DIR_NATIVE'): # we have to assume that STAGING_BINDIR_NATIVE is at usr/bin - staging_bindir_native = '%s/usr/bin' % staging_dir_native - self.set('STAGING_BINDIR_NATIVE', staging_bindir_native) + staging_bindir_native = '%s/usr/bin' % self.get('STAGING_DIR_NATIVE') + logger.info('Setting STAGING_BINDIR_NATIVE to %s' % staging_bindir_native) + self.set('STAGING_BINDIR_NATIVE', '%s/usr/bin' % self.get('STAGING_DIR_NATIVE')) def print_config(self): logger.info('Continuing with the following parameters:\n') if not self.fstype in self.vmtypes: print('KERNEL: [%s]' % self.kernel) + if self.dtb: + print('DTB: [%s]' % self.dtb) print('MACHINE: [%s]' % self.get('MACHINE')) print('FSTYPE: [%s]' % self.fstype) if self.fstype == 'nfs': - print('NFS_DIR: [%s]' % self.nfs_dir) + print('NFS_DIR: [%s]' % self.rootfs) else: print('ROOTFS: [%s]' % self.rootfs) + if self.ovmf_bios: + print('OVMF: %s' % self.ovmf_bios) print('CONFFILE: [%s]' % self.qemuboot) print('') @@ -626,25 +773,43 @@ class BaseConfig(object): 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 + # Figure out a new nfs_instance to allow multiple qemus running. + # CentOS 7.1's ps doesn't print full command line without "ww" + # when invoke by subprocess.Popen(). + cmd = "ps auxww" + ps = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8') + pattern = '/bin/unfsd .* -i .*\.pid -e .*/exports([0-9]+) ' + all_instances = re.findall(pattern, ps, re.M) + if all_instances: + all_instances.sort(key=int) + self.nfs_instance = int(all_instances.pop()) + 1 + + mountd_rpcport = 21111 + self.nfs_instance + nfsd_rpcport = 11111 + self.nfs_instance + nfsd_port = 3049 + 2 * self.nfs_instance + mountd_port = 3048 + 2 * self.nfs_instance + + # Export vars for runqemu-export-rootfs + export_dict = { + 'NFS_INSTANCE': self.nfs_instance, + 'MOUNTD_RPCPORT': mountd_rpcport, + 'NFSD_RPCPORT': nfsd_rpcport, + 'NFSD_PORT': nfsd_port, + 'MOUNTD_PORT': mountd_port, + } + for k, v in export_dict.items(): + # Use '%s' since they are integers + os.putenv(k, '%s' % v) - p = '%s/.runqemu-sdk/pseudo' % os.getenv('HOME') - os.putenv('PSEUDO_LOCALSTATEDIR', p) + self.unfs_opts="nfsvers=3,port=%s,mountprog=%s,nfsprog=%s,udp,mountport=%s" % (nfsd_port, mountd_rpcport, nfsd_rpcport, mountd_port) - # Extract .tar.bz2 or .tar.bz if no self.nfs_dir - if not self.nfs_dir: + # Extract .tar.bz2 or .tar.bz if no nfs dir + if not (self.rootfs and os.path.isdir(self.rootfs)): 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 + self.rootfs = dest else: src = "" src1 = '%s.tar.bz2' % src_prefix @@ -654,29 +819,56 @@ class BaseConfig(object): 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)) + raise Exception("No NFS_DIR is set, and 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 + self.rootfs = dest # Start the userspace NFS server - cmd = 'runqemu-export-rootfs restart %s' % self.nfs_dir + cmd = 'runqemu-export-rootfs start %s' % self.rootfs 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): + """Setup user networking""" + if self.fstype == 'nfs': self.setup_nfs() self.kernel_cmdline_script += ' ip=dhcp' - self.set('NETWORK_CMD', self.get('QB_SLIRP_OPT')) + # Port mapping + hostfwd = ",hostfwd=tcp::2222-:22,hostfwd=tcp::2323-:23" + qb_slirp_opt_default = "-netdev user,id=net0%s" % hostfwd + qb_slirp_opt = self.get('QB_SLIRP_OPT') or qb_slirp_opt_default + # Figure out the port + ports = re.findall('hostfwd=[^-]*:([0-9]+)-[^,-]*', qb_slirp_opt) + ports = [int(i) for i in ports] + mac = 2 + # Find a free port to avoid conflicts + for p in ports[:]: + p_new = p + while not check_free_port('localhost', p_new): + p_new += 1 + mac += 1 + while p_new in ports: + p_new += 1 + mac += 1 + if p != p_new: + ports.append(p_new) + qb_slirp_opt = re.sub(':%s-' % p, ':%s-' % p_new, qb_slirp_opt) + logger.info("Port forward changed: %s -> %s" % (p, p_new)) + mac = "%s%02x" % (self.mac_slirp, mac) + self.set('NETWORK_CMD', '%s %s' % (self.network_device.replace('@MAC@', mac), qb_slirp_opt)) + # Print out port foward + hostfwd = re.findall('(hostfwd=[^,]*)', qb_slirp_opt) + if hostfwd: + logger.info('Port forward: %s' % ' '.join(hostfwd)) def setup_tap(self): """Setup tap""" @@ -691,10 +883,15 @@ class BaseConfig(object): lockdir = "/tmp/qemu-tap-locks" if not (self.qemuifup and self.qemuifdown and ip): - raise Exception("runqemu-ifup, runqemu-ifdown or ip not found") + raise OEPathError("runqemu-ifup, runqemu-ifdown or ip not found") if not os.path.exists(lockdir): - os.mkdir(lockdir) + # There might be a race issue when multi runqemu processess are + # running at the same time. + try: + os.mkdir(lockdir) + except FileExistsError: + pass cmd = '%s link' % ip logger.info('Running %s...' % cmd) @@ -723,7 +920,7 @@ class BaseConfig(object): 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')) + cmd = 'sudo %s %s %s %s' % (self.qemuifup, uid, gid, self.bindir_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' @@ -731,86 +928,169 @@ class BaseConfig(object): self.cleantap = True logger.info('Created tap: %s' % tap) + if not tap: + logger.error("Failed to setup tap device. Run runqemu-gen-tapdevs to manually create.") + return 1 self.tap = tap - n0 = tap[3:] - n1 = int(n0) * 2 + 1 - n2 = n1 + 1 - self.nfs_instance = n0 + tapnum = int(tap[3:]) + gateway = tapnum * 2 + 1 + client = gateway + 1 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) - mac = "52:54:00:12:34:%02x" % n2 + netconf = "192.168.7.%s::192.168.7.%s:255.255.255.0" % (client, gateway) + logger.info("Network configuration: %s", netconf) + self.kernel_cmdline_script += " ip=%s" % netconf + mac = "%s%02x" % (self.mac_tap, client) qb_tap_opt = self.get('QB_TAP_OPT') if qb_tap_opt: - qemu_tap_opt = qb_tap_opt.replace('@TAP@', tap).replace('@MAC@', mac) + qemu_tap_opt = qb_tap_opt.replace('@TAP@', tap) else: - qemu_tap_opt = "-device virtio-net-pci,netdev=net0,mac=%s -netdev tap,id=net0,ifname=%s,script=no,downscript=no" % (mac, self.tap) + qemu_tap_opt = "-netdev tap,id=net0,ifname=%s,script=no,downscript=no" % (self.tap) if self.vhost_enabled: qemu_tap_opt += ',vhost=on' - self.set('NETWORK_CMD', qemu_tap_opt) + self.set('NETWORK_CMD', '%s %s' % (self.network_device.replace('@MAC@', mac), qemu_tap_opt)) def setup_network(self): + if self.get('QB_NET') == 'none': + return cmd = "stty -g" self.saved_stty = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8') + self.network_device = self.get('QB_NETWORK_DEVICE') or self.network_device if self.slirp_enabled: self.setup_slirp() else: self.setup_tap() + def setup_rootfs(self): + if self.get('QB_ROOTFS') == 'none': + return + rootfs_format = self.fstype if self.fstype in ('vmdk', 'qcow2', 'vdi') else 'raw' + 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 + self.rootfs_options = '-drive file=%s,if=virtio,format=%s' % (self.rootfs, rootfs_format) 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: + vm_drive = '' 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: + elif self.get('QB_DRIVE_TYPE'): + drive_type = self.get('QB_DRIVE_TYPE') + if drive_type.startswith("/dev/sd"): 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 + vm_drive = '-drive if=none,id=hd,file=%s,format=%s -device virtio-scsi-pci,id=scsi -device scsi-hd,drive=hd' \ + % (self.rootfs, rootfs_format) + elif drive_type.startswith("/dev/hd"): + logger.info('Using ide drive') + vm_drive = "%s,format=%s" % (self.rootfs, rootfs_format) 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 + # virtio might have been selected explicitly (just use it), or + # is used as fallback (then warn about that). + if not drive_type.startswith("/dev/vd"): + logger.warn("Unknown QB_DRIVE_TYPE: %s" % drive_type) + logger.warn("Failed to figure out drive type, consider define or fix QB_DRIVE_TYPE") + logger.warn('Trying to use virtio block drive') + vm_drive = '-drive if=virtio,file=%s,format=%s' % (self.rootfs, rootfs_format) + + # All branches above set vm_drive. 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) + k_root = '/dev/nfs nfsroot=%s:%s,%s' % (self.nfs_server, self.rootfs, self.unfs_opts) self.kernel_cmdline = 'root=%s rw highres=off' % k_root + if self.fstype == 'none': + self.rootfs_options = '' + self.set('ROOTFS_OPTIONS', self.rootfs_options) + def guess_qb_system(self): + """attempt to determine the appropriate qemu-system binary""" + mach = self.get('MACHINE') + if not mach: + search = '.*(qemux86-64|qemux86|qemuarm64|qemuarm|qemumips64|qemumips64el|qemumipsel|qemumips|qemuppc).*' + if self.rootfs: + match = re.match(search, self.rootfs) + if match: + mach = match.group(1) + elif self.kernel: + match = re.match(search, self.kernel) + if match: + mach = match.group(1) + + if not mach: + return None + + if mach == 'qemuarm': + qbsys = 'arm' + elif mach == 'qemuarm64': + qbsys = 'aarch64' + elif mach == 'qemux86': + qbsys = 'i386' + elif mach == 'qemux86-64': + qbsys = 'x86_64' + elif mach == 'qemuppc': + qbsys = 'ppc' + elif mach == 'qemumips': + qbsys = 'mips' + elif mach == 'qemumips64': + qbsys = 'mips64' + elif mach == 'qemumipsel': + qbsys = 'mipsel' + elif mach == 'qemumips64el': + qbsys = 'mips64el' + + return 'qemu-system-%s' % qbsys + def setup_final(self): qemu_system = self.get('QB_SYSTEM_NAME') if not qemu_system: + qemu_system = self.guess_qb_system() + 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) + qemu_bin = '%s/%s' % (self.bindir_native, qemu_system) + + # It is possible to have qemu-native in ASSUME_PROVIDED, and it won't + # find QEMU in sysroot, it needs to use host's qemu. + if not os.path.exists(qemu_bin): + logger.info("QEMU binary not found in %s, trying host's QEMU" % qemu_bin) + for path in (os.environ['PATH'] or '').split(':'): + qemu_bin_tmp = os.path.join(path, qemu_system) + logger.info("Trying: %s" % qemu_bin_tmp) + if os.path.exists(qemu_bin_tmp): + qemu_bin = qemu_bin_tmp + if not os.path.isabs(qemu_bin): + qemu_bin = os.path.abspath(qemu_bin) + logger.info("Using host's QEMU: %s" % qemu_bin) + break + if not os.access(qemu_bin, os.X_OK): - raise Exception("No QEMU binary '%s' could be found" % qemu_bin) |