Add output.xml with only INFO logging leve

[csit.git] / resources / libraries / python / QemuUtils.py

diff --git a/resources/libraries/python/QemuUtils.py b/resources/libraries/python/QemuUtils.py
index 428599b..193390c 100644 (file)
--- a/resources/libraries/python/QemuUtils.py
+++ b/resources/libraries/python/QemuUtils.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2016 Cisco and/or its affiliates.
+# Copyright (c) 2019 Cisco and/or its affiliates.

 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at:


@@ -13,221 +13,456 @@
 
 """QEMU utilities library."""
 
 
 """QEMU utilities library."""
 

-from time import time, sleep
+from time import sleep
+from string import Template

 import json
 import json

+from re import match
+# Disable due to pylint bug
+# pylint: disable=no-name-in-module,import-error
+from distutils.version import StrictVersion

 
 from robot.api import logger
 
 from robot.api import logger

+from resources.libraries.python.ssh import exec_cmd, exec_cmd_no_error
+from resources.libraries.python.Constants import Constants
+from resources.libraries.python.DpdkUtil import DpdkUtil
+from resources.libraries.python.DUTSetup import DUTSetup
+from resources.libraries.python.topology import NodeType, Topology
+from resources.libraries.python.VppConfigGenerator import VppConfigGenerator
+from resources.libraries.python.VPPUtil import VPPUtil

 
 

-from resources.libraries.python.ssh import SSH, SSHTimeout
-from resources.libraries.python.constants import Constants
-from resources.libraries.python.topology import NodeType
+__all__ = ["QemuOptions", "QemuUtils"]
+
+
+class QemuOptions(object):
+    """QEMU option class.
+
+    The class can handle input parameters that acts as QEMU command line
+    parameters. The only variable is a list of dictionaries where dictionaries
+    can be added multiple times. This emulates the QEMU behavior where one
+    command line parameter can be used multiple times (1..N). Example can be
+    device or object (so it is not an issue to have one memory
+    block of 2G and and second memory block of 512M but from other numa).
+
+    Class does support get value or string representation that will return
+    space separated, dash prefixed string of key value pairs used for command
+    line.
+    """
+
+    # Use one instance of class per tests.
+    ROBOT_LIBRARY_SCOPE = 'TEST CASE'
+
+    def __init__(self):
+        self.variables = list()
+
+    def add(self, variable, value):
+        """Add parameter to the list.
+
+        :param variable: QEMU parameter name (without dash).
+        :param value: Paired value.
+        :type variable: str
+        :type value: str or int
+        """
+        self.variables.append({str(variable): value})
+
+    def __str__(self):
+        """Return space separated string of key value pairs.
+
+        The format is suitable to be pasted to qemu command line.
+
+        :returns: Space separated string of key value pairs.
+        :rtype: str
+        """
+        return " ".join(["-{k} {v}".format(k=d.keys()[0], v=d.values()[0])
+                         for d in self.variables])

 
 
 class QemuUtils(object):
     """QEMU utilities."""
 
 
 
 class QemuUtils(object):
     """QEMU utilities."""
 

-    def __init__(self, qemu_id=1):
-        self._qemu_id = qemu_id
-        # Path to QEMU binary
-        self._qemu_bin = '/usr/bin/qemu-system-x86_64'
-        # QEMU Machine Protocol socket
-        self._qmp_sock = '/tmp/qmp{0}.sock'.format(self._qemu_id)
-        # QEMU Guest Agent socket
-        self._qga_sock = '/tmp/qga{0}.sock'.format(self._qemu_id)
-        # QEMU PID file
-        self._pid_file = '/tmp/qemu{0}.pid'.format(self._qemu_id)
-        self._qemu_opt = {}
-        # Default 1 CPU.
-        self._qemu_opt['smp'] = '-smp 1,sockets=1,cores=1,threads=1'
-        # Daemonize the QEMU process after initialization. Default one
-        # management interface.
-        self._qemu_opt['options'] = '-cpu host -daemonize -enable-kvm ' \
-            '-machine pc,accel=kvm,usb=off,mem-merge=off ' \
-            '-net nic,macaddr=52:54:00:00:{0:02x}:ff -balloon none'\
-            .format(self._qemu_id)
-        self._qemu_opt['ssh_fwd_port'] = 10021 + qemu_id
-        # Default serial console port
-        self._qemu_opt['serial_port'] = 4555 + qemu_id
-        # Default 512MB virtual RAM
-        self._qemu_opt['mem_size'] = 512
-        # Default huge page mount point, required for Vhost-user interfaces.
-        self._qemu_opt['huge_mnt'] = '/mnt/huge'
-        # Default do not allocate huge pages.
-        self._qemu_opt['huge_allocate'] = False
-        # Default image for CSIT virl setup
-        self._qemu_opt['disk_image'] = '/var/lib/vm/vhost-nested.img'
-        # VM node info dict
+    # Use one instance of class per tests.
+    ROBOT_LIBRARY_SCOPE = 'TEST CASE'
+
+    def __init__(self, node, qemu_id=1, smp=1, mem=512, vnf=None,
+                 img='/var/lib/vm/vhost-nested.img', bin_path='/usr/bin'):
+        """Initialize QemuUtil class.
+
+        :param node: Node to run QEMU on.
+        :param qemu_id: QEMU identifier.
+        :param smp: Number of virtual SMP units (cores).
+        :param mem: Amount of memory.
+        :param vnf: Network function workload.
+        :param img: QEMU disk image or kernel image path.
+        :param bin_path: QEMU binary path.
+        :type node: dict
+        :type qemu_id: int
+        :type smp: int
+        :type mem: int
+        :type vnf: str
+        :type img: str
+        :type bin_path: str
+        """
+        self._vhost_id = 0
+        self._node = node

         self._vm_info = {
         self._vm_info = {

+            'host': node['host'],

             'type': NodeType.VM,
             'type': NodeType.VM,

-            'port': self._qemu_opt['ssh_fwd_port'],
+            'port': 10021 + qemu_id,
+            'serial': 4555 + qemu_id,

             'username': 'cisco',
             'password': 'cisco',
             'interfaces': {},
         }
             'username': 'cisco',
             'password': 'cisco',
             'interfaces': {},
         }

