# Copyright 2010 United States Government as represented by the # Administrator of the National Aeronautics and Space Administration. # All Rights Reserved. # Copyright (c) 2010 Citrix Systems, Inc. # Copyright (c) 2011 Piston Cloud Computing, Inc # Copyright (c) 2012 University Of Minho # (c) Copyright 2013 Hewlett-Packard Development Company, L.P. # # 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 # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """ A connection to a hypervisor through libvirt. Supports KVM, LXC, QEMU, UML, XEN and Parallels. """ import binascii import collections from collections import deque import contextlib import copy import errno import functools import glob import grp import itertools import operator import os import pwd import random import shutil import sys import tempfile import time import typing as ty import uuid from castellan import key_manager from copy import deepcopy import eventlet from eventlet import greenthread from eventlet import tpool from lxml import etree from os_brick import encryptors from os_brick.encryptors import luks as luks_encryptor from os_brick import exception as brick_exception from os_brick.initiator import connector import os_resource_classes as orc import os_traits as ot from oslo_concurrency import processutils from oslo_log import log as logging from oslo_serialization import base64 from oslo_serialization import jsonutils from oslo_service import loopingcall from oslo_utils import encodeutils from oslo_utils import excutils from oslo_utils import fileutils from oslo_utils import importutils from oslo_utils import netutils as oslo_netutils from oslo_utils import strutils from oslo_utils import timeutils from oslo_utils import units from oslo_utils import uuidutils import six from six.moves import range from nova.api.metadata import base as instance_metadata from nova.api.metadata import password from nova import block_device from nova.compute import power_state from nova.compute import provider_tree from nova.compute import task_states from nova.compute import utils as compute_utils from nova.compute import vm_states import nova.conf from nova.console import serial as serial_console from nova.console import type as ctype from nova import context as nova_context from nova import crypto from nova.db import constants as db_const from nova import exception from nova.i18n import _ from nova.image import glance from nova.network import model as network_model from nova import objects from nova.objects import diagnostics as diagnostics_obj from nova.objects import fields from nova.pci import manager as pci_manager from nova.pci import utils as pci_utils import nova.privsep.libvirt import nova.privsep.path import nova.privsep.utils from nova.storage import rbd_utils from nova import utils from nova import version from nova.virt import arch from nova.virt import block_device as driver_block_device from nova.virt import configdrive from nova.virt.disk import api as disk_api from nova.virt.disk.vfs import guestfs from nova.virt import driver from nova.virt import hardware from nova.virt.image import model as imgmodel from nova.virt import images from nova.virt.libvirt import blockinfo from nova.virt.libvirt import config as vconfig from nova.virt.libvirt import designer from nova.virt.libvirt import guest as libvirt_guest from nova.virt.libvirt import host from nova.virt.libvirt import imagebackend from nova.virt.libvirt import imagecache from nova.virt.libvirt import instancejobtracker from nova.virt.libvirt import migration as libvirt_migrate from nova.virt.libvirt.storage import dmcrypt from nova.virt.libvirt.storage import lvm from nova.virt.libvirt import utils as libvirt_utils from nova.virt.libvirt import vif as libvirt_vif from nova.virt.libvirt.volume import fs from nova.virt.libvirt.volume import mount from nova.virt.libvirt.volume import remotefs from nova.virt import netutils from nova.volume import cinder libvirt: ty.Any = None uefi_logged = False LOG = logging.getLogger(__name__) CONF = nova.conf.CONF DEFAULT_UEFI_LOADER_PATH = { "x86_64": ['/usr/share/OVMF/OVMF_CODE.fd', '/usr/share/OVMF/OVMF_CODE.secboot.fd', '/usr/share/qemu/ovmf-x86_64-code.bin'], "aarch64": ['/usr/share/AAVMF/AAVMF_CODE.fd', '/usr/share/qemu/aavmf-aarch64-code.bin'] } MAX_CONSOLE_BYTES = 100 * units.Ki VALID_DISK_CACHEMODES = [ "default", "none", "writethrough", "writeback", "directsync", "unsafe", ] # The libvirt driver will prefix any disable reason codes with this string. DISABLE_PREFIX = 'AUTO: ' # Disable reason for the service which was enabled or disabled without reason DISABLE_REASON_UNDEFINED = None # Guest config console string CONSOLE = "console=tty0 console=ttyS0 console=hvc0" GuestNumaConfig = collections.namedtuple( 'GuestNumaConfig', ['cpuset', 'cputune', 'numaconfig', 'numatune']) class InjectionInfo(collections.namedtuple( 'InjectionInfo', ['network_info', 'files', 'admin_pass'])): __slots__ = () def __repr__(self): return ('InjectionInfo(network_info=%r, files=%r, ' 'admin_pass=)') % (self.network_info, self.files) libvirt_volume_drivers = [ 'iscsi=nova.virt.libvirt.volume.iscsi.LibvirtISCSIVolumeDriver', 'iser=nova.virt.libvirt.volume.iser.LibvirtISERVolumeDriver', 'local=nova.virt.libvirt.volume.volume.LibvirtVolumeDriver', 'fake=nova.virt.libvirt.volume.volume.LibvirtFakeVolumeDriver', 'rbd=nova.virt.libvirt.volume.net.LibvirtNetVolumeDriver', 'nfs=nova.virt.libvirt.volume.nfs.LibvirtNFSVolumeDriver', 'smbfs=nova.virt.libvirt.volume.smbfs.LibvirtSMBFSVolumeDriver', 'fibre_channel=' 'nova.virt.libvirt.volume.fibrechannel.' 'LibvirtFibreChannelVolumeDriver', 'gpfs=nova.virt.libvirt.volume.gpfs.LibvirtGPFSVolumeDriver', 'quobyte=nova.virt.libvirt.volume.quobyte.LibvirtQuobyteVolumeDriver', 'scaleio=nova.virt.libvirt.volume.scaleio.LibvirtScaleIOVolumeDriver', 'vzstorage=' 'nova.virt.libvirt.volume.vzstorage.LibvirtVZStorageVolumeDriver', 'storpool=nova.virt.libvirt.volume.storpool.LibvirtStorPoolVolumeDriver', 'nvmeof=nova.virt.libvirt.volume.nvme.LibvirtNVMEVolumeDriver', ] def patch_tpool_proxy(): """eventlet.tpool.Proxy doesn't work with old-style class in __str__() or __repr__() calls. See bug #962840 for details. We perform a monkey patch to replace those two instance methods. """ def str_method(self): return str(self._obj) def repr_method(self): return repr(self._obj) tpool.Proxy.__str__ = str_method tpool.Proxy.__repr__ = repr_method patch_tpool_proxy() # For information about when MIN_LIBVIRT_VERSION and # NEXT_MIN_LIBVIRT_VERSION can be changed, consult # # https://wiki.openstack.org/wiki/LibvirtDistroSupportMatrix # # Currently this is effectively the min version for i686/x86_64 # + KVM/QEMU, as other architectures/hypervisors require newer # versions. Over time, this will become a common min version # for all architectures/hypervisors, as this value rises to # meet them. MIN_LIBVIRT_VERSION = (5, 0, 0) MIN_QEMU_VERSION = (4, 0, 0) # TODO(berrange): Re-evaluate this at start of each release cycle # to decide if we want to plan a future min version bump. # MIN_LIBVIRT_VERSION can be updated to match this after # NEXT_MIN_LIBVIRT_VERSION has been at a higher value for # one cycle NEXT_MIN_LIBVIRT_VERSION = (6, 0, 0) NEXT_MIN_QEMU_VERSION = (4, 2, 0) # Virtuozzo driver support MIN_VIRTUOZZO_VERSION = (7, 0, 0) # Names of the types that do not get compressed during migration NO_COMPRESSION_TYPES = ('qcow2',) # number of serial console limit QEMU_MAX_SERIAL_PORTS = 4 # Qemu supports 4 serial consoles, we remove 1 because of the PTY one defined ALLOWED_QEMU_SERIAL_PORTS = QEMU_MAX_SERIAL_PORTS - 1 VGPU_RESOURCE_SEMAPHORE = 'vgpu_resources' LIBVIRT_PERF_EVENT_PREFIX = 'VIR_PERF_PARAM_' MIN_LIBVIRT_FILE_BACKED_DISCARD_VERSION = (4, 4, 0) MIN_LIBVIRT_NATIVE_TLS_VERSION = (4, 4, 0) MIN_QEMU_NATIVE_TLS_VERSION = (2, 11, 0) # If the host has this libvirt version, then we skip the retry loop of # instance destroy() call, as libvirt itself increased the wait time # before the SIGKILL signal takes effect. MIN_LIBVIRT_BETTER_SIGKILL_HANDLING = (4, 7, 0) # Persistent Memory (PMEM/NVDIMM) Device Support MIN_LIBVIRT_PMEM_SUPPORT = (5, 0, 0) MIN_QEMU_PMEM_SUPPORT = (3, 1, 0) # -blockdev support (replacing -drive) MIN_LIBVIRT_BLOCKDEV = (6, 0, 0) MIN_QEMU_BLOCKDEV = (4, 2, 0) MIN_LIBVIRT_VIR_ERR_DEVICE_MISSING = (4, 1, 0) # Virtual TPM (vTPM) support MIN_LIBVIRT_VTPM = (5, 6, 0) MIN_LIBVIRT_S390X_CPU_COMPARE = (5, 9, 0) # see https://libvirt.org/formatdomain.html#elementsVideo MIN_LIBVIRT_VIDEO_MODEL_VERSIONS = { fields.VideoModel.NONE: (4, 6, 0), } class LibvirtDriver(driver.ComputeDriver): def __init__(self, virtapi, read_only=False): # NOTE(aspiers) Some of these are dynamic, so putting # capabilities on the instance rather than on the class. # This prevents the risk of one test setting a capability # which bleeds over into other tests. # LVM and RBD require raw images. If we are not configured to # force convert images into raw format, then we _require_ raw # images only. raw_only = ('rbd', 'lvm') requires_raw_image = (CONF.libvirt.images_type in raw_only and not CONF.force_raw_images) requires_ploop_image = CONF.libvirt.virt_type == 'parallels' self.capabilities = { "has_imagecache": True, "supports_evacuate": True, "supports_migrate_to_same_host": False, "supports_attach_interface": True, "supports_device_tagging": True, "supports_tagged_attach_interface": True, "supports_tagged_attach_volume": True, "supports_extend_volume": True, "supports_multiattach": True, "supports_trusted_certs": True, # Supported image types "supports_image_type_aki": True, "supports_image_type_ari": True, "supports_image_type_ami": True, # FIXME(danms): I can see a future where people might want to # configure certain compute nodes to not allow giant raw images # to be booted (like nodes that are across a WAN). Thus, at some # point we may want to be able to _not_ expose "supports raw" on # some nodes by policy. Until then, raw is always supported. "supports_image_type_raw": True, "supports_image_type_iso": True, # NOTE(danms): Certain backends do not work with complex image # formats. If we are configured for those backends, then we # should not expose the corresponding support traits. "supports_image_type_qcow2": not requires_raw_image, "supports_image_type_ploop": requires_ploop_image, "supports_pcpus": True, "supports_accelerators": True, "supports_bfv_rescue": True, "supports_vtpm": CONF.libvirt.swtpm_enabled, } super(LibvirtDriver, self).__init__(virtapi) if not sys.platform.startswith('linux'): raise exception.InternalError( _('The libvirt driver only works on Linux')) global libvirt if libvirt is None: libvirt = importutils.import_module('libvirt') libvirt_migrate.libvirt = libvirt self._host = host.Host(self._uri(), read_only, lifecycle_event_handler=self.emit_event, conn_event_handler=self._handle_conn_event) self._supported_perf_events = [] self.vif_driver = libvirt_vif.LibvirtGenericVIFDriver() # TODO(mriedem): Long-term we should load up the volume drivers on # demand as needed rather than doing this on startup, as there might # be unsupported volume drivers in this list based on the underlying # platform. self.volume_drivers = self._get_volume_drivers() self._disk_cachemode = None self.image_cache_manager = imagecache.ImageCacheManager() self.image_backend = imagebackend.Backend(CONF.use_cow_images) self.disk_cachemodes = {} for mode_str in CONF.libvirt.disk_cachemodes: disk_type, sep, cache_mode = mode_str.partition('=') if cache_mode not in VALID_DISK_CACHEMODES: LOG.warning('Invalid cachemode %(cache_mode)s specified ' 'for disk type %(disk_type)s.', {'cache_mode': cache_mode, 'disk_type': disk_type}) continue self.disk_cachemodes[disk_type] = cache_mode self._volume_api = cinder.API() self._image_api = glance.API() # The default choice for the sysinfo_serial config option is "unique" # which does not have a special function since the value is just the # instance.uuid. sysinfo_serial_funcs = { 'none': lambda: None, 'hardware': self._get_host_sysinfo_serial_hardware, 'os': self._get_host_sysinfo_serial_os, 'auto': self._get_host_sysinfo_serial_auto, } self._sysinfo_serial_func = sysinfo_serial_funcs.get( CONF.libvirt.sysinfo_serial, lambda: None) self.job_tracker = instancejobtracker.InstanceJobTracker() self._remotefs = remotefs.RemoteFilesystem() self._live_migration_flags = self._block_migration_flags = 0 self.active_migrations = {} # Compute reserved hugepages from conf file at the very # beginning to ensure any syntax error will be reported and # avoid any re-calculation when computing resources. self._reserved_hugepages = hardware.numa_get_reserved_huge_pages() # Copy of the compute service ProviderTree object that is updated # every time update_provider_tree() is called. # NOTE(sbauza): We only want a read-only cache, this attribute is not # intended to be updatable directly self.provider_tree: provider_tree.ProviderTree = None # driver traits will not change during the runtime of the agent # so calcuate them once and save them self._static_traits = None # The CPU models in the configuration are case-insensitive, but the CPU # model in the libvirt is case-sensitive, therefore create a mapping to # map the lower case CPU model name to normal CPU model name. self.cpu_models_mapping = {} self.cpu_model_flag_mapping = {} self._vpmems_by_name, self._vpmems_by_rc = self._discover_vpmems( vpmem_conf=CONF.libvirt.pmem_namespaces) # We default to not support vGPUs unless the configuration is set. self.pgpu_type_mapping = collections.defaultdict(str) self.supported_vgpu_types = self._get_supported_vgpu_types() def _discover_vpmems(self, vpmem_conf=None): """Discover vpmems on host and configuration. :param vpmem_conf: pmem namespaces configuration from CONF :returns: a dict of vpmem keyed by name, and a dict of vpmem list keyed by resource class :raises: exception.InvalidConfiguration if Libvirt or QEMU version does not meet requirement. """ if not vpmem_conf: return {}, {} if not self._host.has_min_version(lv_ver=MIN_LIBVIRT_PMEM_SUPPORT, hv_ver=MIN_QEMU_PMEM_SUPPORT): raise exception.InvalidConfiguration( _('Nova requires QEMU version %(qemu)s or greater ' 'and Libvirt version %(libvirt)s or greater ' 'for NVDIMM (Persistent Memory) support.') % { 'qemu': libvirt_utils.version_to_string( MIN_QEMU_PMEM_SUPPORT), 'libvirt': libvirt_utils.version_to_string( MIN_LIBVIRT_PMEM_SUPPORT)}) # vpmem keyed by name {name: objects.LibvirtVPMEMDevice,...} vpmems_by_name: ty.Dict[str, 'objects.LibvirtVPMEMDevice'] = {} # vpmem list keyed by resource class # {'RC_0': [objects.LibvirtVPMEMDevice, ...], 'RC_1': [...]} vpmems_by_rc: ty.Dict[str, ty.List['objects.LibvirtVPMEMDevice']] = ( collections.defaultdict(list) ) vpmems_host = self._get_vpmems_on_host() for ns_conf in vpmem_conf: try: ns_label, ns_names = ns_conf.split(":", 1) except ValueError: reason = _("The configuration doesn't follow the format") raise exception.PMEMNamespaceConfigInvalid( reason=reason) ns_names = ns_names.split("|") for ns_name in ns_names: if ns_name not in vpmems_host: reason = _("The PMEM namespace %s isn't on host") % ns_name raise exception.PMEMNamespaceConfigInvalid( reason=reason) if ns_name in vpmems_by_name: reason = (_("Duplicated PMEM namespace %s configured") % ns_name) raise exception.PMEMNamespaceConfigInvalid( reason=reason) pmem_ns_updated = vpmems_host[ns_name] pmem_ns_updated.label = ns_label vpmems_by_name[ns_name] = pmem_ns_updated rc = orc.normalize_name( "PMEM_NAMESPACE_%s" % ns_label) vpmems_by_rc[rc].append(pmem_ns_updated) return vpmems_by_name, vpmems_by_rc def _get_vpmems_on_host(self): """Get PMEM namespaces on host using ndctl utility.""" try: output = nova.privsep.libvirt.get_pmem_namespaces() except Exception as e: reason = _("Get PMEM namespaces by ndctl utility, " "please ensure ndctl is installed: %s") % e raise exception.GetPMEMNamespacesFailed(reason=reason) if not output: return {} namespaces = jsonutils.loads(output) vpmems_host = {} # keyed by namespace name for ns in namespaces: # store namespace info parsed from ndctl utility return if not ns.get('name'): # The name is used to identify namespaces, it's optional # config when creating namespace. If an namespace don't have # name, it can not be used by Nova, we will skip it. continue vpmems_host[ns['name']] = objects.LibvirtVPMEMDevice( name=ns['name'], devpath= '/dev/' + ns['daxregion']['devices'][0]['chardev'], size=ns['size'], align=ns['daxregion']['align']) return vpmems_host def _get_volume_drivers(self): driver_registry = dict() for driver_str in libvirt_volume_drivers: driver_type, _sep, driver = driver_str.partition('=') driver_class = importutils.import_class(driver) try: driver_registry[driver_type] = driver_class(self._host) except brick_exception.InvalidConnectorProtocol: LOG.debug('Unable to load volume driver %s. It is not ' 'supported on this host.', driver) return driver_registry @property def disk_cachemode(self): # It can be confusing to understand the QEMU cache mode # behaviour, because each cache=$MODE is a convenient shorthand # to toggle _three_ cache.* booleans. Consult the below table # (quoting from the QEMU man page): # # | cache.writeback | cache.direct | cache.no-flush # -------------------------------------------------------------- # writeback | on | off | off # none | on | on | off # writethrough | off | off | off # directsync | off | on | off # unsafe | on | off | on # # Where: # # - 'cache.writeback=off' means: QEMU adds an automatic fsync() # after each write request. # # - 'cache.direct=on' means: Use Linux's O_DIRECT, i.e. bypass # the kernel page cache. Caches in any other layer (disk # cache, QEMU metadata caches, etc.) can still be present. # # - 'cache.no-flush=on' means: Ignore flush requests, i.e. # never call fsync(), even if the guest explicitly requested # it. # # Use cache mode "none" (cache.writeback=on, cache.direct=on, # cache.no-flush=off) for consistent performance and # migration correctness. Some filesystems don't support # O_DIRECT, though. For those we fallback to the next # reasonable option that is "writeback" (cache.writeback=on, # cache.direct=off, cache.no-flush=off). if self._disk_cachemode is None: self._disk_cachemode = "none" if not nova.privsep.utils.supports_direct_io(CONF.instances_path): self._disk_cachemode = "writeback" return self._disk_cachemode def _set_cache_mode(self, conf): """Set cache mode on LibvirtConfigGuestDisk object.""" try: source_type = conf.source_type driver_cache = conf.driver_cache except AttributeError: return # Shareable disks like for a multi-attach volume need to have the # driver cache disabled. if getattr(conf, 'shareable', False): conf.driver_cache = 'none' else: cache_mode = self.disk_cachemodes.get(source_type, driver_cache) conf.driver_cache = cache_mode # NOTE(acewit): If the [libvirt]disk_cachemodes is set as # `block=writeback` or `block=writethrough` or `block=unsafe`, # whose correponding Linux's IO semantic is not O_DIRECT in # file nova.conf, then it will result in an attachment failure # because of the libvirt bug # (https://bugzilla.redhat.com/show_bug.cgi?id=1086704) if ((getattr(conf, 'driver_io', None) == "native") and conf.driver_cache not in [None, 'none', 'directsync']): conf.driver_io = "threads" LOG.warning("The guest disk driver io mode has fallen back " "from 'native' to 'threads' because the " "disk cache mode is set as %(cachemode)s, which does " "not use O_DIRECT. See the following bug report " "for more details: https://launchpad.net/bugs/1841363", {'cachemode': conf.driver_cache}) def _do_quality_warnings(self): """Warn about potential configuration issues. This will log a warning message for things such as untested driver or host arch configurations in order to indicate potential issues to administrators. """ if CONF.libvirt.virt_type not in ('qemu', 'kvm'): LOG.warning( "Support for the '%(type)s' libvirt backend has been " "deprecated and will be removed in a future release.", {'type': CONF.libvirt.virt_type}, ) caps = self._host.get_capabilities() hostarch = caps.host.cpu.arch if hostarch not in ( fields.Architecture.I686, fields.Architecture.X86_64, ): LOG.warning( 'The libvirt driver is not tested on %(arch)s by the ' 'OpenStack project and thus its quality can not be ensured. ' 'For more information, see: https://docs.openstack.org/' 'nova/latest/user/support-matrix.html', {'arch': hostarch}, ) def _handle_conn_event(self, enabled, reason): LOG.info("Connection event '%(enabled)d' reason '%(reason)s'", {'enabled': enabled, 'reason': reason}) self._set_host_enabled(enabled, reason) def init_host(self, host): self._host.initialize() self._check_cpu_set_configuration() self._do_quality_warnings() self._parse_migration_flags() self._supported_perf_events = self._get_supported_perf_events() self._check_file_backed_memory_support() self._check_my_ip() if (CONF.libvirt.virt_type == 'lxc' and not (CONF.libvirt.uid_maps and CONF.libvirt.gid_maps)): LOG.warning("Running libvirt-lxc without user namespaces is " "dangerous. Containers spawned by Nova will be run " "as the host's root user. It is highly suggested " "that user namespaces be used in a public or " "multi-tenant environment.") # Stop libguestfs using KVM unless we're also configured # to use this. This solves problem where people need to # stop Nova use of KVM because nested-virt is broken if CONF.libvirt.virt_type != "kvm": guestfs.force_tcg() if not self._host.has_min_version(MIN_LIBVIRT_VERSION): raise exception.InternalError( _('Nova requires libvirt version %s or greater.') % libvirt_utils.version_to_string(MIN_LIBVIRT_VERSION)) if CONF.libvirt.virt_type in ("qemu", "kvm"): if not self._host.has_min_version(hv_ver=MIN_QEMU_VERSION): raise exception.InternalError( _('Nova requires QEMU version %s or greater.') % libvirt_utils.version_to_string(MIN_QEMU_VERSION)) if CONF.libvirt.virt_type == 'parallels': if not self._host.has_min_version(hv_ver=MIN_VIRTUOZZO_VERSION): raise exception.InternalError( _('Nova requires Virtuozzo version %s or greater.') % libvirt_utils.version_to_string(MIN_VIRTUOZZO_VERSION)) # Give the cloud admin a heads up if we are intending to # change the MIN_LIBVIRT_VERSION in the next release. if not self._host.has_min_version(NEXT_MIN_LIBVIRT_VERSION): LOG.warning('Running Nova with a libvirt version less than ' '%(version)s is deprecated. The required minimum ' 'version of libvirt will be raised to %(version)s ' 'in the next release.', {'version': libvirt_utils.version_to_string( NEXT_MIN_LIBVIRT_VERSION)}) if (CONF.libvirt.virt_type in ("qemu", "kvm") and not self._host.has_min_version(hv_ver=NEXT_MIN_QEMU_VERSION)): LOG.warning('Running Nova with a QEMU version less than ' '%(version)s is deprecated. The required minimum ' 'version of QEMU will be raised to %(version)s ' 'in the next release.', {'version': libvirt_utils.version_to_string( NEXT_MIN_QEMU_VERSION)}) # Allowing both "tunnelling via libvirtd" (which will be # deprecated once the MIN_{LIBVIRT,QEMU}_VERSION is sufficiently # new enough) and "native TLS" options at the same time is # nonsensical. if (CONF.libvirt.live_migration_tunnelled and CONF.libvirt.live_migration_with_native_tls): msg = _("Setting both 'live_migration_tunnelled' and " "'live_migration_with_native_tls' at the same " "time is invalid. If you have the relevant " "libvirt and QEMU versions, and TLS configured " "in your environment, pick " "'live_migration_with_native_tls'.") raise exception.Invalid(msg) # Some imagebackends are only able to import raw disk images, # and will fail if given any other format. See the bug # https://bugs.launchpad.net/nova/+bug/1816686 for more details. if CONF.libvirt.images_type in ('rbd',): if not CONF.force_raw_images: msg = _("'[DEFAULT]/force_raw_images = False' is not " "allowed with '[libvirt]/images_type = rbd'. " "Please check the two configs and if you really " "do want to use rbd as images_type, set " "force_raw_images to True.") raise exception.InvalidConfiguration(msg) # TODO(sbauza): Remove this code once mediated devices are persisted # across reboots. self._recreate_assigned_mediated_devices() self._check_cpu_compatibility() self._check_vtpm_support() def _check_cpu_compatibility(self): mode = CONF.libvirt.cpu_mode models = CONF.libvirt.cpu_models if (CONF.libvirt.virt_type not in ("kvm", "qemu") and mode not in (None, 'none')): msg = _("Config requested an explicit CPU model, but " "the current libvirt hypervisor '%s' does not " "support selecting CPU models") % CONF.libvirt.virt_type raise exception.Invalid(msg) if mode != "custom": if not models: return msg = _("The cpu_models option is not required when " "cpu_mode!=custom") raise exception.Invalid(msg) if not models: msg = _("The cpu_models option is required when cpu_mode=custom") raise exception.Invalid(msg) cpu = vconfig.LibvirtConfigGuestCPU() for model in models: cpu.model = self._get_cpu_model_mapping(model) try: self._compare_cpu(cpu, self._get_cpu_info(), None) except exception.InvalidCPUInfo as e: msg = (_("Configured CPU model: %(model)s is not " "compatible with host CPU. Please correct your " "config and try again. %(e)s") % { 'model': model, 'e': e}) raise exception.InvalidCPUInfo(msg) # Use guest CPU model to check the compatibility between guest CPU and # configured extra_flags cpu = vconfig.LibvirtConfigGuestCPU() cpu.model = self._host.get_capabilities().host.cpu.model for flag in set(x.lower() for x in CONF.libvirt.cpu_model_extra_flags): cpu.add_feature(vconfig.LibvirtConfigCPUFeature(flag)) try: self._compare_cpu(cpu, self._get_cpu_info(), None) except exception.InvalidCPUInfo as e: msg = (_("Configured extra flag: %(flag)s it not correct, or " "the host CPU does not support this flag. Please " "correct the config and try again. %(e)s") % { 'flag': flag, 'e': e}) raise exception.InvalidCPUInfo(msg) def _check_vtpm_support(self) -> None: # TODO(efried): A key manager must be configured to create/retrieve # secrets. Is there a way to check that one is set up correctly? # CONF.key_manager.backend is optional :( if not CONF.libvirt.swtpm_enabled: return if CONF.libvirt.virt_type not in ('qemu', 'kvm'): msg = _( "vTPM support requires '[libvirt] virt_type' of 'qemu' or " "'kvm'; found '%s'.") raise exception.InvalidConfiguration(msg % CONF.libvirt.virt_type) if not self._host.has_min_version(lv_ver=MIN_LIBVIRT_VTPM): msg = _( 'vTPM support requires Libvirt version %(libvirt)s or ' 'greater.') raise exception.InvalidConfiguration(msg % { 'libvirt': libvirt_utils.version_to_string(MIN_LIBVIRT_VTPM), }) # These executables need to be installed for libvirt to make use of # emulated TPM. # NOTE(stephenfin): This checks using the PATH of the user running # nova-compute rather than the libvirtd service, meaning it's an # imperfect check but the best we can do if not any(shutil.which(cmd) for cmd in ('swtpm_setup', 'swtpm')): msg = _( "vTPM support is configured but the 'swtpm' and " "'swtpm_setup' binaries could not be found on PATH.") raise exception.InvalidConfiguration(msg) # The user and group must be valid on this host for cold migration and # resize to function. try: pwd.getpwnam(CONF.libvirt.swtpm_user) except KeyError: msg = _( "The user configured in '[libvirt] swtpm_user' does not exist " "on this host; expected '%s'.") raise exception.InvalidConfiguration(msg % CONF.libvirt.swtpm_user) try: grp.getgrnam(CONF.libvirt.swtpm_group) except KeyError: msg = _( "The group configured in '[libvirt] swtpm_group' does not " "exist on this host; expected '%s'.") raise exception.InvalidConfiguration( msg % CONF.libvirt.swtpm_group) LOG.debug('Enabling emulated TPM support') @staticmethod def _is_existing_mdev(uuid): # FIXME(sbauza): Some kernel can have a uevent race meaning that the # libvirt daemon won't know when a mediated device is created unless # you restart that daemon. Until all kernels we support are not having # that possible race, check the sysfs directly instead of asking the # libvirt API. # See https://bugzilla.redhat.com/show_bug.cgi?id=1376907 for ref. return os.path.exists('/sys/bus/mdev/devices/{0}'.format(uuid)) def _recreate_assigned_mediated_devices(self): """Recreate assigned mdevs that could have disappeared if we reboot the host. """ # NOTE(sbauza): This method just calls sysfs to recreate mediated # devices by looking up existing guest XMLs and doesn't use # the Placement API so it works with or without a vGPU reshape. mdevs = self._get_all_assigned_mediated_devices() for (mdev_uuid, instance_uuid) in six.iteritems(mdevs): if not self._is_existing_mdev(mdev_uuid): dev_name = libvirt_utils.mdev_uuid2name(mdev_uuid) dev_info = self._get_mediated_device_information(dev_name) parent = dev_info['parent'] parent_type = self._get_vgpu_type_per_pgpu(parent) if dev_info['type'] != parent_type: # NOTE(sbauza): The mdev was created by using a different # vGPU type. We can't recreate the mdev until the operator # modifies the configuration. parent = "{}:{}:{}.{}".format(*parent[4:].split('_')) msg = ("The instance UUID %(inst)s uses a VGPU that " "its parent pGPU %(parent)s no longer " "supports as the instance vGPU type %(type)s " "is not accepted for the pGPU. Please correct " "the configuration accordingly." % {'inst': instance_uuid, 'parent': parent, 'type': dev_info['type']}) raise exception.InvalidLibvirtGPUConfig(reason=msg) self._create_new_mediated_device(parent, uuid=mdev_uuid) def _check_file_backed_memory_support(self): if not CONF.libvirt.file_backed_memory: return # file_backed_memory is only compatible with qemu/kvm virts if CONF.libvirt.virt_type not in ("qemu", "kvm"): raise exception.InternalError( _('Running Nova with file_backed_memory and virt_type ' '%(type)s is not supported. file_backed_memory is only ' 'supported with qemu and kvm types.') % {'type': CONF.libvirt.virt_type}) # file-backed memory doesn't work with memory overcommit. # Block service startup if file-backed memory is enabled and # ram_allocation_ratio is not 1.0 if CONF.ram_allocation_ratio != 1.0: raise exception.InternalError( 'Running Nova with file_backed_memory requires ' 'ram_allocation_ratio configured to 1.0') if CONF.reserved_host_memory_mb: # this is a hard failure as placement won't allow total < reserved if CONF.reserved_host_memory_mb >= CONF.libvirt.file_backed_memory: msg = _( "'[libvirt] file_backed_memory', which represents total " "memory reported to placement, must be greater than " "reserved memory configured via '[DEFAULT] " "reserved_host_memory_mb'" ) raise exception.InternalError(msg) # TODO(stephenfin): Change this to an exception in W or later LOG.warning( "Reserving memory via '[DEFAULT] reserved_host_memory_mb' " "is not compatible with file-backed memory. Consider " "setting '[DEFAULT] reserved_host_memory_mb' to 0. This will " "be an error in a future release." ) def _check_my_ip(self): ips = compute_utils.get_machine_ips() if CONF.my_ip not in ips: LOG.warning('my_ip address (%(my_ip)s) was not found on ' 'any of the interfaces: %(ifaces)s', {'my_ip': CONF.my_ip, 'ifaces': ", ".join(ips)}) def _check_cpu_set_configuration(self): # evaluate these now to force a quick fail if they're invalid vcpu_pin_set = hardware.get_vcpu_pin_set() or set() cpu_shared_set = hardware.get_cpu_shared_set() or set() cpu_dedicated_set = hardware.get_cpu_dedicated_set() or set() # TODO(stephenfin): Remove this in U once we remove the 'vcpu_pin_set' # option if not vcpu_pin_set: if not (cpu_shared_set or cpu_dedicated_set): return if not cpu_dedicated_set.isdisjoint(cpu_shared_set): msg = _( "The '[compute] cpu_dedicated_set' and '[compute] " "cpu_shared_set' configuration options must be " "disjoint.") raise exception.InvalidConfiguration(msg) if CONF.reserved_host_cpus: msg = _( "The 'reserved_host_cpus' config option cannot be defined " "alongside the '[compute] cpu_shared_set' or '[compute] " "cpu_dedicated_set' options. Unset 'reserved_host_cpus'.") raise exception.InvalidConfiguration(msg) return if cpu_dedicated_set: # NOTE(stephenfin): This is a new option in Train so it can be # an error msg = _( "The 'vcpu_pin_set' config option has been deprecated and " "cannot be defined alongside '[compute] cpu_dedicated_set'. " "Unset 'vcpu_pin_set'.") raise exception.InvalidConfiguration(msg) if cpu_shared_set: LOG.warning( "The '[compute] cpu_shared_set' and 'vcpu_pin_set' config " "options have both been defined. While 'vcpu_pin_set' is " "defined, it will continue to be used to configure the " "specific host CPUs used for 'VCPU' inventory, while " "'[compute] cpu_shared_set' will only be used for guest " "emulator threads when 'hw:emulator_threads_policy=shared' " "is defined in the flavor. This is legacy behavior and will " "not be supported in a future release. " "If you wish to define specific host CPUs to be used for " "'VCPU' or 'PCPU' inventory, you must migrate the " "'vcpu_pin_set' config option value to '[compute] " "cpu_shared_set' and '[compute] cpu_dedicated_set', " "respectively, and undefine 'vcpu_pin_set'.") else: LOG.warning( "The 'vcpu_pin_set' config option has been deprecated and " "will be removed in a future release. When defined, " "'vcpu_pin_set' will be used to calculate 'VCPU' inventory " "and schedule instances that have 'VCPU' allocations. " "If you wish to define specific host CPUs to be used for " "'VCPU' or 'PCPU' inventory, you must migrate the " "'vcpu_pin_set' config option value to '[compute] " "cpu_shared_set' and '[compute] cpu_dedicated_set', " "respectively, and undefine 'vcpu_pin_set'.") def _prepare_migration_flags(self): migration_flags = 0 migration_flags |= libvirt.VIR_MIGRATE_LIVE # Adding p2p flag only if xen is not in use, because xen does not # support p2p migrations if CONF.libvirt.virt_type != 'xen': migration_flags |= libvirt.VIR_MIGRATE_PEER2PEER # Adding VIR_MIGRATE_UNDEFINE_SOURCE because, without it, migrated # instance will remain defined on the source host migration_flags |= libvirt.VIR_MIGRATE_UNDEFINE_SOURCE # Adding VIR_MIGRATE_PERSIST_DEST to persist the VM on the # destination host migration_flags |= libvirt.VIR_MIGRATE_PERSIST_DEST live_migration_flags = block_migration_flags = migration_flags # Adding VIR_MIGRATE_NON_SHARED_INC, otherwise all block-migrations # will be live-migrations instead block_migration_flags |= libvirt.VIR_MIGRATE_NON_SHARED_INC return (live_migration_flags, block_migration_flags) # TODO(kchamart) Once the MIN_LIBVIRT_VERSION and MIN_QEMU_VERSION # reach 4.4.0 and 2.11.0, which provide "native TLS" support by # default, deprecate and remove the support for "tunnelled live # migration" (and related config attribute), because: # # (a) it cannot handle live migration of disks in a non-shared # storage setup (a.k.a. "block migration"); # # (b) has a huge performance overhead and latency, because it burns # more CPU and memory bandwidth due to increased number of data # copies on both source and destination hosts. # # Both the above limitations are addressed by the QEMU-native TLS # support (`live_migration_with_native_tls`). def _handle_live_migration_tunnelled(self, migration_flags): if CONF.libvirt.live_migration_tunnelled: migration_flags |= libvirt.VIR_MIGRATE_TUNNELLED return migration_flags def _is_native_tls_available(self): return self._host.has_min_version(MIN_LIBVIRT_NATIVE_TLS_VERSION, MIN_QEMU_NATIVE_TLS_VERSION) def _handle_native_tls(self, migration_flags): if (CONF.libvirt.live_migration_with_native_tls and self._is_native_tls_available()): migration_flags |= libvirt.VIR_MIGRATE_TLS return migration_flags def _handle_live_migration_post_copy(self, migration_flags): if CONF.libvirt.live_migration_permit_post_copy: migration_flags |= libvirt.VIR_MIGRATE_POSTCOPY return migration_flags def _handle_live_migration_auto_converge(self, migration_flags): if self._is_post_copy_enabled(migration_flags): LOG.info('The live_migration_permit_post_copy is set to ' 'True and post copy live migration is available ' 'so auto-converge will not be in use.') elif CONF.libvirt.live_migration_permit_auto_converge: migration_flags |= libvirt.VIR_MIGRATE_AUTO_CONVERGE return migration_flags def _parse_migration_flags(self): (live_migration_flags, block_migration_flags) = self._prepare_migration_flags() live_migration_flags = self._handle_live_migration_tunnelled( live_migration_flags) block_migration_flags = self._handle_live_migration_tunnelled( block_migration_flags) live_migration_flags = self._handle_native_tls( live_migration_flags) block_migration_flags = self._handle_native_tls( block_migration_flags) live_migration_flags = self._handle_live_migration_post_copy( live_migration_flags) block_migration_flags = self._handle_live_migration_post_copy( block_migration_flags) live_migration_flags = self._handle_live_migration_auto_converge( live_migration_flags) block_migration_flags = self._handle_live_migration_auto_converge( block_migration_flags) self._live_migration_flags = live_migration_flags self._block_migration_flags = block_migration_flags # TODO(sahid): This method is targeted for removal when the tests # have been updated to avoid its use # # All libvirt API calls on the libvirt.Connect object should be # encapsulated by methods on the nova.virt.libvirt.host.Host # object, rather than directly invoking the libvirt APIs. The goal # is to avoid a direct dependency on the libvirt API from the # driver.py file. def _get_connection(self): return self._host.get_connection() _conn = property(_get_connection) @staticmethod def _uri(): if CONF.libvirt.virt_type == 'uml': uri = CONF.libvirt.connection_uri or 'uml:///system' elif CONF.libvirt.virt_type == 'xen': uri = CONF.libvirt.connection_uri or 'xen:///' elif CONF.libvirt.virt_type == 'lxc': uri = CONF.libvirt.connection_uri or 'lxc:///' elif CONF.libvirt.virt_type == 'parallels': uri = CONF.libvirt.connection_uri or 'parallels:///system' else: uri = CONF.libvirt.connection_uri or 'qemu:///system' return uri @staticmethod def _live_migration_uri(dest): uris = { 'kvm': 'qemu+%(scheme)s://%(dest)s/system', 'qemu': 'qemu+%(scheme)s://%(dest)s/system', 'xen': 'xenmigr://%(dest)s/system', 'parallels': 'parallels+tcp://%(dest)s/system', } dest = oslo_netutils.escape_ipv6(dest) virt_type = CONF.libvirt.virt_type # TODO(pkoniszewski): Remove fetching live_migration_uri in Pike uri = CONF.libvirt.live_migration_uri if uri: return uri % dest uri = uris.get(virt_type) if uri is None: raise exception.LiveMigrationURINotAvailable(virt_type=virt_type) str_format = { 'dest': dest, 'scheme': CONF.libvirt.live_migration_scheme or 'tcp', } return uri % str_format @staticmethod def _migrate_uri(dest): uri = None dest = oslo_netutils.escape_ipv6(dest) # Only QEMU live migrations supports migrate-uri parameter virt_type = CONF.libvirt.virt_type if virt_type in ('qemu', 'kvm'): # QEMU accept two schemes: tcp and rdma. By default # libvirt build the URI using the remote hostname and the # tcp schema. uri = 'tcp://%s' % dest # Because dest might be of type unicode, here we might return value of # type unicode as well which is not acceptable by libvirt python # binding when Python 2.7 is in use, so let's convert it explicitly # back to string. When Python 3.x is in use, libvirt python binding # accepts unicode type so it is completely fine to do a no-op str(uri) # conversion which will return value of type unicode. return uri and str(uri) def instance_exists(self, instance): """Efficient override of base instance_exists method.""" try: self._host.get_guest(instance) return True except (exception.InternalError, exception.InstanceNotFound): return False def list_instances(self): names = [] for guest in self._host.list_guests(only_running=False): names.append(guest.name) return names def list_instance_uuids(self): uuids = [] for guest in self._host.list_guests(only_running=False): uuids.append(guest.uuid) return uuids def plug_vifs(self, instance, network_info): """Plug VIFs into networks.""" for vif in network_info: self.vif_driver.plug(instance, vif) def _unplug_vifs(self, instance, network_info, ignore_errors): """Unplug VIFs from networks.""" for vif in network_info: try: self.vif_driver.unplug(instance, vif) except exception.NovaException: if not ignore_errors: raise def unplug_vifs(self, instance, network_info): self._unplug_vifs(instance, network_info, False) def _teardown_container(self, instance): inst_path = libvirt_utils.get_instance_path(instance) container_dir = os.path.join(inst_path, 'rootfs') rootfs_dev = instance.system_metadata.get('rootfs_device_name') LOG.debug('Attempting to teardown container at path %(dir)s with ' 'root device: %(rootfs_dev)s', {'dir': container_dir, 'rootfs_dev': rootfs_dev}, instance=instance) disk_api.teardown_container(container_dir, rootfs_dev) def _destroy(self, instance, attempt=1): try: guest = self._host.get_guest(instance) if CONF.serial_console.enabled: # This method is called for several events: destroy, # rebuild, hard-reboot, power-off - For all of these # events we want to release the serial ports acquired # for the guest before destroying it. serials = self._get_serial_ports_from_guest(guest) for hostname, port in serials: serial_console.release_port(host=hostname, port=port) except exception.InstanceNotFound: guest = None # If the instance is already terminated, we're still happy # Otherwise, destroy it old_domid = -1 if guest is not None: try: old_domid = guest.id guest.poweroff() except libvirt.libvirtError as e: is_okay = False errcode = e.get_error_code() if errcode == libvirt.VIR_ERR_NO_DOMAIN: # Domain already gone. This can safely be ignored. is_okay = True elif errcode == libvirt.VIR_ERR_OPERATION_INVALID: # If the instance is already shut off, we get this: # Code=55 Error=Requested operation is not valid: # domain is not running state = guest.get_power_state(self._host) if state == power_state.SHUTDOWN: is_okay = True elif errcode == libvirt.VIR_ERR_INTERNAL_ERROR: errmsg = e.get_error_message() if (CONF.libvirt.virt_type == 'lxc' and errmsg == 'internal error: ' 'Some processes refused to die'): # Some processes in the container didn't die # fast enough for libvirt. The container will # eventually die. For now, move on and let # the wait_for_destroy logic take over. is_okay = True elif errcode == libvirt.VIR_ERR_OPERATION_TIMEOUT: LOG.warning("Cannot destroy instance, operation time out", instance=instance) reason = _("operation time out") raise exception.InstancePowerOffFailure(reason=reason) elif errcode == libvirt.VIR_ERR_SYSTEM_ERROR: if e.get_int1() == errno.EBUSY: # NOTE(danpb): When libvirt kills a process it sends it # SIGTERM first and waits 10 seconds. If it hasn't gone # it sends SIGKILL and waits another 5 seconds. If it # still hasn't gone then you get this EBUSY error. # Usually when a QEMU process fails to go away upon # SIGKILL it is because it is stuck in an # uninterruptible kernel sleep waiting on I/O from # some non-responsive server. # Given the CPU load of the gate tests though, it is # conceivable that the 15 second timeout is too short, # particularly if the VM running tempest has a high # steal time from the cloud host. ie 15 wallclock # seconds may have passed, but the VM might have only # have a few seconds of scheduled run time. # # TODO(kchamart): Once MIN_LIBVIRT_VERSION # reaches v4.7.0, (a) rewrite the above note, # and (b) remove the following code that retries # _destroy() API call (which gives SIGKILL 30 # seconds to take effect) -- because from v4.7.0 # onwards, libvirt _automatically_ increases the # timeout to 30 seconds. This was added in the # following libvirt commits: # # - 9a4e4b942 (process: wait longer 5->30s on # hard shutdown) # # - be2ca0444 (process: wait longer on kill # per assigned Hostdev) with excutils.save_and_reraise_exception() as ctxt: if not self._host.has_min_version( MIN_LIBVIRT_BETTER_SIGKILL_HANDLING): LOG.warning('Error from libvirt during ' 'destroy. Code=%(errcode)s ' 'Error=%(e)s; attempt ' '%(attempt)d of 6 ', {'errcode': errcode, 'e': e, 'attempt': attempt}, instance=instance) # Try up to 6 times before giving up. if attempt < 6: ctxt.reraise = False self._destroy(instance, attempt + 1) return if not is_okay: with excutils.save_and_reraise_exception(): LOG.error('Error from libvirt during destroy. ' 'Code=%(errcode)s Error=%(e)s', {'errcode': errcode, 'e': e}, instance=instance) def _wait_for_destroy(expected_domid): """Called at an interval until the VM is gone.""" # NOTE(vish): If the instance disappears during the destroy # we ignore it so the cleanup can still be # attempted because we would prefer destroy to # never fail. try: dom_info = self.get_info(instance) state = dom_info.state new_domid = dom_info.internal_id except exception.InstanceNotFound: LOG.debug("During wait destroy, instance disappeared.", instance=instance) state = power_state.SHUTDOWN if state == power_state.SHUTDOWN: LOG.info("Instance destroyed successfully.", instance=instance) raise loopingcall.LoopingCallDone() # NOTE(wangpan): If the instance was booted again after destroy, # this may be an endless loop, so check the id of # domain here, if it changed and the instance is # still running, we should destroy it again. # see https://bugs.launchpad.net/nova/+bug/1111213 for more details if new_domid != expected_domid: LOG.info("Instance may be started again.", instance=instance) kwargs['is_running'] = True raise loopingcall.LoopingCallDone() kwargs = {'is_running': False} timer = loopingcall.FixedIntervalLoopingCall(_wait_for_destroy, old_domid) timer.start(interval=0.5).wait() if kwargs['is_running']: LOG.info("Going to destroy instance again.", instance=instance) self._destroy(instance) else: # NOTE(GuanQiang): teardown container to avoid resource leak if CONF.libvirt.virt_type == 'lxc': self._teardown_container(instance) def destroy(self, context, instance, network_info, block_device_info=None, destroy_disks=True): self._destroy(instance) self.cleanup(context, instance, network_info, block_device_info, destroy_disks) def _undefine_domain(self, instance): try: guest = self._host.get_guest(instance) try: hw_firmware_type = instance.image_meta.properties.get( 'hw_firmware_type') support_uefi = self._check_uefi_support(hw_firmware_type) guest.delete_configuration(support_uefi) except libvirt.libvirtError as e: with excutils.save_and_reraise_exception() as ctxt: errcode = e.get_error_code() if errcode == libvirt.VIR_ERR_NO_DOMAIN: LOG.debug("Called undefine, but domain already gone.", instance=instance) ctxt.reraise = False else: LOG.error('Error from libvirt during undefine. ' 'Code=%(errcode)s Error=%(e)s', {'errcode': errcode, 'e': encodeutils.exception_to_unicode(e)}, instance=instance) except exception.InstanceNotFound: pass def cleanup(self, context, instance, network_info, block_device_info=None, destroy_disks=True, migrate_data=None, destroy_vifs=True): """Cleanup the instance from the host. Identify if the instance disks and instance path should be removed from the host before calling down into the _cleanup method for the actual removal of resources from the host. :param context: security context :param instance: instance object for the instance being cleaned up :param network_info: instance network information :param block_device_info: optional instance block device information :param destroy_disks: if local ephemeral disks should be destroyed :param migrate_data: optional migrate_data object :param destroy_vifs: if plugged vifs should be unplugged """ cleanup_instance_dir = False cleanup_instance_disks = False # We assume destroy_disks means destroy instance directory and disks if destroy_disks: cleanup_instance_dir = True cleanup_instance_disks = True else: # NOTE(mdbooth): I think the theory here was that if this is a # migration with shared block storage then we need to delete the # instance directory because that's not shared. I'm pretty sure # this is wrong. if migrate_data and 'is_shared_block_storage' in migrate_data: cleanup_instance_dir = migrate_data.is_shared_block_storage # NOTE(lyarwood): The following workaround allows operators to # ensure that non-shared instance directories are removed after an # evacuation or revert resize when using the shared RBD # imagebackend. This workaround is not required when cleaning up # migrations that provide migrate_data to this method as the # existing is_shared_block_storage conditional will cause the # instance directory to be removed. if not cleanup_instance_dir: if CONF.workarounds.ensure_libvirt_rbd_instance_dir_cleanup: cleanup_instance_dir = CONF.libvirt.images_type == 'rbd' return self._cleanup( context, instance, network_info, block_device_info=block_device_info, destroy_vifs=destroy_vifs, cleanup_instance_dir=cleanup_instance_dir, cleanup_instance_disks=cleanup_instance_disks) def _cleanup(self, context, instance, network_info, block_device_info=None, destroy_vifs=True, cleanup_instance_dir=False, cleanup_instance_disks=False): """Cleanup the domain and any attached resources from the host. This method cleans up any pmem devices, unplugs VIFs, disconnects attached volumes and undefines the instance domain within libvirt. It also optionally removes the ephemeral disks and the instance directory from the host depending on the cleanup_instance_dir|disks kwargs provided. :param context: security context :param instance: instance object for the instance being cleaned up :param network_info: instance network information :param block_device_info: optional instance block device information :param destroy_vifs: if plugged vifs should be unplugged :param cleanup_instance_dir: If the instance dir should be removed :param cleanup_instance_disks: If the instance disks should be removed """ # zero the data on backend pmem device vpmems = self._get_vpmems(instance) if vpmems: self._cleanup_vpmems(vpmems) if destroy_vifs: self._unplug_vifs(instance, network_info, True) # FIXME(wangpan): if the instance is booted again here, such as the # soft reboot operation boot it here, it will become # "running deleted", should we check and destroy it # at the end of this method? # NOTE(vish): we disconnect from volumes regardless block_device_mapping = driver.block_device_info_get_mapping( block_device_info) for vol in block_device_mapping: connection_info = vol['connection_info'] if not connection_info: # if booting from a volume, creation could have failed meaning # this would be unset continue disk_dev = vol['mount_device'] if disk_dev is not None: disk_dev = disk_dev.rpartition("/")[2] try: self._disconnect_volume(context, connection_info, instance) except Exception as exc: with excutils.save_and_reraise_exception() as ctxt: if cleanup_instance_disks: # Don't block on Volume errors if we're trying to # delete the instance as we may be partially created # or deleted ctxt.reraise = False LOG.warning( "Ignoring Volume Error on vol %(vol_id)s " "during delete %(exc)s", {'vol_id': vol.get('volume_id'), 'exc': encodeutils.exception_to_unicode(exc)}, instance=instance) if cleanup_instance_disks: # NOTE(haomai): destroy volumes if needed if CONF.libvirt.images_type == 'lvm': self._cleanup_lvm(instance, block_device_info) if CONF.libvirt.images_type == 'rbd': self._cleanup_rbd(instance) if cleanup_instance_dir: attempts = int(instance.system_metadata.get('clean_attempts', '0')) success = self.delete_instance_files(instance) # NOTE(mriedem): This is used in the _run_pending_deletes periodic # task in the compute manager. The tight coupling is not great... instance.system_metadata['clean_attempts'] = str(attempts + 1) if success: instance.cleaned = True instance.save() if cleanup_instance_disks: crypto.delete_vtpm_secret(context, instance) self._undefine_domain(instance) def cleanup_lingering_instance_resources(self, instance): # zero the data on backend pmem device, if fails # it will raise an exception vpmems = self._get_vpmems(instance) if vpmems: self._cleanup_vpmems(vpmems) def _cleanup_vpmems(self, vpmems): for vpmem in vpmems: try: nova.privsep.libvirt.cleanup_vpmem(vpmem.devpath) except Exception as e: raise exception.VPMEMCleanupFailed(dev=vpmem.devpath, error=e) def _get_serial_ports_from_guest(self, guest, mode=None): """Returns an iterator over serial port(s) configured on guest. :param mode: Should be a value in (None, bind, connect) """ xml = guest.get_xml_desc() tree = etree.fromstring(xml) # The 'serial' device is the base for x86 platforms. Other platforms # (e.g. kvm on system z = S390X) can only use 'console' devices. xpath_mode = "[@mode='%s']" % mode if mode else "" serial_tcp = "./devices/serial[@type='tcp']/source" + xpath_mode console_tcp = "./devices/console[@type='tcp']/source" + xpath_mode tcp_devices = tree.findall(serial_tcp) if len(tcp_devices) == 0: tcp_devices = tree.findall(console_tcp) for source in tcp_devices: yield (source.get("host"), int(source.get("service"))) def _get_scsi_controller_next_unit(self, guest): """Returns the max disk unit used by scsi controller""" xml = guest.get_xml_desc() tree = etree.fromstring(xml) addrs = "./devices/disk[target/@bus='scsi']/address[@type='drive']" ret = [] for obj in tree.xpath(addrs): ret.append(int(obj.get('unit', 0))) return max(ret) + 1 if ret else 0 def _cleanup_rbd(self, instance): # NOTE(nic): On revert_resize, the cleanup steps for the root # volume are handled with an "rbd snap rollback" command, # and none of this is needed (and is, in fact, harmful) so # filter out non-ephemerals from the list if instance.task_state == task_states.RESIZE_REVERTING: filter_fn = lambda disk: (disk.startswith(instance.uuid) and disk.endswith('disk.local')) else: filter_fn = lambda disk: disk.startswith(instance.uuid) rbd_utils.RBDDriver().cleanup_volumes(filter_fn) def _cleanup_lvm(self, instance, block_device_info): """Delete all LVM disks for given instance object.""" if instance.get('ephemeral_key_uuid') is not None: # detach encrypted volumes disks = self._get_instance_disk_info(instance, block_device_info) for disk in disks: if dmcrypt.is_encrypted(disk['path']): dmcrypt.delete_volume(disk['path']) disks = self._lvm_disks(instance) if disks: lvm.remove_volumes(disks) def _lvm_disks(self, instance): """Returns all LVM disks for given instance object.""" if CONF.libvirt.images_volume_group: vg = os.path.join('/dev', CONF.libvirt.images_volume_group) if not os.path.exists(vg): return [] pattern = '%s_' % instance.uuid def belongs_to_instance(disk): return disk.startswith(pattern) def fullpath(name): return os.path.join(vg, name) logical_volumes = lvm.list_volumes(vg) disks = [fullpath(disk) for disk in logical_volumes if belongs_to_instance(disk)] return disks return [] def get_volume_connector(self, instance): root_helper = utils.get_root_helper() return connector.get_connector_properties( root_helper, CONF.my_block_storage_ip, CONF.libvirt.volume_use_multipath, enforce_multipath=True, host=CONF.host) def _cleanup_resize_vtpm( self, context: nova_context.RequestContext, instance: 'objects.Instance', ) -> None: """Handle vTPM when confirming a migration or resize. If the old flavor have vTPM and the new one doesn't, there are keys to be deleted. """ old_vtpm_config = hardware.get_vtpm_constraint( instance.old_flavor, instance.image_meta) new_vtpm_config = hardware.get_vtpm_constraint( instance.new_flavor, instance.image_meta) if old_vtpm_config and not new_vtpm_config: # the instance no longer cares for its vTPM so delete the related # secret; the deletion of the instance directory and undefining of # the domain will take care of the TPM files themselves LOG.info('New flavor no longer requests vTPM; deleting secret.') crypto.delete_vtpm_secret(context, instance) # TODO(stephenfin): Fold this back into its only caller, cleanup_resize def _cleanup_resize(self, context, instance, network_info): inst_base = libvirt_utils.get_instance_path(instance) target = inst_base + '_resize' # zero the data on backend old pmem device vpmems = self._get_vpmems(instance, prefix='old') if vpmems: self._cleanup_vpmems(vpmems) # Remove any old vTPM data, if necessary self._cleanup_resize_vtpm(context, instance) # Deletion can fail over NFS, so retry the deletion as required. # Set maximum attempt as 5, most test can remove the directory # for the second time. attempts = 0 while(os.path.exists(target) and attempts < 5): shutil.rmtree(target, ignore_errors=True) if os.path.exists(target): time.sleep(random.randint(20, 200) / 100.0) attempts += 1 # NOTE(mriedem): Some image backends will recreate the instance path # and disk.info during init, and all we need the root disk for # here is removing cloned snapshots which is backend-specific, so # check that first before initializing the image backend object. If # there is ever an image type that supports clone *and* re-creates # the instance directory and disk.info on init, this condition will # need to be re-visited to make sure that backend doesn't re-create # the disk. Refer to bugs: 1666831 1728603 1769131 if self.image_backend.backend(CONF.libvirt.images_type).SUPPORTS_CLONE: root_disk = self.image_backend.by_name(instance, 'disk') if root_disk.exists(): root_disk.remove_snap(libvirt_utils.RESIZE_SNAPSHOT_NAME) if instance.host != CONF.host: self._undefine_domain(instance) self.unplug_vifs(instance, network_info) def _get_volume_driver(self, connection_info): driver_type = connection_info.get('driver_volume_type') if driver_type not in self.volume_drivers: raise exception.VolumeDriverNotFound(driver_type=driver_type) return self.volume_drivers[driver_type] def _connect_volume(self, context, connection_info, instance, encryption=None): vol_driver = self._get_volume_driver(connection_info) vol_driver.connect_volume(connection_info, instance) try: self._attach_encryptor(context, connection_info, encryption) except Exception: # Encryption failed so rollback the volume connection. with excutils.save_and_reraise_exception(logger=LOG): LOG.exception("Failure attaching encryptor; rolling back " "volume connection", instance=instance) vol_driver.disconnect_volume(connection_info, instance) def _should_disconnect_target(self, context, instance, multiattach, vol_driver, volume_id): # NOTE(jdg): Multiattach is a special case (not to be confused # with shared_targets). With multiattach we may have a single volume # attached multiple times to *this* compute node (ie Server-1 and # Server-2). So, if we receive a call to delete the attachment for # Server-1 we need to take special care to make sure that the Volume # isn't also attached to another Server on this Node. Otherwise we # will indiscriminantly delete the connection for all Server and that's # no good. So check if it's attached multiple times on this node # if it is we skip the call to brick to delete the connection. if not multiattach: return True # NOTE(deiter): Volume drivers using _HostMountStateManager are another # special case. _HostMountStateManager ensures that the compute node # only attempts to mount a single mountpoint in use by multiple # attachments once, and that it is not unmounted until it is no longer # in use by any attachments. So we can skip the multiattach check for # volume drivers that based on LibvirtMountedFileSystemVolumeDriver. if isinstance(vol_driver, fs.LibvirtMountedFileSystemVolumeDriver): return True connection_count = 0 volume = self._volume_api.get(context, volume_id) attachments = volume.get('attachments', {}) if len(attachments) > 1: # First we get a list of all Server UUID's associated with # this Host (Compute Node). We're going to use this to # determine if the Volume being detached is also in-use by # another Server on this Host, ie just check to see if more # than one attachment.server_id for this volume is in our # list of Server UUID's for this Host servers_this_host = objects.InstanceList.get_uuids_by_host( context, instance.host) # NOTE(jdg): nova.volume.cinder translates the # volume['attachments'] response into a dict which includes # the Server UUID as the key, so we're using that # here to check against our server_this_host list for server_id, data in attachments.items(): if server_id in servers_this_host: connection_count += 1 return (False if connection_count > 1 else True) def _disconnect_volume(self, context, connection_info, instance, encryption=None): self._detach_encryptor(context, connection_info, encryption=encryption) vol_driver = self._get_volume_driver(connection_info) volume_id = driver_block_device.get_volume_id(connection_info) multiattach = connection_info.get('multiattach', False) if self._should_disconnect_target( context, instance, multiattach, vol_driver, volume_id): vol_driver.disconnect_volume(connection_info, instance) else: LOG.info('Detected multiple connections on this host for ' 'volume: %(volume)s, skipping target disconnect.', {'volume': volume_id}) def _extend_volume(self, connection_info, instance, requested_size): vol_driver = self._get_volume_driver(connection_info) return vol_driver.extend_volume(connection_info, instance, requested_size) def _allow_native_luksv1(self, encryption=None): """Check if QEMU's native LUKSv1 decryption should be used. """ # NOTE(lyarwood): Native LUKSv1 decryption can be disabled via a # workarounds configurable in order to aviod known performance issues # with the libgcrypt lib. if CONF.workarounds.disable_native_luksv1: return False # NOTE(lyarwood): Ensure the LUKSv1 provider is used. provider = None if encryption: provider = encryption.get('provider', None) if provider in encryptors.LEGACY_PROVIDER_CLASS_TO_FORMAT_MAP: provider = encryptors.LEGACY_PROVIDER_CLASS_TO_FORMAT_MAP[provider] return provider == encryptors.LUKS def _get_volume_config(self, connection_info, disk_info): vol_driver = self._get_volume_driver(connection_info) conf = vol_driver.get_config(connection_info, disk_info) self._set_cache_mode(conf) return conf def _get_volume_encryptor(self, connection_info, encryption): root_helper = utils.get_root_helper() return encryptors.get_volume_encryptor(root_helper=root_helper, keymgr=key_manager.API(CONF), connection_info=connection_info, **encryption) def _get_volume_encryption(self, context, connection_info): """Get the encryption metadata dict if it is not provided """ encryption = {} volume_id = driver_block_device.get_volume_id(connection_info) if volume_id: encryption = encryptors.get_encryption_metadata(context, self._volume_api, volume_id, connection_info) return encryption def _attach_encryptor(self, context, connection_info, encryption): """Attach the frontend encryptor if one is required by the volume. The request context is only used when an encryption metadata dict is not provided. The encryption metadata dict being populated is then used to determine if an attempt to attach the encryptor should be made. """ # NOTE(lyarwood): Skip any attempt to fetch encryption metadata or the # actual passphrase from the key manager if a libvirt secert already # exists locally for the volume. This suggests that the instance was # only powered off or the underlying host rebooted. volume_id = driver_block_device.get_volume_id(connection_info) if self._host.find_secret('volume', volume_id): LOG.debug("A libvirt secret for volume %s has been found on the " "host, skipping any attempt to create another or attach " "an os-brick encryptor.", volume_id) return if encryption is None: encryption = self._get_volume_encryption(context, connection_info) if encryption and self._allow_native_luksv1(encryption=encryption): # NOTE(lyarwood): Fetch the associated key for the volume and # decode the passphrase from the key. # FIXME(lyarwood): c-vol currently creates symmetric keys for use # with volumes, leading to the binary to hex to string conversion # below. keymgr = key_manager.API(CONF) key = keymgr.get(context, encryption['encryption_key_id']) key_encoded = key.get_encoded() passphrase = binascii.hexlify(key_encoded).decode('utf-8') # NOTE(lyarwood): Retain the behaviour of the original os-brick # encryptors and format any volume that does not identify as # encrypted with LUKS. # FIXME(lyarwood): Remove this once c-vol correctly formats # encrypted volumes during their initial creation: # https://bugs.launchpad.net/cinder/+bug/1739442 device_path = connection_info.get('data').get('device_path') if device_path: root_helper = utils.get_root_helper() if not luks_encryptor.is_luks(root_helper, device_path): encryptor = self._get_volume_encryptor(connection_info, encryption) encryptor._format_volume(passphrase, **encryption) # NOTE(lyarwood): Store the passphrase as a libvirt secret locally # on the compute node. This secret is used later when generating # the volume config. self._host.create_secret('volume', volume_id, password=passphrase) elif encryption: encryptor = self._get_volume_encryptor(connection_info, encryption) encryptor.attach_volume(context, **encryption) def _detach_encryptor(self, context, connection_info, encryption): """Detach the frontend encryptor if one is required by the volume. The request context is only used when an encryption metadata dict is not provided. The encryption metadata dict being populated is then used to determine if an attempt to detach the encryptor should be made. If native LUKS decryption is enabled then delete previously created Libvirt volume secret from the host. """ volume_id = driver_block_device.get_volume_id(connection_info) if volume_id and self._host.find_secret('volume', volume_id): return self._host.delete_secret('volume', volume_id) if encryption is None: encryption = self._get_volume_encryption(context, connection_info) # NOTE(lyarwood): Handle bug #1821696 where volume secrets have been # removed manually by returning if a LUKS provider is being used # and device_path is not present in the connection_info. This avoids # VolumeEncryptionNotSupported being thrown when we incorrectly build # the encryptor below due to the secrets not being present above. if (encryption and self._allow_native_luksv1(encryption=encryption) and not connection_info['data'].get('device_path')): return if encryption: encryptor = self._get_volume_encryptor(connection_info, encryption) encryptor.detach_volume(**encryption) def _check_discard_for_attach_volume(self, conf, instance): """Perform some checks for volumes configured for discard support. If discard is configured for the volume, and the guest is using a configuration known to not work, we will log a message explaining the reason why. """ if conf.driver_discard == 'unmap' and conf.target_bus == 'virtio': LOG.debug('Attempting to attach volume %(id)s with discard ' 'support enabled to an instance using an ' 'unsupported configuration. target_bus = ' '%(bus)s. Trim commands will not be issued to ' 'the storage device.', {'bus': conf.target_bus, 'id': conf.serial}, instance=instance) def attach_volume(self, context, connection_info, instance, mountpoint, disk_bus=None, device_type=None, encryption=None): guest = self._host.get_guest(instance) disk_dev = mountpoint.rpartition("/")[2] bdm = { 'device_name': disk_dev, 'disk_bus': disk_bus, 'device_type': device_type} # Note(cfb): If the volume has a custom block size, check that # that we are using QEMU/KVM and libvirt >= 0.10.2. The # presence of a block size is considered mandatory by # cinder so we fail if we can't honor the request. data = {} if ('data' in connection_info): data = connection_info['data'] if ('logical_block_size' in data or 'physical_block_size' in data): if ((CONF.libvirt.virt_type != "kvm" and CONF.libvirt.virt_type != "qemu")): msg = _("Volume sets block size, but the current " "libvirt hypervisor '%s' does not support custom " "block size") % CONF.libvirt.virt_type raise exception.InvalidHypervisorType(msg) self._connect_volume(context, connection_info, instance, encryption=encryption) disk_info = blockinfo.get_info_from_bdm( instance, CONF.libvirt.virt_type, instance.image_meta, bdm) if disk_info['bus'] == 'scsi': disk_info['unit'] = self._get_scsi_controller_next_unit(guest) conf = self._get_volume_config(connection_info, disk_info) self._check_discard_for_attach_volume(conf, instance) try: state = guest.get_power_state(self._host) live = state in (power_state.RUNNING, power_state.PAUSED) guest.attach_device(conf, persistent=True, live=live) # NOTE(artom) If we're attaching with a device role tag, we need to # rebuild device_metadata. If we're attaching without a role # tag, we're rebuilding it here needlessly anyways. This isn't a # massive deal, and it helps reduce code complexity by not having # to indicate to the virt driver that the attach is tagged. The # really important optimization of not calling the database unless # device_metadata has actually changed is done for us by # instance.save(). instance.device_metadata = self._build_device_metadata( context, instance) instance.save() except Exception: LOG.exception('Failed to attach volume at mountpoint: %s', mountpoint, instance=instance) with excutils.save_and_reraise_exception(): self._disconnect_volume(context, connection_info, instance, encryption=encryption) def _swap_volume(self, guest, disk_dev, conf, resize_to, hw_firmware_type): """Swap existing disk with a new block device. Call virDomainBlockRebase or virDomainBlockCopy with Libvirt >= 6.0.0 to copy and then pivot to a new volume. :param: guest: Guest object representing the guest domain :param: disk_dev: Device within the domain that is being swapped :param: conf: LibvirtConfigGuestDisk object representing the new volume :param: resize_to: Size of the dst volume, 0 if the same as the src :param: hw_firmware_type: fields.FirmwareType if set in the imagemeta """ dev = guest.get_block_device(disk_dev) # Save a copy of the domain's persistent XML file. We'll use this # to redefine the domain if anything fails during the volume swap. xml = guest.get_xml_desc(dump_inactive=True, dump_sensitive=True) # Abort is an idempotent operation, so make sure any block # jobs which may have failed are ended. try: dev.abort_job() except Exception: pass try: # NOTE (rmk): virDomainBlockRebase and virDomainBlockCopy cannot be # executed on persistent domains, so we need to temporarily # undefine it. If any part of this block fails, the domain is # re-defined regardless. if guest.has_persistent_configuration(): support_uefi = self._check_uefi_support(hw_firmware_type) guest.delete_configuration(support_uefi) try: # NOTE(lyarwood): Use virDomainBlockCopy from libvirt >= 6.0.0 # and QEMU >= 4.2.0 with -blockdev domains allowing QEMU to # copy to remote disks. if self._host.has_min_version(lv_ver=MIN_LIBVIRT_BLOCKDEV, hv_ver=MIN_QEMU_BLOCKDEV): dev.copy(conf.to_xml(), reuse_ext=True) else: # TODO(lyarwood): Remove the following use of # virDomainBlockRebase once MIN_LIBVIRT_VERSION hits >= # 6.0.0 and MIN_QEMU_VERSION hits >= 4.2.0. # Start copy with VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT flag to # allow writing to existing external volume file. Use # VIR_DOMAIN_BLOCK_REBASE_COPY_DEV if it's a block device # to make sure XML is generated correctly (bug 1691195) copy_dev = conf.source_type == 'block' dev.rebase(conf.source_path, copy=True, reuse_ext=True, copy_dev=copy_dev) while not dev.is_job_complete(): time.sleep(0.5) dev.abort_job(pivot=True) except Exception as exc: # NOTE(lyarwood): conf.source_path is not set for RBD disks so # fallback to conf.target_dev when None. new_path = conf.source_path or conf.target_dev old_path = disk_dev LOG.exception("Failure rebasing volume %(new_path)s on " "%(old_path)s.", {'new_path': new_path, 'old_path': old_path}) raise exception.VolumeRebaseFailed(reason=six.text_type(exc)) if resize_to: dev.resize(resize_to * units.Gi) # Make sure we will redefine the domain using the updated # configuration after the volume was swapped. The dump_inactive # keyword arg controls whether we pull the inactive (persistent) # or active (live) config from the domain. We want to pull the # live config after the volume was updated to use when we redefine # the domain. xml = guest.get_xml_desc(dump_inactive=False, dump_sensitive=True) finally: self._host.write_instance_config(xml) def swap_volume(self, context, old_connection_info, new_connection_info, instance, mountpoint, resize_to): # NOTE(lyarwood): https://bugzilla.redhat.com/show_bug.cgi?id=760547 old_encrypt = self._get_volume_encryption(context, old_connection_info) new_encrypt = self._get_volume_encryption(context, new_connection_info) if ((old_encrypt and self._allow_native_luksv1(old_encrypt)) or (new_encrypt and self._allow_native_luksv1(new_encrypt))): raise NotImplementedError(_("Swap volume is not supported for " "encrypted volumes when native LUKS decryption is enabled.")) guest = self._host.get_guest(instance) disk_dev = mountpoint.rpartition("/")[2] if not guest.get_disk(disk_dev): raise exception.DiskNotFound(location=disk_dev) disk_info = { 'dev': disk_dev, 'bus': blockinfo.get_disk_bus_for_disk_dev( CONF.libvirt.virt_type, disk_dev), 'type': 'disk', } # NOTE (lyarwood): new_connection_info will be modified by the # following _connect_volume call down into the volume drivers. The # majority of the volume drivers will add a device_path that is in turn # used by _get_volume_config to set the source_path of the # LibvirtConfigGuestDisk object it returns. We do not explicitly save # this to the BDM here as the upper compute swap_volume method will # eventually do this for us. self._connect_volume(context, new_connection_info, instance) conf = self._get_volume_config(new_connection_info, disk_info) if (not conf.source_path and not self._host.has_min_version(lv_ver=MIN_LIBVIRT_BLOCKDEV, hv_ver=MIN_QEMU_BLOCKDEV)): self._disconnect_volume(context, new_connection_info, instance) raise NotImplementedError(_("Swap only supports host devices and " "files with Libvirt < 6.0.0 or QEMU " "< 4.2.0")) hw_firmware_type = instance.image_meta.properties.get( 'hw_firmware_type') try: self._swap_volume(guest, disk_dev, conf, resize_to, hw_firmware_type) except exception.VolumeRebaseFailed: with excutils.save_and_reraise_exception(): self._disconnect_volume(context, new_connection_info, instance) self._disconnect_volume(context, old_connection_info, instance) def _get_existing_domain_xml(self, instance, network_info, block_device_info=None): try: guest = self._host.get_guest(instance) xml = guest.get_xml_desc() except exception.InstanceNotFound: disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type, instance, instance.image_meta, block_device_info) xml = self._get_guest_xml(nova_context.get_admin_context(), instance, network_info, disk_info, instance.image_meta, block_device_info=block_device_info) return xml def detach_volume(self, context, connection_info, instance, mountpoint, encryption=None): disk_dev = mountpoint.rpartition("/")[2] try: guest = self._host.get_guest(instance) state = guest.get_power_state(self._host) live = state in (power_state.RUNNING, power_state.PAUSED) # NOTE(lyarwood): The volume must be detached from the VM before # detaching any attached encryptors or disconnecting the underlying # volume in _disconnect_volume. Otherwise, the encryptor or volume # driver may report that the volume is still in use. supports_device_missing = self._host.has_min_version( MIN_LIBVIRT_VIR_ERR_DEVICE_MISSING) wait_for_detach = guest.detach_device_with_retry( guest.get_disk, disk_dev, live=live, supports_device_missing_error_code=supports_device_missing) wait_for_detach() except exception.InstanceNotFound: # NOTE(zhaoqin): If the instance does not exist, _lookup_by_name() # will throw InstanceNotFound exception. Need to # disconnect volume under this circumstance. LOG.warning("During detach_volume, instance disappeared.", instance=instance) except exception.DeviceNotFound: # We should still try to disconnect logical device from # host, an error might have happened during a previous # call. LOG.info("Device %s not found in instance.", disk_dev, instance=instance) except libvirt.libvirtError as ex: # NOTE(vish): This is called to cleanup volumes after live # migration, so we should still disconnect even if # the instance doesn't exist here anymore. error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_NO_DOMAIN: # NOTE(vish): LOG.warning("During detach_volume, instance disappeared.", instance=instance) else: raise self._disconnect_volume(context, connection_info, instance, encryption=encryption) def _resize_attached_volume(self, new_size, block_device, instance): LOG.debug('Resizing target device %(dev)s to %(size)u', {'dev': block_device._disk, 'size': new_size}, instance=instance) block_device.resize(new_size) def _resize_attached_encrypted_volume(self, original_new_size, block_device, instance, connection_info, encryption): # TODO(lyarwood): Also handle the dm-crpyt encryption providers of # plain and LUKSv2, for now just use the original_new_size. decrypted_device_new_size = original_new_size # NOTE(lyarwood): original_new_size currently refers to the total size # of the extended volume in bytes. With natively decrypted LUKSv1 # volumes we need to ensure this now takes the LUKSv1 header and key # material into account. Otherwise QEMU will attempt and fail to grow # host block devices and remote RBD volumes. if self._allow_native_luksv1(encryption): try: # NOTE(lyarwood): Find the path to provide to qemu-img if 'device_path' in connection_info['data']: path = connection_info['data']['device_path'] elif connection_info['driver_volume_type'] == 'rbd': volume_name = connection_info['data']['name'] path = f"rbd:{volume_name}" if connection_info['data'].get('auth_enabled'): username = connection_info['data']['auth_username'] path = f"rbd:{volume_name}:id={username}" else: path = 'unknown' raise exception.DiskNotFound(location='unknown') info = images.privileged_qemu_img_info(path) format_specific_data = info.format_specific['data'] payload_offset = format_specific_data['payload-offset'] # NOTE(lyarwood): Ensure the underlying device is not resized # by subtracting the LUKSv1 payload_offset (where the users # encrypted data starts) from the original_new_size (the total # size of the underlying volume). Both are reported in bytes. decrypted_device_new_size = original_new_size - payload_offset except exception.DiskNotFound: with excutils.save_and_reraise_exception(): LOG.exception('Unable to access the encrypted disk %s.', path, instance=instance) except Exception: with excutils.save_and_reraise_exception(): LOG.exception('Unknown error when attempting to find the ' 'payload_offset for LUKSv1 encrypted disk ' '%s.', path, instance=instance) # NOTE(lyarwood): Resize the decrypted device within the instance to # the calculated size as with normal volumes. self._resize_attached_volume( decrypted_device_new_size, block_device, instance) def extend_volume(self, context, connection_info, instance, requested_size): try: new_size = self._extend_volume(connection_info, instance, requested_size) except NotImplementedError: raise exception.ExtendVolumeNotSupported() # Resize the device in QEMU so its size is updated and # detected by the instance without rebooting. try: guest = self._host.get_guest(instance) state = guest.get_power_state(self._host) volume_id = driver_block_device.get_volume_id(connection_info) active_state = state in (power_state.RUNNING, power_state.PAUSED) if active_state: if 'device_path' in connection_info['data']: disk_path = connection_info['data']['device_path'] else: # Some drivers (eg. net) don't put the device_path # into the connection_info. Match disks by their serial # number instead disk = next(iter([ d for d in guest.get_all_disks() if d.serial == volume_id ]), None) if not disk: raise exception.VolumeNotFound(volume_id=volume_id) disk_path = disk.target_dev dev = guest.get_block_device(disk_path) encryption = encryptors.get_encryption_metadata( context, self._volume_api, volume_id, connection_info) if encryption: self._resize_attached_encrypted_volume( new_size, dev, instance, connection_info, encryption) else: self._resize_attached_volume( new_size, dev, instance) else: LOG.debug('Skipping block device resize, guest is not running', instance=instance) except exception.InstanceNotFound: with excutils.save_and_reraise_exception(): LOG.warning('During extend_volume, instance disappeared.', instance=instance) except libvirt.libvirtError: with excutils.save_and_reraise_exception(): LOG.exception('resizing block device failed.', instance=instance) def attach_interface(self, context, instance, image_meta, vif): guest = self._host.get_guest(instance) self.vif_driver.plug(instance, vif) cfg = self.vif_driver.get_config(instance, vif, image_meta, instance.flavor, CONF.libvirt.virt_type) try: state = guest.get_power_state(self._host) live = state in (power_state.RUNNING, power_state.PAUSED) guest.attach_device(cfg, persistent=True, live=live) except libvirt.libvirtError: LOG.error('attaching network adapter failed.', instance=instance, exc_info=True) self.vif_driver.unplug(instance, vif) raise exception.InterfaceAttachFailed( instance_uuid=instance.uuid) try: # NOTE(artom) If we're attaching with a device role tag, we need to # rebuild device_metadata. If we're attaching without a role # tag, we're rebuilding it here needlessly anyways. This isn't a # massive deal, and it helps reduce code complexity by not having # to indicate to the virt driver that the attach is tagged. The # really important optimization of not calling the database unless # device_metadata has actually changed is done for us by # instance.save(). instance.device_metadata = self._build_device_metadata( context, instance) instance.save() except Exception: # NOTE(artom) If we fail here it means the interface attached # successfully but building and/or saving the device metadata # failed. Just unplugging the vif is therefore not enough cleanup, # we need to detach the interface. with excutils.save_and_reraise_exception(reraise=False): LOG.error('Interface attached successfully but building ' 'and/or saving device metadata failed.', instance=instance, exc_info=True) self.detach_interface(context, instance, vif) raise exception.InterfaceAttachFailed( instance_uuid=instance.uuid) def detach_interface(self, context, instance, vif): guest = self._host.get_guest(instance) cfg = self.vif_driver.get_config(instance, vif, instance.image_meta, instance.flavor, CONF.libvirt.virt_type) interface = guest.get_interface_by_cfg(cfg) try: # NOTE(mriedem): When deleting an instance and using Neutron, # we can be racing against Neutron deleting the port and # sending the vif-deleted event which then triggers a call to # detach the interface, so if the interface is not found then # we can just log it as a warning. if not interface: mac = vif.get('address') # The interface is gone so just log it as a warning. LOG.warning('Detaching interface %(mac)s failed because ' 'the device is no longer found on the guest.', {'mac': mac}, instance=instance) return state = guest.get_power_state(self._host) live = state in (power_state.RUNNING, power_state.PAUSED) # Now we are going to loop until the interface is detached or we # timeout. supports_device_missing = self._host.has_min_version( MIN_LIBVIRT_VIR_ERR_DEVICE_MISSING) wait_for_detach = guest.detach_device_with_retry( guest.get_interface_by_cfg, cfg, live=live, alternative_device_name=self.vif_driver.get_vif_devname(vif), supports_device_missing_error_code=supports_device_missing) wait_for_detach() except exception.DeviceDetachFailed: # We failed to detach the device even with the retry loop, so let's # dump some debug information to the logs before raising back up. with excutils.save_and_reraise_exception(): devname = self.vif_driver.get_vif_devname(vif) interface = guest.get_interface_by_cfg(cfg) if interface: LOG.warning( 'Failed to detach interface %(devname)s after ' 'repeated attempts. Final interface xml:\n' '%(interface_xml)s\nFinal guest xml:\n%(guest_xml)s', {'devname': devname, 'interface_xml': interface.to_xml(), 'guest_xml': guest.get_xml_desc()}, instance=instance) except exception.DeviceNotFound: # The interface is gone so just log it as a warning. LOG.warning('Detaching interface %(mac)s failed because ' 'the device is no longer found on the guest.', {'mac': vif.get('address')}, instance=instance) except libvirt.libvirtError as ex: error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_NO_DOMAIN: LOG.warning("During detach_interface, instance disappeared.", instance=instance) else: # NOTE(mriedem): When deleting an instance and using Neutron, # we can be racing against Neutron deleting the port and # sending the vif-deleted event which then triggers a call to # detach the interface, so we might have failed because the # network device no longer exists. Libvirt will fail with # "operation failed: no matching network device was found" # which unfortunately does not have a unique error code so we # need to look up the interface by config and if it's not found # then we can just log it as a warning rather than tracing an # error. mac = vif.get('address') # Get a fresh instance of the guest in case it is gone. try: guest = self._host.get_guest(instance) except exception.InstanceNotFound: LOG.info("Instance disappeared while detaching interface " "%s", vif['id'], instance=instance) return interface = guest.get_interface_by_cfg(cfg) if interface: LOG.error('detaching network adapter failed.', instance=instance, exc_info=True) raise exception.InterfaceDetachFailed( instance_uuid=instance.uuid) # The interface is gone so just log it as a warning. LOG.warning('Detaching interface %(mac)s failed because ' 'the device is no longer found on the guest.', {'mac': mac}, instance=instance) finally: # NOTE(gibi): we need to unplug the vif _after_ the detach is done # on the libvirt side as otherwise libvirt will still manage the # device that our unplug code trying to reset. This can cause a # race and leave the detached device configured. Also even if we # are failed to detach due to race conditions the unplug is # necessary for the same reason self.vif_driver.unplug(instance, vif) def _create_snapshot_metadata(self, image_meta, instance, img_fmt, snp_name): metadata = {'status': 'active', 'name': snp_name, 'properties': { 'kernel_id': instance.kernel_id, 'image_location': 'snapshot', 'image_state': 'available', 'owner_id': instance.project_id, 'ramdisk_id': instance.ramdisk_id, } } if instance.os_type: metadata['properties']['os_type'] = instance.os_type # NOTE(vish): glance forces ami disk format to be ami if image_meta.disk_format == 'ami': metadata['disk_format'] = 'ami' else: metadata['disk_format'] = img_fmt if image_meta.obj_attr_is_set("container_format"): metadata['container_format'] = image_meta.container_format else: metadata['container_format'] = "bare" return metadata def snapshot(self, context, instance, image_id, update_task_state): """Create snapshot from a running VM instance. This command only works with qemu 0.14+ """ try: guest = self._host.get_guest(instance) except exception.InstanceNotFound: raise exception.InstanceNotRunning(instance_id=instance.uuid) snapshot = self._image_api.get(context, image_id) # source_format is an on-disk format # source_type is a backend type disk_path, source_format = libvirt_utils.find_disk(guest) source_type = libvirt_utils.get_disk_type_from_path(disk_path) # We won't have source_type for raw or qcow2 disks, because we can't # determine that from the path. We should have it from the libvirt # xml, though. if source_type is None: source_type = source_format # For lxc instances we won't have it either from libvirt xml # (because we just gave libvirt the mounted filesystem), or the path, # so source_type is still going to be None. In this case, # root_disk is going to default to CONF.libvirt.images_type # below, which is still safe. image_format = CONF.libvirt.snapshot_image_format or source_type # NOTE(bfilippov): save lvm and rbd as raw if image_format == 'lvm' or image_format == 'rbd': image_format = 'raw' metadata = self._create_snapshot_metadata(instance.image_meta, instance, image_format, snapshot['name']) snapshot_name = uuidutils.generate_uuid(dashed=False) # store current state so we know what to resume back to if we suspend original_power_state = guest.get_power_state(self._host) # NOTE(dgenin): Instances with LVM encrypted ephemeral storage require # cold snapshots. Currently, checking for encryption is # redundant because LVM supports only cold snapshots. # It is necessary in case this situation changes in the # future. if ( self._host.has_min_version(hv_type=host.HV_DRIVER_QEMU) and source_type != 'lvm' and not CONF.ephemeral_storage_encryption.enabled and not CONF.workarounds.disable_libvirt_livesnapshot and # NOTE(stephenfin): Live snapshotting doesn't make sense for # shutdown instances original_power_state != power_state.SHUTDOWN ): live_snapshot = True else: live_snapshot = False self._suspend_guest_for_snapshot( context, live_snapshot, original_power_state, instance) root_disk = self.image_backend.by_libvirt_path( instance, disk_path, image_type=source_type) if live_snapshot: LOG.info("Beginning live snapshot process", instance=instance) else: LOG.info("Beginning cold snapshot process", instance=instance) update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD) update_task_state(task_state=task_states.IMAGE_UPLOADING, expected_state=task_states.IMAGE_PENDING_UPLOAD) try: metadata['location'] = root_disk.direct_snapshot( context, snapshot_name, image_format, image_id, instance.image_ref) self._resume_guest_after_snapshot( context, live_snapshot, original_power_state, instance, guest) self._image_api.update(context, image_id, metadata, purge_props=False) except (NotImplementedError, exception.ImageUnacceptable, exception.Forbidden) as e: if type(e) != NotImplementedError: LOG.warning('Performing standard snapshot because direct ' 'snapshot failed: %(error)s', {'error': encodeutils.exception_to_unicode(e)}) failed_snap = metadata.pop('location', None) if failed_snap: failed_snap = {'url': str(failed_snap)} root_disk.cleanup_direct_snapshot(failed_snap, also_destroy_volume=True, ignore_errors=True) update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD, expected_state=task_states.IMAGE_UPLOADING) # TODO(nic): possibly abstract this out to the root_disk if source_type == 'rbd' and live_snapshot: # Standard snapshot uses qemu-img convert from RBD which is # not safe to run with live_snapshot. live_snapshot = False # Suspend the guest, so this is no longer a live snapshot self._suspend_guest_for_snapshot( context, live_snapshot, original_power_state, instance) snapshot_directory = CONF.libvirt.snapshots_directory fileutils.ensure_tree(snapshot_directory) with utils.tempdir(dir=snapshot_directory) as tmpdir: try: out_path = os.path.join(tmpdir, snapshot_name) if live_snapshot: # NOTE(xqueralt): libvirt needs o+x in the tempdir os.chmod(tmpdir, 0o701) self._live_snapshot(context, instance, guest, disk_path, out_path, source_format, image_format, instance.image_meta) else: root_disk.snapshot_extract(out_path, image_format) LOG.info("Snapshot extracted, beginning image upload", instance=instance) except libvirt.libvirtError as ex: error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_NO_DOMAIN: LOG.info('Instance %(instance_name)s disappeared ' 'while taking snapshot of it: [Error Code ' '%(error_code)s] %(ex)s', {'instance_name': instance.name, 'error_code': error_code, 'ex': ex}, instance=instance) raise exception.InstanceNotFound( instance_id=instance.uuid) else: raise finally: self._resume_guest_after_snapshot( context, live_snapshot, original_power_state, instance, guest) # Upload that image to the image service update_task_state(task_state=task_states.IMAGE_UPLOADING, expected_state=task_states.IMAGE_PENDING_UPLOAD) with libvirt_utils.file_open(out_path, 'rb') as image_file: # execute operation with disk concurrency semaphore with compute_utils.disk_ops_semaphore: self._image_api.update(context, image_id, metadata, image_file) except Exception: with excutils.save_and_reraise_exception(): LOG.exception("Failed to snapshot image") failed_snap = metadata.pop('location', None) if failed_snap: failed_snap = {'url': str(failed_snap)} root_disk.cleanup_direct_snapshot( failed_snap, also_destroy_volume=True, ignore_errors=True) LOG.info("Snapshot image upload complete", instance=instance) def _needs_suspend_resume_for_snapshot( self, live_snapshot: bool, current_power_state: int, ): # NOTE(dkang): managedSave does not work for LXC if CONF.libvirt.virt_type == 'lxc': return False # Live snapshots do not necessitate suspending the domain if live_snapshot: return False # ...and neither does a non-running domain return current_power_state in (power_state.RUNNING, power_state.PAUSED) def _suspend_guest_for_snapshot( self, context: nova_context.RequestContext, live_snapshot: bool, current_power_state: int, instance: 'objects.Instance', ): if self._needs_suspend_resume_for_snapshot( live_snapshot, current_power_state, ): self.suspend(context, instance) def _resume_guest_after_snapshot( self, context: nova_context.RequestContext, live_snapshot: bool, original_power_state: int, instance: 'objects.Instance', guest: libvirt_guest.Guest, ): if not self._needs_suspend_resume_for_snapshot( live_snapshot, original_power_state, ): return current_power_state = guest.get_power_state(self._host) # TODO(stephenfin): Any reason we couldn't use 'self.resume' here? guest.launch(pause=current_power_state == power_state.PAUSED) self._attach_pci_devices( guest, pci_manager.get_instance_pci_devs(instance)) self._attach_direct_passthrough_ports(context, instance, guest) def _can_set_admin_password(self, image_meta): if CONF.libvirt.virt_type in ('kvm', 'qemu'): if not image_meta.properties.get('hw_qemu_guest_agent', False): raise exception.QemuGuestAgentNotEnabled() elif not CONF.libvirt.virt_type == 'parallels': raise exception.SetAdminPasswdNotSupported() def _save_instance_password_if_sshkey_present(self, instance, new_pass): sshkey = instance.key_data if 'key_data' in instance else None if sshkey and sshkey.startswith("ssh-rsa"): enc = crypto.ssh_encrypt_text(sshkey, new_pass) # NOTE(melwitt): The convert_password method doesn't actually do # anything with the context argument, so we can pass None. instance.system_metadata.update( password.convert_password(None, base64.encode_as_text(enc))) instance.save() def set_admin_password(self, instance, new_pass): self._can_set_admin_password(instance.image_meta) guest = self._host.get_guest(instance) user = instance.image_meta.properties.get("os_admin_user") if not user: if instance.os_type == "windows": user = "Administrator" else: user = "root" try: guest.set_user_password(user, new_pass) except libvirt.libvirtError as ex: error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_AGENT_UNRESPONSIVE: LOG.debug('Failed to set password: QEMU agent unresponsive', instance_uuid=instance.uuid) raise NotImplementedError() err_msg = encodeutils.exception_to_unicode(ex) msg = (_('Error from libvirt while set password for username ' '"%(user)s": [Error Code %(error_code)s] %(ex)s') % {'user': user, 'error_code': error_code, 'ex': err_msg}) raise exception.InternalError(msg) else: # Save the password in sysmeta so it may be retrieved from the # metadata service. self._save_instance_password_if_sshkey_present(instance, new_pass) def _can_quiesce(self, instance, image_meta): if CONF.libvirt.virt_type not in ('kvm', 'qemu'): raise exception.InstanceQuiesceNotSupported( instance_id=instance.uuid) if not image_meta.properties.get('hw_qemu_guest_agent', False): raise exception.QemuGuestAgentNotEnabled() def _requires_quiesce(self, image_meta): return image_meta.properties.get('os_require_quiesce', False) def _set_quiesced(self, context, instance, image_meta, quiesced): self._can_quiesce(instance, image_meta) try: guest = self._host.get_guest(instance) if quiesced: guest.freeze_filesystems() else: guest.thaw_filesystems() except libvirt.libvirtError as ex: error_code = ex.get_error_code() err_msg = encodeutils.exception_to_unicode(ex) msg = (_('Error from libvirt while quiescing %(instance_name)s: ' '[Error Code %(error_code)s] %(ex)s') % {'instance_name': instance.name, 'error_code': error_code, 'ex': err_msg}) raise exception.InternalError(msg) def quiesce(self, context, instance, image_meta): """Freeze the guest filesystems to prepare for snapshot. The qemu-guest-agent must be setup to execute fsfreeze. """ self._set_quiesced(context, instance, image_meta, True) def unquiesce(self, context, instance, image_meta): """Thaw the guest filesystems after snapshot.""" self._set_quiesced(context, instance, image_meta, False) def _live_snapshot(self, context, instance, guest, disk_path, out_path, source_format, image_format, image_meta): """Snapshot an instance without downtime.""" dev = guest.get_block_device(disk_path) # Save a copy of the domain's persistent XML file xml = guest.get_xml_desc(dump_inactive=True, dump_sensitive=True) # Abort is an idempotent operation, so make sure any block # jobs which may have failed are ended. try: dev.abort_job() except Exception: pass # NOTE (rmk): We are using shallow rebases as a workaround to a bug # in QEMU 1.3. In order to do this, we need to create # a destination image with the original backing file # and matching size of the instance root disk. src_disk_size = libvirt_utils.get_disk_size(disk_path, format=source_format) src_back_path = libvirt_utils.get_disk_backing_file(disk_path, format=source_format, basename=False) disk_delta = out_path + '.delta' libvirt_utils.create_cow_image(src_back_path, disk_delta, src_disk_size) quiesced = False try: self._set_quiesced(context, instance, image_meta, True) quiesced = True except exception.NovaException as err: if self._requires_quiesce(image_meta): raise LOG.info('Skipping quiescing instance: %(reason)s.', {'reason': err}, instance=instance) try: # NOTE (rmk): blockRebase cannot be executed on persistent # domains, so we need to temporarily undefine it. # If any part of this block fails, the domain is # re-defined regardless. if guest.has_persistent_configuration(): hw_firmware_type = image_meta.properties.get( 'hw_firmware_type') support_uefi = self._check_uefi_support(hw_firmware_type) guest.delete_configuration(support_uefi) # NOTE (rmk): Establish a temporary mirror of our root disk and # issue an abort once we have a complete copy. dev.rebase(disk_delta, copy=True, reuse_ext=True, shallow=True) while not dev.is_job_complete(): time.sleep(0.5) dev.abort_job() nova.privsep.path.chown(disk_delta, uid=os.getuid()) finally: self._host.write_instance_config(xml) if quiesced: self._set_quiesced(context, instance, image_meta, False) # Convert the delta (CoW) image with a backing file to a flat # image with no backing file. libvirt_utils.extract_snapshot(disk_delta, 'qcow2', out_path, image_format) # Remove the disk_delta file once the snapshot extracted, so that # it doesn't hang around till the snapshot gets uploaded fileutils.delete_if_exists(disk_delta) def _volume_snapshot_update_status(self, context, snapshot_id, status): """Send a snapshot status update to Cinder. This method captures and logs exceptions that occur since callers cannot do anything useful with these exceptions. Operations on the Cinder side waiting for this will time out if a failure occurs sending the update. :param context: security context :param snapshot_id: id of snapshot being updated :param status: new status value """ try: self._volume_api.update_snapshot_status(context, snapshot_id, status) except Exception: LOG.exception('Failed to send updated snapshot status ' 'to volume service.') def _volume_snapshot_create(self, context, instance, guest, volume_id, new_file): """Perform volume snapshot. :param guest: VM that volume is attached to :param volume_id: volume UUID to snapshot :param new_file: relative path to new qcow2 file present on share """ xml = guest.get_xml_desc() xml_doc = etree.fromstring(xml) device_info = vconfig.LibvirtConfigGuest() device_info.parse_dom(xml_doc) disks_to_snap = [] # to be snapshotted by libvirt network_disks_to_snap = [] # network disks (netfs, etc.) disks_to_skip = [] # local disks not snapshotted for guest_disk in device_info.devices: if (guest_disk.root_name != 'disk'): continue if (guest_disk.target_dev is None): continue if (guest_disk.serial is None or guest_disk.serial != volume_id): disks_to_skip.append(guest_disk.target_dev) continue # disk is a Cinder volume with the correct volume_id disk_info = { 'dev': guest_disk.target_dev, 'serial': guest_disk.serial, 'current_file': guest_disk.source_path, 'source_protocol': guest_disk.source_protocol, 'source_name': guest_disk.source_name, 'source_hosts': guest_disk.source_hosts, 'source_ports': guest_disk.source_ports } # Determine path for new_file based on current path if disk_info['current_file'] is not None: current_file = disk_info['current_file'] new_file_path = os.path.join(os.path.dirname(current_file), new_file) disks_to_snap.append((current_file, new_file_path)) # NOTE(mriedem): This used to include a check for gluster in # addition to netfs since they were added together. Support for # gluster was removed in the 16.0.0 Pike release. It is unclear, # however, if other volume drivers rely on the netfs disk source # protocol. elif disk_info['source_protocol'] == 'netfs': network_disks_to_snap.append((disk_info, new_file)) if not disks_to_snap and not network_disks_to_snap: msg = _('Found no disk to snapshot.') raise exception.InternalError(msg) snapshot = vconfig.LibvirtConfigGuestSnapshot() for current_name, new_filename in disks_to_snap: snap_disk = vconfig.LibvirtConfigGuestSnapshotDisk() snap_disk.name = current_name snap_disk.source_path = new_filename snap_disk.source_type = 'file' snap_disk.snapshot = 'external' snap_disk.driver_name = 'qcow2' snapshot.add_disk(snap_disk) for disk_info, new_filename in network_disks_to_snap: snap_disk = vconfig.LibvirtConfigGuestSnapshotDisk() snap_disk.name = disk_info['dev'] snap_disk.source_type = 'network' snap_disk.source_protocol = disk_info['source_protocol'] snap_disk.snapshot = 'external' snap_disk.source_path = new_filename old_dir = disk_info['source_name'].split('/')[0] snap_disk.source_name = '%s/%s' % (old_dir, new_filename) snap_disk.source_hosts = disk_info['source_hosts'] snap_disk.source_ports = disk_info['source_ports'] snapshot.add_disk(snap_disk) for dev in disks_to_skip: snap_disk = vconfig.LibvirtConfigGuestSnapshotDisk() snap_disk.name = dev snap_disk.snapshot = 'no' snapshot.add_disk(snap_disk) snapshot_xml = snapshot.to_xml() LOG.debug("snap xml: %s", snapshot_xml, instance=instance) image_meta = instance.image_meta try: # Check to see if we can quiesce the guest before taking the # snapshot. self._can_quiesce(instance, image_meta) try: guest.snapshot(snapshot, no_metadata=True, disk_only=True, reuse_ext=True, quiesce=True) return except libvirt.libvirtError: # If the image says that quiesce is required then we fail. if self._requires_quiesce(image_meta): raise LOG.exception('Unable to create quiesced VM snapshot, ' 'attempting again with quiescing disabled.', instance=instance) except (exception.InstanceQuiesceNotSupported, exception.QemuGuestAgentNotEnabled) as err: # If the image says that quiesce is required then we need to fail. if self._requires_quiesce(image_meta): raise LOG.info('Skipping quiescing instance: %(reason)s.', {'reason': err}, instance=instance) try: guest.snapshot(snapshot, no_metadata=True, disk_only=True, reuse_ext=True, quiesce=False) except libvirt.libvirtError: LOG.exception('Unable to create VM snapshot, ' 'failing volume_snapshot operation.', instance=instance) raise def _volume_refresh_connection_info(self, context, instance, volume_id): bdm = objects.BlockDeviceMapping.get_by_volume_and_instance( context, volume_id, instance.uuid) driver_bdm = driver_block_device.convert_volume(bdm) if driver_bdm: driver_bdm.refresh_connection_info(context, instance, self._volume_api, self) def volume_snapshot_create(self, context, instance, volume_id, create_info): """Create snapshots of a Cinder volume via libvirt. :param instance: VM instance object reference :param volume_id: id of volume being snapshotted :param create_info: dict of information used to create snapshots - snapshot_id : ID of snapshot - type : qcow2 / - new_file : qcow2 file created by Cinder which becomes the VM's active image after the snapshot is complete """ LOG.debug("volume_snapshot_create: create_info: %(c_info)s", {'c_info': create_info}, instance=instance) try: guest = self._host.get_guest(instance) except exception.InstanceNotFound: raise exception.InstanceNotRunning(instance_id=instance.uuid) if create_info['type'] != 'qcow2': msg = _('Unknown type: %s') % create_info['type'] raise exception.InternalError(msg) snapshot_id = create_info.get('snapshot_id', None) if snapshot_id is None: msg = _('snapshot_id required in create_info') raise exception.InternalError(msg) try: self._volume_snapshot_create(context, instance, guest, volume_id, create_info['new_file']) except Exception: with excutils.save_and_reraise_exception(): LOG.exception('Error occurred during volume_snapshot_create, ' 'sending error status to Cinder.', instance=instance) self._volume_snapshot_update_status( context, snapshot_id, 'error') self._volume_snapshot_update_status( context, snapshot_id, 'creating') def _wait_for_snapshot(): snapshot = self._volume_api.get_snapshot(context, snapshot_id) if snapshot.get('status') != 'creating': self._volume_refresh_connection_info(context, instance, volume_id) raise loopingcall.LoopingCallDone() timer = loopingcall.FixedIntervalLoopingCall(_wait_for_snapshot) timer.start(interval=0.5).wait() @staticmethod def _rebase_with_qemu_img(source_path, rebase_base): """Rebase a disk using qemu-img. :param source_path: the disk source path to rebase :type source_path: string :param rebase_base: the new parent in the backing chain :type rebase_base: None or string """ if rebase_base is None: # If backing_file is specified as "" (the empty string), then # the image is rebased onto no backing file (i.e. it will exist # independently of any backing file). backing_file = "" qemu_img_extra_arg = [] else: # If the rebased image is going to have a backing file then # explicitly set the backing file format to avoid any security # concerns related to file format auto detection. if os.path.isabs(rebase_base): backing_file = rebase_base else: # this is a probably a volume snapshot case where the # rebase_base is relative. See bug # https://bugs.launchpad.net/nova/+bug/1885528 backing_file_name = os.path.basename(rebase_base) volume_path = os.path.dirname(source_path) backing_file = os.path.join(volume_path, backing_file_name) b_file_fmt = images.qemu_img_info(backing_file).file_format qemu_img_extra_arg = ['-F', b_file_fmt] qemu_img_extra_arg.append(source_path) # execute operation with disk concurrency semaphore with compute_utils.disk_ops_semaphore: processutils.execute("qemu-img", "rebase", "-b", backing_file, *qemu_img_extra_arg) def _volume_snapshot_delete(self, context, instance, volume_id, snapshot_id, delete_info=None): """Note: if file being merged into == active image: do a blockRebase (pull) operation else: do a blockCommit operation Files must be adjacent in snap chain. :param instance: instance object reference :param volume_id: volume UUID :param snapshot_id: snapshot UUID (unused currently) :param delete_info: { 'type': 'qcow2', 'file_to_merge': 'a.img', 'merge_target_file': 'b.img' or None (if merging file_to_merge into active image) } """ LOG.debug('volume_snapshot_delete: delete_info: %s', delete_info, instance=instance) if delete_info['type'] != 'qcow2': msg = _('Unknown delete_info type %s') % delete_info['type'] raise exception.InternalError(msg) try: guest = self._host.get_guest(instance) except exception.InstanceNotFound: raise exception.InstanceNotRunning(instance_id=instance.uuid) # Find dev name xml = guest.get_xml_desc() xml_doc = etree.fromstring(xml) device_info = vconfig.LibvirtConfigGuest() device_info.parse_dom(xml_doc) for guest_disk in device_info.devices: if (guest_disk.root_name != 'disk'): continue if (guest_disk.target_dev is None or guest_disk.serial is None): continue if ( guest_disk.source_path is None and guest_disk.source_protocol is None ): continue if guest_disk.serial == volume_id: my_dev = guest_disk.target_dev active_protocol = guest_disk.source_protocol active_disk_object = guest_disk break else: LOG.debug('Domain XML: %s', xml, instance=instance) msg = (_("Disk with id '%s' not found attached to instance.") % volume_id) raise exception.InternalError(msg) LOG.debug("found device at %s", my_dev, instance=instance) def _get_snap_dev(filename, backing_store): if filename is None: msg = _('filename cannot be None') raise exception.InternalError(msg) # libgfapi delete LOG.debug("XML: %s", xml) LOG.debug("active disk object: %s", active_disk_object) # determine reference within backing store for desired image filename_to_merge = filename matched_name = None b = backing_store index = None current_filename = active_disk_object.source_name.split('/')[1] if current_filename == filename_to_merge: return my_dev + '[0]' while b is not None: source_filename = b.source_name.split('/')[1] if source_filename == filename_to_merge: LOG.debug('found match: %s', b.source_name) matched_name = b.source_name index = b.index break b = b.backing_store if matched_name is None: msg = _('no match found for %s') % (filename_to_merge) raise exception.InternalError(msg) LOG.debug('index of match (%s) is %s', b.source_name, index) my_snap_dev = '%s[%s]' % (my_dev, index) return my_snap_dev if delete_info['merge_target_file'] is None: # pull via blockRebase() # Merge the most recent snapshot into the active image rebase_disk = my_dev rebase_base = delete_info['file_to_merge'] # often None if (active_protocol is not None) and (rebase_base is not None): rebase_base = _get_snap_dev(rebase_base, active_disk_object.backing_store) relative = rebase_base is not None LOG.debug( 'disk: %(disk)s, base: %(base)s, ' 'bw: %(bw)s, relative: %(relative)s', {'disk': rebase_disk, 'base': rebase_base, 'bw': libvirt_guest.BlockDevice.REBASE_DEFAULT_BANDWIDTH, 'relative': str(relative)}, instance=instance) dev = guest.get_block_device(rebase_disk) if guest.is_active(): result = dev.rebase(rebase_base, relative=relative) if result == 0: LOG.debug('blockRebase started successfully', instance=instance) while not dev.is_job_complete(): LOG.debug('waiting for blockRebase job completion', instance=instance) time.sleep(0.5) # If the guest is not running libvirt won't do a blockRebase. # In that case, let's ask qemu-img to rebase the disk. else: LOG.debug('Guest is not running so doing a block rebase ' 'using "qemu-img rebase"', instance=instance) # It's unsure how well qemu-img handles network disks for # every protocol. So let's be safe. active_protocol = active_disk_object.source_protocol if active_protocol is not None: msg = _("Something went wrong when deleting a volume " "snapshot: rebasing a %(protocol)s network disk " "using qemu-img has not been fully tested" ) % {'protocol': active_protocol} LOG.error(msg) raise exception.InternalError(msg) self._rebase_with_qemu_img(active_disk_object.source_path, rebase_base) else: # commit with blockCommit() my_snap_base = None my_snap_top = None commit_disk = my_dev if active_protocol is not None: my_snap_base = _get_snap_dev(delete_info['merge_target_file'], active_disk_object.backing_store) my_snap_top = _get_snap_dev(delete_info['file_to_merge'], active_disk_object.backing_store) commit_base = my_snap_base or delete_info['merge_target_file'] commit_top = my_snap_top or delete_info['file_to_merge'] LOG.debug('will call blockCommit with commit_disk=%(commit_disk)s ' 'commit_base=%(commit_base)s ' 'commit_top=%(commit_top)s ', {'commit_disk': commit_disk, 'commit_base': commit_base, 'commit_top': commit_top}, instance=instance) dev = guest.get_block_device(commit_disk) result = dev.commit(commit_base, commit_top, relative=True) if result == 0: LOG.debug('blockCommit started successfully', instance=instance) while not dev.is_job_complete(): LOG.debug('waiting for blockCommit job completion', instance=instance) time.sleep(0.5) def volume_snapshot_delete(self, context, instance, volume_id, snapshot_id, delete_info): try: self._volume_snapshot_delete(context, instance, volume_id, snapshot_id, delete_info=delete_info) except Exception: with excutils.save_and_reraise_exception(): LOG.exception('Error occurred during volume_snapshot_delete, ' 'sending error status to Cinder.', instance=instance) self._volume_snapshot_update_status( context, snapshot_id, 'error_deleting') self._volume_snapshot_update_status(context, snapshot_id, 'deleting') self._volume_refresh_connection_info(context, instance, volume_id) def reboot(self, context, instance, network_info, reboot_type, block_device_info=None, bad_volumes_callback=None, accel_info=None): """Reboot a virtual machine, given an instance reference.""" if reboot_type == 'SOFT': # NOTE(vish): This will attempt to do a graceful shutdown/restart. try: soft_reboot_success = self._soft_reboot(instance) except libvirt.libvirtError as e: LOG.debug("Instance soft reboot failed: %s", encodeutils.exception_to_unicode(e), instance=instance) soft_reboot_success = False if soft_reboot_success: LOG.info("Instance soft rebooted successfully.", instance=instance) return else: LOG.warning("Failed to soft reboot instance. " "Trying hard reboot.", instance=instance) return self._hard_reboot(context, instance, network_info, block_device_info, accel_info) def _soft_reboot(self, instance): """Attempt to shutdown and restart the instance gracefully. We use shutdown and create here so we can return if the guest responded and actually rebooted. Note that this method only succeeds if the guest responds to acpi. Therefore we return success or failure so we can fall back to a hard reboot if necessary. :returns: True if the reboot succeeded """ guest = self._host.get_guest(instance) state = guest.get_power_state(self._host) old_domid = guest.id # NOTE(vish): This check allows us to reboot an instance that # is already shutdown. if state == power_state.RUNNING: guest.shutdown() # NOTE(vish): This actually could take slightly longer than the # FLAG defines depending on how long the get_info # call takes to return. self._prepare_pci_devices_for_use( pci_manager.get_instance_pci_devs(instance, 'all')) for x in range(CONF.libvirt.wait_soft_reboot_seconds): guest = self._host.get_guest(instance) state = guest.get_power_state(self._host) new_domid = guest.id # NOTE(ivoks): By checking domain IDs, we make sure we are # not recreating domain that's already running. if old_domid != new_domid: if state in (power_state.SHUTDOWN, power_state.CRASHED): LOG.info("Instance shutdown successfully.", instance=instance) guest.launch() timer = loopingcall.FixedIntervalLoopingCall( self._wait_for_running, instance) timer.start(interval=0.5).wait() return True else: LOG.info("Instance may have been rebooted during soft " "reboot, so return now.", instance=instance) return True greenthread.sleep(1) return False def _hard_reboot(self, context, instance, network_info, block_device_info=None, accel_info=None): """Reboot a virtual machine, given an instance reference. Performs a Libvirt reset (if supported) on the domain. If Libvirt reset is unavailable this method actually destroys and re-creates the domain to ensure the reboot happens, as the guest OS cannot ignore this action. """ # NOTE(sbauza): Since we undefine the guest XML when destroying, we # need to remember the existing mdevs for reusing them. mdevs = self._get_all_assigned_mediated_devices(instance) mdevs = list(mdevs.keys()) # NOTE(mdbooth): In addition to performing a hard reboot of the domain, # the hard reboot operation is relied upon by operators to be an # automated attempt to fix as many things as possible about a # non-functioning instance before resorting to manual intervention. # With this goal in mind, we tear down all the aspects of an instance # we can here without losing data. This allows us to re-initialise from # scratch, and hopefully fix, most aspects of a non-functioning guest. self.destroy(context, instance, network_info, destroy_disks=False, block_device_info=block_device_info) # Convert the system metadata to image metadata # NOTE(mdbooth): This is a workaround for stateless Nova compute # https://bugs.launchpad.net/nova/+bug/1349978 instance_dir = libvirt_utils.get_instance_path(instance) fileutils.ensure_tree(instance_dir) disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type, instance, instance.image_meta, block_device_info) # NOTE(vish): This could generate the wrong device_format if we are # using the raw backend and the images don't exist yet. # The create_images_and_backing below doesn't properly # regenerate raw backend images, however, so when it # does we need to (re)generate the xml after the images # are in place. xml = self._get_guest_xml(context, instance, network_info, disk_info, instance.image_meta, block_device_info=block_device_info, mdevs=mdevs, accel_info=accel_info) # NOTE(mdbooth): context.auth_token will not be set when we call # _hard_reboot from resume_state_on_host_boot() if context.auth_token is not None: # NOTE (rmk): Re-populate any missing backing files. config = vconfig.LibvirtConfigGuest() config.parse_str(xml) backing_disk_info = self._get_instance_disk_info_from_config( config, block_device_info) self._create_images_and_backing(context, instance, instance_dir, backing_disk_info) # Initialize all the necessary networking, block devices and # start the instance. # NOTE(melwitt): Pass vifs_already_plugged=True here even though we've # unplugged vifs earlier. The behavior of neutron plug events depends # on which vif type we're using and we are working with a stale network # info cache here, so won't rely on waiting for neutron plug events. # vifs_already_plugged=True means "do not wait for neutron plug events" # NOTE(efried): The instance should already have a vtpm_secret_uuid # registered if appropriate. self._create_guest_with_network( context, xml, instance, network_info, block_device_info, vifs_already_plugged=True) self._prepare_pci_devices_for_use( pci_manager.get_instance_pci_devs(instance, 'all')) def _wait_for_reboot(): """Called at an interval until the VM is running again.""" state = self.get_info(instance).state if state == power_state.RUNNING: LOG.info("Instance rebooted successfully.", instance=instance) raise loopingcall.LoopingCallDone() timer = loopingcall.FixedIntervalLoopingCall(_wait_for_reboot) timer.start(interval=0.5).wait() def pause(self, instance): """Pause VM instance.""" self._host.get_guest(instance).pause() def unpause(self, instance): """Unpause paused VM instance.""" guest = self._host.get_guest(instance) guest.resume() guest.sync_guest_time() def _clean_shutdown(self, instance, timeout, retry_interval): """Attempt to shutdown the instance gracefully. :param instance: The instance to be shutdown :param timeout: How long to wait in seconds for the instance to shutdown :param retry_interval: How often in seconds to signal the instance to shutdown while waiting :returns: True if the shutdown succeeded """ # List of states that represent a shutdown instance SHUTDOWN_STATES = [power_state.SHUTDOWN, power_state.CRASHED] try: guest = self._host.get_guest(instance) except exception.InstanceNotFound: # If the instance has gone then we don't need to # wait for it to shutdown return True state = guest.get_power_state(self._host) if state in SHUTDOWN_STATES: LOG.info("Instance already shutdown.", instance=instance) return True LOG.debug("Shutting down instance from state %s", state, instance=instance) guest.shutdown() retry_countdown = retry_interval for sec in range(timeout): guest = self._host.get_guest(instance) state = guest.get_power_state(self._host) if state in SHUTDOWN_STATES: LOG.info("Instance shutdown successfully after %d seconds.", sec, instance=instance) return True # Note(PhilD): We can't assume that the Guest was able to process # any previous shutdown signal (for example it may # have still been startingup, so within the overall # timeout we re-trigger the shutdown every # retry_interval if retry_countdown == 0: retry_countdown = retry_interval # Instance could shutdown at any time, in which case we # will get an exception when we call shutdown try: LOG.debug("Instance in state %s after %d seconds - " "resending shutdown", state, sec, instance=instance) guest.shutdown() except libvirt.libvirtError: # Assume this is because its now shutdown, so loop # one more time to clean up. LOG.debug("Ignoring libvirt exception from shutdown " "request.", instance=instance) continue else: retry_countdown -= 1 time.sleep(1) LOG.info("Instance failed to shutdown in %d seconds.", timeout, instance=instance) return False def power_off(self, instance, timeout=0, retry_interval=0): """Power off the specified instance.""" if timeout: self._clean_shutdown(instance, timeout, retry_interval) self._destroy(instance) def power_on(self, context, instance, network_info, block_device_info=None, accel_info=None): """Power on the specified instance.""" # We use _hard_reboot here to ensure that all backing files, # network, and block device connections, etc. are established # and available before we attempt to start the instance. self._hard_reboot(context, instance, network_info, block_device_info, accel_info) def trigger_crash_dump(self, instance): """Trigger crash dump by injecting an NMI to the specified instance.""" try: self._host.get_guest(instance).inject_nmi() except libvirt.libvirtError as ex: error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_NO_SUPPORT: raise exception.TriggerCrashDumpNotSupported() elif error_code == libvirt.VIR_ERR_OPERATION_INVALID: raise exception.InstanceNotRunning(instance_id=instance.uuid) LOG.exception( 'Error from libvirt while injecting an NMI to ' '%(instance_uuid)s: [Error Code %(error_code)s] %(ex)s', {'instance_uuid': instance.uuid, 'error_code': error_code, 'ex': ex}) raise def suspend(self, context, instance): """Suspend the specified instance.""" guest = self._host.get_guest(instance) self._detach_pci_devices(guest, pci_manager.get_instance_pci_devs(instance)) self._detach_direct_passthrough_ports(context, instance, guest) self._detach_mediated_devices(guest) guest.save_memory_state() def resume(self, context, instance, network_info, block_device_info=None): """resume the specified instance.""" xml = self._get_existing_domain_xml(instance, network_info, block_device_info) # NOTE(efried): The instance should already have a vtpm_secret_uuid # registered if appropriate. guest = self._create_guest_with_network( context, xml, instance, network_info, block_device_info, vifs_already_plugged=True) self._attach_pci_devices(guest, pci_manager.get_instance_pci_devs(instance)) self._attach_direct_passthrough_ports( context, instance, guest, network_info) timer = loopingcall.FixedIntervalLoopingCall(self._wait_for_running, instance) timer.start(interval=0.5).wait() guest.sync_guest_time() def resume_state_on_host_boot(self, context, instance, network_info, block_device_info=None): """resume guest state when a host is booted.""" # Check if the instance is running already and avoid doing # anything if it is. try: guest = self._host.get_guest(instance) state = guest.get_power_state(self._host) ignored_states = (power_state.RUNNING, power_state.SUSPENDED, power_state.NOSTATE, power_state.PAUSED) if state in ignored_states: return except (exception.InternalError, exception.InstanceNotFound): pass # Instance is not up and could be in an unknown state. # Be as absolute as possible about getting it back into # a known and running state. self._hard_reboot(context, instance, network_info, block_device_info) def rescue(self, context, instance, network_info, image_meta, rescue_password, block_device_info): """Loads a VM using rescue images. A rescue is normally performed when something goes wrong with the primary images and data needs to be corrected/recovered. Rescuing should not edit or over-ride the original image, only allow for data recovery. Two modes are provided when rescuing an instance with this driver. The original and default rescue mode, where the rescue boot disk, original root disk and optional regenerated config drive are attached to the instance. A second stable device rescue mode is also provided where all of the original devices are attached to the instance during the rescue attempt with the addition of the rescue boot disk. This second mode is controlled by the hw_rescue_device and hw_rescue_bus image properties on the rescue image provided to this method via image_meta. :param nova.context.RequestContext context: The context for the rescue. :param nova.objects.instance.Instance instance: The instance being rescued. :param nova.network.model.NetworkInfo network_info: Necessary network information for the resume. :param nova.objects.ImageMeta image_meta: The metadata of the image of the instance. :param rescue_password: new root password to set for rescue. :param dict block_device_info: The block device mapping of the instance. """ instance_dir = libvirt_utils.get_instance_path(instance) unrescue_xml = self._get_existing_domain_xml(instance, network_info) unrescue_xml_path = os.path.join(instance_dir, 'unrescue.xml') with open(unrescue_xml_path, 'w') as f: f.write(unrescue_xml) rescue_image_id = None rescue_image_meta = None if image_meta.obj_attr_is_set("id"): rescue_image_id = image_meta.id rescue_images = { 'image_id': (rescue_image_id or CONF.libvirt.rescue_image_id or instance.image_ref), 'kernel_id': (CONF.libvirt.rescue_kernel_id or instance.kernel_id), 'ramdisk_id': (CONF.libvirt.rescue_ramdisk_id or instance.ramdisk_id), } virt_type = CONF.libvirt.virt_type if hardware.check_hw_rescue_props(image_meta): LOG.info("Attempting a stable device rescue", instance=instance) # NOTE(lyarwood): Stable device rescue is not supported when using # the LXC and Xen virt_types as they do not support the required # definitions allowing an instance to boot from the # rescue device added as a final device to the domain. if virt_type in ('lxc', 'xen'): reason = ("Stable device rescue is not supported by virt_type " "%s", virt_type) raise exception.InstanceNotRescuable(instance_id=instance.uuid, reason=reason) # NOTE(lyarwood): Stable device rescue provides the original disk # mapping of the instance with the rescue device appened to the # end. As a result we need to provide the original image_meta, the # new rescue_image_meta and block_device_info when calling # get_disk_info. rescue_image_meta = image_meta if instance.image_ref: image_meta = objects.ImageMeta.from_image_ref( context, self._image_api, instance.image_ref) else: # NOTE(lyarwood): If instance.image_ref isn't set attempt to # lookup the original image_meta from the bdms. This will # return an empty dict if no valid image_meta is found. image_meta_dict = block_device.get_bdm_image_metadata( context, self._image_api, self._volume_api, block_device_info['block_device_mapping'], legacy_bdm=False) image_meta = objects.ImageMeta.from_dict(image_meta_dict) else: LOG.info("Attempting rescue", instance=instance) # NOTE(lyarwood): A legacy rescue only provides the rescue device # and the original root device so we don't need to provide # block_device_info to the get_disk_info call. block_device_info = None disk_info = blockinfo.get_disk_info(virt_type, instance, image_meta, rescue=True, block_device_info=block_device_info, rescue_image_meta=rescue_image_meta) LOG.debug("rescue generated disk_info: %s", disk_info) injection_info = InjectionInfo(network_info=network_info, admin_pass=rescue_password, files=None) gen_confdrive = functools.partial(self._create_configdrive, context, instance, injection_info, rescue=True) # NOTE(sbauza): Since rescue recreates the guest XML, we need to # remember the existing mdevs for reusing them. mdevs = self._get_all_assigned_mediated_devices(instance) mdevs = list(mdevs.keys()) self._create_image(context, instance, disk_info['mapping'], injection_info=injection_info, suffix='.rescue', disk_images=rescue_images) # NOTE(efried): The instance should already have a vtpm_secret_uuid # registered if appropriate. xml = self._get_guest_xml(context, instance, network_info, disk_info, image_meta, rescue=rescue_images, mdevs=mdevs, block_device_info=block_device_info) self._destroy(instance) self._create_guest( context, xml, instance, post_xml_callback=gen_confdrive, ) def unrescue( self, context: nova_context.RequestContext, instance: 'objects.Instance', ): """Reboot the VM which is being rescued back into primary images.""" instance_dir = libvirt_utils.get_instance_path(instance) unrescue_xml_path = os.path.join(instance_dir, 'unrescue.xml') # The xml should already contain the secret_uuid if relevant. xml = libvirt_utils.load_file(unrescue_xml_path) self._destroy(instance) self._create_guest(context, xml, instance) os.unlink(unrescue_xml_path) rescue_files = os.path.join(instance_dir, "*.rescue") for rescue_file in glob.iglob(rescue_files): if os.path.isdir(rescue_file): shutil.rmtree(rescue_file) else: os.unlink(rescue_file) # cleanup rescue volume lvm.remove_volumes([lvmdisk for lvmdisk in self._lvm_disks(instance) if lvmdisk.endswith('.rescue')]) if CONF.libvirt.images_type == 'rbd': filter_fn = lambda disk: (disk.startswith(instance.uuid) and disk.endswith('.rescue')) rbd_utils.RBDDriver().cleanup_volumes(filter_fn) def poll_rebooting_instances(self, timeout, instances): pass def spawn(self, context, instance, image_meta, injected_files, admin_password, allocations, network_info=None, block_device_info=None, power_on=True, accel_info=None): disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type, instance, image_meta, block_device_info) injection_info = InjectionInfo(network_info=network_info, files=injected_files, admin_pass=admin_password) gen_confdrive = functools.partial(self._create_configdrive, context, instance, injection_info) created_instance_dir, created_disks = self._create_image( context, instance, disk_info['mapping'], injection_info=injection_info, block_device_info=block_device_info) # Required by Quobyte CI self._ensure_console_log_for_instance(instance) # Does the guest need to be assigned some vGPU mediated devices ? mdevs = self._allocate_mdevs(allocations) # If the guest needs a vTPM, _get_guest_xml needs its secret to exist # and its uuid to be registered in the instance prior to _get_guest_xml if CONF.libvirt.swtpm_enabled and hardware.get_vtpm_constraint( instance.flavor, image_meta ): if not instance.system_metadata.get('vtpm_secret_uuid'): # Create the secret via the key manager service so that we have # it to hand when generating the XML. This is slightly wasteful # as we'll perform a redundant key manager API call later when # we create the domain but the alternative is an ugly mess crypto.ensure_vtpm_secret(context, instance) xml = self._get_guest_xml(context, instance, network_info, disk_info, image_meta, block_device_info=block_device_info, mdevs=mdevs, accel_info=accel_info) self._create_guest_with_network( context, xml, instance, network_info, block_device_info, post_xml_callback=gen_confdrive, power_on=power_on, cleanup_instance_dir=created_instance_dir, cleanup_instance_disks=created_disks) LOG.debug("Guest created on hypervisor", instance=instance) def _wait_for_boot(): """Called at an interval until the VM is running.""" state = self.get_info(instance).state if state == power_state.RUNNING: LOG.info("Instance spawned successfully.", instance=instance) raise loopingcall.LoopingCallDone() if power_on: timer = loopingcall.FixedIntervalLoopingCall(_wait_for_boot) timer.start(interval=0.5).wait() else: LOG.info("Instance spawned successfully.", instance=instance) def _get_console_output_file(self, instance, console_log): bytes_to_read = MAX_CONSOLE_BYTES log_data = b"" # The last N read bytes i = 0 # in case there is a log rotation (like "virtlogd") path = console_log while bytes_to_read > 0 and os.path.exists(path): read_log_data, remaining = nova.privsep.path.last_bytes( path, bytes_to_read) # We need the log file content in chronological order, # that's why we *prepend* the log data. log_data = read_log_data + log_data # Prep to read the next file in the chain bytes_to_read -= len(read_log_data) path = console_log + "." + str(i) i += 1 if remaining > 0: LOG.info('Truncated console log returned, ' '%d bytes ignored', remaining, instance=instance) return log_data def get_console_output(self, context, instance): guest = self._host.get_guest(instance) xml = guest.get_xml_desc() tree = etree.fromstring(xml) # check for different types of consoles path_sources = [ ('file', "./devices/console[@type='file']/source[@path]", 'path'), ('tcp', "./devices/console[@type='tcp']/log[@file]", 'file'), ('pty', "./devices/console[@type='pty']/source[@path]", 'path')] console_type = "" console_path = "" for c_type, epath, attrib in path_sources: node = tree.find(epath) if (node is not None) and node.get(attrib): console_type = c_type console_path = node.get(attrib) break # instance has no console at all if not console_path: raise exception.ConsoleNotAvailable() # instance has a console, but file doesn't exist (yet?) if not os.path.exists(console_path): LOG.info('console logfile for instance does not exist', instance=instance) return "" # pty consoles need special handling if console_type == 'pty': console_log = self._get_console_log_path(instance) data = nova.privsep.libvirt.readpty(console_path) # NOTE(markus_z): The virt_types kvm and qemu are the only ones # which create a dedicated file device for the console logging. # Other virt_types like xen, lxc, uml, parallels depend on the # flush of that pty device into the "console.log" file to ensure # that a series of "get_console_output" calls return the complete # content even after rebooting a guest. nova.privsep.path.writefile(console_log, 'a+', data) # set console path to logfile, not to pty device console_path = console_log # return logfile content return self._get_console_output_file(instance, console_path) def get_host_ip_addr(self): return CONF.my_ip def get_vnc_console(self, context, instance): def get_vnc_port_for_instance(instance_name): guest = self._host.get_guest(instance) xml = guest.get_xml_desc() xml_dom = etree.fromstring(xml) graphic = xml_dom.find("./devices/graphics[@type='vnc']") if graphic is not None: return graphic.get('port') # NOTE(rmk): We had VNC consoles enabled but the instance in # question is not actually listening for connections. raise exception.ConsoleTypeUnavailable(console_type='vnc') port = get_vnc_port_for_instance(instance.name) host = CONF.vnc.server_proxyclient_address return ctype.ConsoleVNC(host=host, port=port) def get_spice_console(self, context, instance): def get_spice_ports_for_instance(instance_name): guest = self._host.get_guest(instance) xml = guest.get_xml_desc() xml_dom = etree.fromstring(xml) graphic = xml_dom.find("./devices/graphics[@type='spice']") if graphic is not None: return (graphic.get('port'), graphic.get('tlsPort')) # NOTE(rmk): We had Spice consoles enabled but the instance in # question is not actually listening for connections. raise exception.ConsoleTypeUnavailable(console_type='spice') ports = get_spice_ports_for_instance(instance.name) host = CONF.spice.server_proxyclient_address return ctype.ConsoleSpice(host=host, port=ports[0], tlsPort=ports[1]) def get_serial_console(self, context, instance): guest = self._host.get_guest(instance) for hostname, port in self._get_serial_ports_from_guest( guest, mode='bind'): return ctype.ConsoleSerial(host=hostname, port=port) raise exception.ConsoleTypeUnavailable(console_type='serial') @staticmethod def _create_ephemeral(target, ephemeral_size, fs_label, os_type, is_block_dev=False, context=None, specified_fs=None, vm_mode=None): if not is_block_dev: if (CONF.libvirt.virt_type == "parallels" and vm_mode == fields.VMMode.EXE): libvirt_utils.create_ploop_image('expanded', target, '%dG' % ephemeral_size, specified_fs) return libvirt_utils.create_image('raw', target, '%dG' % ephemeral_size) # Run as root only for block devices. disk_api.mkfs(os_type, fs_label, target, run_as_root=is_block_dev, specified_fs=specified_fs) @staticmethod def _create_swap(target, swap_mb, context=None): """Create a swap file of specified size.""" libvirt_utils.create_image('raw', target, '%dM' % swap_mb) nova.privsep.fs.unprivileged_mkfs('swap', target) @staticmethod def _get_console_log_path(instance): return os.path.join(libvirt_utils.get_instance_path(instance), 'console.log') def _ensure_console_log_for_instance(self, instance): # NOTE(mdbooth): Although libvirt will create this file for us # automatically when it starts, it will initially create it with # root ownership and then chown it depending on the configuration of # the domain it is launching. Quobyte CI explicitly disables the # chown by setting dynamic_ownership=0 in libvirt's config. # Consequently when the domain starts it is unable to write to its # console.log. See bug https://bugs.launchpad.net/nova/+bug/1597644 # # To work around this, we create the file manually before starting # the domain so it has the same ownership as Nova. This works # for Quobyte CI because it is also configured to run qemu as the same # user as the Nova service. Installations which don't set # dynamic_ownership=0 are not affected because libvirt will always # correctly configure permissions regardless of initial ownership. # # Setting dynamic_ownership=0 is dubious and potentially broken in # more ways than console.log (see comment #22 on the above bug), so # Future Maintainer who finds this code problematic should check to see # if we still support it. console_file = self._get_console_log_path(instance) LOG.debug('Ensure instance console log exists: %s', console_file, instance=instance) try: libvirt_utils.file_open(console_file, 'a').close() # NOTE(sfinucan): We can safely ignore permission issues here and # assume that it is libvirt that has taken ownership of this file. except IOError as ex: if ex.errno != errno.EACCES: raise LOG.debug('Console file already exists: %s.', console_file) @staticmethod def _get_disk_config_image_type(): # TODO(mikal): there is a bug here if images_type has # changed since creation of the instance, but I am pretty # sure that this bug already exists. return 'rbd' if CONF.libvirt.images_type == 'rbd' else 'raw' @staticmethod def _is_booted_from_volume(block_device_info): """Determines whether the VM is booting from volume Determines whether the block device info indicates that the VM is booting from a volume. """ block_device_mapping = driver.block_device_info_get_mapping( block_device_info) return bool(block_device.get_root_bdm(block_device_mapping)) def _inject_data(self, disk, instance, injection_info): """Injects data in a disk image Helper used for injecting data in a disk image file system. :param disk: The disk we're injecting into (an Image object) :param instance: The instance we're injecting into :param injection_info: Injection info """ # Handles the partition need to be used. LOG.debug('Checking root disk injection %s', str(injection_info), instance=instance) target_partition = None if not instance.kernel_id: target_partition = CONF.libvirt.inject_partition if target_partition == 0: target_partition = None if CONF.libvirt.virt_type == 'lxc': target_partition = None # Handles the key injection. key = None if CONF.libvirt.inject_key and instance.get('key_data'): key = str(instance.key_data) # Handles the admin password injection. admin_pass = None if CONF.libvirt.inject_password: admin_pass = injection_info.admin_pass # Handles the network injection. net = netutils.get_injected_network_template( injection_info.network_info, libvirt_virt_type=CONF.libvirt.virt_type) # Handles the metadata injection metadata = instance.get('metadata') if any((key, net, metadata, admin_pass, injection_info.files)): LOG.debug('Injecting %s', str(injection_info), instance=instance) img_id = instance.image_ref try: disk_api.inject_data(disk.get_model(self._conn), key, net, metadata, admin_pass, injection_info.files, partition=target_partition, mandatory=('files',)) except Exception as e: with excutils.save_and_reraise_exception(): LOG.error('Error injecting data into image ' '%(img_id)s (%(e)s)', {'img_id': img_id, 'e': e}, instance=instance) # NOTE(sileht): many callers of this method assume that this # method doesn't fail if an image already exists but instead # think that it will be reused (ie: (live)-migration/resize) def _create_image(self, context, instance, disk_mapping, injection_info=None, suffix='', disk_images=None, block_device_info=None, fallback_from_host=None, ignore_bdi_for_swap=False): booted_from_volume = self._is_booted_from_volume(block_device_info) def image(fname, image_type=CONF.libvirt.images_type): return self.image_backend.by_name(instance, fname + suffix, image_type) def raw(fname): return image(fname, image_type='raw') created_instance_dir = True # ensure directories exist and are writable instance_dir = libvirt_utils.get_instance_path(instance) if os.path.exists(instance_dir): LOG.debug("Instance directory exists: not creating", instance=instance) created_instance_dir = False else: LOG.debug("Creating instance directory", instance=instance) fileutils.ensure_tree(libvirt_utils.get_instance_path(instance)) LOG.info('Creating image', instance=instance) inst_type = instance.get_flavor() swap_mb = 0 if 'disk.swap' in disk_mapping: mapping = disk_mapping['disk.swap'] if ignore_bdi_for_swap: # This is a workaround to support legacy swap resizing, # which does not touch swap size specified in bdm, # but works with flavor specified size only. # In this case we follow the legacy logic and ignore block # device info completely. # NOTE(ft): This workaround must be removed when a correct # implementation of resize operation changing sizes in bdms is # developed. Also at that stage we probably may get rid of # the direct usage of flavor swap size here, # leaving the work with bdm only. swap_mb = inst_type['swap'] else: swap = driver.block_device_info_get_swap(block_device_info) if driver.swap_is_usable(swap): swap_mb = swap['swap_size'] elif (inst_type['swap'] > 0 and not block_device.volume_in_mapping( mapping['dev'], block_device_info)): swap_mb = inst_type['swap'] if swap_mb > 0: if (CONF.libvirt.virt_type == "parallels" and instance.vm_mode == fields.VMMode.EXE): msg = _("Swap disk is not supported " "for Virtuozzo container") raise exception.Invalid(msg) if not disk_images: disk_images = {'image_id': instance.image_ref, 'kernel_id': instance.kernel_id, 'ramdisk_id': instance.ramdisk_id} # NOTE(mdbooth): kernel and ramdisk, if they are defined, are hardcoded # to use raw, which means they will always be cleaned up with the # instance directory. We must not consider them for created_disks, # which may not be using the instance directory. if disk_images['kernel_id']: fname = imagecache.get_cache_fname(disk_images['kernel_id']) raw('kernel').cache(fetch_func=libvirt_utils.fetch_raw_image, context=context, filename=fname, image_id=disk_images['kernel_id']) if disk_images['ramdisk_id']: fname = imagecache.get_cache_fname(disk_images['ramdisk_id']) raw('ramdisk').cache(fetch_func=libvirt_utils.fetch_raw_image, context=context, filename=fname, image_id=disk_images['ramdisk_id']) if CONF.libvirt.virt_type == 'uml': # PONDERING(mikal): can I assume that root is UID zero in every # OS? Probably not. uid = pwd.getpwnam('root').pw_uid nova.privsep.path.chown(image('disk').path, uid=uid) created_disks = self._create_and_inject_local_root( context, instance, booted_from_volume, suffix, disk_images, injection_info, fallback_from_host) # Lookup the filesystem type if required os_type_with_default = nova.privsep.fs.get_fs_type_for_os_type( instance.os_type) # Generate a file extension based on the file system # type and the mkfs commands configured if any file_extension = nova.privsep.fs.get_file_extension_for_os_type( os_type_with_default, CONF.default_ephemeral_format) vm_mode = fields.VMMode.get_from_instance(instance) ephemeral_gb = instance.flavor.ephemeral_gb if 'disk.local' in disk_mapping: disk_image = image('disk.local') # Short circuit the exists() tests if we already created a disk created_disks = created_disks or not disk_image.exists() fn = functools.partial(self._create_ephemeral, fs_label='ephemeral0', os_type=instance.os_type, is_block_dev=disk_image.is_block_dev, vm_mode=vm_mode) fname = "ephemeral_%s_%s" % (ephemeral_gb, file_extension) size = ephemeral_gb * units.Gi disk_image.cache(fetch_func=fn, context=context, filename=fname, size=size, ephemeral_size=ephemeral_gb) for idx, eph in enumerate(driver.block_device_info_get_ephemerals( block_device_info)): disk_image = image(blockinfo.get_eph_disk(idx)) # Short circuit the exists() tests if we already created a disk created_disks = created_disks or not disk_image.exists() specified_fs = eph.get('guest_format') if specified_fs and not self.is_supported_fs_format(specified_fs): msg = _("%s format is not supported") % specified_fs raise exception.InvalidBDMFormat(details=msg) fn = functools.partial(self._create_ephemeral, fs_label='ephemeral%d' % idx, os_type=instance.os_type, is_block_dev=disk_image.is_block_dev, vm_mode=vm_mode) size = eph['size'] * units.Gi fname = "ephemeral_%s_%s" % (eph['size'], file_extension) disk_image.cache(fetch_func=fn, context=context, filename=fname, size=size, ephemeral_size=eph['size'], specified_fs=specified_fs) if swap_mb > 0: size = swap_mb * units.Mi swap = image('disk.swap') # Short circuit the exists() tests if we already created a disk created_disks = created_disks or not swap.exists() swap.cache(fetch_func=self._create_swap, context=context, filename="swap_%s" % swap_mb, size=size, swap_mb=swap_mb) if created_disks: LOG.debug('Created local disks', instance=instance) else: LOG.debug('Did not create local disks', instance=instance) return (created_instance_dir, created_disks) def _create_and_inject_local_root(self, context, instance, booted_from_volume, suffix, disk_images, injection_info, fallback_from_host): created_disks = False # File injection only if needed need_inject = (not configdrive.required_by(instance) and injection_info is not None and CONF.libvirt.inject_partition != -2) # NOTE(ndipanov): Even if disk_mapping was passed in, which # currently happens only on rescue - we still don't want to # create a base image. if not booted_from_volume: root_fname = imagecache.get_cache_fname(disk_images['image_id']) size = instance.flavor.root_gb * units.Gi if size == 0 or suffix == '.rescue': size = None backend = self.image_backend.by_name(instance, 'disk' + suffix, CONF.libvirt.images_type) created_disks = not backend.exists() if instance.task_state == task_states.RESIZE_FINISH: backend.create_snap(libvirt_utils.RESIZE_SNAPSHOT_NAME) if backend.SUPPORTS_CLONE: def clone_fallback_to_fetch( context, target, image_id, trusted_certs=None, ): refuse_fetch = ( CONF.libvirt.images_type == 'rbd' and CONF.workarounds.never_download_image_if_on_rbd) try: backend.clone(context, disk_images['image_id']) except exception.ImageUnacceptable: if refuse_fetch: # Re-raise the exception from the failed # ceph clone. The compute manager expects # ImageUnacceptable as a possible result # of spawn(), from which this is called. with excutils.save_and_reraise_exception(): LOG.warning( 'Image %s is not on my ceph and ' '[workarounds]/' 'never_download_image_if_on_rbd=True;' ' refusing to fetch and upload.', disk_images['image_id']) libvirt_utils.fetch_image( context, target, image_id, trusted_certs, ) fetch_func = clone_fallback_to_fetch else: fetch_func = libvirt_utils.fetch_image self._try_fetch_image_cache(backend, fetch_func, context, root_fname, disk_images['image_id'], instance, size, fallback_from_host) # During unshelve on Qcow2 backend, we spawn() using snapshot image # created during shelve. Extra work is needed in order to rebase # disk image to its original image_ref. Disk backing file will # then represent back image_ref instead of shelved image. if (instance.vm_state == vm_states.SHELVED_OFFLOADED and isinstance(backend, imagebackend.Qcow2)): self._finalize_unshelve_qcow2_image(context, instance, backend) if need_inject: self._inject_data(backend, instance, injection_info) elif need_inject: LOG.warning('File injection into a boot from volume ' 'instance is not supported', instance=instance) return created_disks def _finalize_unshelve_qcow2_image(self, context, instance, backend): # NOTE(aarents): During qcow2 instance unshelve, backing file # represents shelved image, not original instance.image_ref. # We rebase here instance disk to original image. # This second fetch call does nothing except downloading original # backing file if missing, as image disk have already been # created/resized by first fetch call. base_dir = self.image_cache_manager.cache_dir base_image_ref = instance.system_metadata.get('image_base_image_ref') root_fname = imagecache.get_cache_fname(base_image_ref) base_backing_fname = os.path.join(base_dir, root_fname) try: self._try_fetch_image_cache(backend, libvirt_utils.fetch_image, context, root_fname, base_image_ref, instance, None) except exception.ImageNotFound: # We must flatten here in order to remove dependency with an orphan # backing file (as shelved image will be dropped once unshelve # is successfull). LOG.warning('Current disk image is created on top of shelved ' 'image and cannot be rebased to original image ' 'because it is no longer available in the image ' 'service, disk will be consequently flattened.', instance=instance) base_backing_fname = None LOG.info('Rebasing disk image.', instance=instance) self._rebase_with_qemu_img(backend.path, base_backing_fname) def _create_configdrive(self, context, instance, injection_info, rescue=False): # As this method being called right after the definition of a # domain, but before its actual launch, device metadata will be built # and saved in the instance for it to be used by the config drive and # the metadata service. instance.device_metadata = self._build_device_metadata(context, instance) if configdrive.required_by(instance): LOG.info('Using config drive', instance=instance) name = 'disk.config' if rescue: name += '.rescue' config_disk = self.image_backend.by_name( instance, name, self._get_disk_config_image_type()) # Don't overwrite an existing config drive if not config_disk.exists(): extra_md = {} if injection_info.admin_pass: extra_md['admin_pass'] = injection_info.admin_pass inst_md = instance_metadata.InstanceMetadata( instance, content=injection_info.files, extra_md=extra_md, network_info=injection_info.network_info, request_context=context) cdb = configdrive.ConfigDriveBuilder(instance_md=inst_md) with cdb: # NOTE(mdbooth): We're hardcoding here the path of the # config disk when using the flat backend. This isn't # good, but it's required because we need a local path we # know we can write to in case we're subsequently # importing into rbd. This will be cleaned up when we # replace this with a call to create_from_func, but that # can't happen until we've updated the backends and we # teach them not to cache config disks. This isn't # possible while we're still using cache() under the hood. config_disk_local_path = os.path.join( libvirt_utils.get_instance_path(instance), name) LOG.info('Creating config drive at %(path)s', {'path': config_disk_local_path}, instance=instance) try: cdb.make_drive(config_disk_local_path) except processutils.ProcessExecutionError as e: with excutils.save_and_reraise_exception(): LOG.error('Creating config drive failed with ' 'error: %s', e, instance=instance) try: config_disk.import_file( instance, config_disk_local_path, name) finally: # NOTE(mikal): if the config drive was imported into RBD, # then we no longer need the local copy if CONF.libvirt.images_type == 'rbd': LOG.info('Deleting local config drive %(path)s ' 'because it was imported into RBD.', {'path': config_disk_local_path}, instance=instance) os.unlink(config_disk_local_path) def _prepare_pci_devices_for_use(self, pci_devices): # kvm , qemu support managed mode # In managed mode, the configured device will be automatically # detached from the host OS drivers when the guest is started, # and then re-attached when the guest shuts down. if CONF.libvirt.virt_type != 'xen': # we do manual detach only for xen return try: for dev in pci_devices: libvirt_dev_addr = dev['hypervisor_name'] libvirt_dev = \ self._host.device_lookup_by_name(libvirt_dev_addr) # Note(yjiang5) Spelling for 'dettach' is correct, see # http://libvirt.org/html/libvirt-libvirt.html. libvirt_dev.dettach() # Note(yjiang5): A reset of one PCI device may impact other # devices on the same bus, thus we need two separated loops # to detach and then reset it. for dev in pci_devices: libvirt_dev_addr = dev['hypervisor_name'] libvirt_dev = \ self._host.device_lookup_by_name(libvirt_dev_addr) libvirt_dev.reset() except libvirt.libvirtError as exc: raise exception.PciDevicePrepareFailed(id=dev['id'], instance_uuid= dev['instance_uuid'], reason=six.text_type(exc)) def _detach_pci_devices(self, guest, pci_devs): try: for dev in pci_devs: guest.detach_device(self._get_guest_pci_device(dev), live=True) # after detachDeviceFlags returned, we should check the dom to # ensure the detaching is finished xml = guest.get_xml_desc() xml_doc = etree.fromstring(xml) guest_config = vconfig.LibvirtConfigGuest() guest_config.parse_dom(xml_doc) for hdev in [d for d in guest_config.devices if isinstance(d, vconfig.LibvirtConfigGuestHostdevPCI)]: hdbsf = [hdev.domain, hdev.bus, hdev.slot, hdev.function] dbsf = pci_utils.parse_address(dev.address) if [int(x, 16) for x in hdbsf] ==\ [int(x, 16) for x in dbsf]: raise exception.PciDeviceDetachFailed(reason= "timeout", dev=dev) except libvirt.libvirtError as ex: error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_NO_DOMAIN: LOG.warning("Instance disappeared while detaching " "a PCI device from it.") else: raise def _attach_pci_devices(self, guest, pci_devs): try: for dev in pci_devs: guest.attach_device(self._get_guest_pci_device(dev)) except libvirt.libvirtError: LOG.error('Attaching PCI devices %(dev)s to %(dom)s failed.', {'dev': pci_devs, 'dom': guest.id}) raise @staticmethod def _has_direct_passthrough_port(network_info): for vif in network_info: if (vif['vnic_type'] in network_model.VNIC_TYPES_DIRECT_PASSTHROUGH): return True return False def _attach_direct_passthrough_ports( self, context, instance, guest, network_info=None): if network_info is None: network_info = instance.info_cache.network_info if network_info is None: return if self._has_direct_passthrough_port(network_info): for vif in network_info: if (vif['vnic_type'] in network_model.VNIC_TYPES_DIRECT_PASSTHROUGH): cfg = self.vif_driver.get_config(instance, vif, instance.image_meta, instance.flavor, CONF.libvirt.virt_type) LOG.debug('Attaching direct passthrough port %(port)s ' 'to %(dom)s', {'port': vif, 'dom': guest.id}, instance=instance) guest.attach_device(cfg) def _detach_direct_passthrough_ports(self, context, instance, guest): network_info = instance.info_cache.network_info if network_info is None: return if self._has_direct_passthrough_port(network_info): # In case of VNIC_TYPES_DIRECT_PASSTHROUGH ports we create # pci request per direct passthrough port. Therefore we can trust # that pci_slot value in the vif is correct. direct_passthrough_pci_addresses = [ vif['profile']['pci_slot'] for vif in network_info if (vif['vnic_type'] in network_model.VNIC_TYPES_DIRECT_PASSTHROUGH and vif['profile'].get('pci_slot') is not None) ] # use detach_pci_devices to avoid failure in case of # multiple guest direct passthrough ports with the same MAC # (protection use-case, ports are on different physical # interfaces) pci_devs = pci_manager.get_instance_pci_devs(instance, 'all') direct_passthrough_pci_addresses = ( [pci_dev for pci_dev in pci_devs if pci_dev.address in direct_passthrough_pci_addresses]) self._detach_pci_devices(guest, direct_passthrough_pci_addresses) def _update_compute_provider_status(self, context, service): """Calls the ComputeVirtAPI.update_compute_provider_status method :param context: nova auth RequestContext :param service: nova.objects.Service record for this host which is expected to only manage a single ComputeNode """ rp_uuid = None try: rp_uuid = service.compute_node.uuid self.virtapi.update_compute_provider_status( context, rp_uuid, enabled=not service.disabled) except Exception: # This is best effort so just log the exception but don't fail. # The update_available_resource periodic task will sync the trait. LOG.warning( 'An error occurred while updating compute node ' 'resource provider status to "%s" for provider: %s', 'disabled' if service.disabled else 'enabled', rp_uuid or service.host, exc_info=True) def _set_host_enabled(self, enabled, disable_reason=DISABLE_REASON_UNDEFINED): """Enables / Disables the compute service on this host. This doesn't override non-automatic disablement with an automatic setting; thereby permitting operators to keep otherwise healthy hosts out of rotation. """ status_name = {True: 'disabled', False: 'enabled'} disable_service = not enabled ctx = nova_context.get_admin_context() try: service = objects.Service.get_by_compute_host(ctx, CONF.host) if service.disabled != disable_service: # Note(jang): this is a quick fix to stop operator- # disabled compute hosts from re-enabling themselves # automatically. We prefix any automatic reason code # with a fixed string. We only re-enable a host # automatically if we find that string in place. # This should probably be replaced with a separate flag. if not service.disabled or ( service.disabled_reason and service.disabled_reason.startswith(DISABLE_PREFIX)): service.disabled = disable_service service.disabled_reason = ( DISABLE_PREFIX + disable_reason if disable_service and disable_reason else DISABLE_REASON_UNDEFINED) service.save() LOG.debug('Updating compute service status to %s', status_name[disable_service]) # Update the disabled trait status on the corresponding # compute node resource provider in placement. self._update_compute_provider_status(ctx, service) else: LOG.debug('Not overriding manual compute service ' 'status with: %s', status_name[disable_service]) except exception.ComputeHostNotFound: LOG.warning('Cannot update service status on host "%s" ' 'since it is not registered.', CONF.host) except Exception: LOG.warning('Cannot update service status on host "%s" ' 'due to an unexpected exception.', CONF.host, exc_info=True) if enabled: mount.get_manager().host_up(self._host) else: mount.get_manager().host_down() def _get_cpu_model_mapping(self, model): """Get the CPU model mapping The CPU models which admin configured are case-insensitive, libvirt is case-sensitive, therefore build a mapping to get the correct CPU model name. :param model: Case-insensitive CPU model name. :return: It will validate and return the case-sensitive CPU model name if on a supported platform, otherwise it will just return what was provided :raises: exception.InvalidCPUInfo if the CPU model is not supported. """ cpu_info = self._get_cpu_info() if cpu_info['arch'] not in (fields.Architecture.I686, fields.Architecture.X86_64, fields.Architecture.PPC64, fields.Architecture.PPC64LE, fields.Architecture.PPC): return model if not self.cpu_models_mapping: cpu_models = self._host.get_cpu_model_names() for cpu_model in cpu_models: self.cpu_models_mapping[cpu_model.lower()] = cpu_model if model.lower() not in self.cpu_models_mapping: msg = (_("Configured CPU model: %(model)s is not correct, " "or your host CPU arch does not support this " "model. Please correct your config and try " "again.") % {'model': model}) raise exception.InvalidCPUInfo(msg) return self.cpu_models_mapping.get(model.lower()) def _get_guest_cpu_model_config(self, flavor=None): mode = CONF.libvirt.cpu_mode models = [self._get_cpu_model_mapping(model) for model in CONF.libvirt.cpu_models] extra_flags = set([flag.lower() for flag in CONF.libvirt.cpu_model_extra_flags]) if (CONF.libvirt.virt_type == "kvm" or CONF.libvirt.virt_type == "qemu"): caps = self._host.get_capabilities() if mode is None: # AArch64 lacks 'host-model' support because neither libvirt # nor QEMU are able to tell what the host CPU model exactly is. # And there is no CPU description code for ARM(64) at this # point. # Also worth noting: 'host-passthrough' mode will completely # break live migration, *unless* all the Compute nodes (running # libvirtd) have *identical* CPUs. if caps.host.cpu.arch == fields.Architecture.AARCH64: mode = "host-passthrough" LOG.info('CPU mode "host-passthrough" was chosen. Live ' 'migration can break unless all compute nodes ' 'have identical cpus. AArch64 does not support ' 'other modes.') else: mode = "host-model" if mode == "none": return vconfig.LibvirtConfigGuestCPU() # On AArch64 platform the return of _get_cpu_model_mapping will not # return the default CPU model. if mode == "custom": if caps.host.cpu.arch == fields.Architecture.AARCH64: if not models: models = ['max'] else: if mode is None or mode == "none": return None cpu = vconfig.LibvirtConfigGuestCPU() cpu.mode = mode cpu.model = models[0] if models else None # compare flavor trait and cpu models, select the first mathched model if flavor and mode == "custom": flags = libvirt_utils.get_flags_by_flavor_specs(flavor) if flags: cpu.model = self._match_cpu_model_by_flags(models, flags) LOG.debug("CPU mode '%(mode)s' models '%(models)s' was chosen, " "with extra flags: '%(extra_flags)s'", {'mode': mode, 'models': (cpu.model or ""), 'extra_flags': (extra_flags or "")}) # NOTE (kchamart): Currently there's no existing way to ask if a # given CPU model + CPU flags combination is supported by KVM & # a specific QEMU binary. However, libvirt runs the 'CPUID' # command upfront -- before even a Nova instance (a QEMU # process) is launched -- to construct CPU models and check # their validity; so we are good there. In the long-term, # upstream libvirt intends to add an additional new API that can # do fine-grained validation of a certain CPU model + CPU flags # against a specific QEMU binary (the libvirt RFE bug for that: # https://bugzilla.redhat.com/show_bug.cgi?id=1559832). for flag in extra_flags: cpu.add_feature(vconfig.LibvirtConfigGuestCPUFeature(flag)) return cpu def _match_cpu_model_by_flags(self, models, flags): for model in models: if flags.issubset(self.cpu_model_flag_mapping.get(model, set([]))): return model cpu = vconfig.LibvirtConfigCPU() cpu.arch = self._host.get_capabilities().host.cpu.arch cpu.model = model features_xml = self._get_guest_baseline_cpu_features(cpu.to_xml()) if features_xml: cpu.parse_str(features_xml) feature_names = [f.name for f in cpu.features] self.cpu_model_flag_mapping[model] = feature_names if flags.issubset(feature_names): return model msg = ('No CPU model match traits, models: {models}, required ' 'flags: {flags}'.format(models=models, flags=flags)) raise exception.InvalidCPUInfo(msg) def _get_guest_cpu_config(self, flavor, image_meta, guest_cpu_numa_config, instance_numa_topology): cpu = self._get_guest_cpu_model_config(flavor) if cpu is None: return None topology = hardware.get_best_cpu_topology( flavor, image_meta, numa_topology=instance_numa_topology) cpu.sockets = topology.sockets cpu.cores = topology.cores cpu.threads = topology.threads cpu.numa = guest_cpu_numa_config return cpu def _get_guest_disk_config(self, instance, name, disk_mapping, inst_type, image_type=None, boot_order=None): disk_unit = None disk = self.image_backend.by_name(instance, name, image_type) if (name == 'disk.config' and image_type == 'rbd' and not disk.exists()): # This is likely an older config drive that has not been migrated # to rbd yet. Try to fall back on 'flat' image type. # TODO(melwitt): Add online migration of some sort so we can # remove this fall back once we know all config drives are in rbd. # NOTE(vladikr): make sure that the flat image exist, otherwise # the image will be created after the domain definition. flat_disk = self.image_backend.by_name(instance, name, 'flat') if flat_disk.exists(): disk = flat_disk LOG.debug('Config drive not found in RBD, falling back to the ' 'instance directory', instance=instance) disk_info = disk_mapping[name] if 'unit' in disk_mapping and disk_info['bus'] == 'scsi': disk_unit = disk_mapping['unit'] disk_mapping['unit'] += 1 # Increments for the next disk added conf = disk.libvirt_info(disk_info, self.disk_cachemode, inst_type['extra_specs'], self._host.get_version(), disk_unit=disk_unit, boot_order=boot_order) return conf def _get_guest_fs_config(self, instance, name, image_type=None): disk = self.image_backend.by_name(instance, name, image_type) return disk.libvirt_fs_info("/", "ploop") def _get_guest_storage_config(self, context, instance, image_meta, disk_info, rescue, block_device_info, inst_type, os_type): devices = [] disk_mapping = disk_info['mapping'] block_device_mapping = driver.block_device_info_get_mapping( block_device_info) mount_rootfs = CONF.libvirt.virt_type == "lxc" scsi_controller = self._get_scsi_controller(image_meta) if scsi_controller and scsi_controller.model == 'virtio-scsi': # The virtio-scsi can handle up to 256 devices but the # optional element "address" must be defined to describe # where the device is placed on the controller (see: # LibvirtConfigGuestDeviceAddressDrive). # # Note about why it's added in disk_mapping: It's not # possible to pass an 'int' by reference in Python, so we # use disk_mapping as container to keep reference of the # unit added and be able to increment it for each disk # added. # # NOTE(jaypipes,melwitt): If this is a boot-from-volume instance, # we need to start the disk mapping unit at 1 since we set the # bootable volume's unit to 0 for the bootable volume. disk_mapping['unit'] = 0 if self._is_booted_from_volume(block_device_info): disk_mapping['unit'] = 1 def _get_ephemeral_devices(): eph_devices = [] for idx, eph in enumerate( driver.block_device_info_get_ephemerals( block_device_info)): diskeph = self._get_guest_disk_config( instance, blockinfo.get_eph_disk(idx), disk_mapping, inst_type) eph_devices.append(diskeph) return eph_devices if mount_rootfs: fs = vconfig.LibvirtConfigGuestFilesys() fs.source_type = "mount" fs.source_dir = os.path.join( libvirt_utils.get_instance_path(instance), 'rootfs') devices.append(fs) elif (os_type == fields.VMMode.EXE and CONF.libvirt.virt_type == "parallels"): if rescue: fsrescue = self._get_guest_fs_config(instance, "disk.rescue") devices.append(fsrescue) fsos = self._get_guest_fs_config(instance, "disk") fsos.target_dir = "/mnt/rescue" devices.append(fsos) else: if 'disk' in disk_mapping: fs = self._get_guest_fs_config(instance, "disk") devices.append(fs) devices = devices + _get_ephemeral_devices() else: if rescue and disk_mapping['disk.rescue'] == disk_mapping['root']: diskrescue = self._get_guest_disk_config(instance, 'disk.rescue', disk_mapping, inst_type) devices.append(diskrescue) diskos = self._get_guest_disk_config(instance, 'disk', disk_mapping, inst_type) devices.append(diskos) else: if 'disk' in disk_mapping: diskos = self._get_guest_disk_config(instance, 'disk', disk_mapping, inst_type) devices.append(diskos) if 'disk.local' in disk_mapping: disklocal = self._get_guest_disk_config(instance, 'disk.local', disk_mapping, inst_type) devices.append(disklocal) instance.default_ephemeral_device = ( block_device.prepend_dev(disklocal.target_dev)) devices = devices + _get_ephemeral_devices() if 'disk.swap' in disk_mapping: diskswap = self._get_guest_disk_config(instance, 'disk.swap', disk_mapping, inst_type) devices.append(diskswap) instance.default_swap_device = ( block_device.prepend_dev(diskswap.target_dev)) config_name = 'disk.config' if rescue and disk_mapping['disk.rescue'] == disk_mapping['root']: config_name = 'disk.config.rescue' if config_name in disk_mapping: diskconfig = self._get_guest_disk_config( instance, config_name, disk_mapping, inst_type, self._get_disk_config_image_type()) devices.append(diskconfig) for vol in block_device.get_bdms_to_connect(block_device_mapping, mount_rootfs): connection_info = vol['connection_info'] vol_dev = block_device.prepend_dev(vol['mount_device']) info = disk_mapping[vol_dev] self._connect_volume(context, connection_info, instance) if scsi_controller and scsi_controller.model == 'virtio-scsi': # Check if this is the bootable volume when in a # boot-from-volume instance, and if so, ensure the unit # attribute is 0. if vol.get('boot_index') == 0: info['unit'] = 0 else: info['unit'] = disk_mapping['unit'] disk_mapping['unit'] += 1 cfg = self._get_volume_config(connection_info, info) devices.append(cfg) vol['connection_info'] = connection_info vol.save() for d in devices: self._set_cache_mode(d) if scsi_controller: devices.append(scsi_controller) if rescue and disk_mapping['disk.rescue'] != disk_mapping['root']: diskrescue = self._get_guest_disk_config(instance, 'disk.rescue', disk_mapping, inst_type, boot_order='1') devices.append(diskrescue) return devices @staticmethod def _get_scsi_controller(image_meta): """Return scsi controller or None based on image meta""" if image_meta.properties.get('hw_scsi_model'): hw_scsi_model = image_meta.properties.hw_scsi_model scsi_controller = vconfig.LibvirtConfigGuestController() scsi_controller.type = 'scsi' scsi_controller.model = hw_scsi_model scsi_controller.index = 0 return scsi_controller def _get_host_sysinfo_serial_hardware(self): """Get a UUID from the host hardware Get a UUID for the host hardware reported by libvirt. This is typically from the SMBIOS data, unless it has been overridden in /etc/libvirt/libvirtd.conf """ caps = self._host.get_capabilities() return caps.host.uuid def _get_host_sysinfo_serial_os(self): """Get a UUID from the host operating system Get a UUID for the host operating system. Modern Linux distros based on systemd provide a /etc/machine-id file containing a UUID. This is also provided inside systemd based containers and can be provided by other init systems too, since it is just a plain text file. """ if not os.path.exists("/etc/machine-id"): msg = _("Unable to get host UUID: /etc/machine-id does not exist") raise exception.InternalError(msg) with open("/etc/machine-id") as f: # We want to have '-' in the right place # so we parse & reformat the value lines = f.read().split() if not lines: msg = _("Unable to get host UUID: /etc/machine-id is empty") raise exception.InternalError(msg) return str(uuid.UUID(lines[0])) def _get_host_sysinfo_serial_auto(self): if os.path.exists("/etc/machine-id"): return self._get_host_sysinfo_serial_os() else: return self._get_host_sysinfo_serial_hardware() def _get_guest_config_sysinfo(self, instance): sysinfo = vconfig.LibvirtConfigGuestSysinfo() sysinfo.system_manufacturer = version.vendor_string() sysinfo.system_product = version.product_string() sysinfo.system_version = version.version_string_with_package() if CONF.libvirt.sysinfo_serial == 'unique': sysinfo.system_serial = instance.uuid else: sysinfo.system_serial = self._sysinfo_serial_func() sysinfo.system_uuid = instance.uuid sysinfo.system_family = "Virtual Machine" return sysinfo def _set_managed_mode(self, pcidev): # only kvm support managed mode if CONF.libvirt.virt_type in ('xen', 'parallels',): pcidev.managed = 'no' if CONF.libvirt.virt_type in ('kvm', 'qemu'): pcidev.managed = 'yes' def _get_guest_pci_device(self, pci_device): dbsf = pci_utils.parse_address(pci_device.address) dev = vconfig.LibvirtConfigGuestHostdevPCI() dev.domain, dev.bus, dev.slot, dev.function = dbsf self._set_managed_mode(dev) return dev def _get_guest_config_meta(self, instance): """Get metadata config for guest.""" meta = vconfig.LibvirtConfigGuestMetaNovaInstance() meta.package = version.version_string_with_package() meta.name = instance.display_name meta.creationTime = time.time() if instance.image_ref not in ("", None): meta.roottype = "image" meta.rootid = instance.image_ref system_meta = instance.system_metadata ometa = vconfig.LibvirtConfigGuestMetaNovaOwner() ometa.userid = instance.user_id ometa.username = system_meta.get('owner_user_name', 'N/A') ometa.projectid = instance.project_id ometa.projectname = system_meta.get('owner_project_name', 'N/A') meta.owner = ometa fmeta = vconfig.LibvirtConfigGuestMetaNovaFlavor() flavor = instance.flavor fmeta.name = flavor.name fmeta.memory = flavor.memory_mb fmeta.vcpus = flavor.vcpus fmeta.ephemeral = flavor.ephemeral_gb fmeta.disk = flavor.root_gb fmeta.swap = flavor.swap meta.flavor = fmeta return meta @staticmethod def _create_idmaps(klass, map_strings): idmaps = [] if len(map_strings) > 5: map_strings = map_strings[0:5] LOG.warning("Too many id maps, only included first five.") for map_string in map_strings: try: idmap = klass() values = [int(i) for i in map_string.split(":")] idmap.start = values[0] idmap.target = values[1] idmap.count = values[2] idmaps.append(idmap) except (ValueError, IndexError): LOG.warning("Invalid value for id mapping %s", map_string) return idmaps def _get_guest_idmaps(self): id_maps: ty.List[vconfig.LibvirtConfigGuestIDMap] = [] if CONF.libvirt.virt_type == 'lxc' and CONF.libvirt.uid_maps: uid_maps = self._create_idmaps(vconfig.LibvirtConfigGuestUIDMap, CONF.libvirt.uid_maps) id_maps.extend(uid_maps) if CONF.libvirt.virt_type == 'lxc' and CONF.libvirt.gid_maps: gid_maps = self._create_idmaps(vconfig.LibvirtConfigGuestGIDMap, CONF.libvirt.gid_maps) id_maps.extend(gid_maps) return id_maps def _update_guest_cputune(self, guest, flavor, virt_type): is_able = self._host.is_cpu_control_policy_capable() cputuning = ['shares', 'period', 'quota'] wants_cputune = any([k for k in cputuning if "quota:cpu_" + k in flavor.extra_specs.keys()]) if wants_cputune and not is_able: raise exception.UnsupportedHostCPUControlPolicy() if not is_able or virt_type not in ('lxc', 'kvm', 'qemu'): return if guest.cputune is None: guest.cputune = vconfig.LibvirtConfigGuestCPUTune() # Setting the default cpu.shares value to be a value # dependent on the number of vcpus guest.cputune.shares = 1024 * guest.vcpus for name in cputuning: key = "quota:cpu_" + name if key in flavor.extra_specs: setattr(guest.cputune, name, int(flavor.extra_specs[key])) def _get_cpu_numa_config_from_instance(self, instance_numa_topology, wants_hugepages): if instance_numa_topology: guest_cpu_numa = vconfig.LibvirtConfigGuestCPUNUMA() for instance_cell in instance_numa_topology.cells: guest_cell = vconfig.LibvirtConfigGuestCPUNUMACell() guest_cell.id = instance_cell.id guest_cell.cpus = instance_cell.total_cpus guest_cell.memory = instance_cell.memory * units.Ki # The vhost-user network backend requires file backed # guest memory (ie huge pages) to be marked as shared # access, not private, so an external process can read # and write the pages. # # You can't change the shared vs private flag for an # already running guest, and since we can't predict what # types of NIC may be hotplugged, we have no choice but # to unconditionally turn on the shared flag. This has # no real negative functional effect on the guest, so # is a reasonable approach to take if wants_hugepages: guest_cell.memAccess = "shared" guest_cpu_numa.cells.append(guest_cell) return guest_cpu_numa def _wants_hugepages(self, host_topology, instance_topology): """Determine if the guest / host topology implies the use of huge pages for guest RAM backing """ if host_topology is None or instance_topology is None: return False avail_pagesize = [page.size_kb for page in host_topology.cells[0].mempages] avail_pagesize.sort() # Remove smallest page size as that's not classed as a largepage avail_pagesize = avail_pagesize[1:] # See if we have page size set for cell in instance_topology.cells: if (cell.pagesize is not None and cell.pagesize in avail_pagesize): return True return False def _get_cell_pairs(self, guest_cpu_numa_config, host_topology): """Returns the lists of pairs(tuple) of an instance cell and corresponding host cell: [(LibvirtConfigGuestCPUNUMACell, NUMACell), ...] """ cell_pairs = [] for guest_config_cell in guest_cpu_numa_config.cells: for host_cell in host_topology.cells: if guest_config_cell.id == host_cell.id: cell_pairs.append((guest_config_cell, host_cell)) return cell_pairs def _get_pin_cpuset(self, vcpu, inst_cell, host_cell): """Returns the config object of LibvirtConfigGuestCPUTuneVCPUPin. Prepares vcpupin config for the guest with the following caveats: a) If the specified instance vCPU is intended to be pinned, we pin it to the previously selected host CPU. b) Otherwise we float over the whole host NUMA node """ pin_cpuset = vconfig.LibvirtConfigGuestCPUTuneVCPUPin() pin_cpuset.id = vcpu # 'InstanceNUMACell.cpu_pinning' tracks the CPU pinning pair for guest # CPU and host CPU. If the guest CPU is in the keys of 'cpu_pinning', # fetch the host CPU from it and pin on it, otherwise, let the guest # CPU be floating on the sharing CPU set belonging to this NUMA cell. if inst_cell.cpu_pinning and vcpu in inst_cell.cpu_pinning: pin_cpuset.cpuset = set([inst_cell.cpu_pinning[vcpu]]) else: pin_cpuset.cpuset = host_cell.cpuset return pin_cpuset def _get_emulatorpin_cpuset(self, vcpu, object_numa_cell, vcpus_rt, emulator_threads_policy, pin_cpuset): """Returns a set of cpu_ids to add to the cpuset for emulator threads with the following caveats: a) If emulator threads policy is isolated, we pin emulator threads to one cpu we have reserved for it. b) If emulator threads policy is shared and CONF.cpu_shared_set is defined, we pin emulator threads on the set of pCPUs defined by CONF.cpu_shared_set c) Otherwise; c1) If realtime IS NOT enabled, the emulator threads are allowed to float cross all the pCPUs associated with the guest vCPUs. c2) If realtime IS enabled, at least 1 vCPU is required to be set aside for non-realtime usage. The emulator threads are allowed to float across the pCPUs that are associated with the non-realtime VCPUs. """ emulatorpin_cpuset = set([]) shared_ids = hardware.get_cpu_shared_set() if emulator_threads_policy == fields.CPUEmulatorThreadsPolicy.ISOLATE: if object_numa_cell.cpuset_reserved: emulatorpin_cpuset = object_numa_cell.cpuset_reserved elif ((emulator_threads_policy == fields.CPUEmulatorThreadsPolicy.SHARE) and shared_ids): online_pcpus = self._host.get_online_cpus() cpuset = shared_ids & online_pcpus if not cpuset: msg = (_("Invalid cpu_shared_set config, one or more of the " "specified cpuset is not online. Online cpuset(s): " "%(online)s, requested cpuset(s): %(req)s"), {'online': sorted(online_pcpus), 'req': sorted(shared_ids)}) raise exception.Invalid(msg) emulatorpin_cpuset = cpuset elif not vcpus_rt or vcpu not in vcpus_rt: emulatorpin_cpuset = pin_cpuset.cpuset return emulatorpin_cpuset def _get_guest_numa_config(self, instance_numa_topology, flavor, image_meta): """Returns the config objects for the guest NUMA specs. Determines the CPUs that the guest can be pinned to if the guest specifies a cell topology and the host supports it. Constructs the libvirt XML config object representing the NUMA topology selected for the guest. Returns a tuple of: (cpu_set, guest_cpu_tune, guest_cpu_numa, guest_numa_tune) With the following caveats: a) If there is no specified guest NUMA topology, then all tuple elements except cpu_set shall be None. cpu_set will be populated with the chosen CPUs that the guest allowed CPUs fit within. b) If there is a specified guest NUMA topology, then cpu_set will be None and guest_cpu_numa will be the LibvirtConfigGuestCPUNUMA object representing the guest's NUMA topology. If the host supports NUMA, then guest_cpu_tune will contain a LibvirtConfigGuestCPUTune object representing the optimized chosen cells that match the host capabilities with the instance's requested topology. If the host does not support NUMA, then guest_cpu_tune and guest_numa_tune will be None. """ if (not self._has_numa_support() and instance_numa_topology is not None): # We should not get here, since we should have avoided # reporting NUMA topology from _get_host_numa_topology # in the first place. Just in case of a scheduler # mess up though, raise an exception raise exception.NUMATopologyUnsupported() # We only pin an instance to some host cores if the user has provided # configuration to suggest we should. shared_cpus = None if CONF.vcpu_pin_set or CONF.compute.cpu_shared_set: shared_cpus = self._get_vcpu_available() topology = self._get_host_numa_topology() # We have instance NUMA so translate it to the config class guest_cpu_numa_config = self._get_cpu_numa_config_from_instance( instance_numa_topology, self._wants_hugepages(topology, instance_numa_topology)) if not guest_cpu_numa_config: # No NUMA topology defined for instance - let the host kernel deal # with the NUMA effects. # TODO(ndipanov): Attempt to spread the instance # across NUMA nodes and expose the topology to the # instance as an optimisation return GuestNumaConfig(shared_cpus, None, None, None) if not topology: # No NUMA topology defined for host - This will only happen with # some libvirt versions and certain platforms. return GuestNumaConfig(shared_cpus, None, guest_cpu_numa_config, None) # Now get configuration from the numa_topology # Init CPUTune configuration guest_cpu_tune = vconfig.LibvirtConfigGuestCPUTune() guest_cpu_tune.emulatorpin = ( vconfig.LibvirtConfigGuestCPUTuneEmulatorPin()) guest_cpu_tune.emulatorpin.cpuset = set([]) # Init NUMATune configuration guest_numa_tune = vconfig.LibvirtConfigGuestNUMATune() guest_numa_tune.memory = vconfig.LibvirtConfigGuestNUMATuneMemory() guest_numa_tune.memnodes = [] emulator_threads_policy = None if 'emulator_threads_policy' in instance_numa_topology: emulator_threads_policy = ( instance_numa_topology.emulator_threads_policy) # Set realtime scheduler for CPUTune vcpus_rt = hardware.get_realtime_cpu_constraint(flavor, image_meta) if vcpus_rt: vcpusched = vconfig.LibvirtConfigGuestCPUTuneVCPUSched() designer.set_vcpu_realtime_scheduler( vcpusched, vcpus_rt, CONF.libvirt.realtime_scheduler_priority) guest_cpu_tune.vcpusched.append(vcpusched) cell_pairs = self._get_cell_pairs(guest_cpu_numa_config, topology) for guest_node_id, (guest_config_cell, host_cell) in enumerate( cell_pairs): # set NUMATune for the cell tnode = vconfig.LibvirtConfigGuestNUMATuneMemNode() designer.set_numa_memnode(tnode, guest_node_id, host_cell.id) guest_numa_tune.memnodes.append(tnode) guest_numa_tune.memory.nodeset.append(host_cell.id) # set CPUTune for the cell object_numa_cell = instance_numa_topology.cells[guest_node_id] for cpu in guest_config_cell.cpus: pin_cpuset = self._get_pin_cpuset(cpu, object_numa_cell, host_cell) guest_cpu_tune.vcpupin.append(pin_cpuset) emu_pin_cpuset = self._get_emulatorpin_cpuset( cpu, object_numa_cell, vcpus_rt, emulator_threads_policy, pin_cpuset) guest_cpu_tune.emulatorpin.cpuset.update(emu_pin_cpuset) # TODO(berrange) When the guest has >1 NUMA node, it will # span multiple host NUMA nodes. By pinning emulator threads # to the union of all nodes, we guarantee there will be # cross-node memory access by the emulator threads when # responding to guest I/O operations. The only way to avoid # this would be to pin emulator threads to a single node and # tell the guest OS to only do I/O from one of its virtual # NUMA nodes. This is not even remotely practical. # # The long term solution is to make use of a new QEMU feature # called "I/O Threads" which will let us configure an explicit # I/O thread for each guest vCPU or guest NUMA node. It is # still TBD how to make use of this feature though, especially # how to associate IO threads with guest devices to eliminate # cross NUMA node traffic. This is an area of investigation # for QEMU community devs. # Sort the vcpupin list per vCPU id for human-friendlier XML guest_cpu_tune.vcpupin.sort(key=operator.attrgetter("id")) # normalize cell.id for i, (cell, memnode) in enumerate(zip(guest_cpu_numa_config.cells, guest_numa_tune.memnodes)): cell.id = i memnode.cellid = i return GuestNumaConfig(None, guest_cpu_tune, guest_cpu_numa_config, guest_numa_tune) def _get_guest_os_type(self, virt_type): """Returns the guest OS type based on virt type.""" if virt_type == "lxc": ret = fields.VMMode.EXE elif virt_type == "uml": ret = fields.VMMode.UML elif virt_type == "xen": ret = fields.VMMode.XEN else: ret = fields.VMMode.HVM return ret def _set_guest_for_rescue(self, rescue, guest, inst_path, virt_type, root_device_name): if rescue.get('kernel_id'): guest.os_kernel = os.path.join(inst_path, "kernel.rescue") guest.os_cmdline = ("root=%s %s" % (root_device_name, CONSOLE)) if virt_type == "qemu": guest.os_cmdline += " no_timer_check" if rescue.get('ramdisk_id'): guest.os_initrd = os.path.join(inst_path, "ramdisk.rescue") def _set_guest_for_inst_kernel(self, instance, guest, inst_path, virt_type, root_device_name, image_meta): guest.os_kernel = os.path.join(inst_path, "kernel") guest.os_cmdline = ("root=%s %s" % (root_device_name, CONSOLE)) if virt_type == "qemu": guest.os_cmdline += " no_timer_check" if instance.ramdisk_id: guest.os_initrd = os.path.join(inst_path, "ramdisk") # we only support os_command_line with images with an explicit # kernel set and don't want to break nova if there's an # os_command_line property without a specified kernel_id param if image_meta.properties.get("os_command_line"): guest.os_cmdline = image_meta.properties.os_command_line def _set_clock(self, guest, os_type, image_meta, virt_type): # NOTE(mikal): Microsoft Windows expects the clock to be in # "localtime". If the clock is set to UTC, then you can use a # registry key to let windows know, but Microsoft says this is # buggy in http://support.microsoft.com/kb/2687252 clk = vconfig.LibvirtConfigGuestClock() if os_type == 'windows': LOG.info('Configuring timezone for windows instance to localtime') clk.offset = 'localtime' else: clk.offset = 'utc' guest.set_clock(clk) if virt_type == "kvm": self._set_kvm_timers(clk, os_type, image_meta) def _set_kvm_timers(self, clk, os_type, image_meta): # TODO(berrange) One day this should be per-guest # OS type configurable tmpit = vconfig.LibvirtConfigGuestTimer() tmpit.name = "pit" tmpit.tickpolicy = "delay" tmrtc = vconfig.LibvirtConfigGuestTimer() tmrtc.name = "rtc" tmrtc.tickpolicy = "catchup" clk.add_timer(tmpit) clk.add_timer(tmrtc) hpet = image_meta.properties.get('hw_time_hpet', False) guestarch = libvirt_utils.get_arch(image_meta) if guestarch in (fields.Architecture.I686, fields.Architecture.X86_64): # NOTE(rfolco): HPET is a hardware timer for x86 arch. # qemu -no-hpet is not supported on non-x86 targets. tmhpet = vconfig.LibvirtConfigGuestTimer() tmhpet.name = "hpet" tmhpet.present = hpet clk.add_timer(tmhpet) else: if hpet: LOG.warning('HPET is not turned on for non-x86 guests in image' ' %s.', image_meta.id) # Provide Windows guests with the paravirtualized hyperv timer source. # This is the windows equiv of kvm-clock, allowing Windows # guests to accurately keep time. if os_type == 'windows': tmhyperv = vconfig.LibvirtConfigGuestTimer() tmhyperv.name = "hypervclock" tmhyperv.present = True clk.add_timer(tmhyperv) def _set_features(self, guest, os_type, caps, virt_type, image_meta, flavor): hide_hypervisor_id = (strutils.bool_from_string( flavor.extra_specs.get('hide_hypervisor_id')) or strutils.bool_from_string( flavor.extra_specs.get('hw:hide_hypervisor_id')) or image_meta.properties.get('img_hide_hypervisor_id')) if virt_type == "xen": # PAE only makes sense in X86 if caps.host.cpu.arch in (fields.Architecture.I686, fields.Architecture.X86_64): guest.features.append(vconfig.LibvirtConfigGuestFeaturePAE()) if (virt_type not in ("lxc", "uml", "parallels", "xen") or (virt_type == "xen" and guest.os_type == fields.VMMode.HVM)): guest.features.append(vconfig.LibvirtConfigGuestFeatureACPI()) guest.features.append(vconfig.LibvirtConfigGuestFeatureAPIC()) if (virt_type in ("qemu", "kvm") and os_type == 'windows'): hv = vconfig.LibvirtConfigGuestFeatureHyperV() hv.relaxed = True hv.spinlocks = True # Increase spinlock retries - value recommended by # KVM maintainers who certify Windows guests # with Microsoft hv.spinlock_retries = 8191 hv.vapic = True # NOTE(kosamara): Spoofing the vendor_id aims to allow the nvidia # driver to work on windows VMs. At the moment, the nvidia driver # checks for the hyperv vendorid, and if it doesn't find that, it # works. In the future, its behaviour could become more strict, # checking for the presence of other hyperv feature flags to # determine that it's loaded in a VM. If that happens, this # workaround will not be enough, and we'll need to drop the whole # hyperv element. # That would disable some optimizations, reducing the guest's # performance. if hide_hypervisor_id: hv.vendorid_spoof = True guest.features.append(hv) if virt_type in ("qemu", "kvm"): if hide_hypervisor_id: guest.features.append( vconfig.LibvirtConfigGuestFeatureKvmHidden()) # NOTE(sean-k-mooney): we validate that the image and flavor # cannot have conflicting values in the compute API # so we just use the values directly. If it is not set in # either the flavor or image pmu will be none and we should # not generate the element to allow qemu to decide if a vPMU # should be provided for backwards compatibility. pmu = (flavor.extra_specs.get('hw:pmu') or image_meta.properties.get('hw_pmu')) if pmu is not None: guest.features.append( vconfig.LibvirtConfigGuestFeaturePMU(pmu)) def _check_number_of_serial_console(self, num_ports): virt_type = CONF.libvirt.virt_type if (virt_type in ("kvm", "qemu") and num_ports > ALLOWED_QEMU_SERIAL_PORTS): raise exception.SerialPortNumberLimitExceeded( allowed=ALLOWED_QEMU_SERIAL_PORTS, virt_type=virt_type) def _video_model_supported(self, model): if model not in fields.VideoModel.ALL: return False min_ver = MIN_LIBVIRT_VIDEO_MODEL_VERSIONS.get(model) if min_ver and not self._host.has_min_version(lv_ver=min_ver): return False return True def _add_video_driver(self, guest, image_meta, flavor): video = vconfig.LibvirtConfigGuestVideo() # NOTE(ldbragst): The following logic sets the video.type # depending on supported defaults given the architecture, # virtualization type, and features. The video.type attribute can # be overridden by the user with image_meta.properties, which # is carried out in the next if statement below this one. guestarch = libvirt_utils.get_arch(image_meta) if guest.os_type == fields.VMMode.XEN: video.type = 'xen' elif CONF.libvirt.virt_type == 'parallels': video.type = 'vga' elif guestarch in (fields.Architecture.PPC, fields.Architecture.PPC64, fields.Architecture.PPC64LE): # NOTE(ldbragst): PowerKVM doesn't support 'cirrus' be default # so use 'vga' instead when running on Power hardware. video.type = 'vga' elif guestarch == fields.Architecture.AARCH64: # NOTE(kevinz): Only virtio device type is supported by AARCH64 # so use 'virtio' instead when running on AArch64 hardware. video.type = 'virtio' elif CONF.spice.enabled: video.type = 'qxl' if image_meta.properties.get('hw_video_model'): video.type = image_meta.properties.hw_video_model if not self._video_model_supported(video.type): raise exception.InvalidVideoMode(model=video.type) # Set video memory, only if the flavor's limit is set video_ram = image_meta.properties.get('hw_video_ram', 0) max_vram = int(flavor.extra_specs.get('hw_video:ram_max_mb', 0)) if video_ram > max_vram: raise exception.RequestedVRamTooHigh(req_vram=video_ram, max_vram=max_vram) if max_vram and video_ram: video.vram = video_ram * units.Mi // units.Ki guest.add_device(video) # NOTE(sean-k-mooney): return the video device we added # for simpler testing. return video def _add_qga_device(self, guest, instance): qga = vconfig.LibvirtConfigGuestChannel() qga.type = "unix" qga.target_name = "org.qemu.guest_agent.0" qga.source_path = ("/var/lib/libvirt/qemu/%s.%s.sock" % ("org.qemu.guest_agent.0", instance.name)) guest.add_device(qga) def _add_rng_device(self, guest, flavor, image_meta): rng_allowed_str = flavor.extra_specs.get('hw_rng:allowed', 'True') rng_allowed = strutils.bool_from_string(rng_allowed_str) if not rng_allowed: return rng_device = vconfig.LibvirtConfigGuestRng() rate_bytes = flavor.extra_specs.get('hw_rng:rate_bytes', 0) period = flavor.extra_specs.get('hw_rng:rate_period', 0) if rate_bytes: rng_device.rate_bytes = int(rate_bytes) rng_device.rate_period = int(period) rng_path = CONF.libvirt.rng_dev_path if (rng_path and not os.path.exists(rng_path)): raise exception.RngDeviceNotExist(path=rng_path) rng_device.backend = rng_path guest.add_device(rng_device) def _add_virtio_serial_controller(self, guest, instance): virtio_controller = vconfig.LibvirtConfigGuestController() virtio_controller.type = 'virtio-serial' guest.add_device(virtio_controller) def _add_vtpm_device( self, guest: libvirt_guest.Guest, flavor: 'objects.Flavor', instance: 'objects.Instance', image_meta: 'objects.ImageMeta', ): """Add a vTPM device to the guest, if requested.""" # Enable virtual tpm support if required in the flavor or image. vtpm_config = hardware.get_vtpm_constraint(flavor, image_meta) if not vtpm_config: return vtpm_secret_uuid = instance.system_metadata.get('vtpm_secret_uuid') if not vtpm_secret_uuid: raise exception.Invalid( 'Refusing to create an emulated TPM with no secret!') vtpm = vconfig.LibvirtConfigGuestVTPM(vtpm_config, vtpm_secret_uuid) guest.add_device(vtpm) def _set_qemu_guest_agent(self, guest, flavor, instance, image_meta): # Enable qga only if the 'hw_qemu_guest_agent' is equal to yes if image_meta.properties.get('hw_qemu_guest_agent', False): # a virtio-serial controller is required for qga. If it is not # created explicitly, libvirt will do it by itself. But in case # of AMD SEV, any virtio device should use iommu driver, and # libvirt does not know about it. That is why the controller # should be created manually. if self._sev_enabled(flavor, image_meta): self._add_virtio_serial_controller(guest, instance) LOG.debug("Qemu guest agent is enabled through image " "metadata", instance=instance) self._add_qga_device(guest, instance) def _get_guest_memory_backing_config( self, inst_topology, numatune, flavor, image_meta): wantsrealtime = hardware.is_realtime_enabled(flavor) if ( wantsrealtime and hardware.get_emulator_thread_policy_constraint(flavor) == fields.CPUEmulatorThreadsPolicy.SHARE and not CONF.compute.cpu_shared_set ): # NOTE(stephenfin) Yes, it's horrible that we're doing this here, # but the shared policy unfortunately has different behavior # depending on whether the '[compute] cpu_shared_set' is configured # or not and we need it to be configured. Also note that we have # already handled other conditions, such as no emulator thread # policy being configured whatsoever, at the API level. LOG.warning( 'Instance is requesting real-time CPUs with pooled ' 'emulator threads, but a shared CPU pool has not been ' 'configured on this host.' ) raise exception.RealtimeMaskNotFoundOrInvalid() wantsmempages = False if inst_topology: for cell in inst_topology.cells: if cell.pagesize: wantsmempages = True break wantsfilebacked = CONF.libvirt.file_backed_memory > 0 if wantsmempages and wantsfilebacked: # Can't use file-backed memory with hugepages LOG.warning("Instance requested huge pages, but file-backed " "memory is enabled, and incompatible with huge pages") raise exception.MemoryPagesUnsupported() membacking = None if wantsmempages: pages = self._get_memory_backing_hugepages_support( inst_topology, numatune) if pages: membacking = vconfig.LibvirtConfigGuestMemoryBacking() membacking.hugepages = pages if wantsrealtime: if not membacking: membacking = vconfig.LibvirtConfigGuestMemoryBacking() membacking.locked = True membacking.sharedpages = False if wantsfilebacked: if not membacking: membacking = vconfig.LibvirtConfigGuestMemoryBacking() membacking.filesource = True membacking.sharedaccess = True membacking.allocateimmediate = True if self._host.has_min_version( MIN_LIBVIRT_FILE_BACKED_DISCARD_VERSION): membacking.discard = True if self._sev_enabled(flavor, image_meta): if not membacking: membacking = vconfig.LibvirtConfigGuestMemoryBacking() membacking.locked = True return membacking def _get_memory_backing_hugepages_support(self, inst_topology, numatune): if not self._has_numa_support(): # We should not get here, since we should have avoided # reporting NUMA topology from _get_host_numa_topology # in the first place. Just in case of a scheduler # mess up though, raise an exception raise exception.MemoryPagesUnsupported() host_topology = self._get_host_numa_topology() if host_topology is None: # As above, we should not get here but just in case... raise exception.MemoryPagesUnsupported() # Currently libvirt does not support the smallest # pagesize set as a backend memory. # https://bugzilla.redhat.com/show_bug.cgi?id=1173507 avail_pagesize = [page.size_kb for page in host_topology.cells[0].mempages] avail_pagesize.sort() smallest = avail_pagesize[0] pages = [] for guest_cellid, inst_cell in enumerate(inst_topology.cells): if inst_cell.pagesize and inst_cell.pagesize > smallest: for memnode in numatune.memnodes: if guest_cellid == memnode.cellid: page = ( vconfig.LibvirtConfigGuestMemoryBackingPage()) page.nodeset = [guest_cellid] page.size_kb = inst_cell.pagesize pages.append(page) break # Quit early... return pages def _get_flavor(self, ctxt, instance, flavor): if flavor is not None: return flavor return instance.flavor def _has_uefi_support(self): # This means that the host can support UEFI booting for guests supported_archs = [fields.Architecture.X86_64, fields.Architecture.AARCH64] caps = self._host.get_capabilities() # TODO(dmllr, kchamart): Get rid of probing the OVMF binary file # paths, it is not robust, because nothing but the binary's # filename is reported, which means you have to detect its # architecture and features by other means. To solve this, # query the libvirt's getDomainCapabilities() to get the # firmware paths (as reported in the 'loader' value). Nova now # has a wrapper method for this, get_domain_capabilities(). # This is a more reliable way to detect UEFI boot support. # # Further, with libvirt 5.3 onwards, support for UEFI boot is # much more simplified by the "firmware auto-selection" feature. # When using this, Nova doesn't need to query OVMF file paths at # all; libvirt will take care of it. This is done by taking # advantage of the so-called firmware "descriptor files" -- # small JSON files (which will be shipped by Linux # distributions) that describe a UEFI firmware binary's # "characteristics", such as the binary's file path, its # features, architecture, supported machine type, NVRAM template # and so forth. return ((caps.host.cpu.arch in supported_archs) and any((os.path.exists(p) for p in DEFAULT_UEFI_LOADER_PATH[caps.host.cpu.arch]))) def _check_uefi_support(self, hw_firmware_type): caps = self._host.get_capabilities() return (self._has_uefi_support() and (hw_firmware_type == fields.FirmwareType.UEFI or caps.host.cpu.arch == fields.Architecture.AARCH64)) def _get_supported_perf_events(self): if not len(CONF.libvirt.enabled_perf_events): return [] supported_events = [] for event in CONF.libvirt.enabled_perf_events: libvirt_perf_event_name = LIBVIRT_PERF_EVENT_PREFIX + event.upper() if not hasattr(libvirt, libvirt_perf_event_name): LOG.warning("Libvirt does not support event type '%s'.", event) continue if event in ('cmt', 'mbml', 'mbmt'): LOG.warning( "Monitoring of Intel CMT `perf` event(s) '%s' is not " "supported by recent Linux kernels; ignoring.", event, ) continue supported_events.append(event) return supported_events def _configure_guest_by_virt_type(self, guest, virt_type, caps, instance, image_meta, flavor, root_device_name, sev_enabled): if virt_type == "xen": if guest.os_type == fields.VMMode.HVM: guest.os_loader = CONF.libvirt.xen_hvmloader_path else: guest.os_cmdline = CONSOLE elif virt_type in ("kvm", "qemu"): if caps.host.cpu.arch in (fields.Architecture.I686, fields.Architecture.X86_64): guest.sysinfo = self._get_guest_config_sysinfo(instance) guest.os_smbios = vconfig.LibvirtConfigGuestSMBIOS() hw_firmware_type = image_meta.properties.get('hw_firmware_type') if caps.host.cpu.arch == fields.Architecture.AARCH64: if not hw_firmware_type: hw_firmware_type = fields.FirmwareType.UEFI if hw_firmware_type == fields.FirmwareType.UEFI: if self._has_uefi_support(): global uefi_logged if not uefi_logged: LOG.warning("uefi support is without some kind of " "functional testing and therefore " "considered experimental.") uefi_logged = True for lpath in DEFAULT_UEFI_LOADER_PATH[caps.host.cpu.arch]: if os.path.exists(lpath): guest.os_loader = lpath guest.os_loader_type = "pflash" else: raise exception.UEFINotSupported() guest.os_mach_type = libvirt_utils.get_machine_type(image_meta) if image_meta.properties.get('hw_boot_menu') is None: guest.os_bootmenu = strutils.bool_from_string( flavor.extra_specs.get('hw:boot_menu', 'no')) else: guest.os_bootmenu = image_meta.properties.hw_boot_menu elif virt_type == "lxc": guest.os_init_path = "/sbin/init" guest.os_cmdline = CONSOLE guest.os_init_env["product_name"] = "OpenStack Nova" elif virt_type == "uml": guest.os_kernel = "/usr/bin/linux" guest.os_root = root_device_name elif virt_type == "parallels": if guest.os_type == fields.VMMode.EXE: guest.os_init_path = "/sbin/init" def _conf_non_lxc_uml(self, virt_type, guest, root_device_name, rescue, instance, inst_path, image_meta, disk_info): if rescue: self._set_guest_for_rescue(rescue, guest, inst_path, virt_type, root_device_name) elif instance.kernel_id: self._set_guest_for_inst_kernel(instance, guest, inst_path, virt_type, root_device_name, image_meta) else: guest.os_boot_dev = blockinfo.get_boot_order(disk_info) def _create_consoles(self, virt_type, guest_cfg, instance, flavor, image_meta): # NOTE(markus_z): Beware! Below are so many conditionals that it is # easy to lose track. Use this chart to figure out your case: # # case | is serial | is qemu | resulting # | enabled? | or kvm? | devices # ------------------------------------------- # 1 | no | no | pty* # 2 | no | yes | pty with logd # 3 | yes | no | see case 1 # 4 | yes | yes | tcp with logd # # * exception: `virt_type=parallels` doesn't create a device if virt_type == 'parallels': pass elif virt_type not in ("qemu", "kvm"): log_path = self._get_console_log_path(instance) self._create_pty_device(guest_cfg, vconfig.LibvirtConfigGuestConsole, log_path=log_path) elif (virt_type in ("qemu", "kvm") and self._is_s390x_guest(image_meta)): self._create_consoles_s390x(guest_cfg, instance, flavor, image_meta) elif virt_type in ("qemu", "kvm"): self._create_consoles_qemu_kvm(guest_cfg, instance, flavor, image_meta) def _is_s390x_guest(self, image_meta): s390x_archs = (fields.Architecture.S390, fields.Architecture.S390X) return libvirt_utils.get_arch(image_meta) in s390x_archs def _create_consoles_qemu_kvm(self, guest_cfg, instance, flavor, image_meta): char_dev_cls = vconfig.LibvirtConfigGuestSerial log_path = self._get_console_log_path(instance) if CONF.serial_console.enabled: if not self._serial_ports_already_defined(instance): num_ports = hardware.get_number_of_serial_ports(flavor, image_meta) self._check_number_of_serial_console(num_ports) self._create_serial_consoles(guest_cfg, num_ports, char_dev_cls, log_path) else: self._create_pty_device(guest_cfg, char_dev_cls, log_path=log_path) def _create_consoles_s390x(self, guest_cfg, instance, flavor, image_meta): char_dev_cls = vconfig.LibvirtConfigGuestConsole log_path = self._get_console_log_path(instance) if CONF.serial_console.enabled: if not self._serial_ports_already_defined(instance): num_ports = hardware.get_number_of_serial_ports(flavor, image_meta) self._create_serial_consoles(guest_cfg, num_ports, char_dev_cls, log_path) else: self._create_pty_device(guest_cfg, char_dev_cls, "sclp", log_path) def _create_pty_device(self, guest_cfg, char_dev_cls, target_type=None, log_path=None): consolepty = char_dev_cls() consolepty.target_type = target_type consolepty.type = "pty" log = vconfig.LibvirtConfigGuestCharDeviceLog() log.file = log_path consolepty.log = log guest_cfg.add_device(consolepty) def _serial_ports_already_defined(self, instance): try: guest = self._host.get_guest(instance) if list(self._get_serial_ports_from_guest(guest)): # Serial port are already configured for instance that # means we are in a context of migration. return True except exception.InstanceNotFound: LOG.debug( "Instance does not exist yet on libvirt, we can " "safely pass on looking for already defined serial " "ports in its domain XML", instance=instance) return False def _create_serial_consoles(self, guest_cfg, num_ports, char_dev_cls, log_path): for port in six.moves.range(num_ports): console = char_dev_cls() console.port = port console.type = "tcp" console.listen_host = CONF.serial_console.proxyclient_address listen_port = serial_console.acquire_port(console.listen_host) console.listen_port = listen_port # NOTE: only the first serial console gets the boot messages, # that's why we attach the logd subdevice only to that. if port == 0: log = vconfig.LibvirtConfigGuestCharDeviceLog() log.file = log_path console.log = log guest_cfg.add_device(console) def _cpu_config_to_vcpu_model(self, cpu_config, vcpu_model): """Update VirtCPUModel object according to libvirt CPU config. :param:cpu_config: vconfig.LibvirtConfigGuestCPU presenting the instance's virtual cpu configuration. :param:vcpu_model: VirtCPUModel object. A new object will be created if None. :return: Updated VirtCPUModel object, or None if cpu_config is None """ if not cpu_config: return if not vcpu_model: vcpu_model = objects.VirtCPUModel() vcpu_model.arch = cpu_config.arch vcpu_model.vendor = cpu_config.vendor vcpu_model.model = cpu_config.model vcpu_model.mode = cpu_config.mode vcpu_model.match = cpu_config.match if cpu_config.sockets: vcpu_model.topology = objects.VirtCPUTopology( sockets=cpu_config.sockets, cores=cpu_config.cores, threads=cpu_config.threads) else: vcpu_model.topology = None features = [objects.VirtCPUFeature( name=f.name, policy=f.policy) for f in cpu_config.features] vcpu_model.features = features return vcpu_model def _vcpu_model_to_cpu_config(self, vcpu_model): """Create libvirt CPU config according to VirtCPUModel object. :param:vcpu_model: VirtCPUModel object. :return: vconfig.LibvirtConfigGuestCPU. """ cpu_config = vconfig.LibvirtConfigGuestCPU() cpu_config.arch = vcpu_model.arch cpu_config.model = vcpu_model.model cpu_config.mode = vcpu_model.mode cpu_config.match = vcpu_model.match cpu_config.vendor = vcpu_model.vendor if vcpu_model.topology: cpu_config.sockets = vcpu_model.topology.sockets cpu_config.cores = vcpu_model.topology.cores cpu_config.threads = vcpu_model.topology.threads if vcpu_model.features: for f in vcpu_model.features: xf = vconfig.LibvirtConfigGuestCPUFeature() xf.name = f.name xf.policy = f.policy cpu_config.features.add(xf) return cpu_config def _guest_add_pcie_root_ports(self, guest): """Add PCI Express root ports. PCI Express machine can have as many PCIe devices as it has pcie-root-port controllers (slots in virtual motherboard). If we want to have more PCIe slots for hotplug then we need to create whole PCIe structure (libvirt limitation). """ pcieroot = vconfig.LibvirtConfigGuestPCIeRootController() guest.add_device(pcieroot) for x in range(0, CONF.libvirt.num_pcie_ports): pcierootport = vconfig.LibvirtConfigGuestPCIeRootPortController() guest.add_device(pcierootport) def _guest_needs_pcie(self, guest, caps): """Check for prerequisites for adding PCIe root port controllers """ # TODO(kchamart) In the third 'if' conditional below, for 'x86' # arch, we're assuming: when 'os_mach_type' is 'None', you'll # have "pc" machine type. That assumption, although it is # correct for the "forseeable future", it will be invalid when # libvirt / QEMU changes the default machine types. # # From libvirt 4.7.0 onwards (September 2018), it will ensure # that *if* 'pc' is available, it will be used as the default -- # to not break existing applications. (Refer: # https://libvirt.org/git/?p=libvirt.git;a=commit;h=26cfb1a3 # --"qemu: ensure default machine types don't change if QEMU # changes"). # # But even if libvirt (>=v4.7.0) handled the default case, # relying on such assumptions is not robust. Instead we should # get the default machine type for a given architecture reliably # -- by Nova setting it explicitly (we already do it for Arm / # AArch64 & s390x). A part of this bug is being tracked here: # https://bugs.launchpad.net/nova/+bug/1780138). # Add PCIe root port controllers for PCI Express machines # but only if their amount is configured if not CONF.libvirt.num_pcie_ports: return False if (caps.host.cpu.arch == fields.Architecture.AARCH64 and guest.os_mach_type.startswith('virt')): return True if (caps.host.cpu.arch == fields.Architecture.X86_64 and guest.os_mach_type is not None and 'q35' in guest.os_mach_type): return True return False def _guest_add_usb_host_keyboard(self, guest): """Add USB Host controller and keyboard for graphical console use. Add USB keyboard as PS/2 support may not be present on non-x86 architectures. """ keyboard = vconfig.LibvirtConfigGuestInput() keyboard.type = "keyboard" keyboard.bus = "usb" guest.add_device(keyboard) usbhost = vconfig.LibvirtConfigGuestUSBHostController() usbhost.index = 0 guest.add_device(usbhost) def _get_guest_config(self, instance, network_info, image_meta, disk_info, rescue=None, block_device_info=None, context=None, mdevs=None, accel_info=None): """Get config data for parameters. :param rescue: optional dictionary that should contain the key 'ramdisk_id' if a ramdisk is needed for the rescue image and 'kernel_id' if a kernel is needed for the rescue image. :param mdevs: optional list of mediated devices to assign to the guest. :param accel_info: optional list of accelerator requests (ARQs) """ flavor = instance.flavor inst_path = libvirt_utils.get_instance_path(instance) disk_mapping = disk_info['mapping'] vpmems = self._get_ordered_vpmems(instance, flavor) virt_type = CONF.libvirt.virt_type guest = vconfig.LibvirtConfigGuest() guest.virt_type = virt_type guest.name = instance.name guest.uuid = instance.uuid # We are using default unit for memory: KiB guest.memory = flavor.memory_mb * units.Ki guest.vcpus = flavor.vcpus guest_numa_config = self._get_guest_numa_config( instance.numa_topology, flavor, image_meta) guest.cpuset = guest_numa_config.cpuset guest.cputune = guest_numa_config.cputune guest.numatune = guest_numa_config.numatune guest.membacking = self._get_guest_memory_backing_config( instance.numa_topology, guest_numa_config.numatune, flavor, image_meta) guest.metadata.append(self._get_guest_config_meta(instance)) guest.idmaps = self._get_guest_idmaps() for event in self._supported_perf_events: guest.add_perf_event(event) self._update_guest_cputune(guest, flavor, virt_type) guest.cpu = self._get_guest_cpu_config( flavor, image_meta, guest_numa_config.numaconfig, instance.numa_topology) # Notes(yjiang5): we always sync the instance's vcpu model with # the corresponding config file. instance.vcpu_model = self._cpu_config_to_vcpu_model( guest.cpu, instance.vcpu_model) if 'root' in disk_mapping: root_device_name = block_device.prepend_dev( disk_mapping['root']['dev']) else: root_device_name = None guest.os_type = (fields.VMMode.get_from_instance(instance) or self._get_guest_os_type(virt_type)) caps = self._host.get_capabilities() sev_enabled = self._sev_enabled(flavor, image_meta) self._configure_guest_by_virt_type(guest, virt_type, caps, instance, image_meta, flavor, root_device_name, sev_enabled) if virt_type not in ('lxc', 'uml'): self._conf_non_lxc_uml(virt_type, guest, root_device_name, rescue, instance, inst_path, image_meta, disk_info) self._set_features(guest, instance.os_type, caps, virt_type, image_meta, flavor) self._set_clock(guest, instance.os_type, image_meta, virt_type) storage_configs = self._get_guest_storage_config(context, instance, image_meta, disk_info, rescue, block_device_info, flavor, guest.os_type) for config in storage_configs: guest.add_device(config) for vif in network_info: config = self.vif_driver.get_config( instance, vif, image_meta, flavor, virt_type, ) guest.add_device(config) self._create_consoles(virt_type, guest, instance, flavor, image_meta) pointer = self._get_guest_pointer_model(guest.os_type, image_meta) if pointer: guest.add_device(pointer) self._guest_add_spice_channel(guest) if self._guest_add_video_device(guest): self._add_video_driver(guest, image_meta, flavor) # We want video == we want graphical console. Some architectures # do not have input devices attached in default configuration. # Let then add USB Host controller and USB keyboard. # x86(-64) and ppc64 have usb host controller and keyboard # s390x does not support USB if caps.host.cpu.arch == fields.Architecture.AARCH64: self._guest_add_usb_host_keyboard(guest) # Some features are only supported 'qemu' and 'kvm' hypervisor if virt_type in ('qemu', 'kvm'): self._set_qemu_guest_agent(guest, flavor, instance, image_meta) self._add_rng_device(guest, flavor, image_meta) self._add_vtpm_device(guest, flavor, instance, image_meta) if self._guest_needs_pcie(guest, caps): self._guest_add_pcie_root_ports(guest) self._guest_add_pci_devices(guest, instance) pci_arq_list = [] if accel_info: # NOTE(Sundar): We handle only the case where all attach handles # are of type 'PCI'. The Cyborg fake driver used for testing # returns attach handles of type 'TEST_PCI' and so its ARQs will # not get composed into the VM's domain XML. For now, we do not # expect a mixture of different attach handles for the same # instance; but that case also gets ignored by this logic. ah_types_set = {arq['attach_handle_type'] for arq in accel_info} supported_types_set = {'PCI'} if ah_types_set == supported_types_set: pci_arq_list = accel_info else: LOG.info('Ignoring accelerator requests for instance %s. ' 'Supported Attach handle types: %s. ' 'But got these unsupported types: %s.', instance.uuid, supported_types_set, ah_types_set.difference(supported_types_set)) self._guest_add_accel_pci_devices(guest, pci_arq_list) self._guest_add_watchdog_action(guest, flavor, image_meta) self._guest_add_memory_balloon(guest) if mdevs: self._guest_add_mdevs(guest, mdevs) if sev_enabled: self._guest_configure_sev(guest, caps.host.cpu.arch, guest.os_mach_type) if vpmems: self._guest_add_vpmems(guest, vpmems) return guest def _get_ordered_vpmems(self, instance, flavor): resources = self._get_resources(instance) ordered_vpmem_resources = self._get_ordered_vpmem_resources( resources, flavor) ordered_vpmems = [self._vpmems_by_name[resource.identifier] for resource in ordered_vpmem_resources] return ordered_vpmems def _get_vpmems(self, instance, prefix=None): resources = self._get_resources(instance, prefix=prefix) vpmem_resources = self._get_vpmem_resources(resources) vpmems = [self._vpmems_by_name[resource.identifier] for resource in vpmem_resources] return vpmems def _guest_add_vpmems(self, guest, vpmems): guest.max_memory_size = guest.memory guest.max_memory_slots = 0 for vpmem in vpmems: size_kb = vpmem.size // units.Ki align_kb = vpmem.align // units.Ki vpmem_config = vconfig.LibvirtConfigGuestVPMEM( devpath=vpmem.devpath, size_kb=size_kb, align_kb=align_kb) # max memory size needs contain vpmem size guest.max_memory_size += size_kb # one vpmem will occupy one memory slot guest.max_memory_slots += 1 guest.add_device(vpmem_config) def _sev_enabled(self, flavor, image_meta): """To enable AMD SEV, the following should be true: a) the supports_amd_sev instance variable in the host is true, b) the instance extra specs and/or image properties request memory encryption to be enabled, and c) there are no conflicts between extra specs, image properties and machine type selection. Most potential conflicts in c) should already be caught in the API layer. However there is still one remaining case which needs to be handled here: when the image does not contain an hw_machine_type property, the machine type will be chosen from CONF.libvirt.hw_machine_type if configured, otherwise falling back to the hardcoded value which is currently 'pc'. If it ends up being 'pc' or another value not in the q35 family, we need to raise an exception. So calculate the machine type and pass it to be checked alongside the other sanity checks which are run while determining whether SEV is selected. """ if not self._host.supports_amd_sev: return False mach_type = libvirt_utils.get_machine_type(image_meta) return hardware.get_mem_encryption_constraint(flavor, image_meta, mach_type) def _guest_configure_sev(self, guest, arch, mach_type): sev = self._find_sev_feature(arch, mach_type) if sev is None: # In theory this should never happen because it should # only get called if SEV was requested, in which case the # guest should only get scheduled on this host if it # supports SEV, and SEV support is dependent on the # presence of this feature. That said, it's # conceivable that something could get messed up along the # way, e.g. a mismatch in the choice of machine type. So # make sure that if it ever does happen, we at least get a # helpful error rather than something cryptic like # "AttributeError: 'NoneType' object has no attribute 'cbitpos' raise exception.MissingDomainCapabilityFeatureException( feature='sev') designer.set_driver_iommu_for_sev(guest) self._guest_add_launch_security(guest, sev) def _guest_add_launch_security(self, guest, sev): launch_security = vconfig.LibvirtConfigGuestSEVLaunchSecurity() launch_security.cbitpos = sev.cbitpos launch_security.reduced_phys_bits = sev.reduced_phys_bits guest.launch_security = launch_security def _find_sev_feature(self, arch, mach_type): """Search domain capabilities for the given arch and machine type for the element under , and return it if found. """ domain_caps = self._host.get_domain_capabilities() if arch not in domain_caps: LOG.warning( "Wanted to add SEV to config for guest with arch %(arch)s " "but only had domain capabilities for: %(archs)s", {'arch': arch, 'archs': ' '.join(domain_caps)}) return None if mach_type not in domain_caps[arch]: LOG.warning( "Wanted to add SEV to config for guest with machine type " "%(mtype)s but for arch %(arch)s only had domain capabilities " "for machine types: %(mtypes)s", {'mtype': mach_type, 'arch': arch, 'mtypes': ' '.join(domain_caps[arch])}) return None for feature in domain_caps[arch][mach_type].features: if feature.root_name == 'sev': return feature return None def _guest_add_mdevs(self, guest, chosen_mdevs): for chosen_mdev in chosen_mdevs: mdev = vconfig.LibvirtConfigGuestHostdevMDEV() mdev.uuid = chosen_mdev guest.add_device(mdev) @staticmethod def _guest_add_spice_channel(guest): if (CONF.spice.enabled and CONF.spice.agent_enabled and guest.virt_type not in ('lxc', 'uml', 'xen')): channel = vconfig.LibvirtConfigGuestChannel() channel.type = 'spicevmc' channel.target_name = "com.redhat.spice.0" guest.add_device(channel) @staticmethod def _guest_add_memory_balloon(guest): virt_type = guest.virt_type # Memory balloon device only support 'qemu/kvm' and 'xen' hypervisor if (virt_type in ('xen', 'qemu', 'kvm') and CONF.libvirt.mem_stats_period_seconds > 0): balloon = vconfig.LibvirtConfigMemoryBalloon() if virt_type in ('qemu', 'kvm'): balloon.model = 'virtio' else: balloon.model = 'xen' balloon.period = CONF.libvirt.mem_stats_period_seconds guest.add_device(balloon) @staticmethod def _guest_add_watchdog_action(guest, flavor, image_meta): # image meta takes precedence over flavor extra specs; disable the # watchdog action by default watchdog_action = (flavor.extra_specs.get('hw:watchdog_action') or 'disabled') watchdog_action = image_meta.properties.get('hw_watchdog_action', watchdog_action) # NB(sross): currently only actually supported by KVM/QEmu if watchdog_action != 'disabled': if watchdog_action in fields.WatchdogAction.ALL: bark = vconfig.LibvirtConfigGuestWatchdog() bark.action = watchdog_action guest.add_device(bark) else: raise exception.InvalidWatchdogAction(action=watchdog_action) def _guest_add_pci_devices(self, guest, instance): virt_type = guest.virt_type if virt_type in ('xen', 'qemu', 'kvm'): # Get all generic PCI devices (non-SR-IOV). for pci_dev in pci_manager.get_instance_pci_devs(instance): guest.add_device(self._get_guest_pci_device(pci_dev)) else: # PCI devices is only supported for hypervisors # 'xen', 'qemu' and 'kvm'. if pci_manager.get_instance_pci_devs(instance, 'all'): raise exception.PciDeviceUnsupportedHypervisor(type=virt_type) def _guest_add_accel_pci_devices(self, guest, accel_info): """Add all accelerator PCI functions from ARQ list.""" for arq in accel_info: dev = vconfig.LibvirtConfigGuestHostdevPCI() pci_addr = arq['attach_handle_info'] dev.domain, dev.bus, dev.slot, dev.function = ( pci_addr['domain'], pci_addr['bus'], pci_addr['device'], pci_addr['function']) self._set_managed_mode(dev) guest.add_device(dev) @staticmethod def _guest_add_video_device(guest): # NB some versions of libvirt support both SPICE and VNC # at the same time. We're not trying to second guess which # those versions are. We'll just let libvirt report the # errors appropriately if the user enables both. add_video_driver = False if CONF.vnc.enabled and guest.virt_type not in ('lxc', 'uml'): graphics = vconfig.LibvirtConfigGuestGraphics() graphics.type = "vnc" graphics.listen = CONF.vnc.server_listen guest.add_device(graphics) add_video_driver = True if CONF.spice.enabled and guest.virt_type not in ('lxc', 'uml', 'xen'): graphics = vconfig.LibvirtConfigGuestGraphics() graphics.type = "spice" graphics.listen = CONF.spice.server_listen guest.add_device(graphics) add_video_driver = True return add_video_driver def _get_guest_pointer_model(self, os_type, image_meta): pointer_model = image_meta.properties.get( 'hw_pointer_model', CONF.pointer_model) if pointer_model is None and CONF.libvirt.use_usb_tablet: # TODO(sahid): We set pointer_model to keep compatibility # until the next release O*. It means operators can continue # to use the deprecated option "use_usb_tablet" or set a # specific device to use pointer_model = "usbtablet" LOG.warning('The option "use_usb_tablet" has been ' 'deprecated for Newton in favor of the more ' 'generic "pointer_model". Please update ' 'nova.conf to address this change.') if pointer_model == "usbtablet": # We want a tablet if VNC is enabled, or SPICE is enabled and # the SPICE agent is disabled. If the SPICE agent is enabled # it provides a paravirt mouse which drastically reduces # overhead (by eliminating USB polling). if CONF.vnc.enabled or ( CONF.spice.enabled and not CONF.spice.agent_enabled): return self._get_guest_usb_tablet(os_type) else: if CONF.pointer_model or CONF.libvirt.use_usb_tablet: # For backward compatibility We don't want to break # process of booting an instance if host is configured # to use USB tablet without VNC or SPICE and SPICE # agent disable. LOG.warning('USB tablet requested for guests by host ' 'configuration. In order to accept this ' 'request VNC should be enabled or SPICE ' 'and SPICE agent disabled on host.') else: raise exception.UnsupportedPointerModelRequested( model="usbtablet") def _get_guest_usb_tablet(self, os_type): tablet = None if os_type == fields.VMMode.HVM: tablet = vconfig.LibvirtConfigGuestInput() tablet.type = "tablet" tablet.bus = "usb" else: if CONF.pointer_model or CONF.libvirt.use_usb_tablet: # For backward compatibility We don't want to break # process of booting an instance if virtual machine mode # is not configured as HVM. LOG.warning('USB tablet requested for guests by host ' 'configuration. In order to accept this ' 'request the machine mode should be ' 'configured as HVM.') else: raise exception.UnsupportedPointerModelRequested( model="usbtablet") return tablet def _get_guest_xml(self, context, instance, network_info, disk_info, image_meta, rescue=None, block_device_info=None, mdevs=None, accel_info=None): # NOTE(danms): Stringifying a NetworkInfo will take a lock. Do # this ahead of time so that we don't acquire it while also # holding the logging lock. network_info_str = str(network_info) msg = ('Start _get_guest_xml ' 'network_info=%(network_info)s ' 'disk_info=%(disk_info)s ' 'image_meta=%(image_meta)s rescue=%(rescue)s ' 'block_device_info=%(block_device_info)s' % {'network_info': network_info_str, 'disk_info': disk_info, 'image_meta': image_meta, 'rescue': rescue, 'block_device_info': block_device_info}) # NOTE(mriedem): block_device_info can contain auth_password so we # need to sanitize the password in the message. LOG.debug(strutils.mask_password(msg), instance=instance) conf = self._get_guest_config(instance, network_info, image_meta, disk_info, rescue, block_device_info, context, mdevs, accel_info) xml = conf.to_xml() LOG.debug('End _get_guest_xml xml=%(xml)s', {'xml': xml}, instance=instance) return xml def get_info(self, instance, use_cache=True): """Retrieve information from libvirt for a specific instance. If a libvirt error is encountered during lookup, we might raise a NotFound exception or Error exception depending on how severe the libvirt error is. :param instance: nova.objects.instance.Instance object :param use_cache: unused in this driver :returns: An InstanceInfo object """ guest = self._host.get_guest(instance) # Kind of ugly but we need to pass host to get_info as for a # workaround, see libvirt/compat.py return guest.get_info(self._host) def _create_domain_setup_lxc(self, context, instance, image_meta, block_device_info): inst_path = libvirt_utils.get_instance_path(instance) block_device_mapping = driver.block_device_info_get_mapping( block_device_info) root_disk = block_device.get_root_bdm(block_device_mapping) if root_disk: self._connect_volume(context, root_disk['connection_info'], instance) disk_path = root_disk['connection_info']['data']['device_path'] # NOTE(apmelton) - Even though the instance is being booted from a # cinder volume, it is still presented as a local block device. # LocalBlockImage is used here to indicate that the instance's # disk is backed by a local block device. image_model = imgmodel.LocalBlockImage(disk_path) else: root_disk = self.image_backend.by_name(instance, 'disk') image_model = root_disk.get_model(self._conn) container_dir = os.path.join(inst_path, 'rootfs') fileutils.ensure_tree(container_dir) rootfs_dev = disk_api.setup_container(image_model, container_dir=container_dir) try: # Save rootfs device to disconnect it when deleting the instance if rootfs_dev: instance.system_metadata['rootfs_device_name'] = rootfs_dev if CONF.libvirt.uid_maps or CONF.libvirt.gid_maps: id_maps = self._get_guest_idmaps() libvirt_utils.chown_for_id_maps(container_dir, id_maps) except Exception: with excutils.save_and_reraise_exception(): self._create_domain_cleanup_lxc(instance) def _create_domain_cleanup_lxc(self, instance): inst_path = libvirt_utils.get_instance_path(instance) container_dir = os.path.join(inst_path, 'rootfs') try: state = self.get_info(instance).state except exception.InstanceNotFound: # The domain may not be present if the instance failed to start state = None if state == power_state.RUNNING: # NOTE(uni): Now the container is running with its own private # mount namespace and so there is no need to keep the container # rootfs mounted in the host namespace LOG.debug('Attempting to unmount container filesystem: %s', container_dir, instance=instance) disk_api.clean_lxc_namespace(container_dir=container_dir) else: disk_api.teardown_container(container_dir=container_dir) @contextlib.contextmanager def _lxc_disk_handler(self, context, instance, image_meta, block_device_info): """Context manager to handle the pre and post instance boot, LXC specific disk operations. An image or a volume path will be prepared and setup to be used by the container, prior to starting it. The disk will be disconnected and unmounted if a container has failed to start. """ if CONF.libvirt.virt_type != 'lxc': yield return self._create_domain_setup_lxc(context, instance, image_meta, block_device_info) try: yield finally: self._create_domain_cleanup_lxc(instance) def _create_guest( self, context: nova_context.RequestContext, xml: str, instance: 'objects.Instance', power_on: bool = True, pause: bool = False, post_xml_callback: ty.Callable = None, ) -> libvirt_guest.Guest: """Create a Guest from XML. Create a Guest, which in turn creates a libvirt domain, from XML, optionally starting it after creation. :returns guest.Guest: Created guest. """ libvirt_secret = None # determine whether vTPM is in use and, if so, create the secret if CONF.libvirt.swtpm_enabled and hardware.get_vtpm_constraint( instance.flavor, instance.image_meta, ): secret_uuid, passphrase = crypto.ensure_vtpm_secret( context, instance) libvirt_secret = self._host.create_secret( 'vtpm', instance.uuid, password=passphrase, uuid=secret_uuid) try: guest = libvirt_guest.Guest.create(xml, self._host) if post_xml_callback is not None: post_xml_callback() if power_on or pause: guest.launch(pause=pause) return guest finally: if libvirt_secret is not None: libvirt_secret.undefine() def _neutron_failed_callback(self, event_name, instance): LOG.error('Neutron Reported failure on event ' '%(event)s for instance %(uuid)s', {'event': event_name, 'uuid': instance.uuid}, instance=instance) if CONF.vif_plugging_is_fatal: raise exception.VirtualInterfaceCreateException() def _get_neutron_events(self, network_info): # NOTE(danms): We need to collect any VIFs that are currently # down that we expect a down->up event for. Anything that is # already up will not undergo that transition, and for # anything that might be stale (cache-wise) assume it's # already up so we don't block on it. return [('network-vif-plugged', vif['id']) for vif in network_info if vif.get('active', True) is False] def _cleanup_failed_start(self, context, instance, network_info, block_device_info, guest, cleanup_instance_dir=False, cleanup_instance_disks=False): try: if guest and guest.is_active(): guest.poweroff() finally: self._cleanup(context, instance, network_info, block_device_info=block_device_info, destroy_vifs=True, cleanup_instance_dir=cleanup_instance_dir, cleanup_instance_disks=cleanup_instance_disks) def _create_guest_with_network(self, context, xml, instance, network_info, block_device_info, power_on=True, vifs_already_plugged=False, post_xml_callback=None, external_events=None, cleanup_instance_dir=False, cleanup_instance_disks=False): """Do required network setup and create domain.""" timeout = CONF.vif_plugging_timeout if ( CONF.libvirt.virt_type in ('kvm', 'qemu') and not vifs_already_plugged and power_on and timeout ): events = (external_events if external_events else self._get_neutron_events(network_info)) else: events = [] pause = bool(events) guest: libvirt_guest.Guest = None try: with self.virtapi.wait_for_instance_event( instance, events, deadline=timeout, error_callback=self._neutron_failed_callback): self.plug_vifs(instance, network_info) with self._lxc_disk_handler(context, instance, instance.image_meta, block_device_info): guest = self._create_guest( context, xml, instance, pause=pause, power_on=power_on, post_xml_callback=post_xml_callback) except exception.VirtualInterfaceCreateException: # Neutron reported failure and we didn't swallow it, so # bail here with excutils.save_and_reraise_exception(): self._cleanup_failed_start( context, instance, network_info, block_device_info, guest, cleanup_instance_dir=cleanup_instance_dir, cleanup_instance_disks=cleanup_instance_disks) except eventlet.timeout.Timeout: # We never heard from Neutron LOG.warning('Timeout waiting for %(events)s for ' 'instance with vm_state %(vm_state)s and ' 'task_state %(task_state)s.', {'events': events, 'vm_state': instance.vm_state, 'task_state': instance.task_state}, instance=instance) if CONF.vif_plugging_is_fatal: self._cleanup_failed_start( context, instance, network_info, block_device_info, guest, cleanup_instance_dir=cleanup_instance_dir, cleanup_instance_disks=cleanup_instance_disks) raise exception.VirtualInterfaceCreateException() except Exception: # Any other error, be sure to clean up LOG.error('Failed to start libvirt guest', instance=instance) with excutils.save_and_reraise_exception(): self._cleanup_failed_start( context, instance, network_info, block_device_info, guest, cleanup_instance_dir=cleanup_instance_dir, cleanup_instance_disks=cleanup_instance_disks) # Resume only if domain has been paused if pause: guest.resume() return guest def _get_pcpu_available(self): """Get number of host cores to be used for PCPUs. :returns: The number of host cores to be used for PCPUs. """ if not CONF.compute.cpu_dedicated_set: return set() online_cpus = self._host.get_online_cpus() dedicated_cpus = hardware.get_cpu_dedicated_set() if not dedicated_cpus.issubset(online_cpus): msg = _("Invalid '[compute] cpu_dedicated_set' config: one or " "more of the configured CPUs is not online. Online " "cpuset(s): %(online)s, configured cpuset(s): %(req)s") raise exception.Invalid(msg % { 'online': sorted(online_cpus), 'req': sorted(dedicated_cpus)}) return dedicated_cpus def _get_vcpu_available(self): """Get host cores to be used for VCPUs. :returns: A list of host CPU cores that can be used for VCPUs. """ online_cpus = self._host.get_online_cpus() # NOTE(stephenfin): The use of the legacy 'vcpu_pin_set' option happens # if it's defined, regardless of whether '[compute] cpu_shared_set' is # also configured. This is legacy behavior required for upgrades that # should be removed in the future, when we can rely exclusively on # '[compute] cpu_shared_set'. if CONF.vcpu_pin_set: # TODO(stephenfin): Remove this in U shared_cpus = hardware.get_vcpu_pin_set() elif CONF.compute.cpu_shared_set: shared_cpus = hardware.get_cpu_shared_set() elif CONF.compute.cpu_dedicated_set: return set() else: return online_cpus if not shared_cpus.issubset(online_cpus): msg = _("Invalid '%(config_opt)s' config: one or " "more of the configured CPUs is not online. Online " "cpuset(s): %(online)s, configured cpuset(s): %(req)s") if CONF.vcpu_pin_set: config_opt = 'vcpu_pin_set' else: # CONF.compute.cpu_shared_set config_opt = '[compute] cpu_shared_set' raise exception.Invalid(msg % { 'config_opt': config_opt, 'online': sorted(online_cpus), 'req': sorted(shared_cpus)}) return shared_cpus @staticmethod def _get_local_gb_info(): """Get local storage info of the compute node in GB. :returns: A dict containing: :total: How big the overall usable filesystem is (in gigabytes) :free: How much space is free (in gigabytes) :used: How much space is used (in gigabytes) """ if CONF.libvirt.images_type == 'lvm': info = lvm.get_volume_group_info( CONF.libvirt.images_volume_group) elif CONF.libvirt.images_type == 'rbd': info = rbd_utils.RBDDriver().get_pool_info() else: info = libvirt_utils.get_fs_info(CONF.instances_path) for (k, v) in info.items(): info[k] = v / units.Gi return info def _get_vcpu_used(self): """Get vcpu usage number of physical computer. :returns: The total number of vcpu(s) that are currently being used. """ total = 0 # Not all libvirt drivers will support the get_vcpus_info() # # For example, LXC does not have a concept of vCPUs, while # QEMU (TCG) traditionally handles all vCPUs in a single # thread. So both will report an exception when the vcpus() # API call is made. In such a case we should report the # guest as having 1 vCPU, since that lets us still do # CPU over commit calculations that apply as the total # guest count scales. # # It is also possible that we might see an exception if # the guest is just in middle of shutting down. Technically # we should report 0 for vCPU usage in this case, but we # we can't reliably distinguish the vcpu not supported # case from the just shutting down case. Thus we don't know # whether to report 1 or 0 for vCPU count. # # Under-reporting vCPUs is bad because it could conceivably # let the scheduler place too many guests on the host. Over- # reporting vCPUs is not a problem as it'll auto-correct on # the next refresh of usage data. # # Thus when getting an exception we always report 1 as the # vCPU count, as the least worst value. for guest in self._host.list_guests(): try: vcpus = guest.get_vcpus_info() total += len(list(vcpus)) except libvirt.libvirtError: total += 1 # NOTE(gtt116): give other tasks a chance. greenthread.sleep(0) return total def _get_supported_vgpu_types(self): if not CONF.devices.enabled_vgpu_types: return [] # Make sure we register all the types as the compute service could # be calling this method before init_host() if len(CONF.devices.enabled_vgpu_types) > 1: nova.conf.devices.register_dynamic_opts(CONF) for vgpu_type in CONF.devices.enabled_vgpu_types: group = getattr(CONF, 'vgpu_%s' % vgpu_type, None) if group is None or not group.device_addresses: first_type = CONF.devices.enabled_vgpu_types[0] if len(CONF.devices.enabled_vgpu_types) > 1: # Only provide the warning if the operator provided more # than one type as it's not needed to provide groups # if you only use one vGPU type. msg = ("The vGPU type '%(type)s' was listed in '[devices] " "enabled_vgpu_types' but no corresponding " "'[vgpu_%(type)s]' group or " "'[vgpu_%(type)s] device_addresses' " "option was defined. Only the first type " "'%(ftype)s' will be used." % {'type': vgpu_type, 'ftype': first_type}) LOG.warning(msg) # We need to reset the mapping table that we started to provide # keys and values from previously processed vGPUs but since # there is a problem for this vGPU type, we only want to # support only the first type. self.pgpu_type_mapping.clear() return [first_type] for device_address in group.device_addresses: if device_address in self.pgpu_type_mapping: raise exception.InvalidLibvirtGPUConfig( reason="duplicate types for PCI ID %s" % device_address ) # Just checking whether the operator fat-fingered the address. # If it's wrong, it will return an exception try: pci_utils.parse_address(device_address) except exception.PciDeviceWrongAddressFormat: raise exception.InvalidLibvirtGPUConfig( reason="incorrect PCI address: %s" % device_address ) self.pgpu_type_mapping[device_address] = vgpu_type return CONF.devices.enabled_vgpu_types def _get_vgpu_type_per_pgpu(self, device_address): """Provides the vGPU type the pGPU supports. :param device_address: the libvirt PCI device name, eg.'pci_0000_84_00_0' """ # Bail out quickly if we don't support vGPUs if not self.supported_vgpu_types: return if len(self.supported_vgpu_types) == 1: # The operator wanted to only support one single type so we can # blindly return it for every single pGPU return self.supported_vgpu_types[0] # The libvirt name is like 'pci_0000_84_00_0' try: device_address = "{}:{}:{}.{}".format( *device_address[4:].split('_')) # Validates whether it's a PCI ID... pci_utils.parse_address(device_address) # .format() can return IndexError except (exception.PciDeviceWrongAddressFormat, IndexError): # this is not a valid PCI address LOG.warning("The PCI address %s was invalid for getting the " "related vGPU type", device_address) return try: return self.pgpu_type_mapping.get(device_address) except KeyError: LOG.warning("No vGPU type was configured for PCI address: %s", device_address) # We accept to return None instead of raising an exception # because we prefer the callers to return the existing exceptions # in case we can't find a specific pGPU return def _count_mediated_devices(self, enabled_vgpu_types): """Counts the sysfs objects (handles) that represent a mediated device and filtered by $enabled_vgpu_types. Those handles can be in use by a libvirt guest or not. :param enabled_vgpu_types: list of enabled VGPU types on this host :returns: dict, keyed by parent GPU libvirt PCI device ID, of number of mdev device handles for that GPU """ counts_per_parent: ty.Dict[str, int] = collections.defaultdict(int) mediated_devices = self._get_mediated_devices(types=enabled_vgpu_types) for mdev in mediated_devices: parent_vgpu_type = self._get_vgpu_type_per_pgpu(mdev['parent']) if mdev['type'] != parent_vgpu_type: # Even if some mdev was created for another vGPU type, just # verify all the mdevs related to the type that their pGPU # has continue counts_per_parent[mdev['parent']] += 1 return counts_per_parent def _count_mdev_capable_devices(self, enabled_vgpu_types): """Counts the mdev-capable devices on this host filtered by $enabled_vgpu_types. :param enabled_vgpu_types: list of enabled VGPU types on this host :returns: dict, keyed by device name, to an integer count of available instances of each type per device """ mdev_capable_devices = self._get_mdev_capable_devices( types=enabled_vgpu_types) counts_per_dev: ty.Dict[str, int] = collections.defaultdict(int) for dev in mdev_capable_devices: # dev_id is the libvirt name for the PCI device, # eg. pci_0000_84_00_0 which matches a PCI address of 0000:84:00.0 dev_name = dev['dev_id'] dev_supported_type = self._get_vgpu_type_per_pgpu(dev_name) for _type in dev['types']: if _type != dev_supported_type: # This is not the type the operator wanted to support for # this physical GPU continue available = dev['types'][_type]['availableInstances'] # NOTE(sbauza): Even if we support multiple types, Nova will # only use one per physical GPU. counts_per_dev[dev_name] += available return counts_per_dev def _get_gpu_inventories(self): """Returns the inventories for each physical GPU for a specific type supported by the enabled_vgpu_types CONF option. :returns: dict, keyed by libvirt PCI name, of dicts like: {'pci_0000_84_00_0': {'total': $TOTAL, 'min_unit': 1, 'max_unit': $TOTAL, 'step_size': 1, 'reserved': 0, 'allocation_ratio': 1.0, } } """ # Bail out early if operator doesn't care about providing vGPUs enabled_vgpu_types = self.supported_vgpu_types if not enabled_vgpu_types: return {} inventories = {} count_per_parent = self._count_mediated_devices(enabled_vgpu_types) for dev_name, count in count_per_parent.items(): inventories[dev_name] = {'total': count} # Filter how many available mdevs we can create for all the supported # types. count_per_dev = self._count_mdev_capable_devices(enabled_vgpu_types) # Combine the counts into the dict that we return to the caller. for dev_name, count in count_per_dev.items(): inv_per_parent = inventories.setdefault( dev_name, {'total': 0}) inv_per_parent['total'] += count inv_per_parent.update({ 'min_unit': 1, 'step_size': 1, 'reserved': 0, # NOTE(sbauza): There is no sense to have a ratio but 1.0 # since we can't overallocate vGPU resources 'allocation_ratio': 1.0, # FIXME(sbauza): Some vendors could support only one 'max_unit': inv_per_parent['total'], }) return inventories def _get_instance_capabilities(self): """Get hypervisor instance capabilities Returns a list of tuples that describe instances the hypervisor is capable of hosting. Each tuple consists of the triplet (arch, hypervisor_type, vm_mode). :returns: List of tuples describing instance capabilities """ caps = self._host.get_capabilities() instance_caps = list() for g in caps.guests: for domain_type in g.domains: try: instance_cap = ( fields.Architecture.canonicalize(g.arch), fields.HVType.canonicalize(domain_type), fields.VMMode.canonicalize(g.ostype)) instance_caps.append(instance_cap) except exception.InvalidArchitectureName: # NOTE(danms): Libvirt is exposing a guest arch that nova # does not even know about. Avoid aborting here and # continue to process the rest. pass return instance_caps def _get_cpu_info(self): """Get cpuinfo information. Obtains cpu feature from virConnect.getCapabilities. :return: see above description """ caps = self._host.get_capabilities() cpu_info = dict() cpu_info['arch'] = caps.host.cpu.arch cpu_info['model'] = caps.host.cpu.model cpu_info['vendor'] = caps.host.cpu.vendor topology = dict() topology['cells'] = len(getattr(caps.host.topology, 'cells', [1])) topology['sockets'] = caps.host.cpu.sockets topology['cores'] = caps.host.cpu.cores topology['threads'] = caps.host.cpu.threads cpu_info['topology'] = topology features = set() for f in caps.host.cpu.features: features.add(f.name) cpu_info['features'] = features return cpu_info def _get_pcinet_info( self, dev: 'libvirt.virNodeDevice', net_devs: ty.List['libvirt.virNodeDevice'] ) -> ty.Optional[ty.List[str]]: """Returns a dict of NET device.""" net_dev = {dev.parent(): dev for dev in net_devs}.get(dev.name(), None) if net_dev is None: return None xmlstr = net_dev.XMLDesc(0) cfgdev = vconfig.LibvirtConfigNodeDevice() cfgdev.parse_str(xmlstr) return cfgdev.pci_capability.features def _get_pcidev_info( self, devname: str, dev: 'libvirt.virNodeDevice', net_devs: ty.List['libvirt.virNodeDevice'] ) -> ty.Dict[str, ty.Union[str, dict]]: """Returns a dict of PCI device.""" def _get_device_type( cfgdev: vconfig.LibvirtConfigNodeDevice, pci_address: str, device: 'libvirt.virNodeDevice', net_devs: ty.List['libvirt.virNodeDevice'] ) -> ty.Dict[str, str]: """Get a PCI device's device type. An assignable PCI device can be a normal PCI device, a SR-IOV Physical Function (PF), or a SR-IOV Virtual Function (VF). """ net_dev_parents = {dev.parent() for dev in net_devs} for fun_cap in cfgdev.pci_capability.fun_capability: if fun_cap.type == 'virt_functions': return { 'dev_type': fields.PciDeviceType.SRIOV_PF, } if (fun_cap.type == 'phys_function' and len(fun_cap.device_addrs) != 0): phys_address = "%04x:%02x:%02x.%01x" % ( fun_cap.device_addrs[0][0], fun_cap.device_addrs[0][1], fun_cap.device_addrs[0][2], fun_cap.device_addrs[0][3]) result = { 'dev_type': fields.PciDeviceType.SRIOV_VF, 'parent_addr': phys_address, } parent_ifname = None # NOTE(sean-k-mooney): if the VF is a parent of a netdev # the PF should also have a netdev. if device.name() in net_dev_parents: parent_ifname = pci_utils.get_ifname_by_pci_address( pci_address, pf_interface=True) result['parent_ifname'] = parent_ifname return result return {'dev_type': fields.PciDeviceType.STANDARD} def _get_device_capabilities( device_dict: dict, device: 'libvirt.virNodeDevice', net_devs: ty.List['libvirt.virNodeDevice'] ) -> ty.Dict[str, ty.Dict[str, ty.Optional[ty.List[str]]]]: """Get PCI VF device's additional capabilities. If a PCI device is a virtual function, this function reads the PCI parent's network capabilities (must be always a NIC device) and appends this information to the device's dictionary. """ if device_dict.get('dev_type') == fields.PciDeviceType.SRIOV_VF: pcinet_info = self._get_pcinet_info(device, net_devs) if pcinet_info: return {'capabilities': {'network': pcinet_info}} return {} xmlstr = dev.XMLDesc(0) cfgdev = vconfig.LibvirtConfigNodeDevice() cfgdev.parse_str(xmlstr) address = "%04x:%02x:%02x.%1x" % ( cfgdev.pci_capability.domain, cfgdev.pci_capability.bus, cfgdev.pci_capability.slot, cfgdev.pci_capability.function) device = { "dev_id": cfgdev.name, "address": address, "product_id": "%04x" % cfgdev.pci_capability.product_id, "vendor_id": "%04x" % cfgdev.pci_capability.vendor_id, } device["numa_node"] = cfgdev.pci_capability.numa_node # requirement by DataBase Model device['label'] = 'label_%(vendor_id)s_%(product_id)s' % device device.update(_get_device_type(cfgdev, address, dev, net_devs)) device.update(_get_device_capabilities(device, dev, net_devs)) return device def _get_pci_passthrough_devices(self): """Get host PCI devices information. Obtains pci devices information from libvirt, and returns as a JSON string. Each device information is a dictionary, with mandatory keys of 'address', 'vendor_id', 'product_id', 'dev_type', 'dev_id', 'label' and other optional device specific information. Refer to the objects/pci_device.py for more idea of these keys. :returns: a JSON string containing a list of the assignable PCI devices information """ dev_flags = (libvirt.VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET | libvirt.VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV) devices = {dev.name(): dev for dev in self._host.list_all_devices(flags=dev_flags)} net_devs = [dev for dev in devices.values() if "net" in dev.listCaps()] pci_info = [self._get_pcidev_info(name, dev, net_devs) for name, dev in devices.items() if "pci" in dev.listCaps()] return jsonutils.dumps(pci_info) def _get_mdev_capabilities_for_dev(self, devname, types=None): """Returns a dict of MDEV capable device with the ID as first key and then a list of supported types, each of them being a dict. :param types: Only return those specific types. """ virtdev = self._host.device_lookup_by_name(devname) xmlstr = virtdev.XMLDesc(0) cfgdev = vconfig.LibvirtConfigNodeDevice() cfgdev.parse_str(xmlstr) device = { "dev_id": cfgdev.name, "types": {}, "vendor_id": cfgdev.pci_capability.vendor_id, } for mdev_cap in cfgdev.pci_capability.mdev_capability: for cap in mdev_cap.mdev_types: if not types or cap['type'] in types: device["types"].update({cap['type']: { 'availableInstances': cap['availableInstances'], 'name': cap['name'], 'deviceAPI': cap['deviceAPI']}}) return device def _get_mdev_capable_devices(self, types=None): """Get host devices supporting mdev types. Obtain devices information from libvirt and returns a list of dictionaries. :param types: Filter only devices supporting those types. """ dev_names = self._host.list_mdev_capable_devices() or [] mdev_capable_devices = [] for name in dev_names: device = self._get_mdev_capabilities_for_dev(name, types) if not device["types"]: continue mdev_capable_devices.append(device) return mdev_capable_devices def _get_mediated_device_information(self, devname): """Returns a dict of a mediated device.""" virtdev = self._host.device_lookup_by_name(devname) xmlstr = virtdev.XMLDesc(0) cfgdev = vconfig.LibvirtConfigNodeDevice() cfgdev.parse_str(xmlstr) device = { "dev_id": cfgdev.name, # name is like mdev_00ead764_fdc0_46b6_8db9_2963f5c815b4 "uuid": libvirt_utils.mdev_name2uuid(cfgdev.name), # the physical GPU PCI device "parent": cfgdev.parent, "type": cfgdev.mdev_information.type, "iommu_group": cfgdev.mdev_information.iommu_group, } return device def _get_mediated_devices(self, types=None): """Get host mediated devices. Obtain devices information from libvirt and returns a list of dictionaries. :param types: Filter only devices supporting those types. """ dev_names = self._host.list_mediated_devices() or [] mediated_devices = [] for name in dev_names: device = self._get_mediated_device_information(name) if not types or device["type"] in types: mediated_devices.append(device) return mediated_devices def _get_all_assigned_mediated_devices(self, instance=None): """Lookup all instances from the host and return all the mediated devices that are assigned to a guest. :param instance: Only return mediated devices for that instance. :returns: A dictionary of keys being mediated device UUIDs and their respective values the instance UUID of the guest using it. Returns an empty dict if an instance is provided but not found in the hypervisor. """ allocated_mdevs = {} if instance: # NOTE(sbauza): In some cases (like a migration issue), the # instance can exist in the Nova database but libvirt doesn't know # about it. For such cases, the way to fix that is to hard reboot # the instance, which will recreate the libvirt guest. # For that reason, we need to support that case by making sure # we don't raise an exception if the libvirt guest doesn't exist. try: guest = self._host.get_guest(instance) except exception.InstanceNotFound: # Bail out early if libvirt doesn't know about it since we # can't know the existing mediated devices return {} guests = [guest] else: guests = self._host.list_guests(only_running=False) for guest in guests: cfg = guest.get_config() for device in cfg.devices: if isinstance(device, vconfig.LibvirtConfigGuestHostdevMDEV): allocated_mdevs[device.uuid] = guest.uuid return allocated_mdevs @staticmethod def _vgpu_allocations(allocations): """Filtering only the VGPU allocations from a list of allocations. :param allocations: Information about resources allocated to the instance via placement, of the form returned by SchedulerReportClient.get_allocations_for_consumer. """ if not allocations: # If no allocations, there is no vGPU request. return {} RC_VGPU = orc.VGPU vgpu_allocations = {} for rp in allocations: res = allocations[rp]['resources'] if RC_VGPU in res and res[RC_VGPU] > 0: vgpu_allocations[rp] = {'resources': {RC_VGPU: res[RC_VGPU]}} return vgpu_allocations def _get_existing_mdevs_not_assigned(self, parent, requested_types=None): """Returns the already created mediated devices that are not assigned to a guest yet. :param parent: Filter out result for only mdevs from the parent device. :param requested_types: Filter out the result for only mediated devices having those types. """ allocated_mdevs = self._get_all_assigned_mediated_devices() mdevs = self._get_mediated_devices(requested_types) available_mdevs = set() for mdev in mdevs: parent_vgpu_type = self._get_vgpu_type_per_pgpu(mdev['parent']) if mdev['type'] != parent_vgpu_type: # This mdev is using a vGPU type that is not supported by the # configuration option for its pGPU parent, so we can't use it. continue # FIXME(sbauza): No longer accept the parent value to be nullable # once we fix the reshape functional test if parent is None or mdev['parent'] == parent: available_mdevs.add(mdev["uuid"]) available_mdevs -= set(allocated_mdevs) return available_mdevs def _create_new_mediated_device(self, parent, uuid=None): """Find a physical device that can support a new mediated device and create it. :param parent: The libvirt name of the parent GPU, eg. pci_0000_06_00_0 :param uuid: The possible mdev UUID we want to create again :returns: the newly created mdev UUID or None if not possible """ supported_types = self.supported_vgpu_types # Try to see if we can still create a new mediated device devices = self._get_mdev_capable_devices(supported_types) for device in devices: dev_name = device['dev_id'] # FIXME(sbauza): No longer accept the parent value to be nullable # once we fix the reshape functional test if parent is not None and dev_name != parent: # The device is not the one that was called, not creating # the mdev continue dev_supported_type = self._get_vgpu_type_per_pgpu(dev_name) if dev_supported_type and device['types'][ dev_supported_type]['availableInstances'] > 0: # That physical GPU has enough room for a new mdev # We need the PCI address, not the libvirt name # The libvirt name is like 'pci_0000_84_00_0' pci_addr = "{}:{}:{}.{}".format(*dev_name[4:].split('_')) chosen_mdev = nova.privsep.libvirt.create_mdev( pci_addr, dev_supported_type, uuid=uuid) return chosen_mdev @utils.synchronized(VGPU_RESOURCE_SEMAPHORE) def _allocate_mdevs(self, allocations): """Returns a list of mediated device UUIDs corresponding to available resources we can assign to the guest(s) corresponding to the allocation requests passed as argument. That method can either find an existing but unassigned mediated device it can allocate, or create a new mediated device from a capable physical device if the latter has enough left capacity. :param allocations: Information about resources allocated to the instance via placement, of the form returned by SchedulerReportClient.get_allocations_for_consumer. That code is supporting Placement API version 1.12 """ vgpu_allocations = self._vgpu_allocations(allocations) if not vgpu_allocations: return # TODO(sbauza): For the moment, we only support allocations for only # one pGPU. if len(vgpu_allocations) > 1: LOG.warning('More than one allocation was passed over to libvirt ' 'while at the moment libvirt only supports one. Only ' 'the first allocation will be looked up.') rp_uuid, alloc = six.next(six.iteritems(vgpu_allocations)) vgpus_asked = alloc['resources'][orc.VGPU] # Find if we allocated against a specific pGPU (and then the allocation # is made against a child RP) or any pGPU (in case the VGPU inventory # is still on the root RP) try: allocated_rp = self.provider_tree.data(rp_uuid) except ValueError: # The provider doesn't exist, return a better understandable # exception raise exception.ComputeResourcesUnavailable( reason='vGPU resource is not available') # FIXME(sbauza): The functional reshape test assumes that we could # run _allocate_mdevs() against non-nested RPs but this is impossible # as all inventories have been reshaped *before now* since it's done # on init_host() (when the compute restarts or whatever else calls it). # That said, since fixing the functional test isn't easy yet, let's # assume we still support a non-nested RP for now. if allocated_rp.parent_uuid is None: # We are on a root RP parent_device = None else: rp_name = allocated_rp.name # There can be multiple roots, we need to find the root name # to guess the physical device name roots = list(self.provider_tree.roots) for root in roots: if rp_name.startswith(root.name + '_'): # The RP name convention is : # root_name + '_' + parent_device parent_device = rp_name[len(root.name) + 1:] break else: LOG.warning( "pGPU device name %(name)s can't be guessed from the " "ProviderTree roots %(roots)s", {'name': rp_name, 'roots': ', '.join([root.name for root in roots])}) # We f... have no idea what was the parent device # If we can't find devices having available VGPUs, just raise raise exception.ComputeResourcesUnavailable( reason='vGPU resource is not available') supported_types = self.supported_vgpu_types # Which mediated devices are created but not assigned to a guest ? mdevs_available = self._get_existing_mdevs_not_assigned( parent_device, supported_types) chosen_mdevs = [] for c in six.moves.range(vgpus_asked): chosen_mdev = None if mdevs_available: # Take the first available mdev chosen_mdev = mdevs_available.pop() else: chosen_mdev = self._create_new_mediated_device(parent_device) if not chosen_mdev: # If we can't find devices having available VGPUs, just raise raise exception.ComputeResourcesUnavailable( reason='vGPU resource is not available') else: chosen_mdevs.append(chosen_mdev) return chosen_mdevs def _detach_mediated_devices(self, guest): mdevs = guest.get_all_devices( devtype=vconfig.LibvirtConfigGuestHostdevMDEV) for mdev_cfg in mdevs: try: guest.detach_device(mdev_cfg, live=True) except libvirt.libvirtError as ex: error_code = ex.get_error_code() # NOTE(sbauza): There is a pending issue with libvirt that # doesn't allow to hot-unplug mediated devices. Let's # short-circuit the suspend action and set the instance back # to ACTIVE. # TODO(sbauza): Once libvirt supports this, amend the resume() # operation to support reallocating mediated devices. if error_code == libvirt.VIR_ERR_CONFIG_UNSUPPORTED: reason = _("Suspend is not supported for instances having " "attached vGPUs.") raise exception.InstanceFaultRollback( exception.InstanceSuspendFailure(reason=reason)) else: raise def _has_numa_support(self): # This means that the host can support LibvirtConfigGuestNUMATune # and the nodeset field in LibvirtConfigGuestMemoryBackingPage caps = self._host.get_capabilities() if (caps.host.cpu.arch in (fields.Architecture.I686, fields.Architecture.X86_64, fields.Architecture.AARCH64) and self._host.has_min_version(hv_type=host.HV_DRIVER_QEMU)): return True elif (caps.host.cpu.arch in (fields.Architecture.PPC64, fields.Architecture.PPC64LE)): return True return False def _get_host_numa_topology(self): if not self._has_numa_support(): return caps = self._host.get_capabilities() topology = caps.host.topology if topology is None or not topology.cells: return cells = [] available_shared_cpus = self._get_vcpu_available() available_dedicated_cpus = self._get_pcpu_available() # NOTE(stephenfin): In an ideal world, if the operator had not # configured this host to report PCPUs using the '[compute] # cpu_dedicated_set' option, then we should not be able to used pinned # instances on this host. However, that would force operators to update # their configuration as part of the Stein -> Train upgrade or be # unable to schedule instances on the host. As a result, we need to # revert to legacy behavior and use 'vcpu_pin_set' for both VCPUs and # PCPUs. # TODO(stephenfin): Remove this in U if not available_dedicated_cpus and not ( CONF.compute.cpu_shared_set and not CONF.vcpu_pin_set): available_dedicated_cpus = available_shared_cpus def _get_reserved_memory_for_cell(self, cell_id, page_size): cell = self._reserved_hugepages.get(cell_id, {}) return cell.get(page_size, 0) def _get_physnet_numa_affinity(): affinities: ty.Dict[int, ty.Set[str]] = { cell.id: set() for cell in topology.cells } for physnet in CONF.neutron.physnets: # This will error out if the group is not registered, which is # exactly what we want as that would be a bug group = getattr(CONF, 'neutron_physnet_%s' % physnet) if not group.numa_nodes: msg = ("the physnet '%s' was listed in '[neutron] " "physnets' but no corresponding " "'[neutron_physnet_%s] numa_nodes' option was " "defined." % (physnet, physnet)) raise exception.InvalidNetworkNUMAAffinity(reason=msg) for node in group.numa_nodes: if node not in affinities: msg = ("node %d for physnet %s is not present in host " "affinity set %r" % (node, physnet, affinities)) # The config option referenced an invalid node raise exception.InvalidNetworkNUMAAffinity(reason=msg) affinities[node].add(physnet) return affinities def _get_tunnel_numa_affinity(): affinities = {cell.id: False for cell in topology.cells} for node in CONF.neutron_tunnel.numa_nodes: if node not in affinities: msg = ("node %d for tunneled networks is not present " "in host affinity set %r" % (node, affinities)) # The config option referenced an invalid node raise exception.InvalidNetworkNUMAAffinity(reason=msg) affinities[node] = True return affinities physnet_affinities = _get_physnet_numa_affinity() tunnel_affinities = _get_tunnel_numa_affinity() for cell in topology.cells: cpus = set(cpu.id for cpu in cell.cpus) cpuset = cpus & available_shared_cpus pcpuset = cpus & available_dedicated_cpus # de-duplicate and sort the list of CPU sibling sets siblings = sorted( set(x) for x in set( tuple(cpu.siblings) or () for cpu in cell.cpus ) ) cpus &= available_shared_cpus | available_dedicated_cpus siblings = [sib & cpus for sib in siblings] # Filter out empty sibling sets that may be left siblings = [sib for sib in siblings if len(sib) > 0] mempages = [ objects.NUMAPagesTopology( size_kb=pages.size, total=pages.total, used=0, reserved=_get_reserved_memory_for_cell( self, cell.id, pages.size)) for pages in cell.mempages] network_metadata = objects.NetworkMetadata( physnets=physnet_affinities[cell.id], tunneled=tunnel_affinities[cell.id]) # NOTE(stephenfin): Note that we don't actually return any usage # information here. This is because this is handled by the resource # tracker via the 'update_available_resource' periodic task, which # loops through all instances and calculated usage accordingly cell = objects.NUMACell( id=cell.id, cpuset=cpuset, pcpuset=pcpuset, memory=cell.memory / units.Ki, cpu_usage=0, pinned_cpus=set(), memory_usage=0, siblings=siblings, mempages=mempages, network_metadata=network_metadata) cells.append(cell) return objects.NUMATopology(cells=cells) def get_all_volume_usage(self, context, compute_host_bdms): """Return usage info for volumes attached to vms on a given host. """ vol_usage = [] for instance_bdms in compute_host_bdms: instance = instance_bdms['instance'] for bdm in instance_bdms['instance_bdms']: mountpoint = bdm['device_name'] if mountpoint.startswith('/dev/'): mountpoint = mountpoint[5:] volume_id = bdm['volume_id'] LOG.debug("Trying to get stats for the volume %s", volume_id, instance=instance) vol_stats = self.block_stats(instance, mountpoint) if vol_stats: stats = dict(volume=volume_id, instance=instance, rd_req=vol_stats[0], rd_bytes=vol_stats[1], wr_req=vol_stats[2], wr_bytes=vol_stats[3]) LOG.debug( "Got volume usage stats for the volume=%(volume)s," " rd_req=%(rd_req)d, rd_bytes=%(rd_bytes)d, " "wr_req=%(wr_req)d, wr_bytes=%(wr_bytes)d", stats, instance=instance) vol_usage.append(stats) return vol_usage def block_stats(self, instance, disk_id): """Note that this function takes an instance name.""" try: guest = self._host.get_guest(instance) dev = guest.get_block_device(disk_id) return dev.blockStats() except libvirt.libvirtError as e: errcode = e.get_error_code() LOG.info('Getting block stats failed, device might have ' 'been detached. Instance=%(instance_name)s ' 'Disk=%(disk)s Code=%(errcode)s Error=%(e)s', {'instance_name': instance.name, 'disk': disk_id, 'errcode': errcode, 'e': e}, instance=instance) except exception.InstanceNotFound: LOG.info('Could not find domain in libvirt for instance %s. ' 'Cannot get block stats for device', instance.name, instance=instance) def get_console_pool_info(self, console_type): # TODO(mdragon): console proxy should be implemented for libvirt, # in case someone wants to use it with kvm or # such. For now return fake data. return {'address': '127.0.0.1', 'username': 'fakeuser', 'password': 'fakepassword'} def update_provider_tree(self, provider_tree, nodename, allocations=None): """Update a ProviderTree object with current resource provider, inventory information and CPU traits. :param nova.compute.provider_tree.ProviderTree provider_tree: A nova.compute.provider_tree.ProviderTree object representing all the providers in the tree associated with the compute node, and any sharing providers (those with the ``MISC_SHARES_VIA_AGGREGATE`` trait) associated via aggregate with any of those providers (but not *their* tree- or aggregate-associated providers), as currently known by placement. :param nodename: String name of the compute node (i.e. ComputeNode.hypervisor_hostname) for which the caller is requesting updated provider information. :param allocations: Dict of allocation data of the form: { $CONSUMER_UUID: { # The shape of each "allocations" dict below is identical # to the return from GET /allocations/{consumer_uuid} "allocations": { $RP_UUID: { "generation": $RP_GEN, "resources": { $RESOURCE_CLASS: $AMOUNT, ... }, }, ... }, "project_id": $PROJ_ID, "user_id": $USER_ID, "consumer_generation": $CONSUMER_GEN, }, ... } If None, and the method determines that any inventory needs to be moved (from one provider to another and/or to a different resource class), the ReshapeNeeded exception must be raised. Otherwise, this dict must be edited in place to indicate the desired final state of allocations. :raises ReshapeNeeded: If allocations is None and any inventory needs to be moved from one provider to another and/or to a different resource class. :raises: ReshapeFailed if the requested tree reshape fails for whatever reason. """ disk_gb = int(self._get_local_gb_info()['total']) memory_mb = int(self._host.get_memory_mb_total()) vcpus = len(self._get_vcpu_available()) pcpus = len(self._get_pcpu_available()) memory_enc_slots = self._get_memory_encrypted_slots() # NOTE(yikun): If the inv record does not exists, the allocation_ratio # will use the CONF.xxx_allocation_ratio value if xxx_allocation_ratio # is set, and fallback to use the initial_xxx_allocation_ratio # otherwise. inv = provider_tree.data(nodename).inventory ratios = self._get_allocation_ratios(inv) resources: ty.Dict[str, ty.Set['objects.Resource']] = ( collections.defaultdict(set) ) result = {} if memory_mb: result[orc.MEMORY_MB] = { 'total': memory_mb, 'min_unit': 1, 'max_unit': memory_mb, 'step_size': 1, 'allocation_ratio': ratios[orc.MEMORY_MB], 'reserved': CONF.reserved_host_memory_mb, } # NOTE(stephenfin): We have to optionally report these since placement # forbids reporting inventory with total=0 if vcpus: result[orc.VCPU] = { 'total': vcpus, 'min_unit': 1, 'max_unit': vcpus, 'step_size': 1, 'allocation_ratio': ratios[orc.VCPU], 'reserved': CONF.reserved_host_cpus, } if pcpus: result[orc.PCPU] = { 'total': pcpus, 'min_unit': 1, 'max_unit': pcpus, 'step_size': 1, 'allocation_ratio': 1, 'reserved': 0, } if memory_enc_slots: result[orc.MEM_ENCRYPTION_CONTEXT] = { 'total': memory_enc_slots, 'min_unit': 1, 'max_unit': 1, 'step_size': 1, 'allocation_ratio': 1.0, 'reserved': 0, } # If a sharing DISK_GB provider exists in the provider tree, then our # storage is shared, and we should not report the DISK_GB inventory in # the compute node provider. # TODO(efried): Reinstate non-reporting of shared resource by the # compute RP once the issues from bug #1784020 have been resolved. if provider_tree.has_sharing_provider(orc.DISK_GB): LOG.debug('Ignoring sharing provider - see bug #1784020') if disk_gb: result[orc.DISK_GB] = { 'total': disk_gb, 'min_unit': 1, 'max_unit': disk_gb, 'step_size': 1, 'allocation_ratio': ratios[orc.DISK_GB], 'reserved': (self._get_reserved_host_disk_gb_from_config() + self._get_disk_size_reserved_for_image_cache()), } # TODO(sbauza): Use traits to providing vGPU types. For the moment, # it will be only documentation support by explaining to use # osc-placement to create custom traits for each of the pGPU RPs. self._update_provider_tree_for_vgpu( provider_tree, nodename, allocations=allocations) self._update_provider_tree_for_pcpu( provider_tree, nodename, allocations=allocations) self._update_provider_tree_for_vpmems( provider_tree, nodename, result, resources) provider_tree.update_inventory(nodename, result) provider_tree.update_resources(nodename, resources) # Add supported traits i.e. those equal to True to provider tree while # removing the unsupported ones traits_to_add = [ t for t in self.static_traits if self.static_traits[t] ] traits_to_remove = set(self.static_traits) - set(traits_to_add) provider_tree.add_traits(nodename, *traits_to_add) provider_tree.remove_traits(nodename, *traits_to_remove) # Now that we updated the ProviderTree, we want to store it locally # so that spawn() or other methods can access it thru a getter self.provider_tree = copy.deepcopy(provider_tree) def _update_provider_tree_for_vpmems(self, provider_tree, nodename, inventory, resources): """Update resources and inventory for vpmems in provider tree.""" prov_data = provider_tree.data(nodename) for rc, vpmems in self._vpmems_by_rc.items(): # Skip (and omit) inventories with total=0 because placement does # not allow setting total=0 for inventory. if not len(vpmems): continue inventory[rc] = { 'total': len(vpmems), 'max_unit': len(vpmems), 'min_unit': 1, 'step_size': 1, 'allocation_ratio': 1.0, 'reserved': 0 } for vpmem in vpmems: resource_obj = objects.Resource( provider_uuid=prov_data.uuid, resource_class=rc, identifier=vpmem.name, metadata=vpmem) resources[rc].add(resource_obj) def _get_memory_encrypted_slots(self): slots = CONF.libvirt.num_memory_encrypted_guests if not self._host.supports_amd_sev: if slots and slots > 0: LOG.warning("Host is configured with " "libvirt.num_memory_encrypted_guests set to " "%d, but is not SEV-capable.", slots) return 0 # NOTE(aspiers): Auto-detection of the number of available # slots for AMD SEV is not yet possible, so honor the # configured value, or impose no limit if this is not # specified. This does incur a risk that if operators don't # read the instructions and configure the maximum correctly, # the maximum could be exceeded resulting in SEV guests # failing at launch-time. However at least SEV guests will # launch until the maximum, and when auto-detection code is # added later, an upgrade will magically fix the issue. # # Note also that the configured value can be 0 on an # SEV-capable host, since there might conceivably be good # reasons for the operator to want to disable SEV even when # it's available (e.g. due to performance impact, or # implementation bugs which may surface later). if slots is not None: return slots else: return db_const.MAX_INT @property def static_traits(self) -> ty.Dict[str, bool]: if self._static_traits is not None: return self._static_traits traits: ty.Dict[str, bool] = {} traits.update(self._get_cpu_traits()) traits.update(self._get_storage_bus_traits()) traits.update(self._get_video_model_traits()) traits.update(self._get_vif_model_traits()) traits.update(self._get_tpm_traits()) _, invalid_traits = ot.check_traits(traits) for invalid_trait in invalid_traits: LOG.debug("Trait '%s' is not valid; ignoring.", invalid_trait) del traits[invalid_trait] self._static_traits = traits return self._static_traits @staticmethod def _is_reshape_needed_vgpu_on_root(provider_tree, nodename): """Determine if root RP has VGPU inventories. Check to see if the root compute node provider in the tree for this host already has VGPU inventory because if it does, we either need to signal for a reshape (if _update_provider_tree_for_vgpu() has no allocations) or move the allocations within the ProviderTree if passed. :param provider_tree: The ProviderTree object for this host. :param nodename: The ComputeNode.hypervisor_hostname, also known as the name of the root node provider in the tree for this host. :returns: boolean, whether we have VGPU root inventory. """ root_node = provider_tree.data(nodename) return orc.VGPU in root_node.inventory @staticmethod def _ensure_pgpu_providers(inventories_dict, provider_tree, nodename): """Ensures GPU inventory providers exist in the tree for $nodename. GPU providers are named $nodename_$gpu-device-id, e.g. ``somehost.foo.bar.com_pci_0000_84_00_0``. :param inventories_dict: Dictionary of inventories for VGPU class directly provided by _get_gpu_inventories() and which looks like: {'pci_0000_84_00_0': {'total': $TOTAL, 'min_unit': 1, 'max_unit': $MAX_UNIT, # defaults to $TOTAL 'step_size': 1, 'reserved': 0, 'allocation_ratio': 1.0, } } :param provider_tree: The ProviderTree to update. :param nodename: The ComputeNode.hypervisor_hostname, also known as the name of the root node provider in the tree for this host. :returns: dict, keyed by GPU device ID, to ProviderData object representing that resource provider in the tree """ # Create the VGPU child providers if they do not already exist. # Dict of PGPU RPs keyed by their libvirt PCI name pgpu_rps = {} for pgpu_dev_id, inventory in inventories_dict.items(): # Skip (and omit) inventories with total=0 because placement does # not allow setting total=0 for inventory. if not inventory['total']: continue # For each physical GPU, we make sure to have a child provider pgpu_rp_name = '%s_%s' % (nodename, pgpu_dev_id) if not provider_tree.exists(pgpu_rp_name): # This is the first time creating the child provider so add # it to the tree under the root node provider. provider_tree.new_child(pgpu_rp_name, nodename) # We want to idempotently return the resource providers with VGPUs pgpu_rp = provider_tree.data(pgpu_rp_name) pgpu_rps[pgpu_dev_id] = pgpu_rp # The VGPU inventory goes on a child provider of the given root # node, identified by $nodename. pgpu_inventory = {orc.VGPU: inventory} provider_tree.update_inventory(pgpu_rp_name, pgpu_inventory) return pgpu_rps @staticmethod def _assert_is_root_provider( rp_uuid, root_node, consumer_uuid, alloc_data): """Asserts during a reshape that rp_uuid is for the root node provider. When reshaping, inventory and allocations should be on the root node provider and then moved to child providers. :param rp_uuid: UUID of the provider that holds inventory/allocations. :param root_node: ProviderData object representing the root node in a provider tree. :param consumer_uuid: UUID of the consumer (instance) holding resource allocations against the given rp_uuid provider. :param alloc_data: dict of allocation data for the consumer. :raises: ReshapeFailed if rp_uuid is not the root node indicating a reshape was needed but the inventory/allocation structure is not expected. """ if rp_uuid != root_node.uuid: # Something is wrong - VGPU inventory should # only be on the root node provider if we are # reshaping the tree. msg = (_('Unexpected VGPU resource allocation ' 'on provider %(rp_uuid)s for consumer ' '%(consumer_uuid)s: %(alloc_data)s. ' 'Expected VGPU allocation to be on root ' 'compute node provider %(root_uuid)s.') % {'rp_uuid': rp_uuid, 'consumer_uuid': consumer_uuid, 'alloc_data': alloc_data, 'root_uuid': root_node.uuid}) raise exception.ReshapeFailed(error=msg) def _get_assigned_mdevs_for_reshape( self, instance_uuid, rp_uuid, alloc_data): """Gets the mediated devices assigned to the instance during a reshape. :param instance_uuid: UUID of the instance consuming VGPU resources on this host. :param rp_uuid: UUID of the resource provider with VGPU inventory being consumed by the instance. :param alloc_data: dict of allocation data for the instance consumer. :return: list of mediated device UUIDs assigned to the instance :raises: ReshapeFailed if the instance is not found in the hypervisor or no mediated devices were found to be assigned to the instance indicating VGPU allocations are out of sync with the hypervisor """ # FIXME(sbauza): We don't really need an Instance # object, but given some libvirt.host logs needs # to have an instance name, just provide a fake one Instance = collections.namedtuple('Instance', ['uuid', 'name']) instance = Instance(uuid=instance_uuid, name=instance_uuid) mdevs = self._get_all_assigned_mediated_devices(instance) # _get_all_assigned_mediated_devices returns {} if the instance is # not found in the hypervisor if not mdevs: # If we found a VGPU allocation against a consumer # which is not an instance, the only left case for # Nova would be a migration but we don't support # this at the moment. msg = (_('Unexpected VGPU resource allocation on provider ' '%(rp_uuid)s for consumer %(consumer_uuid)s: ' '%(alloc_data)s. The allocation is made against a ' 'non-existing instance or there are no devices assigned.') % {'rp_uuid': rp_uuid, 'consumer_uuid': instance_uuid, 'alloc_data': alloc_data}) raise exception.ReshapeFailed(error=msg) return mdevs def _count_vgpus_per_pgpu(self, mdev_uuids): """Count the number of VGPUs per physical GPU mediated device. :param mdev_uuids: List of physical GPU mediated device UUIDs. :return: dict, keyed by PGPU device ID, to count of VGPUs on that device """ vgpu_count_per_pgpu: ty.Dict[str, int] = collections.defaultdict(int) for mdev_uuid in mdev_uuids: # libvirt name is like mdev_00ead764_fdc0_46b6_8db9_2963f5c815b4 dev_name = libvirt_utils.mdev_uuid2name(mdev_uuid) # Count how many vGPUs are in use for this instance dev_info = self._get_mediated_device_information(dev_name) pgpu_dev_id = dev_info['parent'] vgpu_count_per_pgpu[pgpu_dev_id] += 1 return vgpu_count_per_pgpu @staticmethod def _check_vgpu_allocations_match_real_use( vgpu_count_per_pgpu, expected_usage, rp_uuid, consumer_uuid, alloc_data): """Checks that the number of GPU devices assigned to the consumer matches what is expected from the allocations in the placement service and logs a warning if there is a mismatch. :param vgpu_count_per_pgpu: dict, keyed by PGPU device ID, to count of VGPUs on that device where each device is assigned to the consumer (guest instance on this hypervisor) :param expected_usage: The expected usage from placement for the given resource provider and consumer :param rp_uuid: UUID of the resource provider with VGPU inventory being consumed by the instance :param consumer_uuid: UUID of the consumer (instance) holding resource allocations against the given rp_uuid provider :param alloc_data: dict of allocation data for the instance consumer """ actual_usage = sum(vgpu_count_per_pgpu.values()) if actual_usage != expected_usage: # Don't make it blocking, just make sure you actually correctly # allocate the existing resources LOG.warning( 'Unexpected VGPU resource allocation on provider %(rp_uuid)s ' 'for consumer %(consumer_uuid)s: %(alloc_data)s. Allocations ' '(%(expected_usage)s) differ from actual use ' '(%(actual_usage)s).', {'rp_uuid': rp_uuid, 'consumer_uuid': consumer_uuid, 'alloc_data': alloc_data, 'expected_usage': expected_usage, 'actual_usage': actual_usage}) def _reshape_vgpu_allocations( self, rp_uuid, root_node, consumer_uuid, alloc_data, resources, pgpu_rps): """Update existing VGPU allocations by moving them from the root node provider to the child provider for the given VGPU provider. :param rp_uuid: UUID of the VGPU resource provider with allocations from consumer_uuid (should be the root node provider before reshaping occurs) :param root_node: ProviderData object for the root compute node resource provider in the provider tree :param consumer_uuid: UUID of the consumer (instance) with VGPU allocations against the resource provider represented by rp_uuid :param alloc_data: dict of allocation information for consumer_uuid :param resources: dict, keyed by resource class, of resources allocated to consumer_uuid from rp_uuid :param pgpu_rps: dict, keyed by GPU device ID, to ProviderData object representing that resource provider in the tree :raises: ReshapeFailed if the reshape fails for whatever reason """ # We've found VGPU allocations on a provider. It should be the root # node provider. self._assert_is_root_provider( rp_uuid, root_node, consumer_uuid, alloc_data) # Find which physical GPU corresponds to this allocation. mdev_uuids = self._get_assigned_mdevs_for_reshape( consumer_uuid, rp_uuid, alloc_data) vgpu_count_per_pgpu = self._count_vgpus_per_pgpu(mdev_uuids) # We need to make sure we found all the mediated devices that # correspond to an allocation. self._check_vgpu_allocations_match_real_use( vgpu_count_per_pgpu, resources[orc.VGPU], rp_uuid, consumer_uuid, alloc_data) # Add the VGPU allocation for each VGPU provider. allocs = alloc_data['allocations'] for pgpu_dev_id, pgpu_rp in pgpu_rps.items(): vgpu_count = vgpu_count_per_pgpu[pgpu_dev_id] if vgpu_count: allocs[pgpu_rp.uuid] = { 'resources': { orc.VGPU: vgpu_count } } # And remove the VGPU allocation from the root node provider. del resources[orc.VGPU] def _reshape_gpu_resources( self, allocations, root_node, pgpu_rps): """Reshapes the provider tree moving VGPU inventory from root to child :param allocations: Dict of allocation data of the form: { $CONSUMER_UUID: { # The shape of each "allocations" dict below is identical # to the return from GET /allocations/{consumer_uuid} "allocations": { $RP_UUID: { "generation": $RP_GEN, "resources": { $RESOURCE_CLASS: $AMOUNT, ... }, }, ... }, "project_id": $PROJ_ID, "user_id": $USER_ID, "consumer_generation": $CONSUMER_GEN, }, ... } :params root_node: The root node in the provider tree :params pgpu_rps: dict, keyed by GPU device ID, to ProviderData object representing that resource provider in the tree """ LOG.info('Reshaping tree; moving VGPU allocations from root ' 'provider %s to child providers %s.', root_node.uuid, pgpu_rps.values()) # For each consumer in the allocations dict, look for VGPU # allocations and move them to the VGPU provider. for consumer_uuid, alloc_data in allocations.items(): # Copy and iterate over the current set of providers to avoid # modifying keys while iterating. allocs = alloc_data['allocations'] for rp_uuid in list(allocs): resources = allocs[rp_uuid]['resources'] if orc.VGPU in resources: self._reshape_vgpu_allocations( rp_uuid, root_node, consumer_uuid, alloc_data, resources, pgpu_rps) def _update_provider_tree_for_vgpu(self, provider_tree, nodename, allocations=None): """Updates the provider tree for VGPU inventory. Before Stein, VGPU inventory and allocations were on the root compute node provider in the tree. Starting in Stein, the VGPU inventory is on a child provider in the tree. As a result, this method will "reshape" the tree if necessary on first start of this compute service in Stein. :param provider_tree: The ProviderTree to update. :param nodename: The ComputeNode.hypervisor_hostname, also known as the name of the root node provider in the tree for this host. :param allocations: If not None, indicates a reshape was requested and should be performed. :raises: nova.exception.ReshapeNeeded if ``allocations`` is None and the method determines a reshape of the tree is needed, i.e. VGPU inventory and allocations must be migrated from the root node provider to a child provider of VGPU resources in the tree. :raises: nova.exception.ReshapeFailed if the requested tree reshape fails for whatever reason. """ # First, check if this host actually has vGPU to reshape inventories_dict = self._get_gpu_inventories() if not inventories_dict: return # Check to see if the root compute node provider in the tree for # this host already has VGPU inventory because if it does, and # we're not currently reshaping (allocations is None), we need # to indicate that a reshape is needed to move the VGPU inventory # onto a child provider in the tree. # Ensure GPU providers are in the ProviderTree for the given inventory. pgpu_rps = self._ensure_pgpu_providers( inventories_dict, provider_tree, nodename) if self._is_reshape_needed_vgpu_on_root(provider_tree, nodename): if allocations is None: # We have old VGPU inventory on root RP, but we haven't yet # allocations. That means we need to ask for a reshape. LOG.info('Requesting provider tree reshape in order to move ' 'VGPU inventory from the root compute node provider ' '%s to a child provider.', nodename) raise exception.ReshapeNeeded() # We have allocations, that means we already asked for a reshape # and the Placement API returned us them. We now need to move # those from the root RP to the needed children RPs. root_node = provider_tree.data(nodename) # Reshape VGPU provider inventory and allocations, moving them # from the root node provider to the child providers. self._reshape_gpu_resources(allocations, root_node, pgpu_rps) # Only delete the root inventory once the reshape is done if orc.VGPU in root_node.inventory: del root_node.inventory[orc.VGPU] provider_tree.update_inventory(nodename, root_node.inventory) def _update_provider_tree_for_pcpu(self, provider_tree, nodename, allocations=None): """Updates the provider tree for PCPU inventory. Before Train, pinned instances consumed VCPU inventory just like unpinned instances. Starting in Train, these instances now consume PCPU inventory. The function can reshape the inventory, changing allocations of VCPUs to PCPUs. :param provider_tree: The ProviderTree to update. :param nodename: The ComputeNode.hypervisor_hostname, also known as the name of the root node provider in the tree for this host. :param allocations: A dict, keyed by consumer UUID, of allocation records, or None:: { $CONSUMER_UUID: { "allocations": { $RP_UUID: { "generation": $RP_GEN, "resources": { $RESOURCE_CLASS: $AMOUNT, ... }, }, ... }, "project_id": $PROJ_ID, "user_id": $USER_ID, "consumer_generation": $CONSUMER_GEN, }, ... } If provided, this indicates a reshape was requested and should be performed. :raises: nova.exception.ReshapeNeeded if ``allocations`` is None and the method determines a reshape of the tree is needed, i.e. VCPU inventory and allocations must be migrated to PCPU resources. :raises: nova.exception.ReshapeFailed if the requested tree reshape fails for whatever reason. """ # If we're not configuring PCPUs, then we've nothing to worry about # (yet) if not CONF.compute.cpu_dedicated_set: return root_node = provider_tree.data(nodename) # Similarly, if PCPU inventories are already reported then there is no # need to reshape if orc.PCPU in root_node.inventory: return ctx = nova_context.get_admin_context() compute_node = objects.ComputeNode.get_by_nodename(ctx, nodename) # Finally, if the compute node doesn't appear to support NUMA, move # swiftly on if not compute_node.numa_topology: return # The ComputeNode.numa_topology is a StringField, deserialize numa = objects.NUMATopology.obj_from_db_obj(compute_node.numa_topology) # If the host doesn't know of any pinned CPUs, we can continue if not any(cell.pinned_cpus for cell in numa.cells): return # At this point, we know there's something to be migrated here but not # how much. If the allocations are None, we're at the startup of the # compute node and a Reshape is needed. Indicate this by raising the # ReshapeNeeded exception if allocations is None: LOG.info( 'Requesting provider tree reshape in order to move ' 'VCPU to PCPU allocations to the compute node ' 'provider %s', nodename) raise exception.ReshapeNeeded() # Go figure out how many VCPUs to migrate to PCPUs. We've been telling # people for years *not* to mix pinned and unpinned instances, meaning # we should be able to move all VCPUs to PCPUs, but we never actually # enforced this in code and there's an all-too-high chance someone # didn't get the memo allocations_needing_reshape = [] # we need to tackle the allocations against instances on this host... instances = objects.InstanceList.get_by_host( ctx, compute_node.host, expected_attrs=['numa_topology']) for instance in instances: if not instance.numa_topology: continue if instance.numa_topology.cpu_policy != ( fields.CPUAllocationPolicy.DEDICATED ): continue allocations_needing_reshape.append(instance.uuid) # ...and those for any migrations migrations = objects.MigrationList.get_in_progress_by_host_and_node( ctx, compute_node.host, compute_node.hypervisor_hostname) for migration in migrations: # we don't care about migrations that have landed here, since we # already have those instances above if not migration.dest_compute or ( migration.dest_compute == compute_node.host): continue instance = objects.Instance.get_by_uuid( ctx, migration.instance_uuid, expected_attrs=['numa_topology']) if not instance.numa_topology: continue if instance.numa_topology.cpu_policy != ( fields.CPUAllocationPolicy.DEDICATED ): continue allocations_needing_reshape.append(migration.uuid) for allocation_uuid in allocations_needing_reshape: consumer_allocations = allocations.get(allocation_uuid, {}).get( 'allocations', {}) # TODO(stephenfin): We can probably just check the allocations for # ComputeNode.uuid since compute nodes are the only (?) provider of # VCPU and PCPU resources for rp_uuid in consumer_allocations: resources = consumer_allocations[rp_uuid]['resources'] if orc.PCPU in resources or orc.VCPU not in resources: # Either this has been migrated or it's not a compute node continue # Switch stuff around. We can do a straight swap since an # instance is either pinned or unpinned. By doing this, we're # modifying the provided 'allocations' dict, which will # eventually be used by the resource tracker to update # placement resources['PCPU'] = resources['VCPU'] del resources[orc.VCPU] def get_available_resource(self, nodename): """Retrieve resource information. This method is called when nova-compute launches, and as part of a periodic task that records the results in the DB. :param nodename: unused in this driver :returns: dictionary containing resource info """ disk_info_dict = self._get_local_gb_info() data = {} # NOTE(dprince): calling capabilities before getVersion works around # an initialization issue with some versions of Libvirt (1.0.5.5). # See: https://bugzilla.redhat.com/show_bug.cgi?id=1000116 # See: https://bugs.launchpad.net/nova/+bug/1215593 data["supported_instances"] = self._get_instance_capabilities() data["vcpus"] = len(self._get_vcpu_available()) data["memory_mb"] = self._host.get_memory_mb_total() data["local_gb"] = disk_info_dict['total'] data["vcpus_used"] = self._get_vcpu_used() data["memory_mb_used"] = self._host.get_memory_mb_used() data["local_gb_used"] = disk_info_dict['used'] data["hypervisor_type"] = self._host.get_driver_type() data["hypervisor_version"] = self._host.get_version() data["hypervisor_hostname"] = self._host.get_hostname() # TODO(berrange): why do we bother converting the # libvirt capabilities XML into a special JSON format ? # The data format is different across all the drivers # so we could just return the raw capabilities XML # which 'compare_cpu' could use directly # # That said, arch_filter.py now seems to rely on # the libvirt drivers format which suggests this # data format needs to be standardized across drivers data["cpu_info"] = jsonutils.dumps(self._get_cpu_info()) disk_free_gb = disk_info_dict['free'] disk_over_committed = self._get_disk_over_committed_size_total() available_least = disk_free_gb * units.Gi - disk_over_committed data['disk_available_least'] = available_least / units.Gi data['pci_passthrough_devices'] = self._get_pci_passthrough_devices() numa_topology = self._get_host_numa_topology() if numa_topology: data['numa_topology'] = numa_topology._to_json() else: data['numa_topology'] = None return data def check_instance_shared_storage_local(self, context, instance): """Check if instance files located on shared storage. This runs check on the destination host, and then calls back to the source host to check the results. :param context: security context :param instance: nova.objects.instance.Instance object :returns: - tempfile: A dict containing the tempfile info on the destination host - None: 1. If the instance path is not existing. 2. If the image backend is shared block storage type. """ if self.image_backend.backend().is_shared_block_storage(): return None dirpath = libvirt_utils.get_instance_path(instance) if not os.path.exists(dirpath): return None fd, tmp_file = tempfile.mkstemp(dir=dirpath) LOG.debug("Creating tmpfile %s to verify with other " "compute node that the instance is on " "the same shared storage.", tmp_file, instance=instance) os.close(fd) return {"filename": tmp_file} def check_instance_shared_storage_remote(self, context, data): return os.path.exists(data['filename']) def check_instance_shared_storage_cleanup(self, context, data): fileutils.delete_if_exists(data["filename"]) def check_can_live_migrate_destination(self, context, instance, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False): """Check if it is possible to execute live migration. This runs checks on the destination host, and then calls back to the source host to check the results. :param context: security context :param instance: nova.db.sqlalchemy.models.Instance :param block_migration: if true, prepare for block migration :param disk_over_commit: if true, allow disk over commit :returns: a LibvirtLiveMigrateData object """ if disk_over_commit: disk_available_gb = dst_compute_info['free_disk_gb'] else: disk_available_gb = dst_compute_info['disk_available_least'] disk_available_mb = ( (disk_available_gb * units.Ki) - CONF.reserved_host_disk_mb) # Compare CPU try: if not instance.vcpu_model or not instance.vcpu_model.model: source_cpu_info = src_compute_info['cpu_info'] self._compare_cpu(None, source_cpu_info, instance) else: self._compare_cpu(instance.vcpu_model, None, instance) except exception.InvalidCPUInfo as e: raise exception.MigrationPreCheckError(reason=e) # Create file on storage, to be checked on source host filename = self._create_shared_storage_test_file(instance) data = objects.LibvirtLiveMigrateData() data.filename = filename data.image_type = CONF.libvirt.images_type data.graphics_listen_addr_vnc = CONF.vnc.server_listen data.graphics_listen_addr_spice = CONF.spice.server_listen if CONF.serial_console.enabled: data.serial_listen_addr = CONF.serial_console.proxyclient_address else: data.serial_listen_addr = None # Notes(eliqiao): block_migration and disk_over_commit are not # nullable, so just don't set them if they are None if block_migration is not None: data.block_migration = block_migration if disk_over_commit is not None: data.disk_over_commit = disk_over_commit data.disk_available_mb = disk_available_mb data.dst_wants_file_backed_memory = CONF.libvirt.file_backed_memory > 0 data.file_backed_memory_discard = (CONF.libvirt.file_backed_memory and self._host.has_min_version( MIN_LIBVIRT_FILE_BACKED_DISCARD_VERSION)) # TODO(artom) Set to indicate that the destination (us) can perform a # NUMA-aware live migration. NUMA-aware live migration will become # unconditionally supported in RPC 6.0, so this sentinel can be removed # then. if instance.numa_topology: data.dst_supports_numa_live_migration = True return data def post_claim_migrate_data(self, context, instance, migrate_data, claim): migrate_data.dst_numa_info = self._get_live_migrate_numa_info( claim.claimed_numa_topology, claim.instance_type, claim.image_meta) return migrate_data def _get_resources(self, instance, prefix=None): resources: 'objects.ResourceList' = [] if prefix: migr_context = instance.migration_context attr_name = prefix + 'resources' if migr_context and attr_name in migr_context: resources = getattr(migr_context, attr_name) or [] else: resources = instance.resources or [] return resources def _get_vpmem_resources(self, resources): vpmem_resources = [] for resource in resources: if 'metadata' in resource and \ isinstance(resource.metadata, objects.LibvirtVPMEMDevice): vpmem_resources.append(resource) return vpmem_resources def _get_ordered_vpmem_resources(self, resources, flavor): vpmem_resources = self._get_vpmem_resources(resources) ordered_vpmem_resources = [] labels = hardware.get_vpmems(flavor) for label in labels: for vpmem_resource in vpmem_resources: if vpmem_resource.metadata.label == label: ordered_vpmem_resources.append(vpmem_resource) vpmem_resources.remove(vpmem_resource) break return ordered_vpmem_resources def _sorted_migrating_resources(self, instance, flavor): """This method is used to sort instance.migration_context.new_resources claimed on dest host, then the ordered new resources will be used to update resources info (e.g. vpmems) in the new xml which is used for live migration. """ resources = self._get_resources(instance, prefix='new_') if not resources: return ordered_resources = [] ordered_vpmem_resources = self._get_ordered_vpmem_resources( resources, flavor) ordered_resources.extend(ordered_vpmem_resources) ordered_resources_obj = objects.ResourceList(objects=ordered_resources) return ordered_resources_obj def _get_live_migrate_numa_info(self, instance_numa_topology, flavor, image_meta): """Builds a LibvirtLiveMigrateNUMAInfo object to send to the source of a live migration, containing information about how the instance is to be pinned on the destination host. :param instance_numa_topology: The InstanceNUMATopology as fitted to the destination by the live migration Claim. :param flavor: The Flavor object for the instance. :param image_meta: The ImageMeta object for the instance. :returns: A LibvirtLiveMigrateNUMAInfo object indicating how to update the XML for the destination host. """ info = objects.LibvirtLiveMigrateNUMAInfo() cpu_set, guest_cpu_tune, guest_cpu_numa, guest_numa_tune = \ self._get_guest_numa_config(instance_numa_topology, flavor, image_meta) # NOTE(artom) These two should always be either None together, or # truth-y together. if guest_cpu_tune and guest_numa_tune: info.cpu_pins = {} for pin in guest_cpu_tune.vcpupin: info.cpu_pins[str(pin.id)] = pin.cpuset info.emulator_pins = guest_cpu_tune.emulatorpin.cpuset if guest_cpu_tune.vcpusched: # NOTE(artom) vcpusched is a list, but there's only ever one # element in it (see _get_guest_numa_config under # wants_realtime) info.sched_vcpus = guest_cpu_tune.vcpusched[0].vcpus info.sched_priority = guest_cpu_tune.vcpusched[0].priority info.cell_pins = {} for node in guest_numa_tune.memnodes: info.cell_pins[str(node.cellid)] = set(node.nodeset) LOG.debug('Built NUMA live migration info: %s', info) return info def cleanup_live_migration_destination_check(self, context, dest_check_data): """Do required cleanup on dest host after check_can_live_migrate calls :param context: security context """ filename = dest_check_data.filename self._cleanup_shared_storage_test_file(filename) def check_can_live_migrate_source(self, context, instance, dest_check_data, block_device_info=None): """Check if it is possible to execute live migration. This checks if the live migration can succeed, based on the results from check_can_live_migrate_destination. :param context: security context :param instance: nova.db.sqlalchemy.models.Instance :param dest_check_data: result of check_can_live_migrate_destination :param block_device_info: result of _get_instance_block_device_info :returns: a LibvirtLiveMigrateData object """ # Checking shared storage connectivity # if block migration, instances_path should not be on shared storage. source = CONF.host dest_check_data.is_shared_instance_path = ( self._check_shared_storage_test_file( dest_check_data.filename, instance)) dest_check_data.is_shared_block_storage = ( self._is_shared_block_storage(instance, dest_check_data, block_device_info)) if 'block_migration' not in dest_check_data: dest_check_data.block_migration = ( not dest_check_data.is_on_shared_storage()) if dest_check_data.block_migration: # TODO(eliqiao): Once block_migration flag is removed from the API # we can safely remove the if condition if dest_check_data.is_on_shared_storage(): reason = _("Block migration can not be used " "with shared storage.") raise exception.InvalidLocalStorage(reason=reason, path=source) if 'disk_over_commit' in dest_check_data: self._assert_dest_node_has_enough_disk(context, instance, dest_check_data.disk_available_mb, dest_check_data.disk_over_commit, block_device_info) if block_device_info: bdm = block_device_info.get('block_device_mapping') # NOTE(eliqiao): Selective disk migrations are not supported # with tunnelled block migrations so we can block them early. if (bdm and (self._block_migration_flags & libvirt.VIR_MIGRATE_TUNNELLED != 0)): msg = (_('Cannot block migrate instance %(uuid)s with' ' mapped volumes. Selective block device' ' migration is not supported with tunnelled' ' block migrations.') % {'uuid': instance.uuid}) LOG.error(msg, instance=instance) raise exception.MigrationPreCheckError(reason=msg) elif not (dest_check_data.is_shared_block_storage or dest_check_data.is_shared_instance_path): reason = _("Shared storage live-migration requires either shared " "storage or boot-from-volume with no local disks.") raise exception.InvalidSharedStorage(reason=reason, path=source) # NOTE(mikal): include the instance directory name here because it # doesn't yet exist on the destination but we want to force that # same name to be used instance_path = libvirt_utils.get_instance_path(instance, relative=True) dest_check_data.instance_relative_path = instance_path # TODO(artom) Set to indicate that the source (us) can perform a # NUMA-aware live migration. NUMA-aware live migration will become # unconditionally supported in RPC 6.0, so this sentinel can be removed # then. if instance.numa_topology: dest_check_data.src_supports_numa_live_migration = True return dest_check_data def _is_shared_block_storage(self, instance, dest_check_data, block_device_info=None): """Check if all block storage of an instance can be shared between source and destination of a live migration. Returns true if the instance is volume backed and has no local disks, or if the image backend is the same on source and destination and the backend shares block storage between compute nodes. :param instance: nova.objects.instance.Instance object :param dest_check_data: dict with boolean fields image_type, is_shared_instance_path, and is_volume_backed """ if (dest_check_data.obj_attr_is_set('image_type') and CONF.libvirt.images_type == dest_check_data.image_type and self.image_backend.backend().is_shared_block_storage()): # NOTE(dgenin): currently true only for RBD image backend return True if (dest_check_data.is_shared_instance_path and self.image_backend.backend().is_file_in_instance_path()): # NOTE(angdraug): file based image backends (Flat, Qcow2) # place block device files under the instance path return True if (dest_check_data.is_volume_backed and not bool(self._get_instance_disk_info(instance, block_device_info))): return True return False def _assert_dest_node_has_enough_disk(self, context, instance, available_mb, disk_over_commit, block_device_info): """Checks if destination has enough disk for block migration.""" # Libvirt supports qcow2 disk format,which is usually compressed # on compute nodes. # Real disk image (compressed) may enlarged to "virtual disk size", # that is specified as the maximum disk size. # (See qemu-img -f path-to-disk) # Scheduler recognizes destination host still has enough disk space # if real disk size < available disk size # if disk_over_commit is True, # otherwise virtual disk size < available disk size. available = 0 if available_mb: available = available_mb * units.Mi disk_infos = self._get_instance_disk_info(instance, block_device_info) necessary = 0 if disk_over_commit: for info in disk_infos: necessary += int(info['disk_size']) else: for info in disk_infos: necessary += int(info['virt_disk_size']) # Check that available disk > necessary disk if (available - necessary) < 0: reason = (_('Unable to migrate %(instance_uuid)s: ' 'Disk of instance is too large(available' ' on destination host:%(available)s ' '< need:%(necessary)s)') % {'instance_uuid': instance.uuid, 'available': available, 'necessary': necessary}) raise exception.MigrationPreCheckError(reason=reason) def _compare_cpu(self, guest_cpu, host_cpu_str, instance): """Check the host is compatible with the requested CPU :param guest_cpu: nova.objects.VirtCPUModel or nova.virt.libvirt.vconfig.LibvirtConfigGuestCPU or None. :param host_cpu_str: JSON from _get_cpu_info() method If the 'guest_cpu' parameter is not None, this will be validated for migration compatibility with the host. Otherwise the 'host_cpu_str' JSON string will be used for validation. :returns: None. if given cpu info is not compatible to this server, raise exception. """ # NOTE(kchamart): Comparing host to guest CPU model for emulated # guests () should not matter -- in this # mode (QEMU "TCG") the CPU is fully emulated in software and no # hardware acceleration, like KVM, is involved. So, skip the CPU # compatibility check for the QEMU domain type, and retain it for # KVM guests. if CONF.libvirt.virt_type not in ['kvm']: return if guest_cpu is None: info = jsonutils.loads(host_cpu_str) LOG.info('Instance launched has CPU info: %s', host_cpu_str) cpu = vconfig.LibvirtConfigCPU() cpu.arch = info['arch'] cpu.model = info['model'] cpu.vendor = info['vendor'] cpu.sockets = info['topology']['sockets'] cpu.cores = info['topology']['cores'] cpu.threads = info['topology']['threads'] for f in info['features']: cpu.add_feature(vconfig.LibvirtConfigCPUFeature(f)) elif isinstance(guest_cpu, vconfig.LibvirtConfigGuestCPU): cpu = guest_cpu else: cpu = self._vcpu_model_to_cpu_config(guest_cpu) # s390x doesn't support cpu model in host info, so compare # cpu info will raise an error anyway, thus have to avoid check # see bug 1854126 for more info if ( cpu.arch in (arch.S390X, arch.S390) and not self._host.has_min_version(MIN_LIBVIRT_S390X_CPU_COMPARE) ): LOG.debug("on s390x platform, the min libvirt version " "support cpu model compare is %s", MIN_LIBVIRT_S390X_CPU_COMPARE) return u = ("http://libvirt.org/html/libvirt-libvirt-host.html#" "virCPUCompareResult") m = _("CPU doesn't have compatibility.\n\n%(ret)s\n\nRefer to %(u)s") # unknown character exists in xml, then libvirt complains try: cpu_xml = cpu.to_xml() LOG.debug("cpu compare xml: %s", cpu_xml, instance=instance) ret = self._host.compare_cpu(cpu_xml) except libvirt.libvirtError as e: if cpu.arch == fields.Architecture.AARCH64: LOG.debug("Host CPU compatibility check does not make " "sense on AArch64; skip CPU comparison") return error_code = e.get_error_code() if error_code == libvirt.VIR_ERR_NO_SUPPORT: LOG.debug("URI %(uri)s does not support cpu comparison. " "It will be proceeded though. Error: %(error)s", {'uri': self._uri(), 'error': e}) return else: LOG.error(m, {'ret': e, 'u': u}) raise exception.InvalidCPUInfo( reason=m % {'ret': e, 'u': u}) if ret <= 0: LOG.error(m, {'ret': ret, 'u': u}) raise exception.InvalidCPUInfo(reason=m % {'ret': ret, 'u': u}) def _create_shared_storage_test_file(self, instance): """Makes tmpfile under CONF.instances_path.""" dirpath = CONF.instances_path fd, tmp_file = tempfile.mkstemp(dir=dirpath) LOG.debug("Creating tmpfile %s to notify to other " "compute nodes that they should mount " "the same storage.", tmp_file, instance=instance) os.close(fd) return os.path.basename(tmp_file) def _check_shared_storage_test_file(self, filename, instance): """Confirms existence of the tmpfile under CONF.instances_path. Cannot confirm tmpfile return False. """ # NOTE(tpatzig): if instances_path is a shared volume that is # under heavy IO (many instances on many compute nodes), # then checking the existence of the testfile fails, # just because it takes longer until the client refreshes and new # content gets visible. # os.utime (like touch) on the directory forces the client to refresh. os.utime(CONF.instances_path, None) tmp_file = os.path.join(CONF.instances_path, filename) if not os.path.exists(tmp_file): exists = False else: exists = True LOG.debug('Check if temp file %s exists to indicate shared storage ' 'is being used for migration. Exists? %s', tmp_file, exists, instance=instance) return exists def _cleanup_shared_storage_test_file(self, filename): """Removes existence of the tmpfile under CONF.instances_path.""" tmp_file = os.path.join(CONF.instances_path, filename) os.remove(tmp_file) def live_migration(self, context, instance, dest, post_method, recover_method, block_migration=False, migrate_data=None): """Spawning live_migration operation for distributing high-load. :param context: security context :param instance: nova.db.sqlalchemy.models.Instance object instance object that is migrated. :param dest: destination host :param post_method: post operation method. expected nova.compute.manager._post_live_migration. :param recover_method: recovery method when any exception occurs. expected nova.compute.manager._rollback_live_migration. :param block_migration: if true, do block migration. :param migrate_data: a LibvirtLiveMigrateData object """ # 'dest' will be substituted into 'migration_uri' so ensure # it does't contain any characters that could be used to # exploit the URI accepted by libvirt if not libvirt_utils.is_valid_hostname(dest): raise exception.InvalidHostname(hostname=dest) self._live_migration(context, instance, dest, post_method, recover_method, block_migration, migrate_data) def live_migration_abort(self, instance): """Aborting a running live-migration. :param instance: instance object that is in migration """ guest = self._host.get_guest(instance) dom = guest._domain try: dom.abortJob() except libvirt.libvirtError as e: LOG.error("Failed to cancel migration %s", encodeutils.exception_to_unicode(e), instance=instance) raise def _verify_serial_console_is_disabled(self): if CONF.serial_console.enabled: msg = _('Your destination node does not support' ' retrieving listen addresses. In order' ' for live migration to work properly you' ' must disable serial console.') raise exception.MigrationError(reason=msg) def _detach_direct_passthrough_vifs(self, context, migrate_data, instance): """detaches passthrough vif to enable live migration :param context: security context :param migrate_data: a LibvirtLiveMigrateData object :param instance: instance object that is migrated. """ # NOTE(sean-k-mooney): if we have vif data available we # loop over each vif and detach all direct passthrough # vifs to allow sriov live migration. direct_vnics = network_model.VNIC_TYPES_DIRECT_PASSTHROUGH vifs = [vif.source_vif for vif in migrate_data.vifs if "source_vif" in vif and vif.source_vif] for vif in vifs: if vif['vnic_type'] in direct_vnics: LOG.info("Detaching vif %s from instance " "%s for live migration", vif['id'], instance.id) self.detach_interface(context, instance, vif) def _live_migration_operation(self, context, instance, dest, block_migration, migrate_data, guest, device_names): """Invoke the live migration operation :param context: security context :param instance: nova.db.sqlalchemy.models.Instance object instance object that is migrated. :param dest: destination host :param block_migration: if true, do block migration. :param migrate_data: a LibvirtLiveMigrateData object :param guest: the guest domain object :param device_names: list of device names that are being migrated with instance This method is intended to be run in a background thread and will block that thread until the migration is finished or failed. """ try: if migrate_data.block_migration: migration_flags = self._block_migration_flags else: migration_flags = self._live_migration_flags if not migrate_data.serial_listen_addr: # In this context we want to ensure that serial console is # disabled on source node. This is because nova couldn't # retrieve serial listen address from destination node, so we # consider that destination node might have serial console # disabled as well. self._verify_serial_console_is_disabled() # NOTE(aplanas) migrate_uri will have a value only in the # case that `live_migration_inbound_addr` parameter is # set, and we propose a non tunneled migration. migrate_uri = None if ('target_connect_addr' in migrate_data and migrate_data.target_connect_addr is not None): dest = migrate_data.target_connect_addr if (migration_flags & libvirt.VIR_MIGRATE_TUNNELLED == 0): migrate_uri = self._migrate_uri(dest) new_xml_str = None if CONF.libvirt.virt_type != "parallels": # If the migrate_data has port binding information for the # destination host, we need to prepare the guest vif config # for the destination before we start migrating the guest. get_vif_config = None if 'vifs' in migrate_data and migrate_data.vifs: # NOTE(mriedem): The vif kwarg must be built on the fly # within get_updated_guest_xml based on migrate_data.vifs. # We could stash the virt_type from the destination host # into LibvirtLiveMigrateData but the host kwarg is a # nova.virt.libvirt.host.Host object and is used to check # information like libvirt version on the destination. # If this becomes a problem, what we could do is get the # VIF configs while on the destination host during # pre_live_migration() and store those in the # LibvirtLiveMigrateData object. For now we just use the # source host information for virt_type and # host (version) since the conductor live_migrate method # _check_compatible_with_source_hypervisor() ensures that # the hypervisor types and versions are compatible. get_vif_config = functools.partial( self.vif_driver.get_config, instance=instance, image_meta=instance.image_meta, inst_type=instance.flavor, virt_type=CONF.libvirt.virt_type, ) self._detach_direct_passthrough_vifs(context, migrate_data, instance) new_resources = None if isinstance(instance, objects.Instance): new_resources = self._sorted_migrating_resources( instance, instance.flavor) new_xml_str = libvirt_migrate.get_updated_guest_xml( # TODO(sahid): It's not a really good idea to pass # the method _get_volume_config and we should to find # a way to avoid this in future. guest, migrate_data, self._get_volume_config, get_vif_config=get_vif_config, new_resources=new_resources) # NOTE(pkoniszewski): Because of precheck which blocks # tunnelled block live migration with mapped volumes we # can safely remove migrate_disks when tunnelling is on. # Otherwise we will block all tunnelled block migrations, # even when an instance does not have volumes mapped. # This is because selective disk migration is not # supported in tunnelled block live migration. Also we # cannot fallback to migrateToURI2 in this case because of # bug #1398999 # # TODO(kchamart) Move the following bit to guest.migrate() if (migration_flags & libvirt.VIR_MIGRATE_TUNNELLED != 0): device_names = [] # TODO(sahid): This should be in # post_live_migration_at_source but no way to retrieve # ports acquired on the host for the guest at this # step. Since the domain is going to be removed from # libvird on source host after migration, we backup the # serial ports to release them if all went well. serial_ports = [] if CONF.serial_console.enabled: serial_ports = list(self._get_serial_ports_from_guest(guest)) LOG.debug("About to invoke the migrate API", instance=instance) guest.migrate(self._live_migration_uri(dest), migrate_uri=migrate_uri, flags=migration_flags, migrate_disks=device_names, destination_xml=new_xml_str, bandwidth=CONF.libvirt.live_migration_bandwidth) LOG.debug("Migrate API has completed", instance=instance) for hostname, port in serial_ports: serial_console.release_port(host=hostname, port=port) except Exception as e: with excutils.save_and_reraise_exception(): LOG.error("Live Migration failure: %s", e, instance=instance) # If 'migrateToURI' fails we don't know what state the # VM instances on each host are in. Possibilities include # # 1. src==running, dst==none # # Migration failed & rolled back, or never started # # 2. src==running, dst==paused # # Migration started but is still ongoing # # 3. src==paused, dst==paused # # Migration data transfer completed, but switchover # is still ongoing, or failed # # 4. src==paused, dst==running # # Migration data transfer completed, switchover # happened but cleanup on source failed # # 5. src==none, dst==running # # Migration fully succeeded. # # Libvirt will aim to complete any migration operation # or roll it back. So even if the migrateToURI call has # returned an error, if the migration was not finished # libvirt should clean up. # # So we take the error raise here with a pinch of salt # and rely on the domain job info status to figure out # what really happened to the VM, which is a much more # reliable indicator. # # In particular we need to try very hard to ensure that # Nova does not "forget" about the guest. ie leaving it # running on a different host to the one recorded in # the database, as that would be a serious resource leak LOG.debug("Migration operation thread has finished", instance=instance) def _live_migration_copy_disk_paths(self, context, instance, guest): '''Get list of disks to copy during migration :param context: security context :param instance: the instance being migrated :param guest: the Guest instance being migrated Get the list of disks to copy during migration. :returns: a list of local source paths and a list of device names to copy ''' disk_paths = [] device_names = [] block_devices = [] if (self._block_migration_flags & libvirt.VIR_MIGRATE_TUNNELLED == 0): bdm_list = objects.BlockDeviceMappingList.get_by_instance_uuid( context, instance.uuid) block_device_info = driver.get_block_device_info(instance, bdm_list) block_device_mappings = driver.block_device_info_get_mapping( block_device_info) for bdm in block_device_mappings: device_name = str(bdm['mount_device'].rsplit('/', 1)[1]) block_devices.append(device_name) for dev in guest.get_all_disks(): if dev.readonly or dev.shareable: continue if dev.source_type not in ["file", "block"]: continue if dev.target_dev in block_devices: continue disk_paths.append(dev.source_path) device_names.append(dev.target_dev) return (disk_paths, device_names) def _live_migration_data_gb(self, instance, disk_paths): '''Calculate total amount of data to be transferred :param instance: the nova.objects.Instance being migrated :param disk_paths: list of disk paths that are being migrated with instance Calculates the total amount of data that needs to be transferred during the live migration. The actual amount copied will be larger than this, due to the guest OS continuing to dirty RAM while the migration is taking place. So this value represents the minimal data size possible. :returns: data size to be copied in GB ''' ram_gb = instance.flavor.memory_mb * units.Mi / units.Gi if ram_gb < 2: ram_gb = 2 disk_gb = 0 for path in disk_paths: try: size = os.stat(path).st_size size_gb = (size / units.Gi) if size_gb < 2: size_gb = 2 disk_gb += size_gb except OSError as e: LOG.warning("Unable to stat %(disk)s: %(ex)s", {'disk': path, 'ex': e}) # Ignore error since we don't want to break # the migration monitoring thread operation return ram_gb + disk_gb def _get_migration_flags(self, is_block_migration): if is_block_migration: return self._block_migration_flags return self._live_migration_flags def _live_migration_monitor(self, context, instance, guest, dest, post_method, recover_method, block_migration, migrate_data, finish_event, disk_paths): on_migration_failure: ty.Deque[str] = deque() data_gb = self._live_migration_data_gb(instance, disk_paths) downtime_steps = list(libvirt_migrate.downtime_steps(data_gb)) migration = migrate_data.migration curdowntime = None migration_flags = self._get_migration_flags( migrate_data.block_migration) n = 0 start = time.time() is_post_copy_enabled = self._is_post_copy_enabled(migration_flags) # vpmem does not support post copy is_post_copy_enabled &= not bool(self._get_vpmems(instance)) while True: info = guest.get_job_info() if info.type == libvirt.VIR_DOMAIN_JOB_NONE: # Either still running, or failed or completed, # lets untangle the mess if not finish_event.ready(): LOG.debug("Operation thread is still running", instance=instance) else: info.type = libvirt_migrate.find_job_type(guest, instance) LOG.debug("Fixed incorrect job type to be %d", info.type, instance=instance) if info.type == libvirt.VIR_DOMAIN_JOB_NONE: # Migration is not yet started LOG.debug("Migration not running yet", instance=instance) elif info.type == libvirt.VIR_DOMAIN_JOB_UNBOUNDED: # Migration is still running # # This is where we wire up calls to change live # migration status. eg change max downtime, cancel # the operation, change max bandwidth libvirt_migrate.run_tasks(guest, instance, self.active_migrations, on_migration_failure, migration, is_post_copy_enabled) now = time.time() elapsed = now - start completion_timeout = int( CONF.libvirt.live_migration_completion_timeout * data_gb) # NOTE(yikun): Check the completion timeout to determine # should trigger the timeout action, and there are two choices # ``abort`` (default) or ``force_complete``. If the action is # set to ``force_complete``, the post-copy will be triggered # if available else the VM will be suspended, otherwise the # live migrate operation will be aborted. if libvirt_migrate.should_trigger_timeout_action( instance, elapsed, completion_timeout, migration.status): timeout_act = CONF.libvirt.live_migration_timeout_action if timeout_act == 'force_complete': self.live_migration_force_complete(instance) else: # timeout action is 'abort' try: guest.abort_job() except libvirt.libvirtError as e: LOG.warning("Failed to abort migration %s", encodeutils.exception_to_unicode(e), instance=instance) self._clear_empty_migration(instance) raise curdowntime = libvirt_migrate.update_downtime( guest, instance, curdowntime, downtime_steps, elapsed) # We loop every 500ms, so don't log on every # iteration to avoid spamming logs for long # running migrations. Just once every 5 secs # is sufficient for developers to debug problems. # We log once every 30 seconds at info to help # admins see slow running migration operations # when debug logs are off. if (n % 10) == 0: # Ignoring memory_processed, as due to repeated # dirtying of data, this can be way larger than # memory_total. Best to just look at what's # remaining to copy and ignore what's done already # # TODO(berrange) perhaps we could include disk # transfer stats in the progress too, but it # might make memory info more obscure as large # disk sizes might dwarf memory size remaining = 100 if info.memory_total != 0: remaining = round(info.memory_remaining * 100 / info.memory_total) libvirt_migrate.save_stats(instance, migration, info, remaining) # NOTE(fanzhang): do not include disk transfer stats in # the progress percentage calculation but log them. disk_remaining = 100 if info.disk_total != 0: disk_remaining = round(info.disk_remaining * 100 / info.disk_total) lg = LOG.debug if (n % 60) == 0: lg = LOG.info lg("Migration running for %(secs)d secs, " "memory %(remaining)d%% remaining " "(bytes processed=%(processed_memory)d, " "remaining=%(remaining_memory)d, " "total=%(total_memory)d); " "disk %(disk_remaining)d%% remaining " "(bytes processed=%(processed_disk)d, " "remaining=%(remaining_disk)d, " "total=%(total_disk)d).", {"secs": n / 2, "remaining": remaining, "processed_memory": info.memory_processed, "remaining_memory": info.memory_remaining, "total_memory": info.memory_total, "disk_remaining": disk_remaining, "processed_disk": info.disk_processed, "remaining_disk": info.disk_remaining, "total_disk": info.disk_total}, instance=instance) n = n + 1 elif info.type == libvirt.VIR_DOMAIN_JOB_COMPLETED: # Migration is all done LOG.info("Migration operation has completed", instance=instance) post_method(context, instance, dest, block_migration, migrate_data) break elif info.type == libvirt.VIR_DOMAIN_JOB_FAILED: # Migration did not succeed LOG.error("Migration operation has aborted", instance=instance) libvirt_migrate.run_recover_tasks(self._host, guest, instance, on_migration_failure) recover_method(context, instance, dest, migrate_data) break elif info.type == libvirt.VIR_DOMAIN_JOB_CANCELLED: # Migration was stopped by admin LOG.warning("Migration operation was cancelled", instance=instance) libvirt_migrate.run_recover_tasks(self._host, guest, instance, on_migration_failure) recover_method(context, instance, dest, migrate_data, migration_status='cancelled') break else: LOG.warning("Unexpected migration job type: %d", info.type, instance=instance) time.sleep(0.5) self._clear_empty_migration(instance) def _clear_empty_migration(self, instance): try: del self.active_migrations[instance.uuid] except KeyError: LOG.warning("There are no records in active migrations " "for instance", instance=instance) def _live_migration(self, context, instance, dest, post_method, recover_method, block_migration, migrate_data): """Do live migration. :param context: security context :param instance: nova.db.sqlalchemy.models.Instance object instance object that is migrated. :param dest: destination host :param post_method: post operation method. expected nova.compute.manager._post_live_migration. :param recover_method: recovery method when any exception occurs. expected nova.compute.manager._rollback_live_migration. :param block_migration: if true, do block migration. :param migrate_data: a LibvirtLiveMigrateData object This fires off a new thread to run the blocking migration operation, and then this thread monitors the progress of migration and controls its operation """ guest = self._host.get_guest(instance) disk_paths = [] device_names = [] if (migrate_data.block_migration and CONF.libvirt.virt_type != "parallels"): disk_paths, device_names = self._live_migration_copy_disk_paths( context, instance, guest) opthread = utils.spawn(self._live_migration_operation, context, instance, dest, block_migration, migrate_data, guest, device_names) finish_event = eventlet.event.Event() self.active_migrations[instance.uuid] = deque() def thread_finished(thread, event): LOG.debug("Migration operation thread notification", instance=instance) event.send() opthread.link(thread_finished, finish_event) # Let eventlet schedule the new thread right away time.sleep(0) try: LOG.debug("Starting monitoring of live migration", instance=instance) self._live_migration_monitor(context, instance, guest, dest, post_method, recover_method, block_migration, migrate_data, finish_event, disk_paths) except Exception as ex: LOG.warning("Error monitoring migration: %(ex)s", {"ex": ex}, instance=instance, exc_info=True) raise finally: LOG.debug("Live migration monitoring is all done", instance=instance) def _is_post_copy_enabled(self, migration_flags): return (migration_flags & libvirt.VIR_MIGRATE_POSTCOPY) != 0 def live_migration_force_complete(self, instance): try: self.active_migrations[instance.uuid].append('force-complete') except KeyError: raise exception.NoActiveMigrationForInstance( instance_id=instance.uuid) def _try_fetch_image(self, context, path, image_id, instance, fallback_from_host=None): try: libvirt_utils.fetch_image(context, path, image_id, instance.trusted_certs) except exception.ImageNotFound: if not fallback_from_host: raise LOG.debug("Image %(image_id)s doesn't exist anymore on " "image service, attempting to copy image " "from %(host)s", {'image_id': image_id, 'host': fallback_from_host}) libvirt_utils.copy_image(src=path, dest=path, host=fallback_from_host, receive=True) def _fetch_instance_kernel_ramdisk(self, context, instance, fallback_from_host=None): """Download kernel and ramdisk for instance in instance directory.""" instance_dir = libvirt_utils.get_instance_path(instance) if instance.kernel_id: kernel_path = os.path.join(instance_dir, 'kernel') # NOTE(dsanders): only fetch image if it's not available at # kernel_path. This also avoids ImageNotFound exception if # the image has been deleted from glance if not os.path.exists(kernel_path): self._try_fetch_image(context, kernel_path, instance.kernel_id, instance, fallback_from_host) if instance.ramdisk_id: ramdisk_path = os.path.join(instance_dir, 'ramdisk') # NOTE(dsanders): only fetch image if it's not available at # ramdisk_path. This also avoids ImageNotFound exception if # the image has been deleted from glance if not os.path.exists(ramdisk_path): self._try_fetch_image(context, ramdisk_path, instance.ramdisk_id, instance, fallback_from_host) def _reattach_instance_vifs(self, context, instance, network_info): guest = self._host.get_guest(instance) # validate that the guest has the expected number of interfaces # attached. guest_interfaces = guest.get_interfaces() # NOTE(sean-k-mooney): In general len(guest_interfaces) will # be equal to len(network_info) as interfaces will not be hot unplugged # unless they are SR-IOV direct mode interfaces. As such we do not # need an else block here as it would be a noop. if len(guest_interfaces) < len(network_info): # NOTE(sean-k-mooney): we are doing a post live migration # for a guest with sriov vif that were detached as part of # the migration. loop over the vifs and attach the missing # vif as part of the post live migration phase. direct_vnics = network_model.VNIC_TYPES_DIRECT_PASSTHROUGH for vif in network_info: if vif['vnic_type'] in direct_vnics: LOG.info("Attaching vif %s to instance %s", vif['id'], instance.id) self.attach_interface(context, instance, instance.image_meta, vif) def rollback_live_migration_at_source(self, context, instance, migrate_data): """reconnect sriov interfaces after failed live migration :param context: security context :param instance: the instance being migrated :param migrate_date: a LibvirtLiveMigrateData object """ network_info = network_model.NetworkInfo( [vif.source_vif for vif in migrate_data.vifs if "source_vif" in vif and vif.source_vif]) self._reattach_instance_vifs(context, instance, network_info) def rollback_live_migration_at_destination(self, context, instance, network_info, block_device_info, destroy_disks=True, migrate_data=None): """Clean up destination node after a failed live migration.""" try: self.destroy(context, instance, network_info, block_device_info, destroy_disks) finally: # NOTE(gcb): Failed block live migration may leave instance # directory at destination node, ensure it is always deleted. is_shared_instance_path = True if migrate_data: is_shared_instance_path = migrate_data.is_shared_instance_path if (migrate_data.obj_attr_is_set("serial_listen_ports") and migrate_data.serial_listen_ports): # Releases serial ports reserved. for port in migrate_data.serial_listen_ports: serial_console.release_port( host=migrate_data.serial_listen_addr, port=port) if not is_shared_instance_path: instance_dir = libvirt_utils.get_instance_path_at_destination( instance, migrate_data) if os.path.exists(instance_dir): shutil.rmtree(instance_dir) def _pre_live_migration_plug_vifs(self, instance, network_info, migrate_data): if 'vifs' in migrate_data and migrate_data.vifs: LOG.debug('Plugging VIFs using destination host port bindings ' 'before live migration.', instance=instance) vif_plug_nw_info = network_model.NetworkInfo([]) for migrate_vif in migrate_data.vifs: vif_plug_nw_info.append(migrate_vif.get_dest_vif()) else: LOG.debug('Plugging VIFs before live migration.', instance=instance) vif_plug_nw_info = network_info # Retry operation is necessary because continuous live migration # requests to the same host cause concurrent requests to iptables, # then it complains. max_retry = CONF.live_migration_retry_count for cnt in range(max_retry): try: self.plug_vifs(instance, vif_plug_nw_info) break except processutils.ProcessExecutionError: if cnt == max_retry - 1: raise else: LOG.warning('plug_vifs() failed %(cnt)d. Retry up to ' '%(max_retry)d.', {'cnt': cnt, 'max_retry': max_retry}, instance=instance) greenthread.sleep(1) def pre_live_migration(self, context, instance, block_device_info, network_info, disk_info, migrate_data): """Preparation live migration.""" if disk_info is not None: disk_info = jsonutils.loads(disk_info) LOG.debug('migrate_data in pre_live_migration: %s', migrate_data, instance=instance) is_shared_block_storage = migrate_data.is_shared_block_storage is_shared_instance_path = migrate_data.is_shared_instance_path is_block_migration = migrate_data.block_migration if not is_shared_instance_path: instance_dir = libvirt_utils.get_instance_path_at_destination( instance, migrate_data) if os.path.exists(instance_dir): raise exception.DestinationDiskExists(path=instance_dir) LOG.debug('Creating instance directory: %s', instance_dir, instance=instance) os.mkdir(instance_dir) # Recreate the disk.info file and in doing so stop the # imagebackend from recreating it incorrectly by inspecting the # contents of each file when using the Raw backend. if disk_info: image_disk_info = {} for info in disk_info: image_file = os.path.basename(info['path']) image_path = os.path.join(instance_dir, image_file) image_disk_info[image_path] = info['type'] LOG.debug('Creating disk.info with the contents: %s', image_disk_info, instance=instance) image_disk_info_path = os.path.join(instance_dir, 'disk.info') with open(image_disk_info_path, 'w') as f: f.write(jsonutils.dumps(image_disk_info)) if not is_shared_block_storage: # Ensure images and backing files are present. LOG.debug('Checking to make sure images and backing files are ' 'present before live migration.', instance=instance) self._create_images_and_backing( context, instance, instance_dir, disk_info, fallback_from_host=instance.host) if (configdrive.required_by(instance) and CONF.config_drive_format == 'iso9660'): # NOTE(pkoniszewski): Due to a bug in libvirt iso config # drive needs to be copied to destination prior to # migration when instance path is not shared and block # storage is not shared. Files that are already present # on destination are excluded from a list of files that # need to be copied to destination. If we don't do that # live migration will fail on copying iso config drive to # destination and writing to read-only device. # Please see bug/1246201 for more details. src = "%s:%s/disk.config" % (instance.host, instance_dir) self._remotefs.copy_file(src, instance_dir) if not is_block_migration: # NOTE(angdraug): when block storage is shared between source # and destination and instance path isn't (e.g. volume backed # or rbd backed instance), instance path on destination has to # be prepared # Required by Quobyte CI self._ensure_console_log_for_instance(instance) # if image has kernel and ramdisk, just download # following normal way. self._fetch_instance_kernel_ramdisk(context, instance) # Establishing connection to volume server. block_device_mapping = driver.block_device_info_get_mapping( block_device_info) if len(block_device_mapping): LOG.debug('Connecting volumes before live migration.', instance=instance) for bdm in block_device_mapping: connection_info = bdm['connection_info'] self._connect_volume(context, connection_info, instance) self._pre_live_migration_plug_vifs( instance, network_info, migrate_data) # Store server_listen and latest disk device info if not migrate_data: migrate_data = objects.LibvirtLiveMigrateData(bdms=[]) else: migrate_data.bdms = [] # Store live_migration_inbound_addr migrate_data.target_connect_addr = \ CONF.libvirt.live_migration_inbound_addr migrate_data.supported_perf_events = self._supported_perf_events migrate_data.serial_listen_ports = [] if CONF.serial_console.enabled: num_ports = hardware.get_number_of_serial_ports( instance.flavor, instance.image_meta) for port in six.moves.range(num_ports): migrate_data.serial_listen_ports.append( serial_console.acquire_port( migrate_data.serial_listen_addr)) for vol in block_device_mapping: connection_info = vol['connection_info'] if connection_info.get('serial'): disk_info = blockinfo.get_info_from_bdm( instance, CONF.libvirt.virt_type, instance.image_meta, vol) bdmi = objects.LibvirtLiveMigrateBDMInfo() bdmi.serial = connection_info['serial'] bdmi.connection_info = connection_info bdmi.bus = disk_info['bus'] bdmi.dev = disk_info['dev'] bdmi.type = disk_info['type'] bdmi.format = disk_info.get('format') bdmi.boot_index = disk_info.get('boot_index') volume_secret = self._host.find_secret('volume', vol.volume_id) if volume_secret: bdmi.encryption_secret_uuid = volume_secret.UUIDString() migrate_data.bdms.append(bdmi) return migrate_data def _try_fetch_image_cache(self, image, fetch_func, context, filename, image_id, instance, size, fallback_from_host=None): try: image.cache(fetch_func=fetch_func, context=context, filename=filename, image_id=image_id, size=size, trusted_certs=instance.trusted_certs) except exception.ImageNotFound: if not fallback_from_host: raise LOG.debug("Image %(image_id)s doesn't exist anymore " "on image service, attempting to copy " "image from %(host)s", {'image_id': image_id, 'host': fallback_from_host}, instance=instance) def copy_from_host(target): libvirt_utils.copy_image(src=target, dest=target, host=fallback_from_host, receive=True) image.cache(fetch_func=copy_from_host, size=size, filename=filename) # NOTE(lyarwood): If the instance vm_state is shelved offloaded then we # must be unshelving for _try_fetch_image_cache to be called. # NOTE(mriedem): Alternatively if we are doing a cross-cell move of a # non-volume-backed server and finishing (spawning) on the dest host, # we have to flatten the rbd image so we can delete the temporary # snapshot in the compute manager. mig_context = instance.migration_context cross_cell_move = ( mig_context and mig_context.is_cross_cell_move() or False) if instance.vm_state == vm_states.SHELVED_OFFLOADED or cross_cell_move: # NOTE(lyarwood): When using the rbd imagebackend the call to cache # above will attempt to clone from the shelved snapshot in Glance # if available from this compute. We then need to flatten the # resulting image to avoid it still referencing and ultimately # blocking the removal of the shelved snapshot at the end of the # unshelve. This is a no-op for all but the rbd imagebackend. action = ( 'migrating instance across cells' if cross_cell_move else 'unshelving instance') try: image.flatten() LOG.debug('Image %s flattened successfully while %s.', image.path, action, instance=instance) except NotImplementedError: # NOTE(lyarwood): There's an argument to be made for logging # our inability to call flatten here, however given this isn't # implemented for most of the backends it may do more harm than # good, concerning operators etc so for now just pass. pass def _create_images_and_backing(self, context, instance, instance_dir, disk_info, fallback_from_host=None): """:param context: security context :param instance: nova.db.sqlalchemy.models.Instance object instance object that is migrated. :param instance_dir: instance path to use, calculated externally to handle block migrating an instance with an old style instance path :param disk_info: disk info specified in _get_instance_disk_info_from_config (list of dicts) :param fallback_from_host: host where we can retrieve images if the glance images are not available. """ # Virtuozzo containers don't use backing file if (CONF.libvirt.virt_type == "parallels" and instance.vm_mode == fields.VMMode.EXE): return if not disk_info: disk_info = [] for info in disk_info: base = os.path.basename(info['path']) # Get image type and create empty disk image, and # create backing file in case of qcow2. instance_disk = os.path.join(instance_dir, base) if not info['backing_file'] and not os.path.exists(instance_disk): libvirt_utils.create_image(info['type'], instance_disk, info['virt_disk_size']) elif info['backing_file']: # Creating backing file follows same way as spawning instances. cache_name = os.path.basename(info['backing_file']) disk = self.image_backend.by_name(instance, instance_disk, CONF.libvirt.images_type) if cache_name.startswith('ephemeral'): # The argument 'size' is used by image.cache to # validate disk size retrieved from cache against # the instance disk size (should always return OK) # and ephemeral_size is used by _create_ephemeral # to build the image if the disk is not already # cached. disk.cache( fetch_func=self._create_ephemeral, fs_label=cache_name, os_type=instance.os_type, filename=cache_name, size=info['virt_disk_size'], ephemeral_size=info['virt_disk_size'] / units.Gi) elif cache_name.startswith('swap'): inst_type = instance.get_flavor() swap_mb = inst_type.swap disk.cache(fetch_func=self._create_swap, filename="swap_%s" % swap_mb, size=swap_mb * units.Mi, swap_mb=swap_mb) else: self._try_fetch_image_cache(disk, libvirt_utils.fetch_image, context, cache_name, instance.image_ref, instance, info['virt_disk_size'], fallback_from_host) # if disk has kernel and ramdisk, just download # following normal way. self._fetch_instance_kernel_ramdisk( context, instance, fallback_from_host=fallback_from_host) def post_live_migration(self, context, instance, block_device_info, migrate_data=None): # NOTE(mdbooth): The block_device_info we were passed was initialized # with BDMs from the source host before they were updated to point to # the destination. We can safely use this to disconnect the source # without re-fetching. block_device_mapping = driver.block_device_info_get_mapping( block_device_info) for vol in block_device_mapping: connection_info = vol['connection_info'] # NOTE(lyarwood): Ignore exceptions here to avoid the instance # being left in an ERROR state and still marked on the source. try: self._disconnect_volume(context, connection_info, instance) except Exception: volume_id = driver_block_device.get_volume_id(connection_info) LOG.exception("Ignoring exception while attempting to " "disconnect volume %s from the source host " "during post_live_migration", volume_id, instance=instance) def post_live_migration_at_source(self, context, instance, network_info): """Unplug VIFs from networks at source. :param context: security context :param instance: instance object reference :param network_info: instance network information """ self.unplug_vifs(instance, network_info) def post_live_migration_at_destination(self, context, instance, network_info, block_migration=False, block_device_info=None): """Post operation of live migration at destination host. :param context: security context :param instance: nova.db.sqlalchemy.models.Instance object instance object that is migrated. :param network_info: instance network information :param block_migration: if true, post operation of block_migration. """ self._reattach_instance_vifs(context, instance, network_info) def _get_instance_disk_info_from_config(self, guest_config, block_device_info): """Get the non-volume disk information from the domain xml :param LibvirtConfigGuest guest_config: the libvirt domain config for the instance :param dict block_device_info: block device info for BDMs :returns disk_info: list of dicts with keys: * 'type': the disk type (str) * 'path': the disk path (str) * 'virt_disk_size': the virtual disk size (int) * 'backing_file': backing file of a disk image (str) * 'disk_size': physical disk size (int) * 'over_committed_disk_size': virt_disk_size - disk_size or 0 """ block_device_mapping = driver.block_device_info_get_mapping( block_device_info) volume_devices = set() for vol in block_device_mapping: disk_dev = vol['mount_device'].rpartition("/")[2] volume_devices.add(disk_dev) disk_info = [] if (guest_config.virt_type == 'parallels' and guest_config.os_type == fields.VMMode.EXE): node_type = 'filesystem' else: node_type = 'disk' for device in guest_config.devices: if device.root_name != node_type: continue disk_type = device.source_type if device.root_name == 'filesystem': target = device.target_dir if device.source_type == 'file': path = device.source_file elif device.source_type == 'block': path = device.source_dev else: path = None else: target = device.target_dev path = device.source_path if not path: LOG.debug('skipping disk for %s as it does not have a path', guest_config.name) continue if disk_type not in ['file', 'block']: LOG.debug('skipping disk because it looks like a volume', path) continue if target in volume_devices: LOG.debug('skipping disk %(path)s (%(target)s) as it is a ' 'volume', {'path': path, 'target': target}) continue if device.root_name == 'filesystem': driver_type = device.driver_type else: driver_type = device.driver_format # get the real disk size or # raise a localized error if image is unavailable if disk_type == 'file' and driver_type == 'ploop': dk_size = 0 for dirpath, dirnames, filenames in os.walk(path): for f in filenames: fp = os.path.join(dirpath, f) dk_size += os.path.getsize(fp) qemu_img_info = disk_api.get_disk_info(path) virt_size = qemu_img_info.virtual_size backing_file = libvirt_utils.get_disk_backing_file(path) over_commit_size = int(virt_size) - dk_size elif disk_type == 'file' and driver_type == 'qcow2': qemu_img_info = disk_api.get_disk_info(path) dk_size = qemu_img_info.disk_size virt_size = qemu_img_info.virtual_size backing_file = libvirt_utils.get_disk_backing_file(path) over_commit_size = max(0, int(virt_size) - dk_size) elif disk_type == 'file': dk_size = os.stat(path).st_blocks * 512 virt_size = os.path.getsize(path) backing_file = "" over_commit_size = int(virt_size) - dk_size elif disk_type == 'block' and block_device_info: dk_size = lvm.get_volume_size(path) virt_size = dk_size backing_file = "" over_commit_size = 0 else: LOG.debug('skipping disk %(path)s (%(target)s) - unable to ' 'determine if volume', {'path': path, 'target': target}) continue disk_info.append({'type': driver_type, 'path': path, 'virt_disk_size': virt_size, 'backing_file': backing_file, 'disk_size': dk_size, 'over_committed_disk_size': over_commit_size}) return disk_info def _get_instance_disk_info(self, instance, block_device_info): try: guest = self._host.get_guest(instance) config = guest.get_config() except libvirt.libvirtError as ex: error_code = ex.get_error_code() LOG.warning('Error from libvirt while getting description of ' '%(instance_name)s: [Error Code %(error_code)s] ' '%(ex)s', {'instance_name': instance.name, 'error_code': error_code, 'ex': encodeutils.exception_to_unicode(ex)}, instance=instance) raise exception.InstanceNotFound(instance_id=instance.uuid) return self._get_instance_disk_info_from_config(config, block_device_info) def get_instance_disk_info(self, instance, block_device_info=None): return jsonutils.dumps( self._get_instance_disk_info(instance, block_device_info)) def _get_disk_over_committed_size_total(self): """Return total over committed disk size for all instances.""" # Disk size that all instance uses : virtual_size - disk_size disk_over_committed_size = 0 instance_domains = self._host.list_instance_domains(only_running=False) if not instance_domains: return disk_over_committed_size # Get all instance uuids instance_uuids = [dom.UUIDString() for dom in instance_domains] ctx = nova_context.get_admin_context() # Get instance object list by uuid filter filters = {'uuid': instance_uuids} # NOTE(ankit): objects.InstanceList.get_by_filters method is # getting called twice one is here and another in the # _update_available_resource method of resource_tracker. Since # _update_available_resource method is synchronized, there is a # possibility the instances list retrieved here to calculate # disk_over_committed_size would differ to the list you would get # in _update_available_resource method for calculating usages based # on instance utilization. local_instance_list = objects.InstanceList.get_by_filters( ctx, filters, use_slave=True) # Convert instance list to dictionary with instance uuid as key. local_instances = {inst.uuid: inst for inst in local_instance_list} # Get bdms by instance uuids bdms = objects.BlockDeviceMappingList.bdms_by_instance_uuid( ctx, instance_uuids) for dom in instance_domains: try: guest = libvirt_guest.Guest(dom) config = guest.get_config() block_device_info = None if guest.uuid in local_instances \ and (bdms and guest.uuid in bdms): # Get block device info for instance block_device_info = driver.get_block_device_info( local_instances[guest.uuid], bdms[guest.uuid]) disk_infos = self._get_instance_disk_info_from_config( config, block_device_info) if not disk_infos: continue for info in disk_infos: disk_over_committed_size += int( info['over_committed_disk_size']) except libvirt.libvirtError as ex: error_code = ex.get_error_code() LOG.warning( 'Error from libvirt while getting description of ' '%(instance_name)s: [Error Code %(error_code)s] %(ex)s', {'instance_name': guest.name, 'error_code': error_code, 'ex': encodeutils.exception_to_unicode(ex)}) except OSError as e: if e.errno in (errno.ENOENT, errno.ESTALE): LOG.warning('Periodic task is updating the host stat, ' 'it is trying to get disk %(i_name)s, ' 'but disk file was removed by concurrent ' 'operations such as resize.', {'i_name': guest.name}) elif e.errno == errno.EACCES: LOG.warning('Periodic task is updating the host stat, ' 'it is trying to get disk %(i_name)s, ' 'but access is denied. It is most likely ' 'due to a VM that exists on the compute ' 'node but is not managed by Nova.', {'i_name': guest.name}) else: raise except (exception.VolumeBDMPathNotFound, exception.DiskNotFound) as e: if isinstance(e, exception.VolumeBDMPathNotFound): thing = 'backing volume block device' elif isinstance(e, exception.DiskNotFound): thing = 'backing disk storage' LOG.warning('Periodic task is updating the host stats, ' 'it is trying to get disk info for %(i_name)s, ' 'but the %(thing)s was removed by a concurrent ' 'operation such as resize. Error: %(error)s', {'i_name': guest.name, 'thing': thing, 'error': e}) # NOTE(gtt116): give other tasks a chance. greenthread.sleep(0) return disk_over_committed_size def get_available_nodes(self, refresh=False): return [self._host.get_hostname()] def get_host_cpu_stats(self): """Return the current CPU state of the host.""" return self._host.get_cpu_stats() def get_host_uptime(self): """Returns the result of calling "uptime".""" out, err = processutils.execute('env', 'LANG=C', 'uptime') return out def manage_image_cache(self, context, all_instances): """Manage the local cache of images.""" self.image_cache_manager.update(context, all_instances) def _cleanup_remote_migration(self, dest, inst_base, inst_base_resize, shared_storage=False): """Used only for cleanup in case migrate_disk_and_power_off fails.""" try: if os.path.exists(inst_base_resize): shutil.rmtree(inst_base, ignore_errors=True) os.rename(inst_base_resize, inst_base) if not shared_storage: self._remotefs.remove_dir(dest, inst_base) except Exception: pass def cache_image(self, context, image_id): cache_dir = os.path.join(CONF.instances_path, CONF.image_cache.subdirectory_name) path = os.path.join(cache_dir, imagecache.get_cache_fname(image_id)) if os.path.exists(path): LOG.info('Image %(image_id)s already cached; updating timestamp', {'image_id': image_id}) # NOTE(danms): The regular image cache routines use a wrapper # (_update_utime_ignore_eacces()) around this to avoid failing # on permissions (which may or may not be legit due to an NFS # race). However, since this is best-effort, errors are swallowed # by compute manager per-image, and we are compelled to report # errors up our stack, we use the raw method here to avoid the # silent ignore of the EACCESS. nova.privsep.path.utime(path) return False else: # NOTE(danms): In case we are running before the first boot, make # sure the cache directory is created if not os.path.isdir(cache_dir): fileutils.ensure_tree(cache_dir) LOG.info('Caching image %(image_id)s by request', {'image_id': image_id}) # NOTE(danms): The imagebackend code, as called via spawn() where # images are normally cached, uses a lock on the root disk it is # creating at the time, but relies on the # compute_utils.disk_ops_semaphore for cache fetch mutual # exclusion, which is grabbed in images.fetch() (which is called # by images.fetch_to_raw() below). So, by calling fetch_to_raw(), # we are sharing the same locking for the cache fetch as the # rest of the code currently called only from spawn(). images.fetch_to_raw(context, image_id, path) return True def _get_disk_size_reserved_for_image_cache(self): """Return the amount of DISK_GB resource need to be reserved for the image cache. :returns: The disk space in GB """ if not CONF.workarounds.reserve_disk_resource_for_image_cache: return 0 return compute_utils.convert_mb_to_ceil_gb( self.image_cache_manager.get_disk_usage() / 1024.0 / 1024.0) def _is_path_shared_with(self, dest, path): # NOTE (rmk): There are two methods of determining whether we are # on the same filesystem: the source and dest IP are the # same, or we create a file on the dest system via SSH # and check whether the source system can also see it. shared_path = (dest == self.get_host_ip_addr()) if not shared_path: tmp_file = uuidutils.generate_uuid(dashed=False) + '.tmp' tmp_path = os.path.join(path, tmp_file) try: self._remotefs.create_file(dest, tmp_path) if os.path.exists(tmp_path): shared_path = True os.unlink(tmp_path) else: self._remotefs.remove_file(dest, tmp_path) except Exception: pass return shared_path def migrate_disk_and_power_off(self, context, instance, dest, flavor, network_info, block_device_info=None, timeout=0, retry_interval=0): LOG.debug("Starting migrate_disk_and_power_off", instance=instance) ephemerals = driver.block_device_info_get_ephemerals(block_device_info) # get_bdm_ephemeral_disk_size() will return 0 if the new # instance's requested block device mapping contain no # ephemeral devices. However, we still want to check if # the original instance's ephemeral_gb property was set and # ensure that the new requested flavor ephemeral size is greater eph_size = (block_device.get_bdm_ephemeral_disk_size(ephemerals) or instance.flavor.ephemeral_gb) # Checks if the migration needs a disk resize down. root_down = flavor.root_gb < instance.flavor.root_gb ephemeral_down = flavor.ephemeral_gb < eph_size booted_from_volume = self._is_booted_from_volume(block_device_info) if (root_down and not booted_from_volume) or ephemeral_down: reason = _("Unable to resize disk down.") raise exception.InstanceFaultRollback( exception.ResizeError(reason=reason)) # NOTE(dgenin): Migration is not implemented for LVM backed instances. if CONF.libvirt.images_type == 'lvm' and not booted_from_volume: reason = _("Migration is not supported for LVM backed instances") raise exception.InstanceFaultRollback( exception.MigrationPreCheckError(reason=reason)) # copy disks to destination # rename instance dir to +_resize at first for using # shared storage for instance dir (eg. NFS). inst_base = libvirt_utils.get_instance_path(instance) inst_base_resize = inst_base + "_resize" shared_instance_path = self._is_path_shared_with(dest, inst_base) # try to create the directory on the remote compute node # if this fails we pass the exception up the stack so we can catch # failures here earlier if not shared_instance_path: try: self._remotefs.create_dir(dest, inst_base) except processutils.ProcessExecutionError as e: reason = _("not able to execute ssh command: %s") % e raise exception.InstanceFaultRollback( exception.ResizeError(reason=reason)) self.power_off(instance, timeout, retry_interval) block_device_mapping = driver.block_device_info_get_mapping( block_device_info) for vol in block_device_mapping: connection_info = vol['connection_info'] self._disconnect_volume(context, connection_info, instance) disk_info = self._get_instance_disk_info(instance, block_device_info) try: os.rename(inst_base, inst_base_resize) # if we are migrating the instance with shared instance path then # create the directory. If it is a remote node the directory # has already been created if shared_instance_path: dest = None fileutils.ensure_tree(inst_base) on_execute = lambda process: \ self.job_tracker.add_job(instance, process.pid) on_completion = lambda process: \ self.job_tracker.remove_job(instance, process.pid) for info in disk_info: # assume inst_base == dirname(info['path']) img_path = info['path'] fname = os.path.basename(img_path) from_path = os.path.join(inst_base_resize, fname) # We will not copy over the swap disk here, and rely on # finish_migration to re-create it for us. This is ok because # the OS is shut down, and as recreating a swap disk is very # cheap it is more efficient than copying either locally or # over the network. This also means we don't have to resize it. if fname == 'disk.swap': continue compression = info['type'] not in NO_COMPRESSION_TYPES libvirt_utils.copy_image(from_path, img_path, host=dest, on_execute=on_execute, on_completion=on_completion, compression=compression) # Ensure disk.info is written to the new path to avoid disks being # reinspected and potentially changing format. src_disk_info_path = os.path.join(inst_base_resize, 'disk.info') if os.path.exists(src_disk_info_path): dst_disk_info_path = os.path.join(inst_base, 'disk.info') libvirt_utils.copy_image(src_disk_info_path, dst_disk_info_path, host=dest, on_execute=on_execute, on_completion=on_completion) # Handle migration of vTPM data if needed libvirt_utils.save_and_migrate_vtpm_dir( instance.uuid, inst_base_resize, inst_base, dest, on_execute, on_completion) except Exception: with excutils.save_and_reraise_exception(): self._cleanup_remote_migration(dest, inst_base, inst_base_resize, shared_instance_path) return jsonutils.dumps(disk_info) def _wait_for_running(self, instance): state = self.get_info(instance).state if state == power_state.RUNNING: LOG.info("Instance running successfully.", instance=instance) raise loopingcall.LoopingCallDone() @staticmethod def _disk_raw_to_qcow2(path): """Converts a raw disk to qcow2.""" path_qcow = path + '_qcow' images.convert_image(path, path_qcow, 'raw', 'qcow2') os.rename(path_qcow, path) def _finish_migration_vtpm( self, context: nova_context.RequestContext, instance: 'objects.Instance', ) -> None: """Handle vTPM when migrating or resizing an instance. Handle the case where we're resizing between different versions of TPM, or enabling/disabling TPM. """ old_vtpm_config = hardware.get_vtpm_constraint( instance.old_flavor, instance.image_meta) new_vtpm_config = hardware.get_vtpm_constraint( instance.new_flavor, instance.image_meta) if old_vtpm_config: # we had a vTPM in the old flavor; figure out if we need to do # anything with it inst_base = libvirt_utils.get_instance_path(instance) swtpm_dir = os.path.join(inst_base, 'swtpm', instance.uuid) copy_swtpm_dir = True if old_vtpm_config != new_vtpm_config: # we had vTPM in the old flavor but the new flavor either # doesn't or has different config; delete old TPM data and let # libvirt create new data if os.path.exists(swtpm_dir): LOG.info( 'Old flavor and new flavor have different vTPM ' 'configuration; removing existing vTPM data.') copy_swtpm_dir = False shutil.rmtree(swtpm_dir) # apparently shutil.rmtree() isn't reliable on NFS so don't rely # only on path existance here. if copy_swtpm_dir and os.path.exists(swtpm_dir): libvirt_utils.restore_vtpm_dir(swtpm_dir) elif new_vtpm_config: # we've requested vTPM in the new flavor and didn't have one # previously so we need to create a new secret crypto.ensure_vtpm_secret(context, instance) def finish_migration( self, context: nova_context.RequestContext, migration: 'objects.Migration', instance: 'objects.Instance', disk_info: str, network_info: network_model.NetworkInfo, image_meta: 'objects.ImageMeta', resize_instance: bool, allocations: ty.Dict[str, ty.Any], block_device_info: ty.Optional[ty.Dict[str, ty.Any]] = None, power_on: bool = True, ) -> None: """Complete the migration process on the destination host.""" LOG.debug("Starting finish_migration", instance=instance) block_disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type, instance, image_meta, block_device_info) # assume _create_image does nothing if a target file exists. # NOTE: This has the intended side-effect of fetching a missing # backing file. self._create_image(context, instance, block_disk_info['mapping'], block_device_info=block_device_info, ignore_bdi_for_swap=True, fallback_from_host=migration.source_compute) # Required by Quobyte CI self._ensure_console_log_for_instance(instance) gen_confdrive = functools.partial( self._create_configdrive, context, instance, InjectionInfo(admin_pass=None, network_info=network_info, files=None)) # Convert raw disks to qcow2 if migrating to host which uses # qcow2 from host which uses raw. for info in jsonutils.loads(disk_info): path = info['path'] disk_name = os.path.basename(path) # NOTE(mdbooth): The code below looks wrong, but is actually # required to prevent a security hole when migrating from a host # with use_cow_images=False to one with use_cow_images=True. # Imagebackend uses use_cow_images to select between the # atrociously-named-Raw and Qcow2 backends. The Qcow2 backend # writes to disk.info, but does not read it as it assumes qcow2. # Therefore if we don't convert raw to qcow2 here, a raw disk will # be incorrectly assumed to be qcow2, which is a severe security # flaw. The reverse is not true, because the atrociously-named-Raw # backend supports both qcow2 and raw disks, and will choose # appropriately between them as long as disk.info exists and is # correctly populated, which it is because Qcow2 writes to # disk.info. # # In general, we do not yet support format conversion during # migration. For example: # * Converting from use_cow_images=True to use_cow_images=False # isn't handled. This isn't a security bug, but is almost # certainly buggy in other cases, as the 'Raw' backend doesn't # expect a backing file. # * Converting to/from lvm and rbd backends is not supported. # # This behaviour is inconsistent, and therefore undesirable for # users. It is tightly-coupled to implementation quirks of 2 # out of 5 backends in imagebackend and defends against a severe # security flaw which is not at all obvious without deep analysis, # and is therefore undesirable to developers. We should aim to # remove it. This will not be possible, though, until we can # represent the storage layout of a specific instance # independent of the default configuration of the local compute # host. # Config disks are hard-coded to be raw even when # use_cow_images=True (see _get_disk_config_image_type),so don't # need to be converted. if (disk_name != 'disk.config' and info['type'] == 'raw' and CONF.use_cow_images): self._disk_raw_to_qcow2(info['path']) # Does the guest need to be assigned some vGPU mediated devices ? mdevs = self._allocate_mdevs(allocations) # Handle the case where the guest has emulated TPM self._finish_migration_vtpm(context, instance) xml = self._get_guest_xml(context, instance, network_info, block_disk_info, image_meta, block_device_info=block_device_info, mdevs=mdevs) # NOTE(mriedem): vifs_already_plugged=True here, regardless of whether # or not we've migrated to another host, because we unplug VIFs locally # and the status change in the port might go undetected by the neutron # L2 agent (or neutron server) so neutron may not know that the VIF was # unplugged in the first place and never send an event. guest = self._create_guest_with_network( context, xml, instance, network_info, block_device_info, power_on=power_on, vifs_already_plugged=True, post_xml_callback=gen_confdrive) if power_on: timer = loopingcall.FixedIntervalLoopingCall( self._wait_for_running, instance) timer.start(interval=0.5).wait() # Sync guest time after migration. guest.sync_guest_time() LOG.debug("finish_migration finished successfully.", instance=instance) def _cleanup_failed_migration(self, inst_base): """Make sure that a failed migrate doesn't prevent us from rolling back in a revert. """ try: shutil.rmtree(inst_base) except OSError as e: if e.errno != errno.ENOENT: raise def _finish_revert_migration_vtpm( self, context: nova_context.RequestContext, instance: 'objects.Instance', ) -> None: """Handle vTPM differences when reverting a migration or resize. We should either restore any emulated vTPM persistent storage files or create new ones. """ old_vtpm_config = hardware.get_vtpm_constraint( instance.old_flavor, instance.image_meta) new_vtpm_config = hardware.get_vtpm_constraint( instance.new_flavor, instance.image_meta) if old_vtpm_config: # the instance had a vTPM before resize and should have one again; # move the previously-saved vTPM data back to its proper location inst_base = libvirt_utils.get_instance_path(instance) swtpm_dir = os.path.join(inst_base, 'swtpm', instance.uuid) if os.path.exists(swtpm_dir): libvirt_utils.restore_vtpm_dir(swtpm_dir) elif new_vtpm_config: # the instance gained a vTPM and must now lose it; delete the vTPM # secret, knowing that libvirt will take care of everything else on # the destination side crypto.delete_vtpm_secret(context, instance) def finish_revert_migration( self, context: nova.context.RequestContext, instance: 'objects.Instance', network_info: network_model.NetworkInfo, migration: 'objects.Migration', block_device_info: ty.Optional[ty.Dict[str, ty.Any]] = None, power_on: bool = True, ) -> None: """Finish the second half of reverting a resize on the source host.""" LOG.debug('Starting finish_revert_migration', instance=instance) inst_base = libvirt_utils.get_instance_path(instance) inst_base_resize = inst_base + "_resize" # NOTE(danms): if we're recovering from a failed migration, # make sure we don't have a left-over same-host base directory # that would conflict. Also, don't fail on the rename if the # failure happened early. if os.path.exists(inst_base_resize): self._cleanup_failed_migration(inst_base) os.rename(inst_base_resize, inst_base) root_disk = self.image_backend.by_name(instance, 'disk') # Once we rollback, the snapshot is no longer needed, so remove it if root_disk.exists(): root_disk.rollback_to_snap(libvirt_utils.RESIZE_SNAPSHOT_NAME) root_disk.remove_snap(libvirt_utils.RESIZE_SNAPSHOT_NAME) self._finish_revert_migration_vtpm(context, instance) disk_info = blockinfo.get_disk_info(CONF.libvirt.virt_type, instance, instance.image_meta, block_device_info) # The guest could already have mediated devices, using them for # the new XML mdevs = list(self._get_all_assigned_mediated_devices(instance)) xml = self._get_guest_xml(context, instance, network_info, disk_info, instance.image_meta, block_device_info=block_device_info, mdevs=mdevs) # NOTE(artom) In some Neutron or port configurations we've already # waited for vif-plugged events in the compute manager's # _finish_revert_resize_network_migrate_finish(), right after updating # the port binding. For any ports not covered by those "bind-time" # events, we wait for "plug-time" events here. events = network_info.get_plug_time_events(migration) if events: LOG.debug('Instance is using plug-time events: %s', events, instance=instance) self._create_guest_with_network( context, xml, instance, network_info, block_device_info, power_on=power_on, external_events=events) if power_on: timer = loopingcall.FixedIntervalLoopingCall( self._wait_for_running, instance) timer.start(interval=0.5).wait() LOG.debug("finish_revert_migration finished successfully.", instance=instance) def confirm_migration(self, context, migration, instance, network_info): """Confirms a resize, destroying the source VM.""" self._cleanup_resize(context, instance, network_info) @staticmethod def _get_io_devices(xml_doc): """get the list of io devices from the xml document.""" result: ty.Dict[str, ty.List[str]] = {"volumes": [], "ifaces": []} try: doc = etree.fromstring(xml_doc) except Exception: return result blocks = [('./devices/disk', 'volumes'), ('./devices/interface', 'ifaces')] for block, key in blocks: section = doc.findall(block) for node in section: for child in node: if child.tag == 'target' and child.get('dev'): result[key].append(child.get('dev')) return result def get_diagnostics(self, instance): guest = self._host.get_guest(instance) # TODO(sahid): We are converting all calls from a # virDomain object to use nova.virt.libvirt.Guest. # We should be able to remove domain at the end. domain = guest._domain output = {} # get cpu time, might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt try: for vcpu in guest.get_vcpus_info(): output["cpu" + str(vcpu.id) + "_time"] = vcpu.time except libvirt.libvirtError: pass # get io status xml = guest.get_xml_desc() dom_io = LibvirtDriver._get_io_devices(xml) for guest_disk in dom_io["volumes"]: try: # blockStats might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt stats = domain.blockStats(guest_disk) output[guest_disk + "_read_req"] = stats[0] output[guest_disk + "_read"] = stats[1] output[guest_disk + "_write_req"] = stats[2] output[guest_disk + "_write"] = stats[3] output[guest_disk + "_errors"] = stats[4] except libvirt.libvirtError: pass for interface in dom_io["ifaces"]: try: # interfaceStats might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt stats = domain.interfaceStats(interface) output[interface + "_rx"] = stats[0] output[interface + "_rx_packets"] = stats[1] output[interface + "_rx_errors"] = stats[2] output[interface + "_rx_drop"] = stats[3] output[interface + "_tx"] = stats[4] output[interface + "_tx_packets"] = stats[5] output[interface + "_tx_errors"] = stats[6] output[interface + "_tx_drop"] = stats[7] except libvirt.libvirtError: pass output["memory"] = domain.maxMemory() # memoryStats might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt try: mem = domain.memoryStats() for key in mem.keys(): output["memory-" + key] = mem[key] except (libvirt.libvirtError, AttributeError): pass return output def get_instance_diagnostics(self, instance): guest = self._host.get_guest(instance) # TODO(sahid): We are converting all calls from a # virDomain object to use nova.virt.libvirt.Guest. # We should be able to remove domain at the end. domain = guest._domain xml = guest.get_xml_desc() xml_doc = etree.fromstring(xml) # TODO(sahid): Needs to use get_info but more changes have to # be done since a mapping STATE_MAP LIBVIRT_POWER_STATE is # needed. state, max_mem, mem, num_cpu, cpu_time = guest._get_domain_info() config_drive = configdrive.required_by(instance) launched_at = timeutils.normalize_time(instance.launched_at) uptime = timeutils.delta_seconds(launched_at, timeutils.utcnow()) diags = diagnostics_obj.Diagnostics(state=power_state.STATE_MAP[state], driver='libvirt', config_drive=config_drive, hypervisor=CONF.libvirt.virt_type, hypervisor_os='linux', uptime=uptime) diags.memory_details = diagnostics_obj.MemoryDiagnostics( maximum=max_mem / units.Mi, used=mem / units.Mi) # get cpu time, might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt try: for vcpu in guest.get_vcpus_info(): diags.add_cpu(id=vcpu.id, time=vcpu.time) except libvirt.libvirtError: pass # get io status dom_io = LibvirtDriver._get_io_devices(xml) for guest_disk in dom_io["volumes"]: try: # blockStats might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt stats = domain.blockStats(guest_disk) diags.add_disk(read_bytes=stats[1], read_requests=stats[0], write_bytes=stats[3], write_requests=stats[2], errors_count=stats[4]) except libvirt.libvirtError: pass for interface in xml_doc.findall('./devices/interface'): mac_address = interface.find('mac').get('address') target = interface.find('./target') # add nic that has no target (therefore no stats) if target is None: diags.add_nic(mac_address=mac_address) continue # add nic with stats dev = target.get('dev') try: if dev: # interfaceStats might launch an exception if the # method is not supported by the underlying hypervisor # being used by libvirt stats = domain.interfaceStats(dev) diags.add_nic(mac_address=mac_address, rx_octets=stats[0], rx_errors=stats[2], rx_drop=stats[3], rx_packets=stats[1], tx_octets=stats[4], tx_errors=stats[6], tx_drop=stats[7], tx_packets=stats[5]) except libvirt.libvirtError: pass return diags @staticmethod def _prepare_device_bus(dev): """Determines the device bus and its hypervisor assigned address """ bus = None address = (dev.device_addr.format_address() if dev.device_addr else None) if isinstance(dev.device_addr, vconfig.LibvirtConfigGuestDeviceAddressPCI): bus = objects.PCIDeviceBus() elif isinstance(dev, vconfig.LibvirtConfigGuestDisk): if dev.target_bus == 'scsi': bus = objects.SCSIDeviceBus() elif dev.target_bus == 'ide': bus = objects.IDEDeviceBus() elif dev.target_bus == 'usb': bus = objects.USBDeviceBus() if address is not None and bus is not None: bus.address = address return bus def _build_interface_metadata(self, dev, vifs_to_expose, vlans_by_mac, trusted_by_mac): """Builds a metadata object for a network interface :param dev: The LibvirtConfigGuestInterface to build metadata for. :param vifs_to_expose: The list of tagged and/or vlan'ed VirtualInterface objects. :param vlans_by_mac: A dictionary of mac address -> vlan associations. :param trusted_by_mac: A dictionary of mac address -> vf_trusted associations. :return: A NetworkInterfaceMetadata object, or None. """ vif = vifs_to_expose.get(dev.mac_addr) if not vif: LOG.debug('No VIF found with MAC %s, not building metadata', dev.mac_addr) return None bus = self._prepare_device_bus(dev) device = objects.NetworkInterfaceMetadata(mac=vif.address) if 'tag' in vif and vif.tag: device.tags = [vif.tag] if bus: device.bus = bus vlan = vlans_by_mac.get(vif.address) if vlan: device.vlan = int(vlan) device.vf_trusted = trusted_by_mac.get(vif.address, False) return device def _build_disk_metadata(self, dev, tagged_bdms): """Builds a metadata object for a disk :param dev: The vconfig.LibvirtConfigGuestDisk to build metadata for. :param tagged_bdms: The list of tagged BlockDeviceMapping objects. :return: A DiskMetadata object, or None. """ bdm = tagged_bdms.get(dev.target_dev) if not bdm: LOG.debug('No BDM found with device name %s, not building ' 'metadata.', dev.target_dev) return None bus = self._prepare_device_bus(dev) device = objects.DiskMetadata(tags=[bdm.tag]) # NOTE(artom) Setting the serial (which corresponds to # volume_id in BlockDeviceMapping) in DiskMetadata allows us to # find the disks's BlockDeviceMapping object when we detach the # volume and want to clean up its metadata. device.serial = bdm.volume_id if bus: device.bus = bus return device def _build_hostdev_metadata(self, dev, vifs_to_expose, vlans_by_mac): """Builds a metadata object for a hostdev. This can only be a PF, so we don't need trusted_by_mac like in _build_interface_metadata because only VFs can be trusted. :param dev: The LibvirtConfigGuestHostdevPCI to build metadata for. :param vifs_to_expose: The list of tagged and/or vlan'ed VirtualInterface objects. :param vlans_by_mac: A dictionary of mac address -> vlan associations. :return: A NetworkInterfaceMetadata object, or None. """ # Strip out the leading '0x' pci_address = pci_utils.get_pci_address( *[x[2:] for x in (dev.domain, dev.bus, dev.slot, dev.function)]) try: mac = pci_utils.get_mac_by_pci_address(pci_address, pf_interface=True) except exception.PciDeviceNotFoundById: LOG.debug('Not exposing metadata for not found PCI device %s', pci_address) return None vif = vifs_to_expose.get(mac) if not vif: LOG.debug('No VIF found with MAC %s, not building metadata', mac) return None device = objects.NetworkInterfaceMetadata(mac=mac) device.bus = objects.PCIDeviceBus(address=pci_address) if 'tag' in vif and vif.tag: device.tags = [vif.tag] vlan = vlans_by_mac.get(mac) if vlan: device.vlan = int(vlan) return device def _build_device_metadata(self, context, instance): """Builds a metadata object for instance devices, that maps the user provided tag to the hypervisor assigned device address. """ def _get_device_name(bdm): return block_device.strip_dev(bdm.device_name) network_info = instance.info_cache.network_info vlans_by_mac = netutils.get_cached_vifs_with_vlan(network_info) trusted_by_mac = netutils.get_cached_vifs_with_trusted(network_info) vifs = objects.VirtualInterfaceList.get_by_instance_uuid(context, instance.uuid) vifs_to_expose = {vif.address: vif for vif in vifs if ('tag' in vif and vif.tag) or vlans_by_mac.get(vif.address)} # TODO(mriedem): We should be able to avoid the DB query here by using # block_device_info['block_device_mapping'] which is passed into most # methods that call this function. bdms = objects.BlockDeviceMappingList.get_by_instance_uuid( context, instance.uuid) tagged_bdms = {_get_device_name(bdm): bdm for bdm in bdms if bdm.tag} devices = [] guest = self._host.get_guest(instance) xml = guest.get_xml_desc() xml_dom = etree.fromstring(xml) guest_config = vconfig.LibvirtConfigGuest() guest_config.parse_dom(xml_dom) for dev in guest_config.devices: device = None if isinstance(dev, vconfig.LibvirtConfigGuestInterface): device = self._build_interface_metadata(dev, vifs_to_expose, vlans_by_mac, trusted_by_mac) if isinstance(dev, vconfig.LibvirtConfigGuestDisk): device = self._build_disk_metadata(dev, tagged_bdms) if isinstance(dev, vconfig.LibvirtConfigGuestHostdevPCI): device = self._build_hostdev_metadata(dev, vifs_to_expose, vlans_by_mac) if device: devices.append(device) if devices: dev_meta = objects.InstanceDeviceMetadata(devices=devices) return dev_meta def instance_on_disk(self, instance): # ensure directories exist and are writable instance_path = libvirt_utils.get_instance_path(instance) LOG.debug('Checking instance files accessibility %s', instance_path, instance=instance) shared_instance_path = os.access(instance_path, os.W_OK) # NOTE(flwang): For shared block storage scenario, the file system is # not really shared by the two hosts, but the volume of evacuated # instance is reachable. shared_block_storage = (self.image_backend.backend(). is_shared_block_storage()) return shared_instance_path or shared_block_storage def inject_network_info(self, instance, nw_info): pass def delete_instance_files(self, instance): target = libvirt_utils.get_instance_path(instance) # A resize may be in progress target_resize = target + '_resize' # Other threads may attempt to rename the path, so renaming the path # to target + '_del' (because it is atomic) and iterating through # twice in the unlikely event that a concurrent rename occurs between # the two rename attempts in this method. In general this method # should be fairly thread-safe without these additional checks, since # other operations involving renames are not permitted when the task # state is not None and the task state should be set to something # other than None by the time this method is invoked. target_del = target + '_del' for i in range(2): try: os.rename(target, target_del) break except Exception: pass try: os.rename(target_resize, target_del) break except Exception: pass # Either the target or target_resize path may still exist if all # rename attempts failed. remaining_path = None for p in (target, target_resize): if os.path.exists(p): remaining_path = p break # A previous delete attempt may have been interrupted, so target_del # may exist even if all rename attempts during the present method # invocation failed due to the absence of both target and # target_resize. if not remaining_path and os.path.exists(target_del): self.job_tracker.terminate_jobs(instance) LOG.info('Deleting instance files %s', target_del, instance=instance) remaining_path = target_del try: shutil.rmtree(target_del) except OSError as e: LOG.error('Failed to cleanup directory %(target)s: %(e)s', {'target': target_del, 'e': e}, instance=instance) # It is possible that the delete failed, if so don't mark the instance # as cleaned. if remaining_path and os.path.exists(remaining_path): LOG.info('Deletion of %s failed', remaining_path, instance=instance) return False LOG.info('Deletion of %s complete', target_del, instance=instance) return True @property def need_legacy_block_device_info(self): return False def default_root_device_name(self, instance, image_meta, root_bdm): disk_bus = blockinfo.get_disk_bus_for_device_type( instance, CONF.libvirt.virt_type, image_meta, "disk") cdrom_bus = blockinfo.get_disk_bus_for_device_type( instance, CONF.libvirt.virt_type, image_meta, "cdrom") root_info = blockinfo.get_root_info( instance, CONF.libvirt.virt_type, image_meta, root_bdm, disk_bus, cdrom_bus) return block_device.prepend_dev(root_info['dev']) def default_device_names_for_instance(self, instance, root_device_name, *block_device_lists): block_device_mapping = list(itertools.chain(*block_device_lists)) # NOTE(ndipanov): Null out the device names so that blockinfo code # will assign them for bdm in block_device_mapping: if bdm.device_name is not None: LOG.info( "Ignoring supplied device name: %(device_name)s. " "Libvirt can't honour user-supplied dev names", {'device_name': bdm.device_name}, instance=instance) bdm.device_name = None block_device_info = driver.get_block_device_info(instance, block_device_mapping) blockinfo.default_device_names(CONF.libvirt.virt_type, nova_context.get_admin_context(), instance, block_device_info, instance.image_meta) def get_device_name_for_instance(self, instance, bdms, block_device_obj): block_device_info = driver.get_block_device_info(instance, bdms) instance_info = blockinfo.get_disk_info( CONF.libvirt.virt_type, instance, instance.image_meta, block_device_info=block_device_info) suggested_dev_name = block_device_obj.device_name if suggested_dev_name is not None: LOG.info( 'Ignoring supplied device name: %(suggested_dev)s', {'suggested_dev': suggested_dev_name}, instance=instance) # NOTE(ndipanov): get_info_from_bdm will generate the new device name # only when it's actually not set on the bd object block_device_obj.device_name = None disk_info = blockinfo.get_info_from_bdm( instance, CONF.libvirt.virt_type, instance.image_meta, block_device_obj, mapping=instance_info['mapping']) return block_device.prepend_dev(disk_info['dev']) def is_supported_fs_format(self, fs_type): return fs_type in [nova.privsep.fs.FS_FORMAT_EXT2, nova.privsep.fs.FS_FORMAT_EXT3, nova.privsep.fs.FS_FORMAT_EXT4, nova.privsep.fs.FS_FORMAT_XFS] def _get_tpm_traits(self) -> ty.Dict[str, bool]: # Assert or deassert TPM support traits return { ot.COMPUTE_SECURITY_TPM_2_0: CONF.libvirt.swtpm_enabled, ot.COMPUTE_SECURITY_TPM_1_2: CONF.libvirt.swtpm_enabled, } def _get_vif_model_traits(self) -> ty.Dict[str, bool]: """Get vif model traits based on the currently enabled virt_type. Not all traits generated by this function may be valid and the result should be validated. :return: A dict of trait names mapped to boolean values. """ all_models = set(itertools.chain( *libvirt_vif.SUPPORTED_VIF_MODELS.values() )) supported_models = libvirt_vif.SUPPORTED_VIF_MODELS.get( CONF.libvirt.virt_type, [] ) # construct the corresponding standard trait from the VIF model name return { f'COMPUTE_NET_VIF_MODEL_{model.replace("-", "_").upper()}': model in supported_models for model in all_models } def _get_storage_bus_traits(self) -> ty.Dict[str, bool]: """Get storage bus traits based on the currently enabled virt_type. For QEMU and KVM this function uses the information returned by the libvirt domain capabilities API. For other virt types we generate the traits based on the static information in the blockinfo module. Not all traits generated by this function may be valid and the result should be validated. :return: A dict of trait names mapped to boolean values. """ all_buses = set(itertools.chain( *blockinfo.SUPPORTED_DEVICE_BUSES.values() )) if CONF.libvirt.virt_type in ('qemu', 'kvm'): dom_caps = self._host.get_domain_capabilities() supported_buses: ty.Set[str] = set() for arch_type in dom_caps: for machine_type in dom_caps[arch_type]: supported_buses.update( dom_caps[arch_type][machine_type].devices.disk.buses ) else: supported_buses = blockinfo.SUPPORTED_DEVICE_BUSES.get( CONF.libvirt.virt_type, [] ) # construct the corresponding standard trait from the storage bus name return { f'COMPUTE_STORAGE_BUS_{bus.replace("-", "_").upper()}': bus in supported_buses for bus in all_buses } def _get_video_model_traits(self) -> ty.Dict[str, bool]: """Get video model traits from libvirt. Not all traits generated by this function may be valid and the result should be validated. :return: A dict of trait names mapped to boolean values. """ all_models = fields.VideoModel.ALL dom_caps = self._host.get_domain_capabilities() supported_models: ty.Set[str] = set() for arch_type in dom_caps: for machine_type in dom_caps[arch_type]: supported_models.update( dom_caps[arch_type][machine_type].devices.video.models ) # construct the corresponding standard trait from the video model name return { f'COMPUTE_GRAPHICS_MODEL_{model.replace("-", "_").upper()}': model in supported_models for model in all_models } def _get_cpu_traits(self) -> ty.Dict[str, bool]: """Get CPU-related traits to be set and unset on the host's resource provider. :return: A dict of trait names mapped to boolean values. """ traits = self._get_cpu_feature_traits() traits[ot.HW_CPU_X86_AMD_SEV] = self._host.supports_amd_sev traits[ot.HW_CPU_HYPERTHREADING] = self._host.has_hyperthreading return traits def _get_cpu_feature_traits(self) -> ty.Dict[str, bool]: """Get CPU traits of VMs based on guest CPU model config. 1. If mode is 'host-model' or 'host-passthrough', use host's CPU features. 2. If mode is None, choose a default CPU model based on CPU architecture. 3. If mode is 'custom', use cpu_models to generate CPU features. The code also accounts for cpu_model_extra_flags configuration when cpu_mode is 'host-model', 'host-passthrough' or 'custom', this ensures user specified CPU feature flags to be included. :return: A dict of trait names mapped to boolean values. """ cpu = self._get_guest_cpu_model_config() if not cpu: LOG.info('The current libvirt hypervisor %(virt_type)s ' 'does not support reporting CPU traits.', {'virt_type': CONF.libvirt.virt_type}) return {} caps = deepcopy(self._host.get_capabilities()) if cpu.mode in ('host-model', 'host-passthrough'): # Account for features in cpu_model_extra_flags conf host_features: ty.Set[str] = { f.name for f in caps.host.cpu.features | cpu.features } return libvirt_utils.cpu_features_to_traits(host_features) def _resolve_features(cpu): xml_str = cpu.to_xml() features_xml = self._get_guest_baseline_cpu_features(xml_str) feature_names = [] if features_xml: cpu = vconfig.LibvirtConfigCPU() cpu.parse_str(features_xml) feature_names = [f.name for f in cpu.features] return feature_names features: ty.Set[str] = set() # Choose a default CPU model when cpu_mode is not specified if cpu.mode is None: caps.host.cpu.model = libvirt_utils.get_cpu_model_from_arch( caps.host.cpu.arch) caps.host.cpu.features = set() features = features.union(_resolve_features(caps.host.cpu)) else: models = [self._get_cpu_model_mapping(model) for model in CONF.libvirt.cpu_models] # Aarch64 platform doesn't return the default CPU models if caps.host.cpu.arch == fields.Architecture.AARCH64: if not models: models = ['max'] # For custom mode, iterate through cpu models for model in models: caps.host.cpu.model = model caps.host.cpu.features = set() features = features.union(_resolve_features(caps.host.cpu)) # Account for features in cpu_model_extra_flags conf features = features.union([f.name for f in cpu.features]) return libvirt_utils.cpu_features_to_traits(features) def _get_guest_baseline_cpu_features(self, xml_str): """Calls libvirt's baselineCPU API to compute the biggest set of CPU features which is compatible with the given host CPU. :param xml_str: XML description of host CPU :return: An XML string of the computed CPU, or None on error """ LOG.debug("Libvirt baseline CPU %s", xml_str) # TODO(lei-zh): baselineCPU is not supported on all platforms. # There is some work going on in the libvirt community to replace the # baseline call. Consider using the new apis when they are ready. See # https://www.redhat.com/archives/libvir-list/2018-May/msg01204.html. try: if hasattr(libvirt, 'VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES'): return self._host.get_connection().baselineCPU( [xml_str], libvirt.VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES) else: return self._host.get_connection().baselineCPU([xml_str]) except libvirt.libvirtError as ex: with excutils.save_and_reraise_exception() as ctxt: error_code = ex.get_error_code() if error_code == libvirt.VIR_ERR_NO_SUPPORT: ctxt.reraise = False LOG.debug('URI %(uri)s does not support full set' ' of host capabilities: %(error)s', {'uri': self._host._uri, 'error': ex}) return None