X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/81e265f54a4fd3a3a2d05e668c3c31f12d95d5d1..bc0a2284f152b87004912daa7727da648b1a12f4:/lib/hypervisor/hv_kvm.py diff --git a/lib/hypervisor/hv_kvm.py b/lib/hypervisor/hv_kvm.py index 6939bcb..4979818 100644 --- a/lib/hypervisor/hv_kvm.py +++ b/lib/hypervisor/hv_kvm.py @@ -80,7 +80,24 @@ _SPICE_ADDITIONAL_PARAMS = frozenset([ ]) -def _ProbeTapVnetHdr(fd): +def _GetTunFeatures(fd, _ioctl=fcntl.ioctl): + """Retrieves supported TUN features from file descriptor. + + @see: L{_ProbeTapVnetHdr} + + """ + req = struct.pack("I", 0) + try: + buf = _ioctl(fd, TUNGETFEATURES, req) + except EnvironmentError, err: + logging.warning("ioctl(TUNGETFEATURES) failed: %s", err) + return None + else: + (flags, ) = struct.unpack("I", buf) + return flags + + +def _ProbeTapVnetHdr(fd, _features_fn=_GetTunFeatures): """Check whether to enable the IFF_VNET_HDR flag. To do this, _all_ of the following conditions must be met: @@ -97,20 +114,19 @@ def _ProbeTapVnetHdr(fd): @param fd: the file descriptor of /dev/net/tun """ - req = struct.pack("I", 0) - try: - res = fcntl.ioctl(fd, TUNGETFEATURES, req) - except EnvironmentError: - logging.warning("TUNGETFEATURES ioctl() not implemented") - return False + flags = _features_fn(fd) - tunflags = struct.unpack("I", res)[0] - if tunflags & IFF_VNET_HDR: - return True - else: - logging.warning("Host does not support IFF_VNET_HDR, not enabling") + if flags is None: + # Not supported return False + result = bool(flags & IFF_VNET_HDR) + + if not result: + logging.warning("Kernel does not support IFF_VNET_HDR, not enabling") + + return result + def _OpenTap(vnet_hdr=True): """Open a new tap device and return its file descriptor. @@ -284,7 +300,7 @@ class QmpConnection: greeting = self._Recv() if not greeting[self._FIRST_MESSAGE_KEY]: self._connected = False - raise errors.HypervisorError("kvm: qmp communication error (wrong" + raise errors.HypervisorError("kvm: QMP communication error (wrong" " server greeting") # Let's put the monitor in command mode using the qmp_capabilities @@ -444,11 +460,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): constants.HV_ACPI: hv_base.NO_CHECK, constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK, constants.HV_SERIAL_SPEED: hv_base.NO_CHECK, - constants.HV_VNC_BIND_ADDRESS: - (False, lambda x: (netutils.IP4Address.IsValid(x) or - utils.IsNormAbsPath(x)), - "the VNC bind address must be either a valid IP address or an absolute" - " pathname", None, None), + constants.HV_VNC_BIND_ADDRESS: hv_base.NO_CHECK, # will be checked later constants.HV_VNC_TLS: hv_base.NO_CHECK, constants.HV_VNC_X509: hv_base.OPT_DIR_CHECK, constants.HV_VNC_X509_VERIFY: hv_base.NO_CHECK, @@ -457,7 +469,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): constants.HV_KVM_SPICE_IP_VERSION: (False, lambda x: (x == constants.IFACE_NO_IP_VERSION_SPECIFIED or x in constants.VALID_IP_VERSIONS), - "the SPICE IP version should be 4 or 6", + "The SPICE IP version should be 4 or 6", None, None), constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK, constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR: @@ -549,11 +561,13 @@ class KVMHypervisor(hv_base.BaseHypervisor): _DISABLE_KVM_RE = re.compile(r"^-disable-kvm\s", re.M) _NETDEV_RE = re.compile(r"^-netdev\s", re.M) _DISPLAY_RE = re.compile(r"^-display\s", re.M) + _MACHINE_RE = re.compile(r"^-machine\s", re.M) _NEW_VIRTIO_RE = re.compile(r"^name \"%s\"" % _VIRTIO_NET_PCI, re.M) # match -drive.*boot=on|off on different lines, but in between accept only # dashes not preceeded by a new line (which would mean another option # different than -drive is starting) _BOOT_RE = re.compile(r"^-drive\s([^-]|(? constants.VNC_BASE_PORT: display = instance.network_port - constants.VNC_BASE_PORT @@ -1206,9 +1242,9 @@ class KVMHypervisor(hv_base.BaseHypervisor): else: vnc_arg = "%s:%d" % (vnc_bind_address, display) else: - logging.error("Network port is not a valid VNC display (%d < %d)." - " Not starting VNC", instance.network_port, - constants.VNC_BASE_PORT) + logging.error("Network port is not a valid VNC display (%d < %d)," + " not starting VNC", + instance.network_port, constants.VNC_BASE_PORT) vnc_arg = "none" # Only allow tls and other option when not binding to a file, for now. @@ -1244,7 +1280,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): # have that kind of IP addresses, throw an exception if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED: if not addresses[spice_ip_version]: - raise errors.HypervisorError("spice: unable to get an IPv%s address" + raise errors.HypervisorError("SPICE: Unable to get an IPv%s address" " for %s" % (spice_ip_version, spice_bind)) @@ -1261,7 +1297,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): elif addresses[constants.IP6_VERSION]: spice_ip_version = constants.IP6_VERSION else: - raise errors.HypervisorError("spice: unable to get an IP address" + raise errors.HypervisorError("SPICE: Unable to get an IP address" " for %s" % (spice_bind)) spice_address = addresses[spice_ip_version][0] @@ -1316,8 +1352,10 @@ class KVMHypervisor(hv_base.BaseHypervisor): # Enable the spice agent communication channel between the host and the # agent. kvm_cmd.extend(["-device", "virtio-serial-pci"]) - kvm_cmd.extend(["-device", "virtserialport,chardev=spicechannel0," - "name=com.redhat.spice.0"]) + kvm_cmd.extend([ + "-device", + "virtserialport,chardev=spicechannel0,name=com.redhat.spice.0", + ]) kvm_cmd.extend(["-chardev", "spicevmc,id=spicechannel0,name=vdagent"]) logging.info("KVM: SPICE will listen on port %s", instance.network_port) @@ -1357,6 +1395,10 @@ class KVMHypervisor(hv_base.BaseHypervisor): for dev in hvp[constants.HV_USB_DEVICES].split(","): kvm_cmd.extend(["-usbdevice", dev]) + # Set system UUID to instance UUID + if self._UUID_RE.search(kvmhelp): + kvm_cmd.extend(["-uuid", instance.uuid]) + if hvp[constants.HV_KVM_EXTRA]: kvm_cmd.extend([hvp[constants.HV_KVM_EXTRA]]) @@ -1654,16 +1696,22 @@ class KVMHypervisor(hv_base.BaseHypervisor): """Invoke a command on the instance monitor. """ + # TODO: Replace monitor calls with QMP once KVM >= 0.14 is the minimum + # version. The monitor protocol is designed for human consumption, whereas + # QMP is made for programmatic usage. In the worst case QMP can also + # execute monitor commands. As it is, all calls to socat take at least + # 500ms and likely more: socat can't detect the end of the reply and waits + # for 500ms of no data received before exiting (500 ms is the default for + # the "-t" parameter). socat = ("echo %s | %s STDIO UNIX-CONNECT:%s" % (utils.ShellQuote(command), constants.SOCAT_PATH, utils.ShellQuote(self._InstanceMonitor(instance_name)))) result = utils.RunCmd(socat) if result.failed: - msg = ("Failed to send command '%s' to instance %s." - " output: %s, error: %s, fail_reason: %s" % - (command, instance_name, - result.stdout, result.stderr, result.fail_reason)) + msg = ("Failed to send command '%s' to instance '%s', reason '%s'," + " output: %s" % + (command, instance_name, result.fail_reason, result.output)) raise errors.HypervisorError(msg) return result @@ -1846,12 +1894,14 @@ class KVMHypervisor(hv_base.BaseHypervisor): else: self.StopInstance(instance, force=True) - def MigrateInstance(self, instance, target, live): + def MigrateInstance(self, cluster_name, instance, target, live): """Migrate an instance to a target node. The migration will not be attempted if the instance is not currently running. + @type cluster_name: string + @param cluster_name: name of the cluster @type instance: L{objects.Instance} @param instance: the instance to be migrated @type target: string @@ -1947,9 +1997,12 @@ class KVMHypervisor(hv_base.BaseHypervisor): """ self._CallMonitorCommand(instance.name, "balloon %d" % mem) - def GetNodeInfo(self): + def GetNodeInfo(self, hvparams=None): """Return information about the node. + @type hvparams: dict of strings + @param hvparams: hypervisor parameters, not used in this class + @return: a dict with the following keys (values in MiB): - memory_total: the total memory size on the node - memory_free: the available memory on the node for instances @@ -2004,11 +2057,14 @@ class KVMHypervisor(hv_base.BaseHypervisor): message=("No serial shell for instance %s" % instance.name)) - def Verify(self): + def Verify(self, hvparams=None): """Verify the hypervisor. Check that the required binaries exist. + @type hvparams: dict of strings + @param hvparams: hypervisor parameters to be verified against, not used here + @return: Problem description if something is wrong, C{None} otherwise """ @@ -2080,13 +2136,13 @@ class KVMHypervisor(hv_base.BaseHypervisor): # IP of that family if (netutils.IP4Address.IsValid(spice_bind) and spice_ip_version != constants.IP4_VERSION): - raise errors.HypervisorError("spice: got an IPv4 address (%s), but" + raise errors.HypervisorError("SPICE: Got an IPv4 address (%s), but" " the specified IP version is %s" % (spice_bind, spice_ip_version)) if (netutils.IP6Address.IsValid(spice_bind) and spice_ip_version != constants.IP6_VERSION): - raise errors.HypervisorError("spice: got an IPv6 address (%s), but" + raise errors.HypervisorError("SPICE: Got an IPv6 address (%s), but" " the specified IP version is %s" % (spice_bind, spice_ip_version)) else: @@ -2094,7 +2150,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): # error if any of them is set without it. for param in _SPICE_ADDITIONAL_PARAMS: if hvparams[param]: - raise errors.HypervisorError("spice: %s requires %s to be set" % + raise errors.HypervisorError("SPICE: %s requires %s to be set" % (param, constants.HV_KVM_SPICE_BIND)) @classmethod @@ -2118,26 +2174,36 @@ class KVMHypervisor(hv_base.BaseHypervisor): except KeyError: raise errors.HypervisorError("Unknown security domain user %s" % username) + vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS] + if vnc_bind_address: + bound_to_addr = netutils.IP4Address.IsValid(vnc_bind_address) + is_interface = netutils.IsValidInterface(vnc_bind_address) + is_path = utils.IsNormAbsPath(vnc_bind_address) + if not bound_to_addr and not is_interface and not is_path: + raise errors.HypervisorError("VNC: The %s parameter must be either" + " a valid IP address, an interface name," + " or an absolute path" % + constants.HV_KVM_SPICE_BIND) spice_bind = hvparams[constants.HV_KVM_SPICE_BIND] if spice_bind: # only one of VNC and SPICE can be used currently. if hvparams[constants.HV_VNC_BIND_ADDRESS]: - raise errors.HypervisorError("both SPICE and VNC are configured, but" + raise errors.HypervisorError("Both SPICE and VNC are configured, but" " only one of them can be used at a" - " given time.") + " given time") # check that KVM supports SPICE kvmhelp = cls._GetKVMOutput(kvm_path, cls._KVMOPT_HELP) if not cls._SPICE_RE.search(kvmhelp): - raise errors.HypervisorError("spice is configured, but it is not" - " supported according to kvm --help") + raise errors.HypervisorError("SPICE is configured, but it is not" + " supported according to 'kvm --help'") # if spice_bind is not an IP address, it must be a valid interface - bound_to_addr = (netutils.IP4Address.IsValid(spice_bind) - or netutils.IP6Address.IsValid(spice_bind)) + bound_to_addr = (netutils.IP4Address.IsValid(spice_bind) or + netutils.IP6Address.IsValid(spice_bind)) if not bound_to_addr and not netutils.IsValidInterface(spice_bind): - raise errors.HypervisorError("spice: the %s parameter must be either" + raise errors.HypervisorError("SPICE: The %s parameter must be either" " a valid IP address or interface name" % constants.HV_KVM_SPICE_BIND) @@ -2149,8 +2215,11 @@ class KVMHypervisor(hv_base.BaseHypervisor): machine_version) @classmethod - def PowercycleNode(cls): + def PowercycleNode(cls, hvparams=None): """KVM powercycle, just a wrapper over Linux powercycle. + @type hvparams: dict of strings + @param hvparams: hypervisor params to be used on this node + """ cls.LinuxPowercycle()