X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/cd04dfd2e90934ede083a48aa6817083e0e478aa..bc0a2284f152b87004912daa7727da648b1a12f4:/lib/hypervisor/hv_kvm.py diff --git a/lib/hypervisor/hv_kvm.py b/lib/hypervisor/hv_kvm.py index 20fddca..4979818 100644 --- a/lib/hypervisor/hv_kvm.py +++ b/lib/hypervisor/hv_kvm.py @@ -1,7 +1,7 @@ # # -# Copyright (C) 2008, 2009, 2010, 2011, 2012 Google Inc. +# Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013 Google Inc. # # 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 @@ -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. @@ -139,39 +155,15 @@ def _OpenTap(vnet_hdr=True): try: res = fcntl.ioctl(tapfd, TUNSETIFF, ifr) - except EnvironmentError: - raise errors.HypervisorError("Failed to allocate a new TAP device") + except EnvironmentError, err: + raise errors.HypervisorError("Failed to allocate a new TAP device: %s" % + err) # Get the interface name from the ioctl ifname = struct.unpack("16sh", res)[0].strip("\x00") return (ifname, tapfd) -def _BuildNetworkEnv(name, network, gateway, network6, gateway6, - network_type, mac_prefix, tags, env): - """Build environment variables concerning a Network. - - """ - if name: - env["NETWORK_NAME"] = name - if network: - env["NETWORK_SUBNET"] = network - if gateway: - env["NETWORK_GATEWAY"] = gateway - if network6: - env["NETWORK_SUBNET6"] = network6 - if gateway6: - env["NETWORK_GATEWAY6"] = gateway6 - if mac_prefix: - env["NETWORK_MAC_PREFIX"] = mac_prefix - if network_type: - env["NETWORK_TYPE"] = network_type - if tags: - env["NETWORK_TAGS"] = " ".join(tags) - - return env - - class QmpMessage: """QEMU Messaging Protocol (QMP) message. @@ -308,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 @@ -468,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, @@ -481,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: @@ -572,11 +560,14 @@ class KVMHypervisor(hv_base.BaseHypervisor): _ENABLE_KVM_RE = re.compile(r"^-enable-kvm\s", re.M) _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 @@ -1229,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. @@ -1267,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)) @@ -1284,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] @@ -1339,15 +1352,22 @@ 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) kvm_cmd.extend(["-spice", spice_arg]) else: - kvm_cmd.extend(["-nographic"]) + # From qemu 1.4 -nographic is incompatible with -daemonize. The new way + # also works in earlier versions though (tested with 1.1 and 1.3) + if self._DISPLAY_RE.search(kvmhelp): + kvm_cmd.extend(["-display", "none"]) + else: + kvm_cmd.extend(["-nographic"]) if hvp[constants.HV_USE_LOCALTIME]: kvm_cmd.extend(["-localtime"]) @@ -1375,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]]) @@ -1528,7 +1552,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): kvm_supports_netdev = self._NETDEV_RE.search(kvmhelp) for nic_seq, nic in enumerate(kvm_nics): - tapname, tapfd = _OpenTap(vnet_hdr) + tapname, tapfd = _OpenTap(vnet_hdr=vnet_hdr) tapfds.append(tapfd) taps.append(tapname) if kvm_supports_netdev: @@ -1672,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 @@ -1713,14 +1743,20 @@ class KVMHypervisor(hv_base.BaseHypervisor): def _GetKVMOutput(cls, kvm_path, option): """Return the output of a kvm invocation + @type kvm_path: string + @param kvm_path: path to the kvm executable + @type option: a key of _KVMOPTS_CMDS + @param option: kvm option to fetch the output from @return: output a supported kvm invocation @raise errors.HypervisorError: when the KVM help output cannot be retrieved """ assert option in cls._KVMOPTS_CMDS, "Invalid output option" - result = utils.RunCmd([kvm_path] + cls._KVMOPTS_CMDS[option]) - if result.failed: + optlist, can_fail = cls._KVMOPTS_CMDS[option] + + result = utils.RunCmd([kvm_path] + optlist) + if result.failed and not can_fail: raise errors.HypervisorError("Unable to get KVM %s output" % " ".join(cls._KVMOPTS_CMDS[option])) return result.output @@ -1858,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 @@ -1959,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 @@ -2016,22 +2057,28 @@ 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 """ - # FIXME: this is the global kvm version, but the actual version can be - # customized as an hv parameter. we should use the nodegroup's default kvm - # path parameter here. + msgs = [] + # FIXME: this is the global kvm binary, but the actual path can be + # customized as an hv parameter; we should use the nodegroup's + # default kvm path parameter here. if not os.path.exists(constants.KVM_PATH): - return "The KVM binary ('%s') does not exist" % constants.KVM_PATH + msgs.append("The KVM binary ('%s') does not exist" % constants.KVM_PATH) if not os.path.exists(constants.SOCAT_PATH): - return "The socat binary ('%s') does not exist" % constants.SOCAT_PATH - return None + msgs.append("The socat binary ('%s') does not exist" % + constants.SOCAT_PATH) + + return self._FormatVerifyResults(msgs) @classmethod def CheckParameterSyntax(cls, hvparams): @@ -2089,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: @@ -2103,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 @@ -2127,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) @@ -2158,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()