CSIT-530: Add common setup and teardown to perf tests

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

diff --git a/resources/libraries/python/QemuUtils.py b/resources/libraries/python/QemuUtils.py
index 7249b5e..2123e42 100644 (file)
--- a/resources/libraries/python/QemuUtils.py
+++ b/resources/libraries/python/QemuUtils.py
@@ -13,11 +13,12 @@
 
 """QEMU utilities library."""
 
 
 """QEMU utilities library."""
 

-import json
-import re

 from time import time, sleep
 from time import time, sleep

+import json
+

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

-from resources.libraries.python.ssh import SSH
+
+from resources.libraries.python.ssh import SSH, SSHTimeout

 from resources.libraries.python.constants import Constants
 from resources.libraries.python.topology import NodeType
 
 from resources.libraries.python.constants import Constants
 from resources.libraries.python.topology import NodeType
 


@@ -25,7 +26,7 @@ from resources.libraries.python.topology import NodeType
 class QemuUtils(object):
     """QEMU utilities."""
 
 class QemuUtils(object):
     """QEMU utilities."""
 

-    __QEMU_BIN = '/tmp/qemu-2.2.1/build/x86_64-softmmu/qemu-system-x86_64'
+    __QEMU_BIN = '/usr/bin/qemu-system-x86_64'

     # QEMU Machine Protocol socket
     __QMP_SOCK = '/tmp/qmp.sock'
     # QEMU Guest Agent socket
     # QEMU Machine Protocol socket
     __QMP_SOCK = '/tmp/qmp.sock'
     # QEMU Guest Agent socket


@@ -37,14 +38,20 @@ class QemuUtils(object):
         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['smp'] = '-smp 1,sockets=1,cores=1,threads=1'
         # Daemonize the QEMU process after initialization. Default one
         # management interface.

-        self._qemu_opt['options'] = '-daemonize -enable-kvm ' \
-            '-machine pc-1.0,accel=kvm,usb=off,mem-merge=off ' \
-            '-net nic,macaddr=52:54:00:00:02:01'
+        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:02:01 -balloon none'

         self._qemu_opt['ssh_fwd_port'] = 10022
         self._qemu_opt['ssh_fwd_port'] = 10022

+        # Default serial console port
+        self._qemu_opt['serial_port'] = 4556

         # 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 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
         self._vm_info = {
             'type': NodeType.VM,
         # VM node info dict
         self._vm_info = {
             'type': NodeType.VM,


@@ -53,6 +60,8 @@ class QemuUtils(object):
             'password': 'cisco',
             'interfaces': {},
         }
             'password': 'cisco',
             'interfaces': {},
         }

+        # Virtio queue count
+        self._qemu_opt['queues'] = 1

         self._vhost_id = 0
         self._ssh = None
         self._node = None
         self._vhost_id = 0
         self._ssh = None
         self._node = None


@@ -82,13 +91,21 @@ class QemuUtils(object):
         self._qemu_opt['ssh_fwd_port'] = fwd_port
         self._vm_info['port'] = fwd_port
 
         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
+        """
+        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
         """
     def qemu_set_mem_size(self, mem_size):
         """Set virtual RAM size.
 
         :param mem_size: RAM size in Mega Bytes.
         :type mem_size: int
         """

-        self._qemu_opt['mem_size'] = mem_size
+        self._qemu_opt['mem_size'] = int(mem_size)

 
     def qemu_set_huge_mnt(self, huge_mnt):
         """Set hugefile mount point.
 
     def qemu_set_huge_mnt(self, huge_mnt):
         """Set hugefile mount point.