-        # Virtio queue count
-        self._qemu_opt['queues'] = 1
-        self._vhost_id = 0
-        self._ssh = None
-        self._node = None
-        self._socks = [self._qmp_sock, self._qga_sock]
-
-    def qemu_set_bin(self, path):
-        """Set binary path for QEMU.
-
-        :param path: Absolute path in filesystem.
-        :type path: str
+        if node['port'] != 22:
+            self._vm_info['host_port'] = node['port']
+            self._vm_info['host_username'] = node['username']
+            self._vm_info['host_password'] = node['password']
+        # Input Options.
+        self._opt = dict()
+        self._opt['qemu_id'] = qemu_id
+        self._opt['bin_path'] = bin_path
+        self._opt['mem'] = int(mem)
+        self._opt['smp'] = int(smp)
+        self._opt['img'] = img
+        self._opt['vnf'] = vnf
+        # Temporary files.
+        self._temp = dict()
+        self._temp['pidfile'] = '/var/run/qemu_{id}.pid'.format(id=qemu_id)
+        if '/var/lib/vm/' in img:
+            self._opt['vm_type'] = 'nestedvm'
+            self._temp['qmp'] = '/var/run/qmp_{id}.sock'.format(id=qemu_id)
+            self._temp['qga'] = '/var/run/qga_{id}.sock'.format(id=qemu_id)
+        elif '/opt/boot/vmlinuz' in img:
+            self._opt['vm_type'] = 'kernelvm'
+            self._temp['log'] = '/tmp/serial_{id}.log'.format(id=qemu_id)
+            self._temp['ini'] = '/etc/vm_init_{id}.conf'.format(id=qemu_id)
+        else:
+            raise RuntimeError('QEMU: Unknown VM image option!')
+        # Computed parameters for QEMU command line.
+        self._params = QemuOptions()
+        self.add_params()
+
+    def add_params(self):
+        """Set QEMU command line parameters."""
+        self.add_default_params()
+        if self._opt.get('vm_type', '') == 'nestedvm':
+            self.add_nestedvm_params()
+        elif self._opt.get('vm_type', '') == 'kernelvm':
+            self.add_kernelvm_params()
+        else:
+            raise RuntimeError('QEMU: Unsupported VM type!')
+
+    def add_default_params(self):
+        """Set default QEMU command line parameters."""
+        self._params.add('daemonize', '')
+        self._params.add('nodefaults', '')
+        self._params.add('name', 'vnf{qemu},debug-threads=on'.
+                         format(qemu=self._opt.get('qemu_id')))
+        self._params.add('no-user-config', '')
+        self._params.add('monitor', 'none')
+        self._params.add('display', 'none')
+        self._params.add('vga', 'none')
+        self._params.add('enable-kvm', '')
+        self._params.add('pidfile', '{pidfile}'.
+                         format(pidfile=self._temp.get('pidfile')))
+        self._params.add('cpu', 'host')
+        self._params.add('machine', 'pc,accel=kvm,usb=off,mem-merge=off')
+        self._params.add('smp', '{smp},sockets=1,cores={smp},threads=1'.
+                         format(smp=self._opt.get('smp')))
+        self._params.add('object',
+                         'memory-backend-file,id=mem,size={mem}M,'
+                         'mem-path=/dev/hugepages,share=on'.
+                         format(mem=self._opt.get('mem')))
+        self._params.add('m', '{mem}M'.
+                         format(mem=self._opt.get('mem')))
+        self._params.add('numa', 'node,memdev=mem')
+        self._params.add('balloon', 'none')
+
+    def add_nestedvm_params(self):
+        """Set NestedVM QEMU parameters."""
+        self._params.add('net', 'nic,macaddr=52:54:00:00:{qemu:02x}:ff'.
+                         format(qemu=self._opt.get('qemu_id')))
+        self._params.add('net', 'user,hostfwd=tcp::{info[port]}-:22'.
+                         format(info=self._vm_info))
+        # TODO: Remove try except after fully migrated to Bionic or
+        # qemu_set_node is removed.
+        try:
+            locking = ',file.locking=off'\
+                if self.qemu_version(version='2.10') else ''
+        except AttributeError:
+            locking = ''
+        self._params.add('drive',
+                         'file={img},format=raw,cache=none,if=virtio{locking}'.
+                         format(img=self._opt.get('img'), locking=locking))
+        self._params.add('qmp', 'unix:{qmp},server,nowait'.
+                         format(qmp=self._temp.get('qmp')))
+        self._params.add('chardev', 'socket,host=127.0.0.1,port={info[serial]},'
+                         'id=gnc0,server,nowait'.format(info=self._vm_info))
+        self._params.add('device', 'isa-serial,chardev=gnc0')
+        self._params.add('chardev',
+                         'socket,path={qga},server,nowait,id=qga0'.
+                         format(qga=self._temp.get('qga')))
+        self._params.add('device', 'isa-serial,chardev=qga0')
+
+    def add_kernelvm_params(self):
+        """Set KernelVM QEMU parameters."""
+        self._params.add('chardev', 'file,id=char0,path={log}'.
+                         format(log=self._temp.get('log')))
+        self._params.add('device', 'isa-serial,chardev=char0')
+        self._params.add('fsdev', 'local,id=root9p,path=/,security_model=none')
+        self._params.add('device',
+                         'virtio-9p-pci,fsdev=root9p,mount_tag=/dev/root')
+        self._params.add('kernel', '$(readlink -m {img}* | tail -1)'.
+                         format(img=self._opt.get('img')))
+        self._params.add('append',
+                         '"ro rootfstype=9p rootflags=trans=virtio '
+                         'console=ttyS0 tsc=reliable hugepages=256 '
+                         'init={init}"'.format(init=self._temp.get('ini')))
+
+    def create_kernelvm_config_vpp(self, **kwargs):
+        """Create QEMU VPP config files.
+
+        :param kwargs: Key-value pairs to replace content of VPP configuration
+            file.
+        :type kwargs: dict

         """
         """

-        self._qemu_bin = path
-
-    def qemu_set_smp(self, cpus, cores, threads, sockets):
-        """Set SMP option for QEMU.
-
-        :param cpus: Number of CPUs.
-        :param cores: Number of CPU cores on one socket.
-        :param threads: Number of threads on one CPU core.
-        :param sockets: Number of discrete sockets in the system.
-        :type cpus: int
-        :type cores: int
-        :type threads: int
-        :type sockets: int
+        startup = ('/etc/vpp/vm_startup_{id}.conf'.
+                   format(id=self._opt.get('qemu_id')))
+        running = ('/etc/vpp/vm_running_{id}.exec'.
+                   format(id=self._opt.get('qemu_id')))
+
+        self._temp['startup'] = startup
+        self._temp['running'] = running
+        self._opt['vnf_bin'] = ('/usr/bin/vpp -c {startup}'.
+                                format(startup=startup))
+
+        # Create VPP startup configuration.
+        vpp_config = VppConfigGenerator()
+        vpp_config.set_node(self._node)
+        vpp_config.add_unix_nodaemon()
+        vpp_config.add_unix_cli_listen()
+        vpp_config.add_unix_exec(running)
+        vpp_config.add_cpu_main_core('0')
+        vpp_config.add_cpu_corelist_workers('1-{smp}'.
+                                            format(smp=self._opt.get('smp')-1))
+        vpp_config.add_dpdk_dev('0000:00:06.0', '0000:00:07.0')
+        vpp_config.add_dpdk_log_level('debug')
+        if not kwargs['jumbo_frames']:
+            vpp_config.add_dpdk_no_multi_seg()
+            vpp_config.add_dpdk_no_tx_checksum_offload()
+        vpp_config.add_plugin('disable', 'default')
+        vpp_config.add_plugin('enable', 'dpdk_plugin.so')
+        vpp_config.apply_config(startup, restart_vpp=False)
+
+        # Create VPP running configuration.
+        template = '{res}/{tpl}.exec'.format(res=Constants.RESOURCES_TPL_VM,
+                                             tpl=self._opt.get('vnf'))
+        exec_cmd_no_error(self._node, 'rm -f {running}'.format(running=running),
+                          sudo=True)
+
+        with open(template, 'r') as src_file:
+            src = Template(src_file.read())
+            exec_cmd_no_error(self._node, "echo '{out}' | sudo tee {running}".
+                              format(out=src.safe_substitute(**kwargs),
+                                     running=running))
+
+    def create_kernelvm_config_testpmd_io(self, **kwargs):
+        """Create QEMU testpmd-io command line.
+
+        :param kwargs: Key-value pairs to construct command line parameters.
+        :type kwargs: dict

         """
         """

