cdf4473332
If some service is to spammy we might miss the login, so search in the entire log instead of just the last few lines. Use qemu in regex too (to avoid a login string from some service). (From OE-Core rev: 1117d25fdfabbf1afdc7030e05efc6a32df871e3) Signed-off-by: Stefan Stanacar <stefanx.stanacar@intel.com> Signed-off-by: Saul Wold <sgw@linux.intel.com> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
238 lines
8.8 KiB
Python
238 lines
8.8 KiB
Python
# Copyright (C) 2013 Intel Corporation
|
|
#
|
|
# Released under the MIT license (see COPYING.MIT)
|
|
|
|
# This module provides a class for starting qemu images using runqemu.
|
|
# It's used by testimage.bbclass.
|
|
|
|
import subprocess
|
|
import os
|
|
import time
|
|
import signal
|
|
import re
|
|
import socket
|
|
import select
|
|
import bb
|
|
|
|
class QemuRunner:
|
|
|
|
def __init__(self, machine, rootfs, display, tmpdir, deploy_dir_image, logfile, boottime):
|
|
|
|
# Popen object for runqemu
|
|
self.runqemu = None
|
|
# pid of the qemu process that runqemu will start
|
|
self.qemupid = None
|
|
# target ip - from the command line
|
|
self.ip = None
|
|
# host ip - where qemu is running
|
|
self.server_ip = None
|
|
|
|
self.machine = machine
|
|
self.rootfs = rootfs
|
|
self.display = display
|
|
self.tmpdir = tmpdir
|
|
self.deploy_dir_image = deploy_dir_image
|
|
self.logfile = logfile
|
|
self.boottime = boottime
|
|
|
|
self.runqemutime = 60
|
|
|
|
self.create_socket()
|
|
|
|
|
|
def create_socket(self):
|
|
|
|
self.bootlog = ''
|
|
self.qemusock = None
|
|
|
|
try:
|
|
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
self.server_socket.setblocking(0)
|
|
self.server_socket.bind(("127.0.0.1",0))
|
|
self.server_socket.listen(2)
|
|
self.serverport = self.server_socket.getsockname()[1]
|
|
bb.note("Created listening socket for qemu serial console on: 127.0.0.1:%s" % self.serverport)
|
|
except socket.error, msg:
|
|
self.server_socket.close()
|
|
bb.fatal("Failed to create listening socket: %s" %msg[1])
|
|
|
|
|
|
def log(self, msg):
|
|
if self.logfile:
|
|
with open(self.logfile, "a") as f:
|
|
f.write("%s" % msg)
|
|
|
|
def start(self, qemuparams = None):
|
|
|
|
if self.display:
|
|
os.environ["DISPLAY"] = self.display
|
|
else:
|
|
bb.error("To start qemu I need a X desktop, please set DISPLAY correctly (e.g. DISPLAY=:1)")
|
|
return False
|
|
if not os.path.exists(self.rootfs):
|
|
bb.error("Invalid rootfs %s" % self.rootfs)
|
|
return False
|
|
if not os.path.exists(self.tmpdir):
|
|
bb.error("Invalid TMPDIR path %s" % self.tmpdir)
|
|
return False
|
|
else:
|
|
os.environ["OE_TMPDIR"] = self.tmpdir
|
|
if not os.path.exists(self.deploy_dir_image):
|
|
bb.error("Invalid DEPLOY_DIR_IMAGE path %s" % self.deploy_dir_image)
|
|
return False
|
|
else:
|
|
os.environ["DEPLOY_DIR_IMAGE"] = self.deploy_dir_image
|
|
|
|
# Set this flag so that Qemu doesn't do any grabs as SDL grabs interact
|
|
# badly with screensavers.
|
|
os.environ["QEMU_DONT_GRAB"] = "1"
|
|
self.qemuparams = 'bootparams="console=tty1 console=ttyS0,115200n8" qemuparams="-serial tcp:127.0.0.1:%s"' % self.serverport
|
|
if qemuparams:
|
|
self.qemuparams = self.qemuparams[:-1] + " " + qemuparams + " " + '\"'
|
|
|
|
launch_cmd = 'runqemu %s %s %s' % (self.machine, self.rootfs, self.qemuparams)
|
|
self.runqemu = subprocess.Popen(launch_cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,preexec_fn=os.setpgrp)
|
|
|
|
bb.note("runqemu started, pid is %s" % self.runqemu.pid)
|
|
bb.note("waiting at most %s seconds for qemu pid" % self.runqemutime)
|
|
endtime = time.time() + self.runqemutime
|
|
while not self.is_alive() and time.time() < endtime:
|
|
time.sleep(1)
|
|
|
|
if self.is_alive():
|
|
bb.note("qemu started - qemu procces pid is %s" % self.qemupid)
|
|
cmdline = ''
|
|
with open('/proc/%s/cmdline' % self.qemupid) as p:
|
|
cmdline = p.read()
|
|
ips = re.findall("((?:[0-9]{1,3}\.){3}[0-9]{1,3})", cmdline.split("ip=")[1])
|
|
if not ips or len(ips) != 3:
|
|
bb.note("Couldn't get ip from qemu process arguments! Here is the qemu command line used: %s" % cmdline)
|
|
self.stop()
|
|
return False
|
|
else:
|
|
self.ip = ips[0]
|
|
self.server_ip = ips[1]
|
|
bb.note("Target IP: %s" % self.ip)
|
|
bb.note("Server IP: %s" % self.server_ip)
|
|
bb.note("Waiting at most %d seconds for login banner" % self.boottime )
|
|
endtime = time.time() + self.boottime
|
|
socklist = [self.server_socket]
|
|
reachedlogin = False
|
|
stopread = False
|
|
while time.time() < endtime and not stopread:
|
|
sread, swrite, serror = select.select(socklist, [], [], 5)
|
|
for sock in sread:
|
|
if sock is self.server_socket:
|
|
self.qemusock, addr = self.server_socket.accept()
|
|
self.qemusock.setblocking(0)
|
|
socklist.append(self.qemusock)
|
|
socklist.remove(self.server_socket)
|
|
bb.note("Connection from %s:%s" % addr)
|
|
else:
|
|
data = sock.recv(1024)
|
|
if data:
|
|
self.log(data)
|
|
self.bootlog += data
|
|
if re.search("qemu.* login:", self.bootlog):
|
|
stopread = True
|
|
reachedlogin = True
|
|
bb.note("Reached login banner")
|
|
else:
|
|
socklist.remove(sock)
|
|
sock.close()
|
|
stopread = True
|
|
|
|
if not reachedlogin:
|
|
bb.note("Target didn't reached login boot in %d seconds" % self.boottime)
|
|
lines = "\n".join(self.bootlog.splitlines()[-5:])
|
|
bb.note("Last 5 lines of text:\n%s" % lines)
|
|
bb.note("Check full boot log: %s" % self.logfile)
|
|
self.stop()
|
|
return False
|
|
else:
|
|
bb.note("Qemu pid didn't appeared in %s seconds" % self.runqemutime)
|
|
output = self.runqemu.stdout
|
|
self.stop()
|
|
bb.note("Output from runqemu:\n%s" % output.read())
|
|
return False
|
|
|
|
return self.is_alive()
|
|
|
|
def stop(self):
|
|
|
|
if self.runqemu:
|
|
bb.note("Sending SIGTERM to runqemu")
|
|
os.killpg(self.runqemu.pid, signal.SIGTERM)
|
|
endtime = time.time() + self.runqemutime
|
|
while self.runqemu.poll() is None and time.time() < endtime:
|
|
time.sleep(1)
|
|
if self.runqemu.poll() is None:
|
|
bb.note("Sending SIGKILL to runqemu")
|
|
os.killpg(self.runqemu.pid, signal.SIGKILL)
|
|
self.runqemu = None
|
|
if self.server_socket:
|
|
self.server_socket.close()
|
|
self.server_socket = None
|
|
self.qemupid = None
|
|
self.ip = None
|
|
|
|
def restart(self, qemuparams = None):
|
|
bb.note("Restarting qemu process")
|
|
if self.runqemu.poll() is None:
|
|
self.stop()
|
|
self.create_socket()
|
|
if self.start(qemuparams):
|
|
return True
|
|
return False
|
|
|
|
def is_alive(self):
|
|
qemu_child = self.find_child(str(self.runqemu.pid))
|
|
if qemu_child:
|
|
self.qemupid = qemu_child[0]
|
|
if os.path.exists("/proc/" + str(self.qemupid)):
|
|
return True
|
|
return False
|
|
|
|
def find_child(self,parent_pid):
|
|
#
|
|
# Walk the process tree from the process specified looking for a qemu-system. Return its [pid'cmd]
|
|
#
|
|
ps = subprocess.Popen(['ps', 'axww', '-o', 'pid,ppid,command'], stdout=subprocess.PIPE).communicate()[0]
|
|
processes = ps.split('\n')
|
|
nfields = len(processes[0].split()) - 1
|
|
pids = {}
|
|
commands = {}
|
|
for row in processes[1:]:
|
|
data = row.split(None, nfields)
|
|
if len(data) != 3:
|
|
continue
|
|
if data[1] not in pids:
|
|
pids[data[1]] = []
|
|
|
|
pids[data[1]].append(data[0])
|
|
commands[data[0]] = data[2]
|
|
|
|
if parent_pid not in pids:
|
|
return []
|
|
|
|
parents = []
|
|
newparents = pids[parent_pid]
|
|
while newparents:
|
|
next = []
|
|
for p in newparents:
|
|
if p in pids:
|
|
for n in pids[p]:
|
|
if n not in parents and n not in next:
|
|
next.append(n)
|
|
if p not in parents:
|
|
parents.append(p)
|
|
newparents = next
|
|
#print "Children matching %s:" % str(parents)
|
|
for p in parents:
|
|
# Need to be careful here since runqemu-internal runs "ldd qemu-system-xxxx"
|
|
# Also, old versions of ldd (2.11) run "LD_XXXX qemu-system-xxxx"
|
|
basecmd = commands[p].split()[0]
|
|
basecmd = os.path.basename(basecmd)
|
|
if "qemu-system" in basecmd and "-serial tcp" in commands[p]:
|
|
return [int(p),commands[p]]
|