blob: c6b7580ddcb16980212ce8e26a1d9d5fe99519ff [file] [log] [blame]
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001#!/usr/bin/env python3
2
Patrick Williamsc124f4f2015-09-15 14:41:29 -05003# Handle running OE images standalone with QEMU
4#
5# Copyright (C) 2006-2011 Linux Foundation
Patrick Williamsc0f7c042017-02-23 20:41:17 -06006# Copyright (c) 2016 Wind River Systems, Inc.
Patrick Williamsc124f4f2015-09-15 14:41:29 -05007#
8# This program is free software; you can redistribute it and/or modify
9# it under the terms of the GNU General Public License version 2 as
10# published by the Free Software Foundation.
11#
12# This program is distributed in the hope that it will be useful,
13# but WITHOUT ANY WARRANTY; without even the implied warranty of
14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15# GNU General Public License for more details.
16#
17# You should have received a copy of the GNU General Public License along
18# with this program; if not, write to the Free Software Foundation, Inc.,
19# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20
Patrick Williamsc0f7c042017-02-23 20:41:17 -060021import os
22import sys
23import logging
24import subprocess
25import re
26import fcntl
27import shutil
28import glob
29import configparser
Brad Bishop004d4992018-10-02 23:54:45 +020030import signal
Patrick Williamsd8c66bc2016-06-20 12:57:21 -050031
Brad Bishopd7bf8c12018-02-25 22:55:05 -050032class RunQemuError(Exception):
33 """Custom exception to raise on known errors."""
34 pass
35
36class OEPathError(RunQemuError):
Patrick Williamsc0f7c042017-02-23 20:41:17 -060037 """Custom Exception to give better guidance on missing binaries"""
38 def __init__(self, message):
Brad Bishopd7bf8c12018-02-25 22:55:05 -050039 super().__init__("In order for this script to dynamically infer paths\n \
Patrick Williamsc0f7c042017-02-23 20:41:17 -060040kernels or filesystem images, you either need bitbake in your PATH\n \
41or to source oe-init-build-env before running this script.\n\n \
42Dynamic path inference can be avoided by passing a *.qemuboot.conf to\n \
Brad Bishopd7bf8c12018-02-25 22:55:05 -050043runqemu, i.e. `runqemu /path/to/my-image-name.qemuboot.conf`\n\n %s" % message)
Patrick Williamsc0f7c042017-02-23 20:41:17 -060044
45
46def create_logger():
47 logger = logging.getLogger('runqemu')
48 logger.setLevel(logging.INFO)
49
50 # create console handler and set level to debug
51 ch = logging.StreamHandler()
Brad Bishopd7bf8c12018-02-25 22:55:05 -050052 ch.setLevel(logging.DEBUG)
Patrick Williamsc0f7c042017-02-23 20:41:17 -060053
54 # create formatter
55 formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
56
57 # add formatter to ch
58 ch.setFormatter(formatter)
59
60 # add ch to logger
61 logger.addHandler(ch)
62
63 return logger
64
65logger = create_logger()
66
67def print_usage():
68 print("""
Patrick Williamsd8c66bc2016-06-20 12:57:21 -050069Usage: you can run this script with any valid combination
70of the following environment variables (in any order):
71 KERNEL - the kernel image file to use
72 ROOTFS - the rootfs image file or nfsroot directory to use
Brad Bishop316dfdd2018-06-25 12:45:53 -040073 DEVICE_TREE - the device tree blob to use
Patrick Williamsd8c66bc2016-06-20 12:57:21 -050074 MACHINE - the machine name (optional, autodetected from KERNEL filename if unspecified)
75 Simplified QEMU command-line options can be passed with:
Patrick Williamsc0f7c042017-02-23 20:41:17 -060076 nographic - disable video console
77 serial - enable a serial console on /dev/ttyS0
78 slirp - enable user networking, no root privileges is required
79 kvm - enable KVM when running x86/x86_64 (VT-capable CPU required)
80 kvm-vhost - enable KVM with vhost when running x86/x86_64 (VT-capable CPU required)
Patrick Williamsd8c66bc2016-06-20 12:57:21 -050081 publicvnc - enable a VNC server open to all hosts
Patrick Williamsc0f7c042017-02-23 20:41:17 -060082 audio - enable audio
Brad Bishop6e60e8b2018-02-01 10:27:11 -050083 [*/]ovmf* - OVMF firmware file or base name for booting with UEFI
Patrick Williamsc0f7c042017-02-23 20:41:17 -060084 tcpserial=<port> - specify tcp serial port number
85 biosdir=<dir> - specify custom bios dir
86 biosfilename=<filename> - specify bios filename
87 qemuparams=<xyz> - specify custom parameters to QEMU
88 bootparams=<xyz> - specify custom kernel parameters during boot
Brad Bishop6e60e8b2018-02-01 10:27:11 -050089 help, -h, --help: print this text
Brad Bishopd7bf8c12018-02-25 22:55:05 -050090 -d, --debug: Enable debug output
91 -q, --quite: Hide most output except error messages
Patrick Williamsd8c66bc2016-06-20 12:57:21 -050092
93Examples:
Brad Bishop6e60e8b2018-02-01 10:27:11 -050094 runqemu
Patrick Williamsc0f7c042017-02-23 20:41:17 -060095 runqemu qemuarm
96 runqemu tmp/deploy/images/qemuarm
Brad Bishop6e60e8b2018-02-01 10:27:11 -050097 runqemu tmp/deploy/images/qemux86/<qemuboot.conf>
Patrick Williamsc0f7c042017-02-23 20:41:17 -060098 runqemu qemux86-64 core-image-sato ext4
99 runqemu qemux86-64 wic-image-minimal wic
100 runqemu path/to/bzImage-qemux86.bin path/to/nfsrootdir/ serial
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500101 runqemu qemux86 iso/hddimg/wic.vmdk/wic.qcow2/wic.vdi/ramfs/cpio.gz...
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600102 runqemu qemux86 qemuparams="-m 256"
103 runqemu qemux86 bootparams="psplash=false"
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600104 runqemu path/to/<image>-<machine>.wic
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500105 runqemu path/to/<image>-<machine>.wic.vmdk
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600106""")
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500107
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600108def check_tun():
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500109 """Check /dev/net/tun"""
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600110 dev_tun = '/dev/net/tun'
111 if not os.path.exists(dev_tun):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500112 raise RunQemuError("TUN control device %s is unavailable; you may need to enable TUN (e.g. sudo modprobe tun)" % dev_tun)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500113
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600114 if not os.access(dev_tun, os.W_OK):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500115 raise RunQemuError("TUN control device %s is not writable, please fix (e.g. sudo chmod 666 %s)" % (dev_tun, dev_tun))
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500116
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600117def check_libgl(qemu_bin):
118 cmd = 'ldd %s' % qemu_bin
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500119 logger.debug('Running %s...' % cmd)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600120 need_gl = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
121 if re.search('libGLU', need_gl):
122 # We can't run without a libGL.so
123 libgl = False
124 check_files = (('/usr/lib/libGL.so', '/usr/lib/libGLU.so'), \
125 ('/usr/lib64/libGL.so', '/usr/lib64/libGLU.so'), \
126 ('/usr/lib/*-linux-gnu/libGL.so', '/usr/lib/*-linux-gnu/libGLU.so'))
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500127
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600128 for (f1, f2) in check_files:
129 if re.search('\*', f1):
130 for g1 in glob.glob(f1):
131 if libgl:
132 break
133 if os.path.exists(g1):
134 for g2 in glob.glob(f2):
135 if os.path.exists(g2):
136 libgl = True
137 break
138 if libgl:
139 break
140 else:
141 if os.path.exists(f1) and os.path.exists(f2):
142 libgl = True
143 break
144 if not libgl:
145 logger.error("You need libGL.so and libGLU.so to exist in your library path to run the QEMU emulator.")
146 logger.error("Ubuntu package names are: libgl1-mesa-dev and libglu1-mesa-dev.")
147 logger.error("Fedora package names are: mesa-libGL-devel mesa-libGLU-devel.")
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500148 raise RunQemuError('%s requires libGLU, but not found' % qemu_bin)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500149
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600150def get_first_file(cmds):
151 """Return first file found in wildcard cmds"""
152 for cmd in cmds:
153 all_files = glob.glob(cmd)
154 if all_files:
155 for f in all_files:
156 if not os.path.isdir(f):
157 return f
158 return ''
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500159
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500160def check_free_port(host, port):
161 """ Check whether the port is free or not """
162 import socket
163 from contextlib import closing
164
165 with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
166 if sock.connect_ex((host, port)) == 0:
167 # Port is open, so not free
168 return False
169 else:
170 # Port is not open, so free
171 return True
172
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600173class BaseConfig(object):
174 def __init__(self):
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500175 # The self.d saved vars from self.set(), part of them are from qemuboot.conf
176 self.d = {'QB_KERNEL_ROOT': '/dev/vda'}
177
178 # Supported env vars, add it here if a var can be got from env,
179 # and don't use os.getenv in the code.
180 self.env_vars = ('MACHINE',
181 'ROOTFS',
182 'KERNEL',
Brad Bishop316dfdd2018-06-25 12:45:53 -0400183 'DEVICE_TREE',
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500184 'DEPLOY_DIR_IMAGE',
185 'OE_TMPDIR',
186 'OECORE_NATIVE_SYSROOT',
187 )
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500188
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600189 self.qemu_opt = ''
190 self.qemu_opt_script = ''
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600191 self.clean_nfs_dir = False
192 self.nfs_server = ''
193 self.rootfs = ''
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500194 # File name(s) of a OVMF firmware file or variable store,
195 # to be added with -drive if=pflash.
196 # Found in the same places as the rootfs, with or without one of
197 # these suffices: qcow2, bin.
198 # Setting one also adds "-vga std" because that is all that
199 # OVMF supports.
200 self.ovmf_bios = []
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600201 self.qemuboot = ''
202 self.qbconfload = False
203 self.kernel = ''
204 self.kernel_cmdline = ''
205 self.kernel_cmdline_script = ''
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500206 self.bootparams = ''
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600207 self.dtb = ''
208 self.fstype = ''
209 self.kvm_enabled = False
210 self.vhost_enabled = False
211 self.slirp_enabled = False
212 self.nfs_instance = 0
213 self.nfs_running = False
214 self.serialstdio = False
215 self.cleantap = False
216 self.saved_stty = ''
217 self.audio_enabled = False
218 self.tcpserial_portnum = ''
219 self.custombiosdir = ''
220 self.lock = ''
Brad Bishopf86d0552018-12-04 14:18:15 -0800221 self.lock_descriptor = None
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600222 self.bitbake_e = ''
223 self.snapshot = False
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500224 self.fstypes = ('ext2', 'ext3', 'ext4', 'jffs2', 'nfs', 'btrfs',
225 'cpio.gz', 'cpio', 'ramfs', 'tar.bz2', 'tar.gz')
226 self.vmtypes = ('hddimg', 'hdddirect', 'wic', 'wic.vmdk',
227 'wic.qcow2', 'wic.vdi', 'iso')
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500228 self.network_device = "-device e1000,netdev=net0,mac=@MAC@"
229 # Use different mac section for tap and slirp to avoid
230 # conflicts, e.g., when one is running with tap, the other is
231 # running with slirp.
232 # The last section is dynamic, which is for avoiding conflicts,
233 # when multiple qemus are running, e.g., when multiple tap or
234 # slirp qemus are running.
235 self.mac_tap = "52:54:00:12:34:"
236 self.mac_slirp = "52:54:00:12:35:"
Brad Bishop004d4992018-10-02 23:54:45 +0200237 # pid of the actual qemu process
238 self.qemupid = None
239 # avoid cleanup twice
240 self.cleaned = False
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500241
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500242 def acquire_lock(self, error=True):
243 logger.debug("Acquiring lockfile %s..." % self.lock)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600244 try:
245 self.lock_descriptor = open(self.lock, 'w')
246 fcntl.flock(self.lock_descriptor, fcntl.LOCK_EX|fcntl.LOCK_NB)
247 except Exception as e:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500248 msg = "Acquiring lockfile %s failed: %s" % (self.lock, e)
249 if error:
250 logger.error(msg)
251 else:
252 logger.info(msg)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600253 if self.lock_descriptor:
254 self.lock_descriptor.close()
Brad Bishopf86d0552018-12-04 14:18:15 -0800255 self.lock_descriptor = None
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600256 return False
257 return True
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500258
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600259 def release_lock(self):
Brad Bishopf86d0552018-12-04 14:18:15 -0800260 if self.lock_descriptor:
261 logger.debug("Releasing lockfile for tap device '%s'" % self.tap)
262 fcntl.flock(self.lock_descriptor, fcntl.LOCK_UN)
263 self.lock_descriptor.close()
264 os.remove(self.lock)
265 self.lock_descriptor = None
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500266
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600267 def get(self, key):
268 if key in self.d:
269 return self.d.get(key)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500270 elif os.getenv(key):
271 return os.getenv(key)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600272 else:
273 return ''
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500274
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600275 def set(self, key, value):
276 self.d[key] = value
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500277
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600278 def is_deploy_dir_image(self, p):
279 if os.path.isdir(p):
280 if not re.search('.qemuboot.conf$', '\n'.join(os.listdir(p)), re.M):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500281 logger.debug("Can't find required *.qemuboot.conf in %s" % p)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600282 return False
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500283 if not any(map(lambda name: '-image-' in name, os.listdir(p))):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500284 logger.debug("Can't find *-image-* in %s" % p)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600285 return False
286 return True
287 else:
288 return False
Patrick Williamsf1e5d692016-03-30 15:21:19 -0500289
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600290 def check_arg_fstype(self, fst):
291 """Check and set FSTYPE"""
292 if fst not in self.fstypes + self.vmtypes:
293 logger.warn("Maybe unsupported FSTYPE: %s" % fst)
294 if not self.fstype or self.fstype == fst:
295 if fst == 'ramfs':
296 fst = 'cpio.gz'
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500297 if fst in ('tar.bz2', 'tar.gz'):
298 fst = 'nfs'
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600299 self.fstype = fst
300 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500301 raise RunQemuError("Conflicting: FSTYPE %s and %s" % (self.fstype, fst))
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500302
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600303 def set_machine_deploy_dir(self, machine, deploy_dir_image):
304 """Set MACHINE and DEPLOY_DIR_IMAGE"""
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500305 logger.debug('MACHINE: %s' % machine)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600306 self.set("MACHINE", machine)
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500307 logger.debug('DEPLOY_DIR_IMAGE: %s' % deploy_dir_image)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600308 self.set("DEPLOY_DIR_IMAGE", deploy_dir_image)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500309
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600310 def check_arg_nfs(self, p):
311 if os.path.isdir(p):
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500312 self.rootfs = p
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600313 else:
314 m = re.match('(.*):(.*)', p)
315 self.nfs_server = m.group(1)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500316 self.rootfs = m.group(2)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600317 self.check_arg_fstype('nfs')
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500318
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600319 def check_arg_path(self, p):
320 """
321 - Check whether it is <image>.qemuboot.conf or contains <image>.qemuboot.conf
322 - Check whether is a kernel file
323 - Check whether is a image file
324 - Check whether it is a nfs dir
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500325 - Check whether it is a OVMF flash file
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600326 """
327 if p.endswith('.qemuboot.conf'):
328 self.qemuboot = p
329 self.qbconfload = True
330 elif re.search('\.bin$', p) or re.search('bzImage', p) or \
331 re.search('zImage', p) or re.search('vmlinux', p) or \
332 re.search('fitImage', p) or re.search('uImage', p):
333 self.kernel = p
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500334 elif os.path.exists(p) and (not os.path.isdir(p)) and '-image-' in os.path.basename(p):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600335 self.rootfs = p
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500336 # Check filename against self.fstypes can hanlde <file>.cpio.gz,
337 # otherwise, its type would be "gz", which is incorrect.
338 fst = ""
339 for t in self.fstypes:
340 if p.endswith(t):
341 fst = t
342 break
343 if not fst:
344 m = re.search('.*\.(.*)$', self.rootfs)
345 if m:
346 fst = m.group(1)
347 if fst:
348 self.check_arg_fstype(fst)
349 qb = re.sub('\.' + fst + "$", '', self.rootfs)
350 qb = '%s%s' % (re.sub('\.rootfs$', '', qb), '.qemuboot.conf')
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600351 if os.path.exists(qb):
352 self.qemuboot = qb
353 self.qbconfload = True
354 else:
355 logger.warn("%s doesn't exist" % qb)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600356 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500357 raise RunQemuError("Can't find FSTYPE from: %s" % p)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500358
359 elif os.path.isdir(p) or re.search(':', p) and re.search('/', p):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600360 if self.is_deploy_dir_image(p):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500361 logger.debug('DEPLOY_DIR_IMAGE: %s' % p)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600362 self.set("DEPLOY_DIR_IMAGE", p)
363 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500364 logger.debug("Assuming %s is an nfs rootfs" % p)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600365 self.check_arg_nfs(p)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500366 elif os.path.basename(p).startswith('ovmf'):
367 self.ovmf_bios.append(p)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600368 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500369 raise RunQemuError("Unknown path arg %s" % p)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500370
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600371 def check_arg_machine(self, arg):
372 """Check whether it is a machine"""
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500373 if self.get('MACHINE') == arg:
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600374 return
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500375 elif self.get('MACHINE') and self.get('MACHINE') != arg:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500376 raise RunQemuError("Maybe conflicted MACHINE: %s vs %s" % (self.get('MACHINE'), arg))
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500377 elif re.search('/', arg):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500378 raise RunQemuError("Unknown arg: %s" % arg)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500379
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500380 logger.debug('Assuming MACHINE = %s' % arg)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500381
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600382 # if we're running under testimage, or similarly as a child
383 # of an existing bitbake invocation, we can't invoke bitbake
384 # to validate the MACHINE setting and must assume it's correct...
385 # FIXME: testimage.bbclass exports these two variables into env,
386 # are there other scenarios in which we need to support being
387 # invoked by bitbake?
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500388 deploy = self.get('DEPLOY_DIR_IMAGE')
389 bbchild = deploy and self.get('OE_TMPDIR')
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600390 if bbchild:
391 self.set_machine_deploy_dir(arg, deploy)
392 return
393 # also check whether we're running under a sourced toolchain
394 # environment file
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500395 if self.get('OECORE_NATIVE_SYSROOT'):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600396 self.set("MACHINE", arg)
397 return
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500398
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600399 cmd = 'MACHINE=%s bitbake -e' % arg
400 logger.info('Running %s...' % cmd)
401 self.bitbake_e = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
402 # bitbake -e doesn't report invalid MACHINE as an error, so
403 # let's check DEPLOY_DIR_IMAGE to make sure that it is a valid
404 # MACHINE.
405 s = re.search('^DEPLOY_DIR_IMAGE="(.*)"', self.bitbake_e, re.M)
406 if s:
407 deploy_dir_image = s.group(1)
408 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500409 raise RunQemuError("bitbake -e %s" % self.bitbake_e)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600410 if self.is_deploy_dir_image(deploy_dir_image):
411 self.set_machine_deploy_dir(arg, deploy_dir_image)
412 else:
413 logger.error("%s not a directory valid DEPLOY_DIR_IMAGE" % deploy_dir_image)
414 self.set("MACHINE", arg)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500415
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600416 def check_args(self):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500417 for debug in ("-d", "--debug"):
418 if debug in sys.argv:
419 logger.setLevel(logging.DEBUG)
420 sys.argv.remove(debug)
421
422 for quiet in ("-q", "--quiet"):
423 if quiet in sys.argv:
424 logger.setLevel(logging.ERROR)
425 sys.argv.remove(quiet)
426
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600427 unknown_arg = ""
428 for arg in sys.argv[1:]:
429 if arg in self.fstypes + self.vmtypes:
430 self.check_arg_fstype(arg)
431 elif arg == 'nographic':
432 self.qemu_opt_script += ' -nographic'
433 self.kernel_cmdline_script += ' console=ttyS0'
434 elif arg == 'serial':
435 self.kernel_cmdline_script += ' console=ttyS0'
436 self.serialstdio = True
437 elif arg == 'audio':
438 logger.info("Enabling audio in qemu")
439 logger.info("Please install sound drivers in linux host")
440 self.audio_enabled = True
441 elif arg == 'kvm':
442 self.kvm_enabled = True
443 elif arg == 'kvm-vhost':
444 self.vhost_enabled = True
445 elif arg == 'slirp':
446 self.slirp_enabled = True
447 elif arg == 'snapshot':
448 self.snapshot = True
449 elif arg == 'publicvnc':
450 self.qemu_opt_script += ' -vnc :0'
451 elif arg.startswith('tcpserial='):
452 self.tcpserial_portnum = arg[len('tcpserial='):]
453 elif arg.startswith('biosdir='):
454 self.custombiosdir = arg[len('biosdir='):]
455 elif arg.startswith('biosfilename='):
456 self.qemu_opt_script += ' -bios %s' % arg[len('biosfilename='):]
457 elif arg.startswith('qemuparams='):
458 self.qemu_opt_script += ' %s' % arg[len('qemuparams='):]
459 elif arg.startswith('bootparams='):
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500460 self.bootparams = arg[len('bootparams='):]
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600461 elif os.path.exists(arg) or (re.search(':', arg) and re.search('/', arg)):
462 self.check_arg_path(os.path.abspath(arg))
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500463 elif re.search(r'-image-|-image$', arg):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600464 # Lazy rootfs
465 self.rootfs = arg
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500466 elif arg.startswith('ovmf'):
467 self.ovmf_bios.append(arg)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600468 else:
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500469 # At last, assume it is the MACHINE
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600470 if (not unknown_arg) or unknown_arg == arg:
471 unknown_arg = arg
472 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500473 raise RunQemuError("Can't handle two unknown args: %s %s\n"
474 "Try 'runqemu help' on how to use it" % \
475 (unknown_arg, arg))
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600476 # Check to make sure it is a valid machine
477 if unknown_arg:
478 if self.get('MACHINE') == unknown_arg:
479 return
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500480 if self.get('DEPLOY_DIR_IMAGE'):
481 machine = os.path.basename(self.get('DEPLOY_DIR_IMAGE'))
482 if unknown_arg == machine:
483 self.set("MACHINE", machine)
484 return
485
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600486 self.check_arg_machine(unknown_arg)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500487
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500488 if not (self.get('DEPLOY_DIR_IMAGE') or self.qbconfload):
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500489 self.load_bitbake_env()
490 s = re.search('^DEPLOY_DIR_IMAGE="(.*)"', self.bitbake_e, re.M)
491 if s:
492 self.set("DEPLOY_DIR_IMAGE", s.group(1))
493
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600494 def check_kvm(self):
495 """Check kvm and kvm-host"""
496 if not (self.kvm_enabled or self.vhost_enabled):
497 self.qemu_opt_script += ' %s %s' % (self.get('QB_MACHINE'), self.get('QB_CPU'))
498 return
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500499
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600500 if not self.get('QB_CPU_KVM'):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500501 raise RunQemuError("QB_CPU_KVM is NULL, this board doesn't support kvm")
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500502
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600503 self.qemu_opt_script += ' %s %s' % (self.get('QB_MACHINE'), self.get('QB_CPU_KVM'))
504 yocto_kvm_wiki = "https://wiki.yoctoproject.org/wiki/How_to_enable_KVM_for_Poky_qemu"
505 yocto_paravirt_kvm_wiki = "https://wiki.yoctoproject.org/wiki/Running_an_x86_Yocto_Linux_image_under_QEMU_KVM"
506 dev_kvm = '/dev/kvm'
507 dev_vhost = '/dev/vhost-net'
508 with open('/proc/cpuinfo', 'r') as f:
509 kvm_cap = re.search('vmx|svm', "".join(f.readlines()))
510 if not kvm_cap:
511 logger.error("You are trying to enable KVM on a cpu without VT support.")
512 logger.error("Remove kvm from the command-line, or refer:")
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500513 raise RunQemuError(yocto_kvm_wiki)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500514
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600515 if not os.path.exists(dev_kvm):
516 logger.error("Missing KVM device. Have you inserted kvm modules?")
517 logger.error("For further help see:")
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500518 raise RunQemuError(yocto_kvm_wiki)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500519
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600520 if os.access(dev_kvm, os.W_OK|os.R_OK):
521 self.qemu_opt_script += ' -enable-kvm'
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500522 if self.get('MACHINE') == "qemux86":
523 # Workaround for broken APIC window on pre 4.15 host kernels which causes boot hangs
524 # See YOCTO #12301
525 # On 64 bit we use x2apic
526 self.kernel_cmdline_script += " clocksource=kvm-clock hpet=disable noapic nolapic"
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600527 else:
528 logger.error("You have no read or write permission on /dev/kvm.")
529 logger.error("Please change the ownership of this file as described at:")
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500530 raise RunQemuError(yocto_kvm_wiki)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500531
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600532 if self.vhost_enabled:
533 if not os.path.exists(dev_vhost):
534 logger.error("Missing virtio net device. Have you inserted vhost-net module?")
535 logger.error("For further help see:")
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500536 raise RunQemuError(yocto_paravirt_kvm_wiki)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500537
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600538 if not os.access(dev_kvm, os.W_OK|os.R_OK):
539 logger.error("You have no read or write permission on /dev/vhost-net.")
540 logger.error("Please change the ownership of this file as described at:")
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500541 raise RunQemuError(yocto_kvm_wiki)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500542
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600543 def check_fstype(self):
544 """Check and setup FSTYPE"""
545 if not self.fstype:
546 fstype = self.get('QB_DEFAULT_FSTYPE')
547 if fstype:
548 self.fstype = fstype
549 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500550 raise RunQemuError("FSTYPE is NULL!")
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500551
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600552 def check_rootfs(self):
553 """Check and set rootfs"""
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500554
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500555 if self.fstype == "none":
556 return
557
558 if self.get('ROOTFS'):
559 if not self.rootfs:
560 self.rootfs = self.get('ROOTFS')
561 elif self.get('ROOTFS') != self.rootfs:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500562 raise RunQemuError("Maybe conflicted ROOTFS: %s vs %s" % (self.get('ROOTFS'), self.rootfs))
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500563
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600564 if self.fstype == 'nfs':
565 return
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500566
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600567 if self.rootfs and not os.path.exists(self.rootfs):
568 # Lazy rootfs
569 self.rootfs = "%s/%s-%s.%s" % (self.get('DEPLOY_DIR_IMAGE'),
570 self.rootfs, self.get('MACHINE'),
571 self.fstype)
572 elif not self.rootfs:
573 cmd_name = '%s/%s*.%s' % (self.get('DEPLOY_DIR_IMAGE'), self.get('IMAGE_NAME'), self.fstype)
574 cmd_link = '%s/%s*.%s' % (self.get('DEPLOY_DIR_IMAGE'), self.get('IMAGE_LINK_NAME'), self.fstype)
575 cmds = (cmd_name, cmd_link)
576 self.rootfs = get_first_file(cmds)
577 if not self.rootfs:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500578 raise RunQemuError("Failed to find rootfs: %s or %s" % cmds)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500579
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600580 if not os.path.exists(self.rootfs):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500581 raise RunQemuError("Can't find rootfs: %s" % self.rootfs)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500582
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500583 def check_ovmf(self):
584 """Check and set full path for OVMF firmware and variable file(s)."""
585
586 for index, ovmf in enumerate(self.ovmf_bios):
587 if os.path.exists(ovmf):
588 continue
589 for suffix in ('qcow2', 'bin'):
590 path = '%s/%s.%s' % (self.get('DEPLOY_DIR_IMAGE'), ovmf, suffix)
591 if os.path.exists(path):
592 self.ovmf_bios[index] = path
593 break
594 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500595 raise RunQemuError("Can't find OVMF firmware: %s" % ovmf)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500596
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600597 def check_kernel(self):
Brad Bishop316dfdd2018-06-25 12:45:53 -0400598 """Check and set kernel"""
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600599 # The vm image doesn't need a kernel
600 if self.fstype in self.vmtypes:
601 return
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500602
Brad Bishop316dfdd2018-06-25 12:45:53 -0400603 # See if the user supplied a KERNEL option
604 if self.get('KERNEL'):
605 self.kernel = self.get('KERNEL')
606
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500607 # QB_DEFAULT_KERNEL is always a full file path
608 kernel_name = os.path.basename(self.get('QB_DEFAULT_KERNEL'))
609
610 # The user didn't want a kernel to be loaded
Brad Bishop316dfdd2018-06-25 12:45:53 -0400611 if kernel_name == "none" and not self.kernel:
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500612 return
613
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600614 deploy_dir_image = self.get('DEPLOY_DIR_IMAGE')
615 if not self.kernel:
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500616 kernel_match_name = "%s/%s" % (deploy_dir_image, kernel_name)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600617 kernel_match_link = "%s/%s" % (deploy_dir_image, self.get('KERNEL_IMAGETYPE'))
618 kernel_startswith = "%s/%s*" % (deploy_dir_image, self.get('KERNEL_IMAGETYPE'))
619 cmds = (kernel_match_name, kernel_match_link, kernel_startswith)
620 self.kernel = get_first_file(cmds)
621 if not self.kernel:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500622 raise RunQemuError('KERNEL not found: %s, %s or %s' % cmds)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500623
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600624 if not os.path.exists(self.kernel):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500625 raise RunQemuError("KERNEL %s not found" % self.kernel)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500626
Brad Bishop316dfdd2018-06-25 12:45:53 -0400627 def check_dtb(self):
628 """Check and set dtb"""
629 # Did the user specify a device tree?
630 if self.get('DEVICE_TREE'):
631 self.dtb = self.get('DEVICE_TREE')
632 if not os.path.exists(self.dtb):
633 raise RunQemuError('Specified DTB not found: %s' % self.dtb)
634 return
635
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600636 dtb = self.get('QB_DTB')
637 if dtb:
Brad Bishop316dfdd2018-06-25 12:45:53 -0400638 deploy_dir_image = self.get('DEPLOY_DIR_IMAGE')
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600639 cmd_match = "%s/%s" % (deploy_dir_image, dtb)
640 cmd_startswith = "%s/%s*" % (deploy_dir_image, dtb)
641 cmd_wild = "%s/*.dtb" % deploy_dir_image
642 cmds = (cmd_match, cmd_startswith, cmd_wild)
643 self.dtb = get_first_file(cmds)
644 if not os.path.exists(self.dtb):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500645 raise RunQemuError('DTB not found: %s, %s or %s' % cmds)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500646
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600647 def check_biosdir(self):
648 """Check custombiosdir"""
649 if not self.custombiosdir:
650 return
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500651
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600652 biosdir = ""
653 biosdir_native = "%s/%s" % (self.get('STAGING_DIR_NATIVE'), self.custombiosdir)
654 biosdir_host = "%s/%s" % (self.get('STAGING_DIR_HOST'), self.custombiosdir)
655 for i in (self.custombiosdir, biosdir_native, biosdir_host):
656 if os.path.isdir(i):
657 biosdir = i
658 break
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500659
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600660 if biosdir:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500661 logger.debug("Assuming biosdir is: %s" % biosdir)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600662 self.qemu_opt_script += ' -L %s' % biosdir
663 else:
664 logger.error("Custom BIOS directory not found. Tried: %s, %s, and %s" % (self.custombiosdir, biosdir_native, biosdir_host))
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500665 raise RunQemuError("Invalid custombiosdir: %s" % self.custombiosdir)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500666
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600667 def check_mem(self):
668 s = re.search('-m +([0-9]+)', self.qemu_opt_script)
669 if s:
670 self.set('QB_MEM', '-m %s' % s.group(1))
671 elif not self.get('QB_MEM'):
672 logger.info('QB_MEM is not set, use 512M by default')
673 self.set('QB_MEM', '-m 512')
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500674
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600675 self.kernel_cmdline_script += ' mem=%s' % self.get('QB_MEM').replace('-m','').strip() + 'M'
676 self.qemu_opt_script += ' %s' % self.get('QB_MEM')
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500677
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600678 def check_tcpserial(self):
679 if self.tcpserial_portnum:
680 if self.get('QB_TCPSERIAL_OPT'):
681 self.qemu_opt_script += ' ' + self.get('QB_TCPSERIAL_OPT').replace('@PORT@', self.tcpserial_portnum)
682 else:
683 self.qemu_opt_script += ' -serial tcp:127.0.0.1:%s' % self.tcpserial_portnum
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500684
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600685 def check_and_set(self):
686 """Check configs sanity and set when needed"""
687 self.validate_paths()
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500688 if not self.slirp_enabled:
689 check_tun()
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600690 # Check audio
691 if self.audio_enabled:
692 if not self.get('QB_AUDIO_DRV'):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500693 raise RunQemuError("QB_AUDIO_DRV is NULL, this board doesn't support audio")
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600694 if not self.get('QB_AUDIO_OPT'):
695 logger.warn('QB_AUDIO_OPT is NULL, you may need define it to make audio work')
696 else:
697 self.qemu_opt_script += ' %s' % self.get('QB_AUDIO_OPT')
698 os.putenv('QEMU_AUDIO_DRV', self.get('QB_AUDIO_DRV'))
699 else:
700 os.putenv('QEMU_AUDIO_DRV', 'none')
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500701
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600702 self.check_kvm()
703 self.check_fstype()
704 self.check_rootfs()
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500705 self.check_ovmf()
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600706 self.check_kernel()
Brad Bishop316dfdd2018-06-25 12:45:53 -0400707 self.check_dtb()
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600708 self.check_biosdir()
709 self.check_mem()
710 self.check_tcpserial()
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500711
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600712 def read_qemuboot(self):
713 if not self.qemuboot:
714 if self.get('DEPLOY_DIR_IMAGE'):
715 deploy_dir_image = self.get('DEPLOY_DIR_IMAGE')
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600716 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500717 logger.warn("Can't find qemuboot conf file, DEPLOY_DIR_IMAGE is NULL!")
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600718 return
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500719
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600720 if self.rootfs and not os.path.exists(self.rootfs):
721 # Lazy rootfs
722 machine = self.get('MACHINE')
723 if not machine:
724 machine = os.path.basename(deploy_dir_image)
725 self.qemuboot = "%s/%s-%s.qemuboot.conf" % (deploy_dir_image,
726 self.rootfs, machine)
727 else:
728 cmd = 'ls -t %s/*.qemuboot.conf' % deploy_dir_image
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500729 logger.debug('Running %s...' % cmd)
730 try:
731 qbs = subprocess.check_output(cmd, shell=True).decode('utf-8')
732 except subprocess.CalledProcessError as err:
733 raise RunQemuError(err)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600734 if qbs:
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500735 for qb in qbs.split():
736 # Don't use initramfs when other choices unless fstype is ramfs
737 if '-initramfs-' in os.path.basename(qb) and self.fstype != 'cpio.gz':
738 continue
739 self.qemuboot = qb
740 break
741 if not self.qemuboot:
742 # Use the first one when no choice
743 self.qemuboot = qbs.split()[0]
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600744 self.qbconfload = True
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500745
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600746 if not self.qemuboot:
747 # If we haven't found a .qemuboot.conf at this point it probably
748 # doesn't exist, continue without
749 return
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500750
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600751 if not os.path.exists(self.qemuboot):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500752 raise RunQemuError("Failed to find %s (wrong image name or BSP does not support running under qemu?)." % self.qemuboot)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500753
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500754 logger.debug('CONFFILE: %s' % self.qemuboot)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500755
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600756 cf = configparser.ConfigParser()
757 cf.read(self.qemuboot)
758 for k, v in cf.items('config_bsp'):
759 k_upper = k.upper()
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500760 if v.startswith("../"):
761 v = os.path.abspath(os.path.dirname(self.qemuboot) + "/" + v)
762 elif v == ".":
763 v = os.path.dirname(self.qemuboot)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600764 self.set(k_upper, v)
765
766 def validate_paths(self):
767 """Ensure all relevant path variables are set"""
768 # When we're started with a *.qemuboot.conf arg assume that image
769 # artefacts are relative to that file, rather than in whatever
770 # directory DEPLOY_DIR_IMAGE in the conf file points to.
771 if self.qbconfload:
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500772 imgdir = os.path.realpath(os.path.dirname(self.qemuboot))
773 if imgdir != os.path.realpath(self.get('DEPLOY_DIR_IMAGE')):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600774 logger.info('Setting DEPLOY_DIR_IMAGE to folder containing %s (%s)' % (self.qemuboot, imgdir))
775 self.set('DEPLOY_DIR_IMAGE', imgdir)
776
777 # If the STAGING_*_NATIVE directories from the config file don't exist
778 # and we're in a sourced OE build directory try to extract the paths
779 # from `bitbake -e`
780 havenative = os.path.exists(self.get('STAGING_DIR_NATIVE')) and \
781 os.path.exists(self.get('STAGING_BINDIR_NATIVE'))
782
783 if not havenative:
784 if not self.bitbake_e:
785 self.load_bitbake_env()
786
787 if self.bitbake_e:
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500788 native_vars = ['STAGING_DIR_NATIVE']
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600789 for nv in native_vars:
790 s = re.search('^%s="(.*)"' % nv, self.bitbake_e, re.M)
791 if s and s.group(1) != self.get(nv):
792 logger.info('Overriding conf file setting of %s to %s from Bitbake environment' % (nv, s.group(1)))
793 self.set(nv, s.group(1))
794 else:
795 # when we're invoked from a running bitbake instance we won't
796 # be able to call `bitbake -e`, then try:
797 # - get OE_TMPDIR from environment and guess paths based on it
798 # - get OECORE_NATIVE_SYSROOT from environment (for sdk)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500799 tmpdir = self.get('OE_TMPDIR')
800 oecore_native_sysroot = self.get('OECORE_NATIVE_SYSROOT')
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600801 if tmpdir:
802 logger.info('Setting STAGING_DIR_NATIVE and STAGING_BINDIR_NATIVE relative to OE_TMPDIR (%s)' % tmpdir)
803 hostos, _, _, _, machine = os.uname()
804 buildsys = '%s-%s' % (machine, hostos.lower())
805 staging_dir_native = '%s/sysroots/%s' % (tmpdir, buildsys)
806 self.set('STAGING_DIR_NATIVE', staging_dir_native)
807 elif oecore_native_sysroot:
808 logger.info('Setting STAGING_DIR_NATIVE to OECORE_NATIVE_SYSROOT (%s)' % oecore_native_sysroot)
809 self.set('STAGING_DIR_NATIVE', oecore_native_sysroot)
810 if self.get('STAGING_DIR_NATIVE'):
811 # we have to assume that STAGING_BINDIR_NATIVE is at usr/bin
812 staging_bindir_native = '%s/usr/bin' % self.get('STAGING_DIR_NATIVE')
813 logger.info('Setting STAGING_BINDIR_NATIVE to %s' % staging_bindir_native)
814 self.set('STAGING_BINDIR_NATIVE', '%s/usr/bin' % self.get('STAGING_DIR_NATIVE'))
815
816 def print_config(self):
817 logger.info('Continuing with the following parameters:\n')
818 if not self.fstype in self.vmtypes:
819 print('KERNEL: [%s]' % self.kernel)
820 if self.dtb:
821 print('DTB: [%s]' % self.dtb)
822 print('MACHINE: [%s]' % self.get('MACHINE'))
823 print('FSTYPE: [%s]' % self.fstype)
824 if self.fstype == 'nfs':
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500825 print('NFS_DIR: [%s]' % self.rootfs)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600826 else:
827 print('ROOTFS: [%s]' % self.rootfs)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500828 if self.ovmf_bios:
829 print('OVMF: %s' % self.ovmf_bios)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600830 print('CONFFILE: [%s]' % self.qemuboot)
831 print('')
832
833 def setup_nfs(self):
834 if not self.nfs_server:
835 if self.slirp_enabled:
836 self.nfs_server = '10.0.2.2'
837 else:
838 self.nfs_server = '192.168.7.1'
839
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500840 # Figure out a new nfs_instance to allow multiple qemus running.
841 # CentOS 7.1's ps doesn't print full command line without "ww"
842 # when invoke by subprocess.Popen().
843 cmd = "ps auxww"
844 ps = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
845 pattern = '/bin/unfsd .* -i .*\.pid -e .*/exports([0-9]+) '
846 all_instances = re.findall(pattern, ps, re.M)
847 if all_instances:
848 all_instances.sort(key=int)
849 self.nfs_instance = int(all_instances.pop()) + 1
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600850
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500851 nfsd_port = 3049 + 2 * self.nfs_instance
852 mountd_port = 3048 + 2 * self.nfs_instance
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600853
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500854 # Export vars for runqemu-export-rootfs
855 export_dict = {
856 'NFS_INSTANCE': self.nfs_instance,
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500857 'NFSD_PORT': nfsd_port,
858 'MOUNTD_PORT': mountd_port,
859 }
860 for k, v in export_dict.items():
861 # Use '%s' since they are integers
862 os.putenv(k, '%s' % v)
863
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500864 self.unfs_opts="nfsvers=3,port=%s,udp,mountport=%s" % (nfsd_port, mountd_port)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600865
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500866 # Extract .tar.bz2 or .tar.bz if no nfs dir
867 if not (self.rootfs and os.path.isdir(self.rootfs)):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600868 src_prefix = '%s/%s' % (self.get('DEPLOY_DIR_IMAGE'), self.get('IMAGE_LINK_NAME'))
869 dest = "%s-nfsroot" % src_prefix
870 if os.path.exists('%s.pseudo_state' % dest):
871 logger.info('Use %s as NFS_DIR' % dest)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500872 self.rootfs = dest
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600873 else:
874 src = ""
875 src1 = '%s.tar.bz2' % src_prefix
876 src2 = '%s.tar.gz' % src_prefix
877 if os.path.exists(src1):
878 src = src1
879 elif os.path.exists(src2):
880 src = src2
881 if not src:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500882 raise RunQemuError("No NFS_DIR is set, and can't find %s or %s to extract" % (src1, src2))
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600883 logger.info('NFS_DIR not found, extracting %s to %s' % (src, dest))
884 cmd = 'runqemu-extract-sdk %s %s' % (src, dest)
885 logger.info('Running %s...' % cmd)
886 if subprocess.call(cmd, shell=True) != 0:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500887 raise RunQemuError('Failed to run %s' % cmd)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600888 self.clean_nfs_dir = True
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500889 self.rootfs = dest
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600890
891 # Start the userspace NFS server
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500892 cmd = 'runqemu-export-rootfs start %s' % self.rootfs
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600893 logger.info('Running %s...' % cmd)
894 if subprocess.call(cmd, shell=True) != 0:
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500895 raise RunQemuError('Failed to run %s' % cmd)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600896
897 self.nfs_running = True
898
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600899 def setup_slirp(self):
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500900 """Setup user networking"""
901
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600902 if self.fstype == 'nfs':
903 self.setup_nfs()
904 self.kernel_cmdline_script += ' ip=dhcp'
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500905 # Port mapping
906 hostfwd = ",hostfwd=tcp::2222-:22,hostfwd=tcp::2323-:23"
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500907 qb_slirp_opt_default = "-netdev user,id=net0%s,tftp=%s" % (hostfwd, self.get('DEPLOY_DIR_IMAGE'))
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500908 qb_slirp_opt = self.get('QB_SLIRP_OPT') or qb_slirp_opt_default
909 # Figure out the port
910 ports = re.findall('hostfwd=[^-]*:([0-9]+)-[^,-]*', qb_slirp_opt)
911 ports = [int(i) for i in ports]
912 mac = 2
913 # Find a free port to avoid conflicts
914 for p in ports[:]:
915 p_new = p
916 while not check_free_port('localhost', p_new):
917 p_new += 1
918 mac += 1
919 while p_new in ports:
920 p_new += 1
921 mac += 1
922 if p != p_new:
923 ports.append(p_new)
924 qb_slirp_opt = re.sub(':%s-' % p, ':%s-' % p_new, qb_slirp_opt)
925 logger.info("Port forward changed: %s -> %s" % (p, p_new))
926 mac = "%s%02x" % (self.mac_slirp, mac)
927 self.set('NETWORK_CMD', '%s %s' % (self.network_device.replace('@MAC@', mac), qb_slirp_opt))
928 # Print out port foward
929 hostfwd = re.findall('(hostfwd=[^,]*)', qb_slirp_opt)
930 if hostfwd:
931 logger.info('Port forward: %s' % ' '.join(hostfwd))
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600932
933 def setup_tap(self):
934 """Setup tap"""
935
936 # This file is created when runqemu-gen-tapdevs creates a bank of tap
937 # devices, indicating that the user should not bring up new ones using
938 # sudo.
939 nosudo_flag = '/etc/runqemu-nosudo'
940 self.qemuifup = shutil.which('runqemu-ifup')
941 self.qemuifdown = shutil.which('runqemu-ifdown')
942 ip = shutil.which('ip')
943 lockdir = "/tmp/qemu-tap-locks"
944
945 if not (self.qemuifup and self.qemuifdown and ip):
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500946 logger.error("runqemu-ifup: %s" % self.qemuifup)
947 logger.error("runqemu-ifdown: %s" % self.qemuifdown)
948 logger.error("ip: %s" % ip)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600949 raise OEPathError("runqemu-ifup, runqemu-ifdown or ip not found")
950
951 if not os.path.exists(lockdir):
952 # There might be a race issue when multi runqemu processess are
953 # running at the same time.
954 try:
955 os.mkdir(lockdir)
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500956 os.chmod(lockdir, 0o777)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600957 except FileExistsError:
958 pass
959
960 cmd = '%s link' % ip
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500961 logger.debug('Running %s...' % cmd)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600962 ip_link = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8')
963 # Matches line like: 6: tap0: <foo>
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500964 possibles = re.findall('^[0-9]+: +(tap[0-9]+): <.*', ip_link, re.M)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600965 tap = ""
966 for p in possibles:
967 lockfile = os.path.join(lockdir, p)
968 if os.path.exists('%s.skip' % lockfile):
969 logger.info('Found %s.skip, skipping %s' % (lockfile, p))
970 continue
971 self.lock = lockfile + '.lock'
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500972 if self.acquire_lock(error=False):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600973 tap = p
974 logger.info("Using preconfigured tap device %s" % tap)
975 logger.info("If this is not intended, touch %s.skip to make runqemu skip %s." %(lockfile, tap))
976 break
977
978 if not tap:
979 if os.path.exists(nosudo_flag):
980 logger.error("Error: There are no available tap devices to use for networking,")
981 logger.error("and I see %s exists, so I am not going to try creating" % nosudo_flag)
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500982 raise RunQemuError("a new one with sudo.")
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600983
984 gid = os.getgid()
985 uid = os.getuid()
986 logger.info("Setting up tap interface under sudo")
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500987 cmd = 'sudo %s %s %s %s' % (self.qemuifup, uid, gid, self.bindir_native)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600988 tap = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE).stdout.read().decode('utf-8').rstrip('\n')
989 lockfile = os.path.join(lockdir, tap)
990 self.lock = lockfile + '.lock'
991 self.acquire_lock()
992 self.cleantap = True
Brad Bishopd7bf8c12018-02-25 22:55:05 -0500993 logger.debug('Created tap: %s' % tap)
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600994
995 if not tap:
996 logger.error("Failed to setup tap device. Run runqemu-gen-tapdevs to manually create.")
997 return 1
998 self.tap = tap
Brad Bishop37a0e4d2017-12-04 01:01:44 -0500999 tapnum = int(tap[3:])
1000 gateway = tapnum * 2 + 1
1001 client = gateway + 1
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001002 if self.fstype == 'nfs':
1003 self.setup_nfs()
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001004 netconf = "192.168.7.%s::192.168.7.%s:255.255.255.0" % (client, gateway)
1005 logger.info("Network configuration: %s", netconf)
1006 self.kernel_cmdline_script += " ip=%s" % netconf
1007 mac = "%s%02x" % (self.mac_tap, client)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001008 qb_tap_opt = self.get('QB_TAP_OPT')
1009 if qb_tap_opt:
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001010 qemu_tap_opt = qb_tap_opt.replace('@TAP@', tap)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001011 else:
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001012 qemu_tap_opt = "-netdev tap,id=net0,ifname=%s,script=no,downscript=no" % (self.tap)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001013
1014 if self.vhost_enabled:
1015 qemu_tap_opt += ',vhost=on'
1016
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001017 self.set('NETWORK_CMD', '%s %s' % (self.network_device.replace('@MAC@', mac), qemu_tap_opt))
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001018
1019 def setup_network(self):
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001020 if self.get('QB_NET') == 'none':
1021 return
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001022 if sys.stdin.isatty():
1023 self.saved_stty = subprocess.check_output("stty -g", shell=True).decode('utf-8')
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001024 self.network_device = self.get('QB_NETWORK_DEVICE') or self.network_device
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001025 if self.slirp_enabled:
1026 self.setup_slirp()
1027 else:
1028 self.setup_tap()
1029
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001030 def setup_rootfs(self):
1031 if self.get('QB_ROOTFS') == 'none':
1032 return
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001033 if 'wic.' in self.fstype:
1034 self.fstype = self.fstype[4:]
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001035 rootfs_format = self.fstype if self.fstype in ('vmdk', 'qcow2', 'vdi') else 'raw'
1036
1037 qb_rootfs_opt = self.get('QB_ROOTFS_OPT')
1038 if qb_rootfs_opt:
1039 self.rootfs_options = qb_rootfs_opt.replace('@ROOTFS@', self.rootfs)
1040 else:
1041 self.rootfs_options = '-drive file=%s,if=virtio,format=%s' % (self.rootfs, rootfs_format)
1042
1043 if self.fstype in ('cpio.gz', 'cpio'):
1044 self.kernel_cmdline = 'root=/dev/ram0 rw debugshell'
1045 self.rootfs_options = '-initrd %s' % self.rootfs
1046 else:
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001047 vm_drive = ''
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001048 if self.fstype in self.vmtypes:
1049 if self.fstype == 'iso':
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001050 vm_drive = '-drive file=%s,if=virtio,media=cdrom' % self.rootfs
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001051 elif self.get('QB_DRIVE_TYPE'):
1052 drive_type = self.get('QB_DRIVE_TYPE')
1053 if drive_type.startswith("/dev/sd"):
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001054 logger.info('Using scsi drive')
1055 vm_drive = '-drive if=none,id=hd,file=%s,format=%s -device virtio-scsi-pci,id=scsi -device scsi-hd,drive=hd' \
1056 % (self.rootfs, rootfs_format)
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001057 elif drive_type.startswith("/dev/hd"):
Brad Bishop37a0e4d2017-12-04 01:01:44 -05001058 logger.info('Using ide drive')
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001059 vm_drive = "-drive file=%s,format=%s" % (self.rootfs, rootfs_format)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001060 else:
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001061 # virtio might have been selected explicitly (just use it), or
1062 # is used as fallback (then warn about that).
1063 if not drive_type.startswith("/dev/vd"):
1064 logger.warn("Unknown QB_DRIVE_TYPE: %s" % drive_type)
1065 logger.warn("Failed to figure out drive type, consider define or fix QB_DRIVE_TYPE")
1066 logger.warn('Trying to use virtio block drive')
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001067 vm_drive = '-drive if=virtio,file=%s,format=%s' % (self.rootfs, rootfs_format)
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001068
1069 # All branches above set vm_drive.
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001070 self.rootfs_options = '%s -no-reboot' % vm_drive
1071 self.kernel_cmdline = 'root=%s rw highres=off' % (self.get('QB_KERNEL_ROOT'))
1072
1073 if self.fstype == 'nfs':
1074 self.rootfs_options = ''
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001075 k_root = '/dev/nfs nfsroot=%s:%s,%s' % (self.nfs_server, os.path.abspath(self.rootfs), self.unfs_opts)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001076 self.kernel_cmdline = 'root=%s rw highres=off' % k_root
1077
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001078 if self.fstype == 'none':
1079 self.rootfs_options = ''
1080
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001081 self.set('ROOTFS_OPTIONS', self.rootfs_options)
1082
1083 def guess_qb_system(self):
1084 """attempt to determine the appropriate qemu-system binary"""
1085 mach = self.get('MACHINE')
1086 if not mach:
1087 search = '.*(qemux86-64|qemux86|qemuarm64|qemuarm|qemumips64|qemumips64el|qemumipsel|qemumips|qemuppc).*'
1088 if self.rootfs:
1089 match = re.match(search, self.rootfs)
1090 if match:
1091 mach = match.group(1)
1092 elif self.kernel:
1093 match = re.match(search, self.kernel)
1094 if match:
1095 mach = match.group(1)
1096
1097 if not mach:
1098 return None
1099
1100 if mach == 'qemuarm':
1101 qbsys = 'arm'
1102 elif mach == 'qemuarm64':
1103 qbsys = 'aarch64'
1104 elif mach == 'qemux86':
1105 qbsys = 'i386'
1106 elif mach == 'qemux86-64':
1107 qbsys = 'x86_64'
1108 elif mach == 'qemuppc':
1109 qbsys = 'ppc'
1110 elif mach == 'qemumips':
1111 qbsys = 'mips'
1112 elif mach == 'qemumips64':
1113 qbsys = 'mips64'
1114 elif mach == 'qemumipsel':
1115 qbsys = 'mipsel'
1116 elif mach == 'qemumips64el':
1117 qbsys = 'mips64el'
Brad Bishop316dfdd2018-06-25 12:45:53 -04001118 elif mach == 'qemuriscv64':
1119 qbsys = 'riscv64'
1120 elif mach == 'qemuriscv32':
1121 qbsys = 'riscv32'
Brad Bishop004d4992018-10-02 23:54:45 +02001122 else:
1123 logger.error("Unable to determine QEMU PC System emulator for %s machine." % mach)
1124 logger.error("As %s is not among valid QEMU machines such as," % mach)
1125 logger.error("qemux86-64, qemux86, qemuarm64, qemuarm, qemumips64, qemumips64el, qemumipsel, qemumips, qemuppc")
1126 raise RunQemuError("Set qb_system_name with suitable QEMU PC System emulator in .*qemuboot.conf.")
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001127
1128 return 'qemu-system-%s' % qbsys
1129
1130 def setup_final(self):
1131 qemu_system = self.get('QB_SYSTEM_NAME')
1132 if not qemu_system:
1133 qemu_system = self.guess_qb_system()
1134 if not qemu_system:
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001135 raise RunQemuError("Failed to boot, QB_SYSTEM_NAME is NULL!")
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001136
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001137 qemu_bin = '%s/%s' % (self.bindir_native, qemu_system)
1138
1139 # It is possible to have qemu-native in ASSUME_PROVIDED, and it won't
1140 # find QEMU in sysroot, it needs to use host's qemu.
1141 if not os.path.exists(qemu_bin):
1142 logger.info("QEMU binary not found in %s, trying host's QEMU" % qemu_bin)
1143 for path in (os.environ['PATH'] or '').split(':'):
1144 qemu_bin_tmp = os.path.join(path, qemu_system)
1145 logger.info("Trying: %s" % qemu_bin_tmp)
1146 if os.path.exists(qemu_bin_tmp):
1147 qemu_bin = qemu_bin_tmp
1148 if not os.path.isabs(qemu_bin):
1149 qemu_bin = os.path.abspath(qemu_bin)
1150 logger.info("Using host's QEMU: %s" % qemu_bin)
1151 break
1152
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001153 if not os.access(qemu_bin, os.X_OK):
1154 raise OEPathError("No QEMU binary '%s' could be found" % qemu_bin)
1155
1156 check_libgl(qemu_bin)
1157
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001158 self.qemu_opt = "%s %s %s %s" % (qemu_bin, self.get('NETWORK_CMD'), self.get('ROOTFS_OPTIONS'), self.get('QB_OPT_APPEND'))
1159
1160 for ovmf in self.ovmf_bios:
1161 format = ovmf.rsplit('.', 1)[-1]
1162 self.qemu_opt += ' -drive if=pflash,format=%s,file=%s' % (format, ovmf)
1163 if self.ovmf_bios:
1164 # OVMF only supports normal VGA, i.e. we need to override a -vga vmware
1165 # that gets added for example for normal qemux86.
1166 self.qemu_opt += ' -vga std'
1167
1168 self.qemu_opt += ' ' + self.qemu_opt_script
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001169
1170 if self.snapshot:
1171 self.qemu_opt += " -snapshot"
1172
1173 if self.serialstdio:
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001174 if sys.stdin.isatty():
1175 subprocess.check_call("stty intr ^]", shell=True)
1176 logger.info("Interrupt character is '^]'")
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001177
1178 first_serial = ""
1179 if not re.search("-nographic", self.qemu_opt):
1180 first_serial = "-serial mon:vc"
1181 # We always want a ttyS1. Since qemu by default adds a serial
1182 # port when nodefaults is not specified, it seems that all that
1183 # would be needed is to make sure a "-serial" is there. However,
1184 # it appears that when "-serial" is specified, it ignores the
1185 # default serial port that is normally added. So here we make
1186 # sure to add two -serial if there are none. And only one if
1187 # there is one -serial already.
1188 serial_num = len(re.findall("-serial", self.qemu_opt))
1189 if serial_num == 0:
1190 self.qemu_opt += " %s %s" % (first_serial, self.get("QB_SERIAL_OPT"))
1191 elif serial_num == 1:
1192 self.qemu_opt += " %s" % self.get("QB_SERIAL_OPT")
1193
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001194 # We always wants ttyS0 and ttyS1 in qemu machines (see SERIAL_CONSOLES),
1195 # if not serial or serialtcp options was specified only ttyS0 is created
1196 # and sysvinit shows an error trying to enable ttyS1:
1197 # INIT: Id "S1" respawning too fast: disabled for 5 minutes
1198 serial_num = len(re.findall("-serial", self.qemu_opt))
1199 if serial_num == 0:
1200 if re.search("-nographic", self.qemu_opt):
1201 self.qemu_opt += " -serial mon:stdio -serial null"
1202 else:
1203 self.qemu_opt += " -serial mon:vc -serial null"
1204
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001205 def start_qemu(self):
Brad Bishop004d4992018-10-02 23:54:45 +02001206 import shlex
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001207 if self.kernel:
Brad Bishop37a0e4d2017-12-04 01:01:44 -05001208 kernel_opts = "-kernel %s -append '%s %s %s %s'" % (self.kernel, self.kernel_cmdline,
1209 self.kernel_cmdline_script, self.get('QB_KERNEL_CMDLINE_APPEND'),
1210 self.bootparams)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001211 if self.dtb:
1212 kernel_opts += " -dtb %s" % self.dtb
1213 else:
1214 kernel_opts = ""
1215 cmd = "%s %s" % (self.qemu_opt, kernel_opts)
Brad Bishop004d4992018-10-02 23:54:45 +02001216 cmds = shlex.split(cmd)
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001217 logger.info('Running %s\n' % cmd)
Brad Bishopf86d0552018-12-04 14:18:15 -08001218 pass_fds = []
1219 if self.lock_descriptor:
1220 pass_fds = [self.lock_descriptor.fileno()]
1221 process = subprocess.Popen(cmds, stderr=subprocess.PIPE, pass_fds=pass_fds)
Brad Bishop004d4992018-10-02 23:54:45 +02001222 self.qemupid = process.pid
1223 retcode = process.wait()
1224 if retcode:
1225 if retcode == -signal.SIGTERM:
1226 logger.info("Qemu terminated by SIGTERM")
1227 else:
1228 logger.error("Failed to run qemu: %s", process.stderr.read().decode())
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001229
1230 def cleanup(self):
Brad Bishop004d4992018-10-02 23:54:45 +02001231 if self.cleaned:
1232 return
1233
1234 # avoid dealing with SIGTERM when cleanup function is running
1235 signal.signal(signal.SIGTERM, signal.SIG_IGN)
1236
1237 logger.info("Cleaning up")
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001238 if self.cleantap:
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001239 cmd = 'sudo %s %s %s' % (self.qemuifdown, self.tap, self.bindir_native)
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001240 logger.debug('Running %s' % cmd)
1241 subprocess.check_call(cmd, shell=True)
Brad Bishopf86d0552018-12-04 14:18:15 -08001242 self.release_lock()
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001243
1244 if self.nfs_running:
1245 logger.info("Shutting down the userspace NFS server...")
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001246 cmd = "runqemu-export-rootfs stop %s" % self.rootfs
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001247 logger.debug('Running %s' % cmd)
1248 subprocess.check_call(cmd, shell=True)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001249
1250 if self.saved_stty:
1251 cmd = "stty %s" % self.saved_stty
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001252 subprocess.check_call(cmd, shell=True)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001253
1254 if self.clean_nfs_dir:
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001255 logger.info('Removing %s' % self.rootfs)
1256 shutil.rmtree(self.rootfs)
1257 shutil.rmtree('%s.pseudo_state' % self.rootfs)
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001258
Brad Bishop004d4992018-10-02 23:54:45 +02001259 self.cleaned = True
1260
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001261 def load_bitbake_env(self, mach=None):
1262 if self.bitbake_e:
1263 return
1264
1265 bitbake = shutil.which('bitbake')
1266 if not bitbake:
1267 return
1268
1269 if not mach:
1270 mach = self.get('MACHINE')
1271
1272 if mach:
1273 cmd = 'MACHINE=%s bitbake -e' % mach
1274 else:
1275 cmd = 'bitbake -e'
1276
1277 logger.info('Running %s...' % cmd)
1278 try:
1279 self.bitbake_e = subprocess.check_output(cmd, shell=True).decode('utf-8')
1280 except subprocess.CalledProcessError as err:
1281 self.bitbake_e = ''
1282 logger.warn("Couldn't run 'bitbake -e' to gather environment information:\n%s" % err.output.decode('utf-8'))
1283
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001284 def validate_combos(self):
1285 if (self.fstype in self.vmtypes) and self.kernel:
1286 raise RunQemuError("%s doesn't need kernel %s!" % (self.fstype, self.kernel))
1287
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001288 @property
1289 def bindir_native(self):
1290 result = self.get('STAGING_BINDIR_NATIVE')
1291 if result and os.path.exists(result):
1292 return result
1293
1294 cmd = 'bitbake qemu-helper-native -e'
1295 logger.info('Running %s...' % cmd)
1296 out = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
1297 out = out.stdout.read().decode('utf-8')
1298
1299 match = re.search('^STAGING_BINDIR_NATIVE="(.*)"', out, re.M)
1300 if match:
1301 result = match.group(1)
1302 if os.path.exists(result):
1303 self.set('STAGING_BINDIR_NATIVE', result)
1304 return result
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001305 raise RunQemuError("Native sysroot directory %s doesn't exist" % result)
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001306 else:
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001307 raise RunQemuError("Can't find STAGING_BINDIR_NATIVE in '%s' output" % cmd)
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001308
1309
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001310def main():
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001311 if "help" in sys.argv or '-h' in sys.argv or '--help' in sys.argv:
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001312 print_usage()
1313 return 0
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001314 try:
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001315 config = BaseConfig()
Brad Bishop004d4992018-10-02 23:54:45 +02001316
1317 def sigterm_handler(signum, frame):
1318 logger.info("SIGTERM received")
1319 os.kill(config.qemupid, signal.SIGTERM)
1320 config.cleanup()
Brad Bishopf86d0552018-12-04 14:18:15 -08001321 subprocess.check_call(["tput", "smam"])
Brad Bishop004d4992018-10-02 23:54:45 +02001322 signal.signal(signal.SIGTERM, sigterm_handler)
1323
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001324 config.check_args()
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001325 config.read_qemuboot()
1326 config.check_and_set()
1327 # Check whether the combos is valid or not
1328 config.validate_combos()
1329 config.print_config()
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001330 config.setup_network()
Brad Bishop6e60e8b2018-02-01 10:27:11 -05001331 config.setup_rootfs()
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001332 config.setup_final()
1333 config.start_qemu()
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001334 except RunQemuError as err:
1335 logger.error(err)
1336 return 1
1337 except Exception as err:
Patrick Williamsc0f7c042017-02-23 20:41:17 -06001338 import traceback
1339 traceback.print_exc()
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001340 return 1
1341 finally:
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001342 config.cleanup()
Brad Bishopf86d0552018-12-04 14:18:15 -08001343 subprocess.check_call(["tput", "smam"])
Brad Bishopd7bf8c12018-02-25 22:55:05 -05001344
1345if __name__ == "__main__":
1346 sys.exit(main())