-        self._qemu_opt['smp'] = '-smp {},cores={},threads={},sockets={}'.format(
-            cpus, cores, threads, sockets)
-
-    def qemu_set_ssh_fwd_port(self, fwd_port):
-        """Set host port for guest SSH forwarding.
-
-        :param fwd_port: Port number on host for guest SSH forwarding.
-        :type fwd_port: int
+        testpmd_path = ('{path}/{arch}-native-linuxapp-gcc/app'.
+                        format(path=Constants.QEMU_PERF_VM_DPDK,
+                               arch=Topology.get_node_arch(self._node)))
+        testpmd_cmd = DpdkUtil.get_testpmd_cmdline(
+            eal_corelist='0-{smp}'.format(smp=self._opt.get('smp') - 1),
+            eal_driver=False,
+            eal_in_memory=True,
+            pmd_num_mbufs=16384,
+            pmd_rxq=kwargs['queues'],
+            pmd_txq=kwargs['queues'],
+            pmd_tx_offloads=False,
+            pmd_disable_hw_vlan=False,
+            pmd_max_pkt_len=9200 if kwargs['jumbo_frames'] else None,
+            pmd_nb_cores=str(self._opt.get('smp') - 1))
+
+        self._opt['vnf_bin'] = ('{testpmd_path}/{testpmd_cmd}'.
+                                format(testpmd_path=testpmd_path,
+                                       testpmd_cmd=testpmd_cmd))
+
+    def create_kernelvm_config_testpmd_mac(self, **kwargs):
+        """Create QEMU testpmd-mac command line.
+
+        :param kwargs: Key-value pairs to construct command line parameters.
+        :type kwargs: dict

         """
         """

-        self._qemu_opt['ssh_fwd_port'] = fwd_port
-        self._vm_info['port'] = fwd_port
-
-    def qemu_set_serial_port(self, port):
-        """Set serial console port.
-
-        :param port: Serial console port.
-        :type port: int
+        testpmd_path = ('{path}/{arch}-native-linuxapp-gcc/app'.
+                        format(path=Constants.QEMU_PERF_VM_DPDK,
+                               arch=Topology.get_node_arch(self._node)))
+        testpmd_cmd = DpdkUtil.get_testpmd_cmdline(
+            eal_corelist='0-{smp}'.format(smp=self._opt.get('smp') - 1),
+            eal_driver=False,
+            eal_in_memory=True,
+            pmd_num_mbufs=16384,
+            pmd_fwd_mode='mac',
+            pmd_eth_peer_0='0,{mac}'.format(mac=kwargs['vif1_mac']),
+            pmd_eth_peer_1='1,{mac}'.format(mac=kwargs['vif2_mac']),
+            pmd_rxq=kwargs['queues'],
+            pmd_txq=kwargs['queues'],
+            pmd_tx_offloads=False,
+            pmd_disable_hw_vlan=False,
+            pmd_max_pkt_len=9200 if kwargs['jumbo_frames'] else None,
+            pmd_nb_cores=str(self._opt.get('smp') - 1))
+
+        self._opt['vnf_bin'] = ('{testpmd_path}/{testpmd_cmd}'.
+                                format(testpmd_path=testpmd_path,
+                                       testpmd_cmd=testpmd_cmd))
+
+    def create_kernelvm_init(self, **kwargs):
+        """Create QEMU init script.
+
+        :param kwargs: Key-value pairs to replace content of init startup file.
+        :type kwargs: dict

         """
         """

-        self._qemu_opt['serial_port'] = port
-
-    def qemu_set_mem_size(self, mem_size):
-        """Set virtual RAM size.
-
-        :param mem_size: RAM size in Mega Bytes.
-        :type mem_size: int
+        template = '{res}/init.sh'.format(res=Constants.RESOURCES_TPL_VM)
+        init = self._temp.get('ini')
+        exec_cmd_no_error(self._node, 'rm -f {init}'.format(init=init),
+                          sudo=True)
+
+        with open(template, 'r') as src_file:
+            src = Template(src_file.read())
+            exec_cmd_no_error(self._node, "echo '{out}' | sudo tee {init}".
+                              format(out=src.safe_substitute(**kwargs),
+                                     init=init))
+            exec_cmd_no_error(self._node, "chmod +x {init}".
+                              format(init=init), sudo=True)
+
+    def configure_kernelvm_vnf(self, **kwargs):
+        """Create KernelVM VNF configurations.
+
+        :param kwargs: Key-value pairs for templating configs.
+        :type kwargs: dict

         """
         """

-        self._qemu_opt['mem_size'] = int(mem_size)
+        if 'vpp' in self._opt.get('vnf'):
+            self.create_kernelvm_config_vpp(**kwargs)
+        elif 'testpmd_io' in self._opt.get('vnf'):
+            self.create_kernelvm_config_testpmd_io(**kwargs)
+        elif 'testpmd_mac' in self._opt.get('vnf'):
+            self.create_kernelvm_config_testpmd_mac(**kwargs)
+        else:
+            raise RuntimeError('QEMU: Unsupported VNF!')
+        self.create_kernelvm_init(vnf_bin=self._opt.get('vnf_bin'))

 
 

-    def qemu_set_huge_mnt(self, huge_mnt):
-        """Set hugefile mount point.
+    def get_qemu_pids(self):
+        """Get QEMU CPU pids.

 
 

-        :param huge_mnt: System hugefile mount point.
-        :type huge_mnt: int
+        :returns: List of QEMU CPU pids.
+        :rtype: list of str

         """
         """

-        self._qemu_opt['huge_mnt'] = huge_mnt
-
-    def qemu_set_huge_allocate(self):
-        """Set flag to allocate more huge pages if needed."""
-        self._qemu_opt['huge_allocate'] = True
-
-    def qemu_set_disk_image(self, disk_image):
-        """Set disk image.
+        command = ("grep -rwl 'CPU' /proc/$(sudo cat {pidfile})/task/*/comm ".
+                   format(pidfile=self._temp.get('pidfile')))
+        command += (r"| xargs dirname | sed -e 's/\/.*\///g' | uniq")

 
 

-        :param disk_image: Path of the disk image.
-        :type disk_image: str
-        """
-        self._qemu_opt['disk_image'] = disk_image
+        stdout, _ = exec_cmd_no_error(self._node, command)
+        return stdout.splitlines()

 
     def qemu_set_affinity(self, *host_cpus):
         """Set qemu affinity by getting thread PIDs via QMP and taskset to list
 
     def qemu_set_affinity(self, *host_cpus):
         """Set qemu affinity by getting thread PIDs via QMP and taskset to list

-        of CPU cores.
+        of CPU cores. Function tries to execute 3 times to avoid race condition
+        in getting thread PIDs.

 
         :param host_cpus: List of CPU cores.
         :type host_cpus: list
         """
 
         :param host_cpus: List of CPU cores.
         :type host_cpus: list
         """

