class QemuUtils(object):
"""QEMU utilities."""
- __QEMU_BIN = '/opt/qemu/bin/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
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['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.
+ 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 -p {0} {1}'.format(hex(1 << int(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.
- :param mask: Hex CPU mask.
- :type mask: str
+ :raises RuntimeError: Set scheduler policy failed.
"""
- self._qemu_opt['affinity'] = mask
+ 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.
'{ \\"execute\\": \\"' + cmd + '\\" }" | sudo -S nc -U ' + \
self.__QMP_SOCK
(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))
- 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()
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):
+ 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']))
+ raise RuntimeError('QGA execute "{0}" '
+ 'failed on {1}'.format(cmd, self._node['host']))
logger.trace(stdout)
if not stdout:
return {}
qga_cmd = 'echo "{ \\"execute\\": \\"' + cmd + '\\" }" | sudo -S nc ' \
'-q 1 -U ' + self.__QGA_SOCK
(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))
- 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 {}
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')
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))
+ # Check if memory reqested by qemu is available on host
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')
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)
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 -mem-prealloc'.format(
- self._qemu_opt.get('mem_size'), self._qemu_opt.get('huge_mnt'))
- self._huge_page_check()
+ '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 availbale.
+ # If 'huge_allocate' is set to true try to allocate as well.
+ self._huge_page_check(allocate=self._qemu_opt.get('huge_allocate'))
+
# 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'))
+ 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 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} {8} {9}'.format(
- qbin, self._qemu_opt.get('smp'), mem, ssh_fwd,
+ self.__QEMU_BIN, self._qemu_opt.get('smp'), mem, ssh_fwd,
self._qemu_opt.get('options'),
self._qemu_opt.get('disk_image'), qmp, serial, qga, graphic)
(ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd, timeout=300)
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:
- 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):
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
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']))
Code Review / csit.git / blobdiff