resources/libraries/python/QemuUtils.py

   1 # Copyright (c) 2016 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """QEMU utilities library."""
  15
  16 from time import time, sleep
  17 import json
  18 import re
  19
  20 from robot.api import logger
  21
  22 from resources.libraries.python.ssh import SSH
  23 from resources.libraries.python.constants import Constants
  24 from resources.libraries.python.topology import NodeType
  25
  26
  27 class QemuUtils(object):
  28     """QEMU utilities."""
  29
  30     __QEMU_BIN = '/opt/qemu/bin/qemu-system-x86_64'
  31     # QEMU Machine Protocol socket
  32     __QMP_SOCK = '/tmp/qmp.sock'
  33     # QEMU Guest Agent socket
  34     __QGA_SOCK = '/tmp/qga.sock'
  35
  36     def __init__(self):
  37         self._qemu_opt = {}
  38         # Default 1 CPU.
  39         self._qemu_opt['smp'] = '-smp 1,sockets=1,cores=1,threads=1'
  40         # Daemonize the QEMU process after initialization. Default one
  41         # management interface.
  42         self._qemu_opt['options'] = '-daemonize -enable-kvm ' \
  43             '-machine pc-1.0,accel=kvm,usb=off,mem-merge=off ' \
  44             '-net nic,macaddr=52:54:00:00:02:01'
  45         self._qemu_opt['ssh_fwd_port'] = 10022
  46         # Default serial console port
  47         self._qemu_opt['serial_port'] = 4556
  48         # Default 512MB virtual RAM
  49         self._qemu_opt['mem_size'] = 512
  50         # Default huge page mount point, required for Vhost-user interfaces.
  51         self._qemu_opt['huge_mnt'] = '/mnt/huge'
  52         # Default image for CSIT virl setup
  53         self._qemu_opt['disk_image'] = '/var/lib/vm/vhost-nested.img'
  54         # VM node info dict
  55         self._vm_info = {
  56             'type': NodeType.VM,
  57             'port': 10022,
  58             'username': 'cisco',
  59             'password': 'cisco',
  60             'interfaces': {},
  61         }
  62         self._vhost_id = 0
  63         self._ssh = None
  64         self._node = None
  65         self._socks = [self.__QMP_SOCK, self.__QGA_SOCK]
  66
  67     def qemu_set_smp(self, cpus, cores, threads, sockets):
  68         """Set SMP option for QEMU
  69
  70         :param cpus: Number of CPUs.
  71         :param cores: Number of CPU cores on one socket.
  72         :param threads: Number of threads on one CPU core.
  73         :param sockets: Number of discrete sockets in the system.
  74         :type cpus: int
  75         :type cores: int
  76         :type threads: int
  77         :type sockets: int
  78         """
  79         self._qemu_opt['smp'] = '-smp {},cores={},threads={},sockets={}'.format(
  80             cpus, cores, threads, sockets)
  81
  82     def qemu_set_ssh_fwd_port(self, fwd_port):
  83         """Set host port for guest SSH forwarding.
  84
  85         :param fwd_port: Port number on host for guest SSH forwarding.
  86         :type fwd_port: int
  87         """
  88         self._qemu_opt['ssh_fwd_port'] = fwd_port
  89         self._vm_info['port'] = fwd_port
  90
  91     def qemu_set_serial_port(self, port):
  92         """Set serial console port.
  93
  94         :param port: Serial console port.
  95         :type port: int
  96         """
  97         self._qemu_opt['serial_port'] = port
  98
  99     def qemu_set_mem_size(self, mem_size):
 100         """Set virtual RAM size.
 101
 102         :param mem_size: RAM size in Mega Bytes.
 103         :type mem_size: int
 104         """
 105         self._qemu_opt['mem_size'] = mem_size
 106
 107     def qemu_set_huge_mnt(self, huge_mnt):
 108         """Set hugefile mount point.
 109
 110         :param huge_mnt: System hugefile mount point.
 111         :type huge_mnt: int
 112         """
 113         self._qemu_opt['huge_mnt'] = huge_mnt
 114
 115     def qemu_set_disk_image(self, disk_image):
 116         """Set disk image.
 117
 118         :param disk_image: Path of the disk image.
 119         :type disk_image: str
 120         """
 121         self._qemu_opt['disk_image'] = disk_image
 122
 123     def qemu_set_node(self, node):
 124         """Set node to run QEMU on.
 125
 126         :param node: Node to run QEMU on.
 127         :type node: dict
 128         """
 129         self._node = node
 130         self._ssh = SSH()
 131         self._ssh.connect(node)
 132         self._vm_info['host'] = node['host']
 133
 134     def qemu_add_vhost_user_if(self, socket, server=True, mac=None):
 135         """Add Vhost-user interface.
 136
 137         :param socket: Path of the unix socket.
 138         :param server: If True the socket shall be a listening socket.
 139         :param mac: Vhost-user interface MAC address (optional, otherwise is
 140             used autogenerated MAC 52:54:00:00:04:xx).
 141         :type socket: str
 142         :type server: bool
 143         :type mac: str
 144         """
 145         self._vhost_id += 1
 146         # Create unix socket character device.
 147         chardev = ' -chardev socket,id=char{0},path={1}'.format(self._vhost_id,
 148                                                                 socket)
 149         if server is True:
 150             chardev += ',server'
 151         self._qemu_opt['options'] += chardev
 152         # Create Vhost-user network backend.
 153         netdev = ' -netdev vhost-user,id=vhost{0},chardev=char{0}'.format(
 154             self._vhost_id)
 155         self._qemu_opt['options'] += netdev
 156         # If MAC is not specified use autogenerated 52:54:00:00:04:<vhost_id>
 157         # e.g. vhost1 MAC is 52:54:00:00:04:01
 158         if mac is None:
 159             mac = '52:54:00:00:04:{0:02x}'.format(self._vhost_id)
 160         # Create Virtio network device.
 161         device = ' -device virtio-net-pci,netdev=vhost{0},mac={1}'.format(
 162             self._vhost_id, mac)
 163         self._qemu_opt['options'] += device
 164         # Add interface MAC and socket to the node dict
 165         if_data = {'mac_address': mac, 'socket': socket}
 166         if_name = 'vhost{}'.format(self._vhost_id)
 167         self._vm_info['interfaces'][if_name] = if_data
 168         # Add socket to the socket list
 169         self._socks.append(socket)
 170
 171     def _qemu_qmp_exec(self, cmd):
 172         """Execute QMP command.
 173
 174         QMP is JSON based protocol which allows to control QEMU instance.
 175
 176         :param cmd: QMP command to execute.
 177         :type cmd: str
 178         :return: Command output in python representation of JSON format. The
 179             { "return": {} } response is QMP's success response. An error
 180             response will contain the "error" keyword instead of "return".
 181         """
 182         # To enter command mode, the qmp_capabilities command must be issued.
 183         qmp_cmd = 'echo "{ \\"execute\\": \\"qmp_capabilities\\" }' + \
 184             '{ \\"execute\\": \\"' + cmd + '\\" }" | sudo -S nc -U ' + \
 185             self.__QMP_SOCK
 186         (ret_code, stdout, stderr) = self._ssh.exec_command(qmp_cmd)
 187         if 0 != int(ret_code):
 188             logger.debug('QMP execute failed {0}'.format(stderr))
 189             raise RuntimeError('QMP execute "{0}" failed on {1}'.format(cmd,
 190                 self._node['host']))
 191         logger.trace(stdout)
 192         # Skip capabilities negotiation messages.
 193         out_list = stdout.splitlines()
 194         if len(out_list) < 3:
 195             raise RuntimeError('Invalid QMP output on {0}'.format(
 196                 self._node['host']))
 197         return json.loads(out_list[2])
 198
 199     def _qemu_qga_exec(self, cmd):
 200         """Execute QGA command.
 201
 202         QGA provide access to a system-level agent via standard QMP commands.
 203
 204         :param cmd: QGA command to execute.
 205         :type cmd: str
 206         """
 207         qga_cmd = 'echo "{ \\"execute\\": \\"' + cmd + '\\" }" | sudo -S nc ' \
 208             '-q 1 -U ' + self.__QGA_SOCK
 209         (ret_code, stdout, stderr) = self._ssh.exec_command(qga_cmd)
 210         if 0 != int(ret_code):
 211             logger.debug('QGA execute failed {0}'.format(stderr))
 212             raise RuntimeError('QGA execute "{0}" failed on {1}'.format(cmd,
 213                 self._node['host']))
 214         logger.trace(stdout)
 215         if not stdout:
 216             return {}
 217         return json.loads(stdout)
 218
 219     def _wait_until_vm_boot(self, timeout=300):
 220         """Wait until QEMU VM is booted.
 221
 222         Ping QEMU guest agent each 5s until VM booted or timeout.
 223
 224         :param timeout: Waiting timeout in seconds (optional, default 300s).
 225         :type timeout: int
 226         """
 227         start = time()
 228         while 1:
 229             if time() - start > timeout:
 230                 raise RuntimeError('timeout, VM {0} not booted on {1}'.format(
 231                     self._qemu_opt['disk_image'], self._node['host']))
 232             out = self._qemu_qga_exec('guest-ping')
 233             # Empty output - VM not booted yet
 234             if not out:
 235                 sleep(5)
 236             # Non-error return - VM booted
 237             elif out.get('return') is not None:
 238                 break
 239             else:
 240                 raise RuntimeError('QGA guest-ping unexpected output {}'.format(
 241                     out))
 242         logger.trace('VM {0} booted on {1}'.format(self._qemu_opt['disk_image'],
 243                                                    self._node['host']))
 244
 245     def _update_vm_interfaces(self):
 246         """Update interface names in VM node dict."""
 247         # Send guest-network-get-interfaces command via QGA, output example:
 248         # {"return": [{"name": "eth0", "hardware-address": "52:54:00:00:04:01"},
 249         # {"name": "eth1", "hardware-address": "52:54:00:00:04:02"}]}
 250         out = self._qemu_qga_exec('guest-network-get-interfaces')
 251         interfaces = out.get('return')
 252         mac_name = {}
 253         if not interfaces:
 254             raise RuntimeError('Get VM {0} interface list failed on {1}'.format(
 255                 self._qemu_opt['disk_image'], self._node['host']))
 256         # Create MAC-name dict
 257         for interface in interfaces:
 258             if 'hardware-address' not in interface:
 259                 continue
 260             mac_name[interface['hardware-address']] = interface['name']
 261         # Match interface by MAC and save interface name
 262         for interface in self._vm_info['interfaces'].values():
 263             mac = interface.get('mac_address')
 264             if_name = mac_name.get(mac)
 265             if if_name is None:
 266                 logger.trace('Interface name for MAC {} not found'.format(mac))
 267             else:
 268                 interface['name'] = if_name
 269
 270     def _huge_page_check(self):
 271         """Huge page check."""
 272         huge_mnt = self._qemu_opt.get('huge_mnt')
 273         mem_size = self._qemu_opt.get('mem_size')
 274         # Check size of free huge pages
 275         (_, output, _) = self._ssh.exec_command('grep Huge /proc/meminfo')
 276         regex = re.compile(r'HugePages_Free:\s+(\d+)')
 277         match = regex.search(output)
 278         huge_free = int(match.group(1))
 279         regex = re.compile(r'Hugepagesize:\s+(\d+)')
 280         match = regex.search(output)
 281         huge_size = int(match.group(1))
 282         if (mem_size * 1024) > (huge_free * huge_size):
 283             raise RuntimeError('Not enough free huge pages {0} kB, required '
 284                 '{1} MB'.format(huge_free * huge_size, mem_size))
 285         # Check if huge pages mount point exist
 286         has_huge_mnt = False
 287         (_, output, _) = self._ssh.exec_command('cat /proc/mounts')
 288         for line in output.splitlines():
 289             # Try to find something like:
 290             # none /mnt/huge hugetlbfs rw,relatime,pagesize=2048k 0 0
 291             mount = line.split()
 292             if mount[2] == 'hugetlbfs' and mount[1] == huge_mnt:
 293                 has_huge_mnt = True
 294                 break
 295         # If huge page mount point not exist create one
 296         if not has_huge_mnt:
 297             cmd = 'mount -t hugetlbfs -o pagesize=2048k none {0}'.format(
 298                 huge_mnt)
 299             (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd)
 300             if int(ret_code) != 0:
 301                 logger.debug('Mount huge pages failed {0}'.format(stderr))
 302                 raise RuntimeError('Mount huge pages failed on {0}'.format(
 303                     self._node['host']))
 304
 305     def qemu_start(self):
 306         """Start QEMU and wait until VM boot.
 307
 308         :return: VM node info.
 309         :rtype: dict
 310         .. note:: First set at least node to run QEMU on.
 311         .. warning:: Starts only one VM on the node.
 312         """
 313         # SSH forwarding
 314         ssh_fwd = '-net user,hostfwd=tcp::{0}-:22'.format(
 315             self._qemu_opt.get('ssh_fwd_port'))
 316         # Memory and huge pages
 317         mem = '-object memory-backend-file,id=mem,size={0}M,mem-path={1},' \
 318             'share=on -m {0} -numa node,memdev=mem'.format(
 319             self._qemu_opt.get('mem_size'), self._qemu_opt.get('huge_mnt'))
 320         self._huge_page_check()
 321         # Setup QMP via unix socket
 322         qmp = '-qmp unix:{0},server,nowait'.format(self.__QMP_SOCK)
 323         # Setup serial console
 324         serial = '-chardev socket,host=127.0.0.1,port={0},id=gnc0,server,' \
 325             'nowait -device isa-serial,chardev=gnc0'.format(
 326             self._qemu_opt.get('serial_port'))
 327         # Setup QGA via chardev (unix socket) and isa-serial channel
 328         qga = '-chardev socket,path=/tmp/qga.sock,server,nowait,id=qga0 ' \
 329             '-device isa-serial,chardev=qga0'
 330         # Graphic setup
 331         graphic = '-monitor none -display none -vga none'
 332         # Run QEMU
 333         cmd = '{0} {1} {2} {3} {4} -hda {5} {6} {7} {8} {9}'.format(
 334             self.__QEMU_BIN, self._qemu_opt.get('smp'), mem, ssh_fwd,
 335             self._qemu_opt.get('options'),
 336             self._qemu_opt.get('disk_image'), qmp, serial, qga, graphic)
 337         (ret_code, _, stderr) = self._ssh.exec_command_sudo(cmd, timeout=300)
 338         if int(ret_code) != 0:
 339             logger.debug('QEMU start failed {0}'.format(stderr))
 340             raise RuntimeError('QEMU start failed on {0}'.format(
 341                 self._node['host']))
 342         logger.trace('QEMU running')
 343         # Wait until VM boot
 344         self._wait_until_vm_boot()
 345         # Update interface names in VM node dict
 346         self._update_vm_interfaces()
 347         # Return VM node dict
 348         return self._vm_info
 349
 350     def qemu_quit(self):
 351         """Quit the QEMU emulator."""
 352         out = self._qemu_qmp_exec('quit')
 353         err = out.get('error')
 354         if err is not None:
 355             raise RuntimeError('QEMU quit failed on {0}, error: {1}'.format(
 356                 self._node['host'], json.dumps(err)))
 357
 358     def qemu_system_powerdown(self):
 359         """Power down the system (if supported)."""
 360         out = self._qemu_qmp_exec('system_powerdown')
 361         err = out.get('error')
 362         if err is not None:
 363             raise RuntimeError('QEMU system powerdown failed on {0}, '
 364                 'error: {1}'.format(self._node['host'], json.dumps(err)))
 365
 366     def qemu_system_reset(self):
 367         """Reset the system."""
 368         out = self._qemu_qmp_exec('system_reset')
 369         err = out.get('error')
 370         if err is not None:
 371             raise RuntimeError('QEMU system reset failed on {0}, '
 372                 'error: {1}'.format(self._node['host'], json.dumps(err)))
 373
 374     def qemu_kill(self):
 375         """Kill qemu process."""
 376         # TODO: add PID storage so that we can kill specific PID
 377         # Note: in QEMU start phase there are 3 QEMU processes because we
 378         # daemonize QEMU
 379         self._ssh.exec_command_sudo('pkill -SIGKILL qemu')
 380
 381     def qemu_clear_socks(self):
 382         """Remove all sockets created by QEMU."""
 383         # If serial console port still open kill process
 384         cmd = 'fuser -k {}/tcp'.format(self._qemu_opt.get('serial_port'))
 385         self._ssh.exec_command_sudo(cmd)
 386         # Delete all created sockets
 387         for sock in self._socks:
 388             cmd = 'rm -f {}'.format(sock)
 389             self._ssh.exec_command_sudo(cmd)
 390
 391     def qemu_system_status(self):
 392         """Return current VM status.
 393
 394         VM should be in following status:
 395
 396             - debug: QEMU running on a debugger
 397             - finish-migrate: paused to finish the migration process
 398             - inmigrate: waiting for an incoming migration
 399             - internal-error: internal error has occurred
 400             - io-error: the last IOP has failed
 401             - paused: paused
 402             - postmigrate: paused following a successful migrate
 403             - prelaunch: QEMU was started with -S and guest has not started
 404             - restore-vm: paused to restore VM state
 405             - running: actively running
 406             - save-vm: paused to save the VM state
 407             - shutdown: shut down (and -no-shutdown is in use)
 408             - suspended: suspended (ACPI S3)
 409             - watchdog: watchdog action has been triggered
 410             - guest-panicked: panicked as a result of guest OS panic
 411
 412         :return: VM status.
 413         :rtype: str
 414         """
 415         out = self._qemu_qmp_exec('query-status')
 416         ret = out.get('return')
 417         if ret is not None:
 418             return ret.get('status')
 419         else:
 420             err = out.get('error')
 421             raise RuntimeError('QEMU query-status failed on {0}, '
 422                 'error: {1}'.format(self._node['host'], json.dumps(err)))
 423
 424     @staticmethod
 425     def build_qemu(node):
 426         """Build QEMU from sources.
 427
 428         :param node: Node to build QEMU on.
 429         :type node: dict
 430         """
 431         ssh = SSH()
 432         ssh.connect(node)
 433
 434         (ret_code, stdout, stderr) = \
 435             ssh.exec_command('sudo -Sn bash {0}/{1}/qemu_build.sh'.format(
 436                 Constants.REMOTE_FW_DIR, Constants.RESOURCES_LIB_SH), 1000)
 437         logger.trace(stdout)
 438         if 0 != int(ret_code):
 439             logger.debug('QEMU build failed {0}'.format(stderr))
 440             raise RuntimeError('QEMU build failed on {0}'.format(node['host']))