-        qemu_cpus = self._qemu_qmp_exec('query-cpus')['return']
-
-        if len(qemu_cpus) != len(host_cpus):
-            logger.debug('Host CPU count {0}, Qemu Thread count {1}'.format(
-                len(host_cpus), len(qemu_cpus)))
-            raise ValueError('Host CPU count must match Qemu Thread count')
-
-        for qemu_cpu, host_cpu in zip(qemu_cpus, host_cpus):
-            cmd = 'taskset -pc {0} {1}'.format(host_cpu, qemu_cpu['thread_id'])
-            (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)
-            if int(ret_code) != 0:
-                logger.debug('Set affinity failed {0}'.format(stderr))
-                raise RuntimeError('Set affinity failed on {0}'.format(
-                    self._node['host']))
+        for _ in range(3):
+            try:
+                qemu_cpus = self.get_qemu_pids()
+
+                if len(qemu_cpus) != len(host_cpus):
+                    sleep(1)
+                    continue
+                for qemu_cpu, host_cpu in zip(qemu_cpus, host_cpus):
+                    command = ('taskset -pc {host_cpu} {thread}'.
+                               format(host_cpu=host_cpu, thread=qemu_cpu))
+                    message = ('QEMU: Set affinity failed on {host}!'.
+                               format(host=self._node['host']))
+                    exec_cmd_no_error(self._node, command, sudo=True,
+                                      message=message)
+                break
+            except (RuntimeError, ValueError):
+                self.qemu_kill_all()
+                raise
+        else:
+            self.qemu_kill_all()
+            raise RuntimeError('Failed to set Qemu threads affinity!')

 
     def qemu_set_scheduler_policy(self):
         """Set scheduler policy to SCHED_RR with priority 1 for all Qemu CPU
         processes.
 
 
     def qemu_set_scheduler_policy(self):
         """Set scheduler policy to SCHED_RR with priority 1 for all Qemu CPU
         processes.
 

-       :raises RuntimeError: Set scheduler policy failed.
-        """
-        qemu_cpus = self._qemu_qmp_exec('query-cpus')['return']
-
-        for qemu_cpu in qemu_cpus:
-            cmd = 'chrt -r -p 1 {0}'.format(qemu_cpu['thread_id'])
-            (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)
-            if int(ret_code) != 0:
-                logger.debug('Set SCHED_RR failed {0}'.format(stderr))
-                raise RuntimeError('Set SCHED_RR failed on {0}'.format(
-                    self._node['host']))
-
-    def qemu_set_node(self, node):
-        """Set node to run QEMU on.
-
-        :param node: Node to run QEMU on.
-        :type node: dict
+        :raises RuntimeError: Set scheduler policy failed.

         """
         """

-        self._node = node
-        self._ssh = SSH()
-        self._ssh.connect(node)
-        self._vm_info['host'] = node['host']
+        try:
+            qemu_cpus = self.get_qemu_pids()
+
+            for qemu_cpu in qemu_cpus:
+                command = ('chrt -r -p 1 {thread}'.
+                           format(thread=qemu_cpu))
+                message = ('QEMU: Set SCHED_RR failed on {host}'.
+                           format(host=self._node['host']))
+                exec_cmd_no_error(self._node, command, sudo=True,
+                                  message=message)
+        except (RuntimeError, ValueError):
+            self.qemu_kill_all()
+            raise

 
 

-    def qemu_add_vhost_user_if(self, socket, server=True, mac=None):
+    def qemu_add_vhost_user_if(self, socket, server=True, jumbo_frames=False,
+                               queue_size=None, queues=1):

         """Add Vhost-user interface.
 
         :param socket: Path of the unix socket.
         :param server: If True the socket shall be a listening socket.
         """Add Vhost-user interface.
 
         :param socket: Path of the unix socket.
         :param server: If True the socket shall be a listening socket.

-        :param mac: Vhost-user interface MAC address (optional, otherwise is
-            used auto-generated MAC 52:54:00:00:xx:yy).
+        :param jumbo_frames: Set True if jumbo frames are used in the test.
+        :param queue_size: Vring queue size.
+        :param queues: Number of queues.

         :type socket: str
         :type server: bool
         :type socket: str
         :type server: bool

-        :type mac: str
+        :type jumbo_frames: bool
+        :type queue_size: int
+        :type queues: int

         """
         self._vhost_id += 1
         """
         self._vhost_id += 1

-        # Create unix socket character device.
-        chardev = ' -chardev socket,id=char{0},path={1}'.format(self._vhost_id,
-                                                                socket)
-        if server is True:
-            chardev += ',server'
-        self._qemu_opt['options'] += chardev
-        # Create Vhost-user network backend.
-        netdev = (' -netdev vhost-user,id=vhost{0},chardev=char{0},queues={1}'
-                  .format(self._vhost_id, self._qemu_opt['queues']))
-        self._qemu_opt['options'] += netdev
-        # If MAC is not specified use auto-generated MAC address based on
-        # template 52:54:00:00:<qemu_id>:<vhost_id>, e.g. vhost1 MAC of QEMU
-        #  with ID 1 is 52:54:00:00:01:01
-        if mac is None:
-            mac = '52:54:00:00:{0:02x}:{1:02x}'.\
-                format(self._qemu_id, self._vhost_id)
-        extend_options = 'mq=on,csum=off,gso=off,guest_tso4=off,'\
-            'guest_tso6=off,guest_ecn=off,mrg_rxbuf=off'
-        # Create Virtio network device.
-        device = ' -device virtio-net-pci,netdev=vhost{0},mac={1},{2}'.format(
-            self._vhost_id, mac, extend_options)
-        self._qemu_opt['options'] += device
-        # Add interface MAC and socket to the node dict
+        self._params.add('chardev',
+                         'socket,id=char{vhost},path={socket}{server}'.
+                         format(vhost=self._vhost_id, socket=socket,
+                                server=',server' if server is True else ''))
+        self._params.add('netdev',
+                         'vhost-user,id=vhost{vhost},'
+                         'chardev=char{vhost},queues={queues}'.
+                         format(vhost=self._vhost_id, queues=queues))
+        mac = ('52:54:00:00:{qemu:02x}:{vhost:02x}'.
+               format(qemu=self._opt.get('qemu_id'), vhost=self._vhost_id))
+        queue_size = ('rx_queue_size={queue_size},tx_queue_size={queue_size}'.
+                      format(queue_size=queue_size)) if queue_size else ''
+        mbuf = 'on,host_mtu=9200'
+        self._params.add('device',
+                         'virtio-net-pci,netdev=vhost{vhost},'
+                         'mac={mac},bus=pci.0,addr={addr}.0,mq=on,'
+                         'vectors={vectors},csum=off,gso=off,'
+                         'guest_tso4=off,guest_tso6=off,guest_ecn=off,'
+                         'mrg_rxbuf={mbuf},{queue_size}'.
+                         format(addr=self._vhost_id+5,
+                                vhost=self._vhost_id, mac=mac,
+                                mbuf=mbuf if jumbo_frames else 'off',
+                                queue_size=queue_size,
+                                vectors=(2 * queues + 2)))
+
+        # Add interface MAC and socket to the node dict.

         if_data = {'mac_address': mac, 'socket': socket}
         if_data = {'mac_address': mac, 'socket': socket}

