Lines Matching full:self
36 …def __init__(self, machine, rootfs, display, tmpdir, deploy_dir_image, logfile, boottime, dump_dir… argument
40 self.runqemu = None
41 self.runqemu_exited = False
43 self.qemupid = None
45 self.ip = None
47 self.server_ip = None
49 self.netmask = None
51 self.machine = machine
52 self.rootfs = rootfs
53 self.display = display
54 self.tmpdir = tmpdir
55 self.deploy_dir_image = deploy_dir_image
56 self.logfile = logfile
57 self.boottime = boottime
58 self.logged = False
59 self.thread = None
60 self.use_kvm = use_kvm
61 self.use_ovmf = use_ovmf
62 self.use_slirp = use_slirp
63 self.serial_ports = serial_ports
64 self.msg = ''
65 self.boot_patterns = boot_patterns
66 self.tmpfsdir = tmpfsdir
68 self.runqemutime = 300
71 self.qemu_pidfile = workdir + '/pidfile_' + str(os.getpid())
72 self.host_dumper = HostDumper(dump_host_cmds, dump_dir)
73 self.monitorpipe = None
75 self.logger = logger
77 self.canexit = False
95 if not self.boot_patterns[pattern]:
96 self.boot_patterns[pattern] = default_boot_patterns[pattern]
98 def create_socket(self): argument
105 … self.logger.debug("Created listening socket for qemu serial console on: 127.0.0.1:%s" % port)
112 def log(self, msg): argument
113 if self.logfile:
118 self.msg += msg
119 with codecs.open(self.logfile, "a", encoding="utf-8") as f:
122 def getOutput(self, o): argument
132 def handleSIGCHLD(self, signum, frame): argument
133 if self.runqemu and self.runqemu.poll():
134 if self.runqemu.returncode:
135 self.logger.error('runqemu exited with code %d' % self.runqemu.returncode)
136 self.logger.error('Output from runqemu:\n%s' % self.getOutput(self.runqemu.stdout))
137 self.stop()
138 self._dump_host()
140 …def start(self, qemuparams = None, get_ip = True, extra_bootparams = None, runqemuparams='', launc… argument
142 if self.display:
143 env["DISPLAY"] = self.display
147 if not os.path.exists(self.rootfs):
148 self.logger.error("Invalid rootfs %s" % self.rootfs)
150 if not os.path.exists(self.tmpdir):
151 self.logger.error("Invalid TMPDIR path %s" % self.tmpdir)
154 env["OE_TMPDIR"] = self.tmpdir
155 if not os.path.exists(self.deploy_dir_image):
156 self.logger.error("Invalid DEPLOY_DIR_IMAGE path %s" % self.deploy_dir_image)
159 env["DEPLOY_DIR_IMAGE"] = self.deploy_dir_image
161 if self.tmpfsdir:
162 env["RUNQEMU_TMPFS_DIR"] = self.tmpfsdir
166 if self.use_kvm:
167 self.logger.debug('Using kvm for runqemu')
170 self.logger.debug('Not using kvm for runqemu')
171 if not self.display:
173 if self.use_slirp:
175 if self.use_ovmf:
177 launch_cmd += ' %s %s %s' % (runqemuparams, self.machine, self.rootfs)
179 …return self.launch(launch_cmd, qemuparams=qemuparams, get_ip=get_ip, extra_bootparams=extra_bootpa…
181 …def launch(self, launch_cmd, get_ip = True, qemuparams = None, extra_bootparams = None, env = None… argument
185 python_path = os.path.dirname(os.path.dirname(self.logfile))
192 self.logger.error("qemurunner: qmp.py missing, please ensure it's installed")
197 qmp_port = self.tmpdir + "/" + qmp_file
202 qmp_port2 = self.tmpdir + "/" + qmp_file2
203 self.logger.info("QMP Available for connection at %s" % (qmp_port2))
206 if self.serial_ports >= 2:
207 self.threadsock, threadport = self.create_socket()
208 self.server_socket, self.serverport = self.create_socket()
210 self.logger.error("Failed to create listening socket: %s" % msg[1])
219 if os.path.exists(self.qemu_pidfile):
220 os.remove(self.qemu_pidfile)
221 …self.qemuparams = 'bootparams="{0}" qemuparams="-pidfile {1} {2}"'.format(bootparams, self.qemu_pi…
224 self.qemuparams = self.qemuparams[:-1] + " " + qemuparams + " " + '\"'
226 if self.serial_ports >= 2:
227 launch_cmd += ' tcpserial=%s:%s %s' % (threadport, self.serverport, self.qemuparams)
229 launch_cmd += ' tcpserial=%s %s' % (self.serverport, self.qemuparams)
231 self.origchldhandler = signal.getsignal(signal.SIGCHLD)
232 signal.signal(signal.SIGCHLD, self.handleSIGCHLD)
234 self.logger.debug('launchcmd=%s'%(launch_cmd))
240 …self.runqemu = subprocess.Popen(launch_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.…
241 output = self.runqemu.stdout
257 self.monitorpid = os.fork()
258 if self.monitorpid:
260 self.monitorpipe = os.fdopen(w, "w")
267 os.killpg(os.getpgid(self.runqemu.pid), signal.SIGTERM)
270 self.logger.debug("runqemu started, pid is %s" % self.runqemu.pid)
271 self.logger.debug("waiting at most %s seconds for qemu pid (%s)" %
272 (self.runqemutime, time.strftime("%D %H:%M:%S")))
273 endtime = time.time() + self.runqemutime
274 while not self.is_alive() and time.time() < endtime:
275 if self.runqemu.poll():
276 if self.runqemu_exited:
277 self.logger.warning("runqemu during is_alive() test")
279 if self.runqemu.returncode:
281 self.logger.warning('runqemu exited with code %d' % self.runqemu.returncode)
282 self._dump_host()
283 self.logger.warning("Output from runqemu:\n%s" % self.getOutput(output))
284 self.stop()
288 if self.runqemu_exited:
289 self.logger.warning("runqemu after timeout")
291 if self.runqemu.returncode:
292 self.logger.warning('runqemu exited with code %d' % self.runqemu.returncode)
294 if not self.is_alive():
295 self.logger.error("Qemu pid didn't appear in %s seconds (%s)" %
296 (self.runqemutime, time.strftime("%D %H:%M:%S")))
299 if os.path.isfile(self.qemu_pidfile):
300 with open(self.qemu_pidfile, 'r') as f:
303 …self.logger.error("Status information, poll status: %s, pidfile exists: %s, pidfile contents %s, p…
304 …% (self.runqemu.poll(), os.path.isfile(self.qemu_pidfile), str(qemu_pid), os.path.exists("/proc/" …
309 self.logger.debug("Running processes:\n%s" % processes)
310 self._dump_host()
311 op = self.getOutput(output)
312 self.stop()
314 self.logger.error("Output from runqemu:\n%s" % op)
316 self.logger.error("No output from runqemu.\n")
322 self.logger.debug("QMP Initializing to %s" % (qmp_port))
328 self.qmp = qmp.QEMUMonitorProtocol(os.path.basename(qmp_port))
330 … self.logger.warning("Failed to initialize qemu monitor socket: %s File: %s" % (msg, msg.filename))
333 self.logger.debug("QMP Connecting to %s" % (qmp_port))
334 if not os.path.exists(qmp_port) and self.is_alive():
335 self.logger.debug("QMP Port does not exist waiting for it to be created")
336 endtime = time.time() + self.runqemutime
337 while not os.path.exists(qmp_port) and self.is_alive() and time.time() < endtime:
338 self.logger.info("QMP port does not exist yet!")
340 if not os.path.exists(qmp_port) and self.is_alive():
341 self.logger.warning("QMP Port still does not exist but QEMU is alive")
346 self.qmp.settimeout(self.runqemutime)
347 self.qmp.connect()
349 self.logger.info("QMP connected to QEMU at %s and took %s seconds" %
353 … self.logger.warning("Failed to connect qemu monitor socket: %s File: %s" % (msg, msg.filename))
356 self.logger.warning("Failed to communicate with qemu monitor: %s" % (msg))
364 mapdir = "/proc/" + str(self.qemupid) + "/map_files/"
382 self.run_monitor('cont')
383 self.logger.info("QMP released QEMU at %s and took %s seconds from connect" %
388 out = self.getOutput(output)
390 self.logger.debug("qemu started in %s seconds - qemu procces pid is %s (%s)" %
391 (time.time() - (endtime - self.runqemutime),
392 self.qemupid, time.strftime("%D %H:%M:%S")))
395 with open('/proc/%s/cmdline' % self.qemupid) as p:
401 if self.use_slirp:
404 self.ip = "localhost:%s" % host_port
407 self.ip = ips[0]
408 self.server_ip = ips[1]
409 self.logger.debug("qemu cmdline used:\n{}".format(cmdline))
415 self.ip, self.server_ip, self.netmask = match.groups()
421 self.logger.error("Couldn't get ip from qemu command line and runqemu output! "
424 self._dump_host()
425 self.stop()
428 self.logger.debug("Target IP: %s" % self.ip)
429 self.logger.debug("Server IP: %s" % self.server_ip)
431 if self.serial_ports >= 2:
432 self.thread = LoggingThread(self.log, self.threadsock, self.logger)
433 self.thread.start()
434 if not self.thread.connection_established.wait(self.boottime):
435 self.logger.error("Didn't receive a console connection from qemu. "
438 self.stop_thread()
441 self.logger.debug("Output from runqemu:\n%s", out)
442 self.logger.debug("Waiting at most %d seconds for login banner (%s)" %
443 (self.boottime, time.strftime("%D %H:%M:%S")))
444 endtime = time.time() + self.boottime
445 socklist = [self.server_socket]
457 if sock is self.server_socket:
458 qemusock, addr = self.server_socket.accept()
461 socklist.remove(self.server_socket)
462 self.logger.debug("Connection from %s:%s" % addr)
469 if self.serial_ports < 2:
471 self.log(data)
474 if self.boot_patterns['search_reached_prompt'] in bootlog:
475 self.server_socket = qemusock
478 self.logger.debug("Reached login banner in %s seconds (%s, %s)" %
479 (time.time() - (endtime - self.boottime),
483 … self.logger.debug("QEMU socket disconnected before login banner reached. (%s)" %
491 self.logger.warning("Target didn't reach login banner in %d seconds (%s)" %
492 (self.boottime, time.strftime("%D %H:%M:%S")))
495 # in case bootlog is empty, use tail qemu log store at self.msg
496 lines = tail(bootlog if bootlog else self.msg)
497 self.logger.warning("Last 25 lines of text:\n%s" % lines)
498 self.logger.warning("Check full boot log: %s" % self.logfile)
499 self._dump_host()
500 self.stop()
505 … (status, output) = self.run_serial(self.boot_patterns['send_login_user'], raw=True, timeout=120)
506 if re.search(self.boot_patterns['search_login_succeeded'], output):
507 self.logged = True
508 self.logger.debug("Logged as root in serial console")
511 cmd = "ifconfig eth0 %s netmask %s up\n" % (self.ip, self.netmask)
512 output = self.run_serial(cmd, raw=True)[1]
514 self.logger.debug("configured ip address %s", self.ip)
516 self.logger.debug("Couldn't configure guest networking")
518 self.logger.warning("Couldn't login into serial console"
520 self.logger.warning("The output:\n%s" % output)
522 self.logger.warning("Serial console failed while trying to login")
525 def stop(self): argument
526 if hasattr(self, "origchldhandler"):
527 signal.signal(signal.SIGCHLD, self.origchldhandler)
528 self.stop_thread()
529 self.stop_qemu_system()
530 if self.runqemu:
531 if hasattr(self, "monitorpid"):
532 os.kill(self.monitorpid, signal.SIGKILL)
533 self.logger.debug("Sending SIGTERM to runqemu")
535 os.killpg(os.getpgid(self.runqemu.pid), signal.SIGTERM)
540 outs, errs = self.runqemu.communicate(timeout = self.runqemutime)
542 self.logger.info("Output from runqemu:\n%s", outs.decode("utf-8"))
544 self.logger.info("Stderr from runqemu:\n%s", errs.decode("utf-8"))
546 self.logger.debug("Sending SIGKILL to runqemu")
547 os.killpg(os.getpgid(self.runqemu.pid), signal.SIGKILL)
548 if not self.runqemu.stdout.closed:
549 self.logger.info("Output from runqemu:\n%s" % self.getOutput(self.runqemu.stdout))
550 self.runqemu.stdin.close()
551 self.runqemu.stdout.close()
552 self.runqemu_exited = True
554 if hasattr(self, 'qmp') and self.qmp:
555 self.qmp.close()
556 self.qmp = None
557 if hasattr(self, 'server_socket') and self.server_socket:
558 self.server_socket.close()
559 self.server_socket = None
560 if hasattr(self, 'threadsock') and self.threadsock:
561 self.threadsock.close()
562 self.threadsock = None
563 self.qemupid = None
564 self.ip = None
565 if os.path.exists(self.qemu_pidfile):
567 os.remove(self.qemu_pidfile)
571 if self.monitorpipe:
572 self.monitorpipe.close()
574 def stop_qemu_system(self): argument
575 if self.qemupid:
578 os.kill(self.qemupid, signal.SIGTERM)
580 self.logger.warning('qemu-system ended unexpectedly')
582 def stop_thread(self): argument
583 if self.thread and self.thread.is_alive():
584 self.thread.stop()
585 self.thread.join()
587 def allowexit(self): argument
588 self.canexit = True
589 if self.thread:
590 self.thread.allowexit()
592 def restart(self, qemuparams = None): argument
593 self.logger.warning("Restarting qemu process")
594 if self.runqemu.poll() is None:
595 self.stop()
596 if self.start(qemuparams):
600 def is_alive(self): argument
601 if not self.runqemu or self.runqemu.poll() is not None or self.runqemu_exited:
603 if os.path.isfile(self.qemu_pidfile):
608 with open(self.qemu_pidfile, 'r') as f:
616 self.qemupid = int(qemu_pid)
620 def run_monitor(self, command, args=None, timeout=60): argument
621 if hasattr(self, 'qmp') and self.qmp:
622 self.qmp.settimeout(timeout)
624 return self.qmp.cmd(command, args)
626 return self.qmp.cmd(command)
628 def run_serial(self, command, raw=False, timeout=60): argument
637 self.server_socket.sendall(command.encode('utf-8'))
646 sread, _, _ = select.select([self.server_socket],[],[], end - now)
652 answer = self.server_socket.recv(1024)
656 if re.search(self.boot_patterns['search_cmd_finished'], data):
659 if self.canexit:
681 def _dump_host(self): argument
682 self.host_dumper.create_dir("qemu")
683 self.logger.warning("Qemu ended unexpectedly, dump data from host"
684 " is in %s" % self.host_dumper.dump_dir)
685 self.host_dumper.dump_host()
692 def __init__(self, logfunc, sock, logger): argument
693 self.connection_established = threading.Event()
694 self.serversock = sock
695 self.logfunc = logfunc
696 self.logger = logger
697 self.readsock = None
698 self.running = False
699 self.canexit = False
701 self.errorevents = select.POLLERR | select.POLLHUP | select.POLLNVAL
702 self.readevents = select.POLLIN | select.POLLPRI
704 threading.Thread.__init__(self, target=self.threadtarget)
706 def threadtarget(self): argument
708 self.eventloop()
710 self.teardown()
712 def run(self): argument
713 self.logger.debug("Starting logging thread")
714 self.readpipe, self.writepipe = os.pipe()
715 threading.Thread.run(self)
717 def stop(self): argument
718 self.logger.debug("Stopping logging thread")
719 if self.running:
720 os.write(self.writepipe, bytes("stop", "utf-8"))
722 def teardown(self): argument
723 self.logger.debug("Tearing down logging thread")
724 self.close_socket(self.serversock)
726 if self.readsock is not None:
727 self.close_socket(self.readsock)
729 self.close_ignore_error(self.readpipe)
730 self.close_ignore_error(self.writepipe)
731 self.running = False
733 def allowexit(self): argument
734 self.canexit = True
736 def eventloop(self): argument
738 event_read_mask = self.errorevents | self.readevents
739 poll.register(self.serversock.fileno())
740 poll.register(self.readpipe, event_read_mask)
743 self.running = True
744 self.logger.debug("Starting thread event loop")
749 if event[1] & self.errorevents:
750 raise Exception(self.stringify_event(event[1]))
753 if self.readpipe == event[0]:
754 self.logger.debug("Stop event received")
759 elif self.serversock.fileno() == event[0]:
760 self.logger.debug("Connection request received")
761 self.readsock, _ = self.serversock.accept()
762 self.readsock.setblocking(0)
763 poll.unregister(self.serversock.fileno())
764 poll.register(self.readsock.fileno(), event_read_mask)
766 self.logger.debug("Setting connection established event")
767 self.connection_established.set()
770 elif self.readsock.fileno() == event[0]:
771 data = self.recv(1024)
772 self.logfunc(data)
776 def recv(self, count): argument
778 data = self.readsock.recv(count)
792 if not self.canexit:
798 def stringify_event(self, event): argument
808 def close_socket(self, sock): argument
812 def close_ignore_error(self, fd): argument