@@ -98,6 +115,10 @@ class QemuUtils(object):
         """
         self._qemu_opt['huge_mnt'] = huge_mnt
 
         """
         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.
 
     def qemu_set_disk_image(self, disk_image):
         """Set disk image.
 


@@ -106,11 +127,49 @@ class QemuUtils(object):
         """
         self._qemu_opt['disk_image'] = disk_image
 
         """
         self._qemu_opt['disk_image'] = disk_image
 

+    def qemu_set_affinity(self, *host_cpus):
+        """Set qemu affinity by getting thread PIDs via QMP and taskset to list
+        of CPU cores.
+
+        :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']))
+
+    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.
     def qemu_set_node(self, node):
         """Set node to run QEMU on.
 
         :param node: Node to run QEMU on.

-        :param node: dict
+        :type node: dict

         """
         self._node = node
         self._ssh = SSH()
         """
         self._node = node
         self._ssh = SSH()


@@ -136,16 +195,18 @@ class QemuUtils(object):
             chardev += ',server'
         self._qemu_opt['options'] += chardev
         # Create Vhost-user network backend.
             chardev += ',server'
         self._qemu_opt['options'] += chardev
         # Create Vhost-user network backend.

-        netdev = ' -netdev vhost-user,id=vhost{0},chardev=char{0}'.format(
-            self._vhost_id)
+        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 autogenerated 52:54:00:00:04:<vhost_id>
         # e.g. vhost1 MAC is 52:54:00:00:04:01
         if mac is None:
             mac = '52:54:00:00:04:{0:02x}'.format(self._vhost_id)
         self._qemu_opt['options'] += netdev
         # If MAC is not specified use autogenerated 52:54:00:00:04:<vhost_id>
         # e.g. vhost1 MAC is 52:54:00:00:04:01
         if mac is None:
             mac = '52:54:00:00:04:{0:02x}'.format(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.
         # Create Virtio network device.

-        device = ' -device virtio-net-pci,netdev=vhost{0},mac={1}'.format(
-            self._vhost_id, mac)
+        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
         if_data = {'mac_address': mac, 'socket': socket}
         self._qemu_opt['options'] += device
         # Add interface MAC and socket to the node dict
         if_data = {'mac_address': mac, 'socket': socket}


@@ -166,14 +227,15 @@ class QemuUtils(object):
             response will contain the "error" keyword instead of "return".
         """
         # To enter command mode, the qmp_capabilities command must be issued.
             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 nc -U ' + \
-            self.__QMP_SOCK
+        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)
         (ret_code, stdout, stderr) = self._ssh.exec_command(qmp_cmd)

-        if 0 != int(ret_code):
+        if int(ret_code) != 0:

             logger.debug('QMP execute failed {0}'.format(stderr))
             logger.debug('QMP execute failed {0}'.format(stderr))

-            raise RuntimeError('QMP execute "{0}" failed on {1}'.format(cmd,
-                self._node['host']))
+            raise RuntimeError('QMP execute "{0}"'
+                               ' failed on {1}'.format(cmd, self._node['host']))

         logger.trace(stdout)
         # Skip capabilities negotiation messages.
         out_list = stdout.splitlines()
         logger.trace(stdout)
         # Skip capabilities negotiation messages.
         out_list = stdout.splitlines()


@@ -182,6 +244,23 @@ class QemuUtils(object):
                 self._node['host']))
         return json.loads(out_list[2])
 
                 self._node['host']))
         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])
+

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


@@ -190,41 +269,53 @@ 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 + '\\" }" | sudo -S nc ' \
-            '-q 1 -U ' + self.__QGA_SOCK
+        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)
         (ret_code, stdout, stderr) = self._ssh.exec_command(qga_cmd)

-        if 0 != int(ret_code):
+        if int(ret_code) != 0:

             logger.debug('QGA execute failed {0}'.format(stderr))
             logger.debug('QGA execute failed {0}'.format(stderr))

-            raise RuntimeError('QGA execute "{0}" failed on {1}'.format(cmd,
-                self._node['host']))
+            raise RuntimeError('QGA execute "{0}"'
+                               ' failed on {1}'.format(cmd, self._node['host']))

         logger.trace(stdout)
         if not stdout:
             return {}
         logger.trace(stdout)
         if not stdout:
             return {}

-        return json.loads(stdout)
+        return json.loads(stdout.split('\n', 1)[0])

 
 

-    def _wait_until_vm_boot(self, timeout=300):
+    def _wait_until_vm_boot(self, timeout=60):

         """Wait until QEMU VM is booted.
 
         Ping QEMU guest agent each 5s until VM booted or timeout.
 
         """Wait until QEMU VM is booted.
 
         Ping QEMU guest agent each 5s until VM booted or timeout.
 

-        :param timeout: Waiting timeout in seconds (optional, default 300s).
+        :param timeout: Waiting timeout in seconds (optional, default 60s).

         :type timeout: int
         """
         start = time()
         :type timeout: int
         """
         start = time()