-        if_name = 'vhost{}'.format(self._vhost_id)
+        if_name = 'vhost{vhost}'.format(vhost=self._vhost_id)

         self._vm_info['interfaces'][if_name] = if_data
         self._vm_info['interfaces'][if_name] = if_data

-        # Add socket to the socket list
-        self._socks.append(socket)
+        # Add socket to temporary file list.
+        self._temp[if_name] = socket

 
     def _qemu_qmp_exec(self, cmd):
         """Execute QMP command.
 
     def _qemu_qmp_exec(self, cmd):
         """Execute QMP command.


@@ -236,44 +471,37 @@ class QemuUtils(object):
 
         :param cmd: QMP command to execute.
         :type cmd: str
 
         :param cmd: QMP command to execute.
         :type cmd: str

-        :return: Command output in python representation of JSON format. The
+        :returns: Command output in python representation of JSON format. The

             { "return": {} } response is QMP's success response. An error
             response will contain the "error" keyword instead of "return".
         """
         # To enter command mode, the qmp_capabilities command must be issued.
             { "return": {} } response is QMP's success response. An error
             response will contain the "error" keyword instead of "return".
         """
         # To enter command mode, the qmp_capabilities command must be issued.

-        qmp_cmd = 'echo "{ \\"execute\\": \\"qmp_capabilities\\" }' \
-                  '{ \\"execute\\": \\"' + cmd + \
-                  '\\" }" | sudo -S socat - UNIX-CONNECT:' + self._qmp_sock
-
-        (ret_code, stdout, stderr) = self._ssh.exec_command(qmp_cmd)
-        if int(ret_code) != 0:
-            logger.debug('QMP execute failed {0}'.format(stderr))
-            raise RuntimeError('QMP execute "{0}"'
-                               ' failed on {1}'.format(cmd, self._node['host']))
-        logger.trace(stdout)
+        command = ('echo "{{ \\"execute\\": \\"qmp_capabilities\\" }}'
+                   '{{ \\"execute\\": \\"{cmd}\\" }}" | '
+                   'sudo -S socat - UNIX-CONNECT:{qmp}'.
+                   format(cmd=cmd, qmp=self._temp.get('qmp')))
+        message = ('QMP execute "{cmd}" failed on {host}'.
+                   format(cmd=cmd, host=self._node['host']))
+        stdout, _ = exec_cmd_no_error(self._node, command, sudo=False,
+                                      message=message)
+

         # Skip capabilities negotiation messages.
         out_list = stdout.splitlines()
         if len(out_list) < 3:
         # Skip capabilities negotiation messages.
         out_list = stdout.splitlines()
         if len(out_list) < 3:

-            raise RuntimeError('Invalid QMP output on {0}'.format(
-                self._node['host']))
+            raise RuntimeError('Invalid QMP output on {host}'.
+                               format(host=self._node['host']))

         return json.loads(out_list[2])
 
     def _qemu_qga_flush(self):
         return json.loads(out_list[2])
 
     def _qemu_qga_flush(self):

-        """Flush the QGA parser state
-        """
-        qga_cmd = '(printf "\xFF"; sleep 1) | sudo -S socat - UNIX-CONNECT:' + \
-                  self._qga_sock
-        #TODO: probably need something else
-        (ret_code, stdout, stderr) = self._ssh.exec_command(qga_cmd)
-        if int(ret_code) != 0:
-            logger.debug('QGA execute failed {0}'.format(stderr))
-            raise RuntimeError('QGA execute "{0}" '
-                               'failed on {1}'.format(qga_cmd,
-                                                      self._node['host']))
-        logger.trace(stdout)
-        if not stdout:
-            return {}
-        return json.loads(stdout.split('\n', 1)[0])
+        """Flush the QGA parser state."""
+        command = ('(printf "\xFF"; sleep 1) | '
+                   'sudo -S socat - UNIX-CONNECT:{qga}'.
+                   format(qga=self._temp.get('qga')))
+        message = ('QGA flush failed on {host}'.format(host=self._node['host']))
+        stdout, _ = exec_cmd_no_error(self._node, command, sudo=False,
+                                      message=message)
+
+        return json.loads(stdout.split('\n', 1)[0]) if stdout else dict()

 
     def _qemu_qga_exec(self, cmd):
         """Execute QGA command.
 
     def _qemu_qga_exec(self, cmd):
         """Execute QGA command.


@@ -283,380 +511,188 @@ class QemuUtils(object):
         :param cmd: QGA command to execute.
         :type cmd: str
         """
         :param cmd: QGA command to execute.
         :type cmd: str
         """

-        qga_cmd = '(echo "{ \\"execute\\": \\"' + \
-                  cmd + \
-                  '\\" }"; sleep 1) | sudo -S socat - UNIX-CONNECT:' + \
-                  self._qga_sock
-        (ret_code, stdout, stderr) = self._ssh.exec_command(qga_cmd)
-        if int(ret_code) != 0:
-            logger.debug('QGA execute failed {0}'.format(stderr))
-            raise RuntimeError('QGA execute "{0}"'
-                               ' failed on {1}'.format(cmd, self._node['host']))
-        logger.trace(stdout)
-        if not stdout:
-            return {}
-        return json.loads(stdout.split('\n', 1)[0])
-
-    def _wait_until_vm_boot(self, timeout=60):
-        """Wait until QEMU VM is booted.
+        command = ('(echo "{{ \\"execute\\": \\"{cmd}\\" }}"; sleep 1) | '
+                   'sudo -S socat - UNIX-CONNECT:{qga}'.
+                   format(cmd=cmd, qga=self._temp.get('qga')))
+        message = ('QGA execute "{cmd}" failed on {host}'.
+                   format(cmd=cmd, host=self._node['host']))
+        stdout, _ = exec_cmd_no_error(self._node, command, sudo=False,
+                                      message=message)
+
+        return json.loads(stdout.split('\n', 1)[0]) if stdout else dict()
+
+    def _wait_until_vm_boot(self):
+        """Wait until QEMU with NestedVM is booted."""
+        if self._opt.get('vm_type') == 'nestedvm':
+            self._wait_until_nestedvm_boot()
+            self._update_vm_interfaces()
+        elif self._opt.get('vm_type') == 'kernelvm':
+            self._wait_until_kernelvm_boot()
+        else:
+            raise RuntimeError('QEMU: Unsupported VM type!')
+
+    def _wait_until_nestedvm_boot(self, retries=12):
+        """Wait until QEMU with NestedVM is booted.

 
         First try to flush qga until there is output.
         Then ping QEMU guest agent each 5s until VM booted or timeout.
 
 
         First try to flush qga until there is output.
         Then ping QEMU guest agent each 5s until VM booted or timeout.
 

-        :param timeout: Waiting timeout in seconds (optional, default 60s).
-        :type timeout: int
+        :param retries: Number of retries with 5s between trials.
+        :type retries: int

         """
         """

-        start = time()
-        while True:
-            if time() - start > timeout:
-                raise RuntimeError('timeout, VM {0} not booted on {1}'.format(
-                    self._qemu_opt['disk_image'], self._node['host']))
+        for _ in range(retries):

             out = None
             try:
                 out = self._qemu_qga_flush()
             except ValueError:
             out = None
             try:
                 out = self._qemu_qga_flush()
             except ValueError:

