mirror of
https://github.com/virt-manager/virt-manager.git
synced 2025-01-08 21:18:04 +03:00
de9cd87fda
This is required in order to ask for correct domcapabilities. If you don't specify any machine libvirt will return domcapabilities for default machine which is xenpv. Signed-off-by: Pavel Hrdina <phrdina@redhat.com>
535 lines
15 KiB
Python
535 lines
15 KiB
Python
#
|
|
# Some code for parsing libvirt's capabilities XML
|
|
#
|
|
# Copyright 2007, 2012-2014 Red Hat, Inc.
|
|
# Mark McLoughlin <markmc@redhat.com>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
# MA 02110-1301 USA.
|
|
|
|
import logging
|
|
import os
|
|
import re
|
|
|
|
from .cpu import CPU as DomainCPU
|
|
from .xmlbuilder import XMLBuilder, XMLChildProperty, XMLProperty
|
|
|
|
|
|
##########################
|
|
# CPU model list objects #
|
|
##########################
|
|
|
|
class _CPUMapModel(XMLBuilder):
|
|
"""
|
|
Single <model> instance from cpu_map.xml
|
|
"""
|
|
_XML_ROOT_NAME = "model"
|
|
name = XMLProperty("./@name")
|
|
|
|
|
|
class _CPUMapArch(XMLBuilder):
|
|
"""
|
|
Single <arch> instance of valid CPU from cpu_map.xml
|
|
"""
|
|
_XML_ROOT_NAME = "arch"
|
|
arch = XMLProperty("./@name")
|
|
models = XMLChildProperty(_CPUMapModel)
|
|
|
|
|
|
class _CPUMapFileValues(XMLBuilder):
|
|
"""
|
|
Fallback method to lists cpu models, parsed directly from libvirt's local
|
|
cpu_map.xml
|
|
"""
|
|
# This is overwritten as part of the test suite
|
|
_cpu_filename = "/usr/share/libvirt/cpu_map.xml"
|
|
|
|
def __init__(self, conn):
|
|
if os.path.exists(self._cpu_filename):
|
|
xml = file(self._cpu_filename).read()
|
|
else:
|
|
xml = None
|
|
logging.debug("CPU map file not found: %s", self._cpu_filename)
|
|
|
|
XMLBuilder.__init__(self, conn, parsexml=xml)
|
|
|
|
self._archmap = {}
|
|
|
|
_cpuvalues = XMLChildProperty(_CPUMapArch)
|
|
|
|
|
|
##############
|
|
# Public API #
|
|
##############
|
|
|
|
def get_cpus(self, arch):
|
|
if re.match(r'i[4-9]86', arch):
|
|
arch = "x86"
|
|
elif arch == "x86_64":
|
|
arch = "x86"
|
|
|
|
cpumap = self._archmap.get(arch)
|
|
if not cpumap:
|
|
for vals in self._cpuvalues:
|
|
if vals.arch == arch:
|
|
cpumap = vals
|
|
|
|
if not cpumap:
|
|
# Create a stub object
|
|
cpumap = _CPUMapArch(self.conn)
|
|
|
|
self._archmap[arch] = cpumap
|
|
return [m.name for m in cpumap.models]
|
|
|
|
|
|
class _CPUAPIValues(object):
|
|
"""
|
|
Lists valid values for cpu models obtained from libvirt's getCPUModelNames
|
|
"""
|
|
def __init__(self, conn):
|
|
self.conn = conn
|
|
self._cpus = None
|
|
|
|
def get_cpus(self, arch):
|
|
if self._cpus is not None:
|
|
return self._cpus
|
|
|
|
if self.conn.check_support(self.conn.SUPPORT_CONN_CPU_MODEL_NAMES):
|
|
names = self.conn.getCPUModelNames(arch, 0)
|
|
|
|
# Bindings were broke for a long time, so catch -1
|
|
if names != -1:
|
|
self._cpus = names
|
|
return self._cpus
|
|
|
|
return []
|
|
|
|
|
|
###################################
|
|
# capabilities host <cpu> parsing #
|
|
###################################
|
|
|
|
class _CapsCPU(DomainCPU):
|
|
arch = XMLProperty("./arch")
|
|
|
|
# capabilities used to just expose these properties as bools
|
|
_svm_bool = XMLProperty("./features/svm", is_bool=True)
|
|
_vmx_bool = XMLProperty("./features/vmx", is_bool=True)
|
|
|
|
|
|
##############
|
|
# Public API #
|
|
##############
|
|
|
|
def has_feature(self, name):
|
|
if name == "svm" and self._svm_bool:
|
|
return True
|
|
if name == "vmx" and self._vmx_bool:
|
|
return True
|
|
return name in [f.name for f in self.features]
|
|
|
|
|
|
###########################
|
|
# Caps <topology> parsers #
|
|
###########################
|
|
|
|
class _CapsTopologyCPU(XMLBuilder):
|
|
_XML_ROOT_NAME = "cpu"
|
|
id = XMLProperty("./@id")
|
|
|
|
|
|
class _TopologyCell(XMLBuilder):
|
|
_XML_ROOT_NAME = "cell"
|
|
cpus = XMLChildProperty(_CapsTopologyCPU, relative_xpath="./cpus")
|
|
|
|
|
|
class _CapsTopology(XMLBuilder):
|
|
_XML_ROOT_NAME = "topology"
|
|
cells = XMLChildProperty(_TopologyCell, relative_xpath="./cells")
|
|
|
|
|
|
######################################
|
|
# Caps <host> and <secmodel> parsers #
|
|
######################################
|
|
|
|
class _CapsSecmodelBaselabel(XMLBuilder):
|
|
_XML_ROOT_NAME = "baselabel"
|
|
type = XMLProperty("./@type")
|
|
content = XMLProperty(".")
|
|
|
|
|
|
class _CapsSecmodel(XMLBuilder):
|
|
_XML_ROOT_NAME = "secmodel"
|
|
model = XMLProperty("./model")
|
|
baselabels = XMLChildProperty(_CapsSecmodelBaselabel)
|
|
|
|
|
|
class _CapsHost(XMLBuilder):
|
|
_XML_ROOT_NAME = "host"
|
|
secmodels = XMLChildProperty(_CapsSecmodel)
|
|
cpu = XMLChildProperty(_CapsCPU, is_single=True)
|
|
topology = XMLChildProperty(_CapsTopology, is_single=True)
|
|
|
|
|
|
################################
|
|
# <guest> and <domain> parsers #
|
|
################################
|
|
|
|
class _CapsMachine(XMLBuilder):
|
|
_XML_ROOT_NAME = "machine"
|
|
name = XMLProperty(".")
|
|
canonical = XMLProperty("./@canonical")
|
|
|
|
|
|
class _CapsDomain(XMLBuilder):
|
|
def __init__(self, *args, **kwargs):
|
|
XMLBuilder.__init__(self, *args, **kwargs)
|
|
|
|
self.machines = []
|
|
for m in self._machines:
|
|
self.machines.append(m.name)
|
|
if m.canonical:
|
|
self.machines.append(m.canonical)
|
|
|
|
_XML_ROOT_NAME = "domain"
|
|
hypervisor_type = XMLProperty("./@type")
|
|
emulator = XMLProperty("./emulator")
|
|
_machines = XMLChildProperty(_CapsMachine)
|
|
|
|
|
|
class _CapsGuestFeatures(XMLBuilder):
|
|
_XML_ROOT_NAME = "features"
|
|
|
|
pae = XMLProperty("./pae", is_bool=True)
|
|
acpi = XMLProperty("./acpi/@default", is_onoff=True)
|
|
apic = XMLProperty("./apic/@default", is_onoff=True)
|
|
|
|
|
|
class _CapsGuest(XMLBuilder):
|
|
def __init__(self, *args, **kwargs):
|
|
XMLBuilder.__init__(self, *args, **kwargs)
|
|
|
|
machines = []
|
|
for m in self._machines:
|
|
machines.append(m.name)
|
|
if m.canonical:
|
|
machines.append(m.canonical)
|
|
|
|
for d in self.domains:
|
|
if not d.emulator:
|
|
d.emulator = self._emulator
|
|
if not d.machines:
|
|
d.machines = machines
|
|
|
|
|
|
_XML_ROOT_NAME = "guest"
|
|
|
|
os_type = XMLProperty("./os_type")
|
|
arch = XMLProperty("./arch/@name")
|
|
loader = XMLProperty("./arch/loader")
|
|
_emulator = XMLProperty("./arch/emulator")
|
|
|
|
domains = XMLChildProperty(_CapsDomain, relative_xpath="./arch")
|
|
features = XMLChildProperty(_CapsGuestFeatures, is_single=True)
|
|
_machines = XMLChildProperty(_CapsMachine, relative_xpath="./arch")
|
|
|
|
|
|
###############
|
|
# Public APIs #
|
|
###############
|
|
|
|
def bestDomainType(self, dtype=None, machine=None):
|
|
"""
|
|
Return the recommended domain for use if the user does not explicitly
|
|
request one.
|
|
"""
|
|
domains = []
|
|
for d in self.domains:
|
|
if dtype and d.hypervisor_type != dtype.lower():
|
|
continue
|
|
if machine and machine not in d.machines:
|
|
continue
|
|
|
|
domains.append(d)
|
|
|
|
if not domains:
|
|
return None
|
|
|
|
priority = ["kvm", "xen", "qemu"]
|
|
|
|
for t in priority:
|
|
for d in domains:
|
|
if d.hypervisor_type == t:
|
|
return d
|
|
|
|
# Fallback, just return last item in list
|
|
return domains[-1]
|
|
|
|
def has_install_options(self):
|
|
"""
|
|
Return True if there are any install options available
|
|
"""
|
|
return bool(len(self.domains) > 0)
|
|
|
|
def is_kvm_available(self):
|
|
"""
|
|
Return True if kvm guests can be installed
|
|
"""
|
|
if self.os_type != "hvm":
|
|
return False
|
|
|
|
for d in self.domains:
|
|
if d.hypervisor_type == "kvm":
|
|
return True
|
|
|
|
return False
|
|
|
|
def supports_pae(self):
|
|
"""
|
|
Return True if capabilities report support for PAE
|
|
"""
|
|
return bool(self.features.pae)
|
|
|
|
def supports_acpi(self):
|
|
"""
|
|
Return Tree if capabilities report support for ACPI
|
|
"""
|
|
return bool(self.features.acpi)
|
|
|
|
def supports_apic(self):
|
|
"""
|
|
Return Tree if capabilities report support for APIC
|
|
"""
|
|
return bool(self.features.apic)
|
|
|
|
|
|
############################
|
|
# Main capabilities object #
|
|
############################
|
|
|
|
class _CapsInfo(object):
|
|
"""
|
|
Container object to hold the results of guest_lookup, so users don't
|
|
need to juggle two objects
|
|
"""
|
|
def __init__(self, conn, guest, domain, requested_machine):
|
|
self.conn = conn
|
|
self.guest = guest
|
|
self.domain = domain
|
|
self._requested_machine = requested_machine
|
|
|
|
self.hypervisor_type = self.domain.hypervisor_type
|
|
self.os_type = self.guest.os_type
|
|
self.arch = self.guest.arch
|
|
self.loader = self.guest.loader
|
|
|
|
self.emulator = self.domain.emulator
|
|
self.machines = self.domain.machines[:]
|
|
|
|
def get_recommended_machine(self):
|
|
"""
|
|
Return the recommended machine type.
|
|
|
|
However, if the user already requested an explicit machine type,
|
|
via guest_lookup, return that instead.
|
|
"""
|
|
if self._requested_machine:
|
|
return self._requested_machine
|
|
|
|
# For any other HV just let libvirt get us the default, these
|
|
# are the only ones we've tested.
|
|
if (not self.conn.is_test() and
|
|
not self.conn.is_qemu() and
|
|
not self.conn.is_xen()):
|
|
return None
|
|
|
|
if self.conn.is_xen() and len(self.machines):
|
|
return self.machines[0]
|
|
|
|
if (self.arch in ["ppc64", "ppc64le"] and
|
|
"pseries" in self.machines):
|
|
return "pseries"
|
|
|
|
if self.arch in ["armv7l", "aarch64"]:
|
|
if "virt" in self.machines:
|
|
return "virt"
|
|
if "vexpress-a15" in self.machines:
|
|
return "vexpress-a15"
|
|
|
|
if self.arch in ["s390x"]:
|
|
if "s390-ccw-virtio" in self.machines:
|
|
return "s390-ccw-virtio"
|
|
|
|
return None
|
|
|
|
|
|
class Capabilities(XMLBuilder):
|
|
# Set by the test suite to force a particular code path
|
|
_force_cpumap = False
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
XMLBuilder.__init__(self, *args, **kwargs)
|
|
self._cpu_values = None
|
|
|
|
_XML_ROOT_NAME = "capabilities"
|
|
|
|
host = XMLChildProperty(_CapsHost, is_single=True)
|
|
guests = XMLChildProperty(_CapsGuest)
|
|
|
|
|
|
###################
|
|
# Private helpers #
|
|
###################
|
|
|
|
def _is_xen(self):
|
|
for g in self.guests:
|
|
if g.os_type != "xen":
|
|
continue
|
|
|
|
for d in g.domains:
|
|
if d.hypervisor_type == "xen":
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
##############
|
|
# Public API #
|
|
##############
|
|
|
|
def get_cpu_values(self, arch):
|
|
if not arch:
|
|
return []
|
|
if self._cpu_values:
|
|
return self._cpu_values.get_cpus(arch)
|
|
|
|
order = [_CPUAPIValues, _CPUMapFileValues]
|
|
if self._force_cpumap:
|
|
order = [_CPUMapFileValues]
|
|
|
|
# Iterate over the available methods until a set of CPU models is found
|
|
for mode in order:
|
|
cpu_values = mode(self.conn)
|
|
cpus = cpu_values.get_cpus(arch)
|
|
|
|
if len(cpus) > 0:
|
|
self._cpu_values = cpu_values
|
|
return cpus
|
|
|
|
return []
|
|
|
|
|
|
############################
|
|
# Public XML building APIs #
|
|
############################
|
|
|
|
def _guestForOSType(self, typ=None, arch=None):
|
|
if self.host is None:
|
|
return None
|
|
|
|
archs = [arch]
|
|
if arch is None:
|
|
archs = [self.host.cpu.arch, None]
|
|
|
|
for a in archs:
|
|
for g in self.guests:
|
|
if ((typ is None or g.os_type == typ) and
|
|
(a is None or g.arch == a)):
|
|
return g
|
|
|
|
def guest_lookup(self, os_type=None, arch=None, typ=None, machine=None):
|
|
"""
|
|
Simple virtualization availability lookup
|
|
|
|
Convenience function for looking up 'Guest' and 'Domain' capabilities
|
|
objects for the desired virt type. If type, arch, or os_type are none,
|
|
we return the default virt type associated with those values. These are
|
|
typically:
|
|
|
|
- os_type : hvm, then xen
|
|
- typ : kvm over plain qemu
|
|
- arch : host arch over all others
|
|
|
|
Otherwise the default will be the first listed in the capabilities xml.
|
|
This function throws C{ValueError}s if any of the requested values are
|
|
not found.
|
|
|
|
@param typ: Virtualization type ('hvm', 'xen', ...)
|
|
@param arch: Guest architecture ('x86_64', 'i686' ...)
|
|
@param os_type: Hypervisor name ('qemu', 'kvm', 'xen', ...)
|
|
@param machine: Optional machine type to emulate
|
|
|
|
@returns: A _CapsInfo object containing the found guest and domain
|
|
"""
|
|
# F22 libxl xen still puts type=linux in the XML, so we need
|
|
# to handle it for caps lookup
|
|
if os_type == "linux":
|
|
os_type = "xen"
|
|
|
|
guest = self._guestForOSType(os_type, arch)
|
|
if not guest:
|
|
archstr = _("for arch '%s'") % arch
|
|
if not arch:
|
|
archstr = ""
|
|
|
|
osstr = _("virtualization type '%s'") % os_type
|
|
if not os_type:
|
|
osstr = _("any virtualization options")
|
|
|
|
raise ValueError(_("Host does not support %(virttype)s %(arch)s") %
|
|
{'virttype' : osstr, 'arch' : archstr})
|
|
|
|
domain = guest.bestDomainType(dtype=typ, machine=machine)
|
|
if domain is None:
|
|
machinestr = " with machine '%s'" % machine
|
|
if not machine:
|
|
machinestr = ""
|
|
raise ValueError(_("Host does not support domain type %(domain)s"
|
|
"%(machine)s for virtualization type "
|
|
"'%(virttype)s' arch '%(arch)s'") %
|
|
{'domain': typ, 'virttype': guest.os_type,
|
|
'arch': guest.arch, 'machine': machinestr})
|
|
|
|
capsinfo = _CapsInfo(self.conn, guest, domain, machine)
|
|
return capsinfo
|
|
|
|
def build_virtinst_guest(self, capsinfo):
|
|
"""
|
|
Fill in a new Guest() object from the results of guest_lookup
|
|
"""
|
|
from .guest import Guest
|
|
gobj = Guest(self.conn)
|
|
gobj.type = capsinfo.hypervisor_type
|
|
gobj.os.os_type = capsinfo.os_type
|
|
gobj.os.arch = capsinfo.arch
|
|
gobj.os.loader = capsinfo.loader
|
|
gobj.emulator = capsinfo.emulator
|
|
|
|
gobj.os.machine = capsinfo.get_recommended_machine()
|
|
|
|
gobj.capsinfo = capsinfo
|
|
|
|
return gobj
|
|
|
|
def lookup_virtinst_guest(self, *args, **kwargs):
|
|
"""
|
|
Call guest_lookup and pass the results to build_virtinst_guest.
|
|
|
|
This is a shortcut for API users that don't need to do anything
|
|
with the output from guest_lookup
|
|
"""
|
|
capsinfo = self.guest_lookup(*args, **kwargs)
|
|
return self.build_virtinst_guest(capsinfo)
|