"""QEMU utilities library."""
+from time import time, sleep
import json
import re
-from time import time, sleep
+
from robot.api import logger
+
from resources.libraries.python.ssh import SSH
from resources.libraries.python.constants import Constants
from resources.libraries.python.topology import NodeType
class QemuUtils(object):
"""QEMU utilities."""
- __QEMU_BIN = '/tmp/qemu-2.2.1/build/x86_64-softmmu/qemu-system-x86_64'
+ __QEMU_BIN = '/opt/qemu/bin/qemu-system-x86_64'
# QEMU Machine Protocol socket
__QMP_SOCK = '/tmp/qmp.sock'
# QEMU Guest Agent socket
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 ' \
+ self._qemu_opt['options'] = '-cpu host -daemonize -enable-kvm ' \
'-machine pc-1.0,accel=kvm,usb=off,mem-merge=off ' \
- '-net nic,macaddr=52:54:00:00:02:01'
+ '-net nic,macaddr=52:54:00:00:02:01 -balloon none'
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 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'
+ # Affinity of qemu processes
+ self._qemu_opt['affinity'] = False
# VM node info dict
self._vm_info = {
'type': NodeType.VM,
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
"""
- 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.
"""
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.
"""
self._qemu_opt['disk_image'] = disk_image
+ def qemu_set_affinity(self, mask):
+ """Set qemu affinity by taskset with cpu mask.
+
+ :param mask: Hex CPU mask.
+ :type mask: str
+ """
+ self._qemu_opt['affinity'] = mask
+
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()
# 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 = '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}'.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._node['host']))
return json.loads(out_list[2])
+ def _qemu_qga_flush(self):
+ """Flush the QGA parser state
+ """
+ qga_cmd = 'printf "\xFF" | sudo -S nc ' \
+ '-q 1 -U ' + self.__QGA_SOCK
+ (ret_code, stdout, stderr) = self._ssh.exec_command(qga_cmd)
+ if 0 != int(ret_code):
+ 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 _qemu_qga_exec(self, cmd):
"""Execute QGA command.
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):
"""Wait until QEMU VM is booted.
if time() - start > timeout:
raise RuntimeError('timeout, VM {0} not booted on {1}'.format(
self._qemu_opt['disk_image'], self._node['host']))
+ self._qemu_qga_flush()
out = self._qemu_qga_exec('guest-ping')
# Empty output - VM not booted yet
if not out:
# 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:
raise RuntimeError('QGA guest-ping unexpected output {}'.format(
out))
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():
raise RuntimeError('Mount huge pages failed on {0}'.format(
self._node['host']))
+ def _huge_page_allocate(self):
+ """Huge page allocate."""
+ 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'HugePages_Total:\s+(\d+)')
+ match = regex.search(output)
+ huge_total = int(match.group(1))
+ regex = re.compile(r'Hugepagesize:\s+(\d+)')
+ match = regex.search(output)
+ huge_size = int(match.group(1))
+
+ mem_needed = abs((huge_free * huge_size) - (mem_size * 1024))
+
+ if mem_needed:
+ huge_to_allocate = (mem_needed / huge_size) + huge_total
+ # Increase limit of allowed max hugepage count
+ cmd = 'echo "{0}" | sudo tee /proc/sys/vm/max_map_count'.format(
+ huge_to_allocate*3)
+ (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']))
+
def qemu_start(self):
"""Start QEMU and wait until VM boot.
- :return: VM node info
+ :return: VM node info.
: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(
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()
+
+ # By default check only if hugepages are availbale.
+ # If 'huge_allocate' is set to true try to allocate as well.
+ try:
+ self._huge_page_check()
+ except RuntimeError as runtime_error:
+ if self._qemu_opt.get('huge_allocate'):
+ self._huge_page_allocate()
+ else:
+ raise runtime_error
+
# 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 ' \
- '-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'
+ qbin = 'taskset {0} {1}'.format(self._qemu_opt.get('affinity'),
+ self.__QEMU_BIN) if self._qemu_opt.get(
+ 'affinity') else self.__QEMU_BIN
# Run QEMU
- cmd = '{0} {1} {2} {3} {4} -hda {5} {6} {7}'.format(
- self.__QEMU_BIN, self._qemu_opt.get('smp'), mem, ssh_fwd,
+ cmd = '{0} {1} {2} {3} {4} -hda {5} {6} {7} {8} {9}'.format(
+ qbin, self._qemu_opt.get('smp'), mem, ssh_fwd,
self._qemu_opt.get('options'),
- self._qemu_opt.get('disk_image'), qmp, qga)
+ self._qemu_opt.get('disk_image'), 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))
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
"""
Code Review / csit.git / blobdiff