-                logger.trace('QGA qga flush unexpected output {}'.format(out))
+                logger.trace('QGA qga flush unexpected output {out}'.
+                             format(out=out))

             # Empty output - VM not booted yet
             if not out:
                 sleep(5)
             else:
                 break
             # Empty output - VM not booted yet
             if not out:
                 sleep(5)
             else:
                 break

-        while True:
-            if time() - start > timeout:
-                raise RuntimeError('timeout, VM {0} not booted on {1}'.format(
-                    self._qemu_opt['disk_image'], self._node['host']))
+        else:
+            raise RuntimeError('QEMU: Timeout, VM not booted on {host}!'.
+                               format(host=self._node['host']))
+        for _ in range(retries):

             out = None
             try:
                 out = self._qemu_qga_exec('guest-ping')
             except ValueError:
             out = None
             try:
                 out = self._qemu_qga_exec('guest-ping')
             except ValueError:

-                logger.trace('QGA guest-ping unexpected output {}'.format(out))
-            # Empty output - VM not booted yet
+                logger.trace('QGA guest-ping unexpected output {out}'.
+                             format(out=out))
+            # Empty output - VM not booted yet.

             if not out:
                 sleep(5)
             if not out:
                 sleep(5)

-            # Non-error return - VM booted
+            # Non-error return - VM booted.

             elif out.get('return') is not None:
                 break
             elif out.get('return') is not None:
                 break

-            # Skip error and wait
+            # Skip error and wait.

             elif out.get('error') is not None:
                 sleep(5)
             else:
                 # If there is an unexpected output from QGA guest-info, try
                 # again until timeout.
             elif out.get('error') is not None:
                 sleep(5)
             else:
                 # If there is an unexpected output from QGA guest-info, try
                 # again until timeout.

-                logger.trace('QGA guest-ping unexpected output {}'.format(out))
+                logger.trace('QGA guest-ping unexpected output {out}'.
+                             format(out=out))
+        else:
+            raise RuntimeError('QEMU: Timeout, VM not booted on {host}!'.
+                               format(host=self._node['host']))
+
+    def _wait_until_kernelvm_boot(self, retries=60):
+        """Wait until QEMU KernelVM is booted.

 
 

-        logger.trace('VM {0} booted on {1}'.format(self._qemu_opt['disk_image'],
-                                                   self._node['host']))
+        :param retries: Number of retries.
+        :type retries: int
+        """
+        vpp_ver = VPPUtil.vpp_show_version(self._node)
+
+        for _ in range(retries):
+            command = ('tail -1 {log}'.format(log=self._temp.get('log')))
+            stdout = None
+            try:
+                stdout, _ = exec_cmd_no_error(self._node, command, sudo=True)
+                sleep(1)
+            except RuntimeError:
+                pass
+            if vpp_ver in stdout or 'Press enter to exit' in stdout:
+                break
+            if 'reboot: Power down' in stdout:
+                raise RuntimeError('QEMU: NF failed to run on {host}!'.
+                                   format(host=self._node['host']))
+        else:
+            raise RuntimeError('QEMU: Timeout, VM not booted on {host}!'.
+                               format(host=self._node['host']))

 
     def _update_vm_interfaces(self):
         """Update interface names in VM node dict."""
         # Send guest-network-get-interfaces command via QGA, output example:
         # {"return": [{"name": "eth0", "hardware-address": "52:54:00:00:04:01"},
 
     def _update_vm_interfaces(self):
         """Update interface names in VM node dict."""
         # Send guest-network-get-interfaces command via QGA, output example:
         # {"return": [{"name": "eth0", "hardware-address": "52:54:00:00:04:01"},

-        # {"name": "eth1", "hardware-address": "52:54:00:00:04:02"}]}
+        # {"name": "eth1", "hardware-address": "52:54:00:00:04:02"}]}.

         out = self._qemu_qga_exec('guest-network-get-interfaces')
         interfaces = out.get('return')
         mac_name = {}
         if not interfaces:
         out = self._qemu_qga_exec('guest-network-get-interfaces')
         interfaces = out.get('return')
         mac_name = {}
         if not interfaces:

-            raise RuntimeError('Get VM {0} interface list failed on {1}'.format(
-                self._qemu_opt['disk_image'], self._node['host']))
-        # Create MAC-name dict
+            raise RuntimeError('Get VM interface list failed on {host}'.
+                               format(host=self._node['host']))
+        # Create MAC-name dict.

         for interface in interfaces:
             if 'hardware-address' not in interface:
                 continue
             mac_name[interface['hardware-address']] = interface['name']
         for interface in interfaces:
             if 'hardware-address' not in interface:
                 continue
             mac_name[interface['hardware-address']] = interface['name']

-        # Match interface by MAC and save interface name
+        # Match interface by MAC and save interface name.

         for interface in self._vm_info['interfaces'].values():
             mac = interface.get('mac_address')
             if_name = mac_name.get(mac)
             if if_name is None:
         for interface in self._vm_info['interfaces'].values():
             mac = interface.get('mac_address')
             if_name = mac_name.get(mac)
             if if_name is None:

-                logger.trace('Interface name for MAC {} not found'.format(mac))
+                logger.trace('Interface name for MAC {mac} not found'.
+                             format(mac=mac))

             else:
                 interface['name'] = if_name
 
             else:
                 interface['name'] = if_name
 