-        while 1:
+        while True:

             if time() - start > timeout:
                 raise RuntimeError('timeout, VM {0} not booted on {1}'.format(
                     self._qemu_opt['disk_image'], self._node['host']))
             if time() - start > timeout:
                 raise RuntimeError('timeout, VM {0} not booted on {1}'.format(
                     self._qemu_opt['disk_image'], self._node['host']))

-            out = self._qemu_qga_exec('guest-ping')
+            out = None
+            try:
+                self._qemu_qga_flush()
+                out = self._qemu_qga_exec('guest-ping')
+            except ValueError:
+                logger.trace('QGA guest-ping unexpected output {}'.format(out))

             # Empty output - VM not booted yet
             if not out:
                 sleep(5)
             # Non-error return - VM booted
             elif out.get('return') is not None:
                 break
             # Empty output - VM not booted yet
             if not out:
                 sleep(5)
             # Non-error return - VM booted
             elif out.get('return') is not None:
                 break

+            # Skip error and wait
+            elif out.get('error') is not None:
+                sleep(5)

             else:
             else:

-                raise RuntimeError('QGA guest-ping unexpected output {}'.format(
-                    out))
+                # 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('VM {0} booted on {1}'.format(self._qemu_opt['disk_image'],
                                                    self._node['host']))
 
         logger.trace('VM {0} booted on {1}'.format(self._qemu_opt['disk_image'],
                                                    self._node['host']))
 


@@ -241,6 +332,8 @@ class QemuUtils(object):
                 self._qemu_opt['disk_image'], self._node['host']))
         # Create MAC-name dict
         for interface in interfaces:
                 self._qemu_opt['disk_image'], 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']
         # Match interface by MAC and save interface name
         for interface in self._vm_info['interfaces'].values():
             mac_name[interface['hardware-address']] = interface['name']
         # Match interface by MAC and save interface name
         for interface in self._vm_info['interfaces'].values():


@@ -251,21 +344,41 @@ class QemuUtils(object):
             else:
                 interface['name'] = if_name
 
             else:
                 interface['name'] = if_name
 

-    def _huge_page_check(self):
+    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')
         """Huge page check."""
         huge_mnt = self._qemu_opt.get('huge_mnt')
         mem_size = self._qemu_opt.get('mem_size')

-        # Check size of free huge pages
-        (_, output, _) = self._ssh.exec_command('grep Huge /proc/meminfo')
-        regex = re.compile(r'HugePages_Free:\s+(\d+)')
-        match = regex.search(output)
-        huge_free = int(match.group(1))
-        regex = re.compile(r'Hugepagesize:\s+(\d+)')
-        match = regex.search(output)
-        huge_size = int(match.group(1))
+
+        # 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 (mem_size * 1024) > (huge_free * huge_size):