-    def _huge_page_check(self, allocate=False):
-        """Huge page check."""
-        huge_mnt = self._qemu_opt.get('huge_mnt')
-        mem_size = self._qemu_opt.get('mem_size')
-
-        # Get huge pages information
-        huge_size = self._get_huge_page_size()
-        huge_free = self._get_huge_page_free(huge_size)
-        huge_total = self._get_huge_page_total(huge_size)
-
-        # Check if memory reqested by qemu is available on host
-        if (mem_size * 1024) > (huge_free * huge_size):
-            # If we want to allocate hugepage dynamically
-            if allocate:
-                mem_needed = abs((huge_free * huge_size) - (mem_size * 1024))
-                huge_to_allocate = ((mem_needed / huge_size) * 2) + huge_total
-                max_map_count = huge_to_allocate*4
-                # Increase maximum number of memory map areas a process may have
-                cmd = 'echo "{0}" | sudo tee /proc/sys/vm/max_map_count'.format(
-                    max_map_count)
-                (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)
-                # Increase hugepage count
-                cmd = 'echo "{0}" | sudo tee /proc/sys/vm/nr_hugepages'.format(
-                    huge_to_allocate)
-                (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)
-                if int(ret_code) != 0:
-                    logger.debug('Mount huge pages failed {0}'.format(stderr))
-                    raise RuntimeError('Mount huge pages failed on {0}'.format(
-                        self._node['host']))
-            # If we do not want to allocate dynamicaly end with error
-            else:
-                raise RuntimeError(
-                    'Not enough free huge pages: {0}, '
-                    '{1} MB'.format(huge_free, huge_free * huge_size)
-                )
-        # Check if huge pages mount point exist
-        has_huge_mnt = False
-        (_, output, _) = self._ssh.exec_command('cat /proc/mounts')
-        for line in output.splitlines():
-            # Try to find something like:
-            # none /mnt/huge hugetlbfs rw,relatime,pagesize=2048k 0 0
-            mount = line.split()
-            if mount[2] == 'hugetlbfs' and mount[1] == huge_mnt:
-                has_huge_mnt = True
-                break
-        # If huge page mount point not exist create one
-        if not has_huge_mnt:
-            cmd = 'mkdir -p {0}'.format(huge_mnt)
-            (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)
-            if int(ret_code) != 0:
-                logger.debug('Create mount dir failed: {0}'.format(stderr))
-                raise RuntimeError('Create mount dir failed on {0}'.format(
-                    self._node['host']))
-            cmd = 'mount -t hugetlbfs -o pagesize=2048k none {0}'.format(
-                huge_mnt)
-            (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)
-            if int(ret_code) != 0:
-                logger.debug('Mount huge pages failed {0}'.format(stderr))
-                raise RuntimeError('Mount huge pages failed on {0}'.format(
-                    self._node['host']))
-
-    def _get_huge_page_size(self):
-        """Get default size of huge pages in system.
-
-        :returns: Default size of free huge pages in system.
-        :rtype: int
-        :raises: RuntimeError if reading failed for three times.
-        """
-        # TODO: remove to dedicated library
-        cmd_huge_size = "grep Hugepagesize /proc/meminfo | awk '{ print $2 }'"
-        for _ in range(3):
-            (ret, out, _) = self._ssh.exec_command_sudo(cmd_huge_size)
-            if ret == 0:
-                try:
-                    huge_size = int(out)
-                except ValueError:
-                    logger.trace('Reading huge page size information failed')
-                else:
-                    break
-        else:
-            raise RuntimeError('Getting huge page size information failed.')
-        return huge_size
-
-    def _get_huge_page_free(self, huge_size):
-        """Get total number of huge pages in system.
-
-        :param huge_size: Size of hugepages.
-        :type huge_size: int
-        :returns: Number of free huge pages in system.
-        :rtype: int
-        :raises: RuntimeError if reading failed for three times.
-        """
-        # TODO: add numa aware option
-        # TODO: remove to dedicated library
-        cmd_huge_free = 'cat /sys/kernel/mm/hugepages/hugepages-{0}kB/'\
-            'free_hugepages'.format(huge_size)
-        for _ in range(3):
-            (ret, out, _) = self._ssh.exec_command_sudo(cmd_huge_free)
-            if ret == 0:
-                try:
-                    huge_free = int(out)
-                except ValueError:
-                    logger.trace('Reading free huge pages information failed')
-                else:
-                    break
-        else:
-            raise RuntimeError('Getting free huge pages information failed.')
-        return huge_free
-
-    def _get_huge_page_total(self, huge_size):
-        """Get total number of huge pages in system.
-
-        :param huge_size: Size of hugepages.
-        :type huge_size: int
-        :returns: Total number of huge pages in system.
-        :rtype: int
-        :raises: RuntimeError if reading failed for three times.
-        """
-        # TODO: add numa aware option
-        # TODO: remove to dedicated library
-        cmd_huge_total = 'cat /sys/kernel/mm/hugepages/hugepages-{0}kB/'\
-            'nr_hugepages'.format(huge_size)
-        for _ in range(3):
-            (ret, out, _) = self._ssh.exec_command_sudo(cmd_huge_total)
-            if ret == 0:
-                try:
-                    huge_total = int(out)
-                except ValueError:
-                    logger.trace('Reading total huge pages information failed')
-                else:
-                    break
-        else:
-            raise RuntimeError('Getting total huge pages information failed.')
-        return huge_total
-

     def qemu_start(self):
         """Start QEMU and wait until VM boot.
 
     def qemu_start(self):
         """Start QEMU and wait until VM boot.
 

-        :return: VM node info.
+        :returns: VM node info.

         :rtype: dict
         :rtype: dict

-        .. note:: First set at least node to run QEMU on.
-        .. warning:: Starts only one VM on the node.

         """
         """

-        # SSH forwarding
-        ssh_fwd = '-net user,hostfwd=tcp::{0}-:22'.format(
-            self._qemu_opt.get('ssh_fwd_port'))
-        # Memory and huge pages
-        mem = '-object memory-backend-file,id=mem,size={0}M,mem-path={1},' \
-            'share=on -m {0} -numa node,memdev=mem'.format(
-                self._qemu_opt.get('mem_size'), self._qemu_opt.get('huge_mnt'))
-
-        # By default check only if hugepages are available.
-        # If 'huge_allocate' is set to true try to allocate as well.
-        self._huge_page_check(allocate=self._qemu_opt.get('huge_allocate'))
-
-        # Disk option
-        drive = '-drive file={0},format=raw,cache=none,if=virtio'.format(
-            self._qemu_opt.get('disk_image'))
-        # Setup QMP via unix socket
-        qmp = '-qmp unix:{0},server,nowait'.format(self._qmp_sock)
-        # Setup serial console
-        serial = '-chardev socket,host=127.0.0.1,port={0},id=gnc0,server,' \
-            'nowait -device isa-serial,chardev=gnc0'.format(
-                self._qemu_opt.get('serial_port'))
-        # Setup QGA via chardev (unix socket) and isa-serial channel
-        qga = '-chardev socket,path={0},server,nowait,id=qga0 ' \
-            '-device isa-serial,chardev=qga0'.format(self._qga_sock)
-        # Graphic setup
-        graphic = '-monitor none -display none -vga none'
-        # PID file
-        pid = '-pidfile {}'.format(self._pid_file)
-
-        # Run QEMU
-        cmd = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10}'.format(
-            self._qemu_bin, self._qemu_opt.get('smp'), mem, ssh_fwd,
-            self._qemu_opt.get('options'),
-            drive, qmp, serial, qga, graphic, pid)
+        command = ('{bin_path}/qemu-system-{arch} {params}'.
+                   format(bin_path=self._opt.get('bin_path'),
+                          arch=Topology.get_node_arch(self._node),
+                          params=self._params))
+        message = ('QEMU: Start failed on {host}!'.
+                   format(host=self._node['host']))

         try:
         try:

-            (ret_code, _, _) = self._ssh.exec_command_sudo(cmd, timeout=300)
-            if int(ret_code) != 0:
-                raise RuntimeError('QEMU start failed on {0}'.format(
-                    self._node['host']))
-            # Wait until VM boot
+            DUTSetup.check_huge_page(self._node, '/dev/hugepages',
+                                     self._opt.get('mem'))
+
+            exec_cmd_no_error(self._node, command, timeout=300, sudo=True,
+                              message=message)

             self._wait_until_vm_boot()
             self._wait_until_vm_boot()

-        except (RuntimeError, SSHTimeout):
+        except RuntimeError:

             self.qemu_kill_all()
             self.qemu_kill_all()

-            self.qemu_clear_socks()

             raise
             raise

-        logger.trace('QEMU started successfully.')
-        # Update interface names in VM node dict
-        self._update_vm_interfaces()
-        # Return VM node dict

         return self._vm_info
 
         return self._vm_info
 