-            raise RuntimeError('Not enough free huge pages {0} kB, required '
-                '{1} MB'.format(huge_free * huge_size, mem_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')
         # Check if huge pages mount point exist
         has_huge_mnt = False
         (_, output, _) = self._ssh.exec_command('cat /proc/mounts')


@@ -278,6 +391,12 @@ class QemuUtils(object):
                 break
         # If huge page mount point not exist create one
         if not has_huge_mnt:
                 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)
             cmd = 'mount -t hugetlbfs -o pagesize=2048k none {0}'.format(
                 huge_mnt)
             (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)


@@ -286,12 +405,87 @@ class QemuUtils(object):
                 raise RuntimeError('Mount huge pages failed on {0}'.format(
                     self._node['host']))
 
                 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
+        :return: VM node info.

         :rtype: dict
         :rtype: dict

-        .. note:: First set at least disk image and node to run QEMU on.
+        .. 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(
         """
         # SSH forwarding
         ssh_fwd = '-net user,hostfwd=tcp::{0}-:22'.format(


@@ -299,19 +493,32 @@ class QemuUtils(object):
         # 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(
         # 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'))
-        self._huge_page_check()
+                self._qemu_opt.get('mem_size'), self._qemu_opt.get('huge_mnt'))
+
+        # By default check only if hugepages are availbale.
+        # 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={},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 QMP via unix socket
         qmp = '-qmp unix:{0},server,nowait'.format(self.__QMP_SOCK)

-        # Setup QGA via chardev (unix socket) and virtio-serial channel
+        # 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=/tmp/qga.sock,server,nowait,id=qga0 ' \
         qga = '-chardev socket,path=/tmp/qga.sock,server,nowait,id=qga0 ' \

-            '-device virtio-serial ' \
-            '-device virtserialport,chardev=qga0,name=org.qemu.guest_agent.0'
+            '-device isa-serial,chardev=qga0'
+        # Graphic setup
+        graphic = '-monitor none -display none -vga none'
+

         # Run QEMU
         # Run QEMU

-        cmd = '{0} {1} {2} {3} {4} -hda {5} {6} {7}'.format(
+        cmd = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9}'.format(

             self.__QEMU_BIN, self._qemu_opt.get('smp'), mem, ssh_fwd,
             self._qemu_opt.get('options'),
             self.__QEMU_BIN, self._qemu_opt.get('smp'), mem, ssh_fwd,
             self._qemu_opt.get('options'),

-            self._qemu_opt.get('disk_image'), qmp, qga)
+            drive, qmp, serial, qga, graphic)

         (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd, timeout=300)
         if int(ret_code) != 0:
             logger.debug('QEMU start failed {0}'.format(stderr))
         (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd, timeout=300)
         if int(ret_code) != 0:
             logger.debug('QEMU start failed {0}'.format(stderr))


@@ -319,7 +526,12 @@ class QemuUtils(object):
                 self._node['host']))
         logger.trace('QEMU running')
         # Wait until VM boot
                 self._node['host']))
         logger.trace('QEMU running')
         # Wait until VM boot

-        self._wait_until_vm_boot()
+        try:
+            self._wait_until_vm_boot()
+        except (RuntimeError, SSHTimeout):
+            self.qemu_kill()
+            self.qemu_clear_socks()
+            raise

         # Update interface names in VM node dict
         self._update_vm_interfaces()
         # Return VM node dict
         # Update interface names in VM node dict
         self._update_vm_interfaces()
         # Return VM node dict


@@ -338,15 +550,18 @@ class QemuUtils(object):
         out = self._qemu_qmp_exec('system_powerdown')
         err = out.get('error')
         if err is not None:
         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)))
+            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:
 
     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}, '
+            raise RuntimeError(
+                'QEMU system reset failed on {0}, '

                 'error: {1}'.format(self._node['host'], json.dumps(err)))
 
     def qemu_kill(self):
                 'error: {1}'.format(self._node['host'], json.dumps(err)))
 
     def qemu_kill(self):


@@ -358,6 +573,10 @@ class QemuUtils(object):
 
     def qemu_clear_socks(self):
         """Remove all sockets created by 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)
         for sock in self._socks:
             cmd = 'rm -f {}'.format(sock)
             self._ssh.exec_command_sudo(cmd)


@@ -365,6 +584,24 @@ class QemuUtils(object):
     def qemu_system_status(self):
         """Return current VM status.
 
     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
         """
         :return: VM status.
         :rtype: str
         """


@@ -374,7 +611,8 @@ class QemuUtils(object):
             return ret.get('status')
         else:
             err = out.get('error')
             return ret.get('status')
         else:
             err = out.get('error')

-            raise RuntimeError('QEMU query-status failed on {0}, '
+            raise RuntimeError(
+                'QEMU query-status failed on {0}, '

                 'error: {1}'.format(self._node['host'], json.dumps(err)))
 
     @staticmethod
                 'error: {1}'.format(self._node['host'], json.dumps(err)))
 
     @staticmethod


@@ -391,6 +629,6 @@ class QemuUtils(object):
             ssh.exec_command('sudo -Sn bash {0}/{1}/qemu_build.sh'.format(
                 Constants.REMOTE_FW_DIR, Constants.RESOURCES_LIB_SH), 1000)
         logger.trace(stdout)
             ssh.exec_command('sudo -Sn bash {0}/{1}/qemu_build.sh'.format(
                 Constants.REMOTE_FW_DIR, Constants.RESOURCES_LIB_SH), 1000)
         logger.trace(stdout)

-        if 0 != int(ret_code):
+        if int(ret_code) != 0:

             logger.debug('QEMU build failed {0}'.format(stderr))
             raise RuntimeError('QEMU build failed on {0}'.format(node['host']))
             logger.debug('QEMU build failed {0}'.format(stderr))
             raise RuntimeError('QEMU build failed on {0}'.format(node['host']))