-    def qemu_quit(self):
-        """Quit the QEMU emulator."""
-        out = self._qemu_qmp_exec('quit')
-        err = out.get('error')
-        if err is not None:
-            raise RuntimeError('QEMU quit failed on {0}, error: {1}'.format(
-                self._node['host'], json.dumps(err)))
-
-    def qemu_system_powerdown(self):
-        """Power down the system (if supported)."""
-        out = self._qemu_qmp_exec('system_powerdown')
-        err = out.get('error')
-        if err is not None:
-            raise RuntimeError(
-                'QEMU system powerdown failed on {0}, '
-                'error: {1}'.format(self._node['host'], json.dumps(err))
-            )
-
-    def qemu_system_reset(self):
-        """Reset the system."""
-        out = self._qemu_qmp_exec('system_reset')
-        err = out.get('error')
-        if err is not None:
-            raise RuntimeError(
-                'QEMU system reset failed on {0}, '
-                'error: {1}'.format(self._node['host'], json.dumps(err)))
-

     def qemu_kill(self):
         """Kill qemu process."""
     def qemu_kill(self):
         """Kill qemu process."""

-        # Note: in QEMU start phase there are 3 QEMU processes because we
-        # daemonize QEMU
-        self._ssh.exec_command_sudo('chmod +r {}'.format(self._pid_file))
-        self._ssh.exec_command_sudo('kill -SIGKILL $(cat {})'
-                                    .format(self._pid_file))
-        # Delete PID file
-        cmd = 'rm -f {}'.format(self._pid_file)
-        self._ssh.exec_command_sudo(cmd)
-
-    def qemu_kill_all(self, node=None):
-        """Kill all qemu processes on DUT node if specified.
-
-        :param node: Node to kill all QEMU processes on.
-        :type node: dict
+        exec_cmd(self._node, 'chmod +r {pidfile}'.
+                 format(pidfile=self._temp.get('pidfile')), sudo=True)
+        exec_cmd(self._node, 'kill -SIGKILL $(cat {pidfile})'.
+                 format(pidfile=self._temp.get('pidfile')), sudo=True)
+
+        for value in self._temp.values():
+            exec_cmd(self._node, 'cat {value}'.format(value=value), sudo=True)
+            exec_cmd(self._node, 'rm -f {value}'.format(value=value), sudo=True)
+
+    def qemu_kill_all(self):
+        """Kill all qemu processes on DUT node if specified."""
+        exec_cmd(self._node, 'pkill -SIGKILL qemu', sudo=True)
+
+        for value in self._temp.values():
+            exec_cmd(self._node, 'cat {value}'.format(value=value), sudo=True)
+            exec_cmd(self._node, 'rm -f {value}'.format(value=value), sudo=True)
+
+    def qemu_version(self, version=None):
+        """Return Qemu version or compare if version is higher than parameter.
+
+        :param version: Version to compare.
+        :type version: str
+        :returns: Qemu version or Boolean if version is higher than parameter.
+        :rtype: str or bool

         """
         """

-        if node:
-            self.qemu_set_node(node)
-        self._ssh.exec_command_sudo('pkill -SIGKILL qemu')
-
-    def qemu_clear_socks(self):
-        """Remove all sockets created by QEMU."""
-        # If serial console port still open kill process
-        cmd = 'fuser -k {}/tcp'.format(self._qemu_opt.get('serial_port'))
-        self._ssh.exec_command_sudo(cmd)
-        # Delete all created sockets
-        for sock in self._socks:
-            cmd = 'rm -f {}'.format(sock)
-            self._ssh.exec_command_sudo(cmd)
-
-    def qemu_system_status(self):
-        """Return current VM status.
-
-        VM should be in following status:
-
-            - debug: QEMU running on a debugger
-            - finish-migrate: paused to finish the migration process
-            - inmigrate: waiting for an incoming migration
-            - internal-error: internal error has occurred
-            - io-error: the last IOP has failed
-            - paused: paused
-            - postmigrate: paused following a successful migrate
-            - prelaunch: QEMU was started with -S and guest has not started
-            - restore-vm: paused to restore VM state
-            - running: actively running
-            - save-vm: paused to save the VM state
-            - shutdown: shut down (and -no-shutdown is in use)
-            - suspended: suspended (ACPI S3)
-            - watchdog: watchdog action has been triggered
-            - guest-panicked: panicked as a result of guest OS panic
-
-        :return: VM status.
-        :rtype: str
-        """
-        out = self._qemu_qmp_exec('query-status')
-        ret = out.get('return')
-        if ret is not None:
-            return ret.get('status')
-        else:
-            err = out.get('error')
-            raise RuntimeError(
-                'QEMU query-status failed on {0}, '
-                'error: {1}'.format(self._node['host'], json.dumps(err)))
+        command = ('{bin_path}/qemu-system-{arch} --version'.
+                   format(bin_path=self._opt.get('bin_path'),
+                          arch=Topology.get_node_arch(self._node)))
+        try:
+            stdout, _ = exec_cmd_no_error(self._node, command, sudo=True)
+            ver = match(r'QEMU emulator version ([\d.]*)', stdout).group(1)
+            return StrictVersion(ver) > StrictVersion(version) \
+                if version else ver
+        except RuntimeError:
+            self.qemu_kill_all()
+            raise

 
     @staticmethod
     def build_qemu(node, force_install=False, apply_patch=False):
 
     @staticmethod
     def build_qemu(node, force_install=False, apply_patch=False):


@@ -668,22 +704,25 @@ class QemuUtils(object):
         :type node: dict
         :type force_install: bool
         :type apply_patch: bool
         :type node: dict
         :type force_install: bool
         :type apply_patch: bool

-        :raises: RuntimeError if building QEMU failed.
+        :raises RuntimeError: If building QEMU failed.

         """
         """

-        ssh = SSH()
-        ssh.connect(node)
-
-        directory = ' --directory={0}'.format(Constants.QEMU_INSTALL_DIR)
-        version = ' --version={0}'.format(Constants.QEMU_INSTALL_VERSION)
+        directory = (' --directory={install_dir}{patch}'.
+                     format(install_dir=Constants.QEMU_INSTALL_DIR,
+                            patch='-patch' if apply_patch else '-base'))
+        version = (' --version={install_version}'.
+                   format(install_version=Constants.QEMU_INSTALL_VERSION))

         force = ' --force' if force_install else ''
         patch = ' --patch' if apply_patch else ''
         force = ' --force' if force_install else ''
         patch = ' --patch' if apply_patch else ''

-
-        (ret_code, stdout, stderr) = \
-            ssh.exec_command(
-                "sudo -E sh -c '{0}/{1}/qemu_build.sh{2}{3}{4}{5}'"\
-                .format(Constants.REMOTE_FW_DIR, Constants.RESOURCES_LIB_SH,
-                        version, directory, force, patch), 1000)
-
-        if int(ret_code) != 0:
-            logger.debug('QEMU build failed {0}'.format(stdout + stderr))
-            raise RuntimeError('QEMU build failed on {0}'.format(node['host']))
+        target_list = (' --target-list={arch}-softmmu'.
+                       format(arch=Topology.get_node_arch(node)))
+
+        command = ("sudo -E sh -c "
+                   "'{fw_dir}/{lib_sh}/qemu_build.sh{version}{directory}"
+                   "{force}{patch}{target_list}'".
+                   format(fw_dir=Constants.REMOTE_FW_DIR,
+                          lib_sh=Constants.RESOURCES_LIB_SH,
+                          version=version, directory=directory, force=force,
+                          patch=patch, target_list=target_list))
+        message = ('QEMU: Build failed on {host}!'.format(host=node['host']))
+        exec_cmd_no_error(node, command, sudo=False, message=message,
+                          timeout=1000)