X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/a2faf9ee552bf7f0bbb7e03e0be05562763fcb01..e1876432f740aa4937efc64fa1aa496b1bc341d3:/lib/hypervisor/hv_kvm.py diff --git a/lib/hypervisor/hv_kvm.py b/lib/hypervisor/hv_kvm.py index 48a8850..3dec178 100644 --- a/lib/hypervisor/hv_kvm.py +++ b/lib/hypervisor/hv_kvm.py @@ -52,8 +52,18 @@ class KVMHypervisor(hv_base.BaseHypervisor): constants.HV_KERNEL_PATH, constants.HV_INITRD_PATH, constants.HV_ROOT_PATH, + constants.HV_KERNEL_ARGS, constants.HV_ACPI, constants.HV_SERIAL_CONSOLE, + constants.HV_VNC_BIND_ADDRESS, + constants.HV_VNC_TLS, + constants.HV_VNC_X509, + constants.HV_VNC_X509_VERIFY, + constants.HV_CDROM_IMAGE_PATH, + constants.HV_BOOT_ORDER, + constants.HV_NIC_TYPE, + constants.HV_DISK_TYPE, + constants.HV_USB_MOUSE, ] _MIGRATION_STATUS_RE = re.compile('Migration\s+status:\s+(\w+)', @@ -63,9 +73,8 @@ class KVMHypervisor(hv_base.BaseHypervisor): hv_base.BaseHypervisor.__init__(self) # Let's make sure the directories we need exist, even if the RUN_DIR lives # in a tmpfs filesystem or has been otherwise wiped out. - for mydir in self._DIRS: - if not os.path.exists(mydir): - os.mkdir(mydir) + dirs = [(dir, constants.RUN_DIRS_MODE) for dir in self._DIRS] + utils.EnsureDirs(dirs) def _InstancePidAlive(self, instance_name): """Returns the instance pid and pidfile @@ -185,9 +194,9 @@ class KVMHypervisor(hv_base.BaseHypervisor): while arg_list: arg = arg_list.pop(0) if arg == '-m': - memory = arg_list.pop(0) + memory = int(arg_list.pop(0)) elif arg == '-smp': - vcpus = arg_list.pop(0) + vcpus = int(arg_list.pop(0)) return (instance_name, pid, memory, vcpus, stat, times) @@ -201,11 +210,16 @@ class KVMHypervisor(hv_base.BaseHypervisor): for name in os.listdir(self._PIDS_DIR): filename = "%s/%s" % (self._PIDS_DIR, name) if utils.IsProcessAlive(utils.ReadPidFile(filename)): - data.append(self.GetInstanceInfo(name)) + try: + info = self.GetInstanceInfo(name) + except errors.HypervisorError, err: + continue + if info: + data.append(info) return data - def _GenerateKVMRuntime(self, instance, block_devices, extra_args): + def _GenerateKVMRuntime(self, instance, block_devices): """Generate KVM information to start an instance. """ @@ -221,49 +235,106 @@ class KVMHypervisor(hv_base.BaseHypervisor): if not instance.hvparams[constants.HV_ACPI]: kvm_cmd.extend(['-no-acpi']) - boot_drive = True + hvp = instance.hvparams + boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK + boot_cdrom = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_CDROM + boot_network = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_NETWORK + + if boot_network: + kvm_cmd.extend(['-boot', 'n']) + + disk_type = hvp[constants.HV_DISK_TYPE] + if disk_type == constants.HT_DISK_PARAVIRTUAL: + if_val = ',if=virtio' + else: + if_val = ',if=%s' % disk_type for cfdev, dev_path in block_devices: if cfdev.mode != constants.DISK_RDWR: raise errors.HypervisorError("Instance has read-only disks which" " are not supported by KVM") # TODO: handle FD_LOOP and FD_BLKTAP (?) - if boot_drive: + if boot_disk: + kvm_cmd.extend(['-boot', 'c']) boot_val = ',boot=on' - boot_drive = False + # We only boot from the first disk + boot_disk = False else: boot_val = '' - # TODO: handle different if= types - if_val = ',if=virtio' - drive_val = 'file=%s,format=raw%s%s' % (dev_path, if_val, boot_val) kvm_cmd.extend(['-drive', drive_val]) - kvm_cmd.extend(['-kernel', instance.hvparams[constants.HV_KERNEL_PATH]]) + iso_image = hvp[constants.HV_CDROM_IMAGE_PATH] + if iso_image: + options = ',format=raw,media=cdrom' + if boot_cdrom: + kvm_cmd.extend(['-boot', 'd']) + options = '%s,boot=on' % options + else: + options = '%s,if=virtio' % options + drive_val = 'file=%s%s' % (iso_image, options) + kvm_cmd.extend(['-drive', drive_val]) - initrd_path = instance.hvparams[constants.HV_INITRD_PATH] - if initrd_path: - kvm_cmd.extend(['-initrd', initrd_path]) + kernel_path = hvp[constants.HV_KERNEL_PATH] + if kernel_path: + kvm_cmd.extend(['-kernel', kernel_path]) + initrd_path = hvp[constants.HV_INITRD_PATH] + if initrd_path: + kvm_cmd.extend(['-initrd', initrd_path]) + root_append = ['root=%s' % hvp[constants.HV_ROOT_PATH], + hvp[constants.HV_KERNEL_ARGS]] + if hvp[constants.HV_SERIAL_CONSOLE]: + root_append.append('console=ttyS0,38400') + kvm_cmd.extend(['-append', ' '.join(root_append)]) + + mouse_type = hvp[constants.HV_USB_MOUSE] + if mouse_type: + kvm_cmd.extend(['-usb']) + kvm_cmd.extend(['-usbdevice', mouse_type]) + + # FIXME: handle vnc password + vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS] + if vnc_bind_address: + if utils.IsValidIP(vnc_bind_address): + if instance.network_port > constants.VNC_BASE_PORT: + display = instance.network_port - constants.VNC_BASE_PORT + if vnc_bind_address == '0.0.0.0': + vnc_arg = ':%d' % (display) + 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)) + vnc_arg = 'none' + + # Only allow tls and other option when not binding to a file, for now. + # kvm/qemu gets confused otherwise about the filename to use. + vnc_append = '' + if hvp[constants.HV_VNC_TLS]: + vnc_append = '%s,tls' % vnc_append + if hvp[constants.HV_VNC_X509_VERIFY]: + vnc_append = '%s,x509verify=%s' % (vnc_append, + hvp[constants.HV_VNC_X509]) + elif hvp[constants.HV_VNC_X509]: + vnc_append = '%s,x509=%s' % (vnc_append, + hvp[constants.HV_VNC_X509]) + vnc_arg = '%s%s' % (vnc_arg, vnc_append) - root_append = 'root=%s ro' % instance.hvparams[constants.HV_ROOT_PATH] - if instance.hvparams[constants.HV_SERIAL_CONSOLE]: - kvm_cmd.extend(['-append', 'console=ttyS0,38400 %s' % root_append]) - else: - kvm_cmd.extend(['-append', root_append]) + else: + vnc_arg = 'unix:%s/%s.vnc' % (vnc_bind_address, instance.name) - #"hvm_boot_order", - #"hvm_cdrom_image_path", + kvm_cmd.extend(['-vnc', vnc_arg]) + else: + kvm_cmd.extend(['-nographic']) - kvm_cmd.extend(['-nographic']) - # FIXME: handle vnc, if needed - # How do we decide whether to have it or not?? :( - #"vnc_bind_address", - #"network_port" monitor_dev = 'unix:%s,server,nowait' % \ self._InstanceMonitor(instance.name) kvm_cmd.extend(['-monitor', monitor_dev]) - if instance.hvparams[constants.HV_SERIAL_CONSOLE]: - serial_dev = 'unix:%s,server,nowait' % self._InstanceSerial(instance.name) + if hvp[constants.HV_SERIAL_CONSOLE]: + serial_dev = ('unix:%s,server,nowait' % + self._InstanceSerial(instance.name)) kvm_cmd.extend(['-serial', serial_dev]) else: kvm_cmd.extend(['-serial', 'none']) @@ -271,8 +342,9 @@ class KVMHypervisor(hv_base.BaseHypervisor): # Save the current instance nics, but defer their expansion as parameters, # as we'll need to generate executable temp files for them. kvm_nics = instance.nics + hvparams = hvp - return (kvm_cmd, kvm_nics) + return (kvm_cmd, kvm_nics, hvparams) def _WriteKVMRuntime(self, instance_name, data): """Write an instance's KVM runtime @@ -298,9 +370,9 @@ class KVMHypervisor(hv_base.BaseHypervisor): """Save an instance's KVM runtime """ - kvm_cmd, kvm_nics = kvm_runtime + kvm_cmd, kvm_nics, hvparams = kvm_runtime serialized_nics = [nic.ToDict() for nic in kvm_nics] - serialized_form = serializer.Dump((kvm_cmd, serialized_nics)) + serialized_form = serializer.Dump((kvm_cmd, serialized_nics, hvparams)) self._WriteKVMRuntime(instance.name, serialized_form) def _LoadKVMRuntime(self, instance, serialized_runtime=None): @@ -310,9 +382,9 @@ class KVMHypervisor(hv_base.BaseHypervisor): if not serialized_runtime: serialized_runtime = self._ReadKVMRuntime(instance.name) loaded_runtime = serializer.Load(serialized_runtime) - kvm_cmd, serialized_nics = loaded_runtime + kvm_cmd, serialized_nics, hvparams = loaded_runtime kvm_nics = [objects.NIC.FromDict(snic) for snic in serialized_nics] - return (kvm_cmd, kvm_nics) + return (kvm_cmd, kvm_nics, hvparams) def _ExecuteKVMRuntime(self, instance, kvm_runtime, incoming=None): """Execute a KVM cmd, after completing it with some last minute data @@ -328,13 +400,19 @@ class KVMHypervisor(hv_base.BaseHypervisor): temp_files = [] - kvm_cmd, kvm_nics = kvm_runtime + kvm_cmd, kvm_nics, hvparams = kvm_runtime if not kvm_nics: kvm_cmd.extend(['-net', 'none']) else: + nic_type = hvparams[constants.HV_NIC_TYPE] + if nic_type == constants.HT_NIC_PARAVIRTUAL: + nic_model = "model=virtio" + else: + nic_model = "model=%s" % nic_type + for nic_seq, nic in enumerate(kvm_nics): - nic_val = "nic,macaddr=%s,model=virtio" % nic.mac + nic_val = "nic,macaddr=%s,%s" % (nic.mac, nic_model) script = self._WriteNetScript(instance, nic_seq, nic) kvm_cmd.extend(['-net', nic_val]) kvm_cmd.extend(['-net', 'tap,script=%s' % script]) @@ -357,7 +435,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): for filename in temp_files: utils.RemoveFile(filename) - def StartInstance(self, instance, block_devices, extra_args): + def StartInstance(self, instance, block_devices): """Start an instance. """ @@ -366,7 +444,7 @@ class KVMHypervisor(hv_base.BaseHypervisor): raise errors.HypervisorError("Failed to start instance %s: %s" % (instance.name, "already running")) - kvm_runtime = self._GenerateKVMRuntime(instance, block_devices, extra_args) + kvm_runtime = self._GenerateKVMRuntime(instance, block_devices) self._SaveKVMRuntime(instance, kvm_runtime) self._ExecuteKVMRuntime(instance, kvm_runtime) @@ -382,7 +460,8 @@ class KVMHypervisor(hv_base.BaseHypervisor): if result.failed: msg = ("Failed to send command '%s' to instance %s." " output: %s, error: %s, fail_reason: %s" % - (instance.name, result.stdout, result.stderr, result.fail_reason)) + (command, instance_name, + result.stdout, result.stderr, result.fail_reason)) raise errors.HypervisorError(msg) return result @@ -539,54 +618,15 @@ class KVMHypervisor(hv_base.BaseHypervisor): def GetNodeInfo(self): """Return information about the node. + This is just a wrapper over the base GetLinuxNodeInfo method. + @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 - memory_dom0: the memory used by the node itself, if available """ - # global ram usage from the xm info command - # memory : 3583 - # free_memory : 747 - # note: in xen 3, memory has changed to total_memory - try: - fh = file("/proc/meminfo") - try: - data = fh.readlines() - finally: - fh.close() - except EnvironmentError, err: - raise errors.HypervisorError("Failed to list node info: %s" % err) - - result = {} - sum_free = 0 - for line in data: - splitfields = line.split(":", 1) - - if len(splitfields) > 1: - key = splitfields[0].strip() - val = splitfields[1].strip() - if key == 'MemTotal': - result['memory_total'] = int(val.split()[0])/1024 - elif key in ('MemFree', 'Buffers', 'Cached'): - sum_free += int(val.split()[0])/1024 - elif key == 'Active': - result['memory_dom0'] = int(val.split()[0])/1024 - result['memory_free'] = sum_free - - cpu_total = 0 - try: - fh = open("/proc/cpuinfo") - try: - cpu_total = len(re.findall("(?m)^processor\s*:\s*[0-9]+\s*$", - fh.read())) - finally: - fh.close() - except EnvironmentError, err: - raise errors.HypervisorError("Failed to list node info: %s" % err) - result['cpu_total'] = cpu_total - - return result + return self.GetLinuxNodeInfo() @classmethod def GetShellCommandForConsole(cls, instance, hvparams, beparams): @@ -606,6 +646,17 @@ class KVMHypervisor(hv_base.BaseHypervisor): utils.ShellQuote(cls._InstanceSerial(instance.name)))) else: shell_command = "echo 'No serial shell for instance %s'" % instance.name + + vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS] + if vnc_bind_address: + if instance.network_port > constants.VNC_BASE_PORT: + display = instance.network_port - constants.VNC_BASE_PORT + vnc_command = ("echo 'Instance has VNC listening on %s:%d" + " (display: %d)'" % (vnc_bind_address, + instance.network_port, + display)) + shell_command = "%s; %s" % (vnc_command, shell_command) + return shell_command def Verify(self): @@ -624,9 +675,6 @@ class KVMHypervisor(hv_base.BaseHypervisor): def CheckParameterSyntax(cls, hvparams): """Check the given parameters for validity. - For the KVM hypervisor, this only check the existence of the - kernel. - @type hvparams: dict @param hvparams: dictionary with parameter names/value @raise errors.HypervisorError: when a parameter is not valid @@ -634,20 +682,81 @@ class KVMHypervisor(hv_base.BaseHypervisor): """ super(KVMHypervisor, cls).CheckParameterSyntax(hvparams) - if not hvparams[constants.HV_KERNEL_PATH]: - raise errors.HypervisorError("Need a kernel for the instance") - - if not os.path.isabs(hvparams[constants.HV_KERNEL_PATH]): - raise errors.HypervisorError("The kernel path must be an absolute path") + kernel_path = hvparams[constants.HV_KERNEL_PATH] + if kernel_path: + if not os.path.isabs(hvparams[constants.HV_KERNEL_PATH]): + raise errors.HypervisorError("The kernel path must be an absolute path" + ", if defined") - if not hvparams[constants.HV_ROOT_PATH]: - raise errors.HypervisorError("Need a root partition for the instance") + if not hvparams[constants.HV_ROOT_PATH]: + raise errors.HypervisorError("Need a root partition for the instance" + ", if a kernel is defined") if hvparams[constants.HV_INITRD_PATH]: if not os.path.isabs(hvparams[constants.HV_INITRD_PATH]): - raise errors.HypervisorError("The initrd path must be an absolute path" + raise errors.HypervisorError("The initrd path must an absolute path" ", if defined") + vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS] + if vnc_bind_address: + if not utils.IsValidIP(vnc_bind_address): + if not os.path.isabs(vnc_bind_address): + raise errors.HypervisorError("The VNC bind address must be either" + " a valid IP address or an absolute" + " pathname. '%s' given" % + vnc_bind_address) + + if hvparams[constants.HV_VNC_X509_VERIFY] and \ + not hvparams[constants.HV_VNC_X509]: + raise errors.HypervisorError("%s must be defined, if %s is" % + (constants.HV_VNC_X509, + constants.HV_VNC_X509_VERIFY)) + + if hvparams[constants.HV_VNC_X509]: + if not os.path.isabs(hvparams[constants.HV_VNC_X509]): + raise errors.HypervisorError("The vnc x509 path must an absolute path" + ", if defined") + + iso_path = hvparams[constants.HV_CDROM_IMAGE_PATH] + if iso_path and not os.path.isabs(iso_path): + raise errors.HypervisorError("The path to the CDROM image must be" + " an absolute path, if defined") + + boot_order = hvparams[constants.HV_BOOT_ORDER] + if boot_order not in constants.HT_KVM_VALID_BO_TYPES: + raise errors.HypervisorError(\ + "The boot order must be one of %s" % + utils.CommaJoin(constants.HT_KVM_VALID_BO_TYPES)) + + if boot_order == constants.HT_BO_CDROM and not iso_path: + raise errors.HypervisorError("Cannot boot from cdrom without an" + " ISO path") + + nic_type = hvparams[constants.HV_NIC_TYPE] + if nic_type not in constants.HT_KVM_VALID_NIC_TYPES: + raise errors.HypervisorError(\ + "Invalid NIC type %s specified for the KVM" + " hypervisor. Please choose one of: %s" % + (nic_type, utils.CommaJoin(constants.HT_KVM_VALID_NIC_TYPES))) + elif (boot_order == constants.HT_BO_NETWORK and + nic_type == constants.HT_NIC_PARAVIRTUAL): + raise errors.HypervisorError("Cannot boot from a paravirtual NIC. Please" + " change the NIC type.") + + disk_type = hvparams[constants.HV_DISK_TYPE] + if disk_type not in constants.HT_KVM_VALID_DISK_TYPES: + raise errors.HypervisorError(\ + "Invalid disk type %s specified for the KVM" + " hypervisor. Please choose one of: %s" % + (disk_type, utils.CommaJoin(constants.HT_KVM_VALID_DISK_TYPES))) + + mouse_type = hvparams[constants.HV_USB_MOUSE] + if mouse_type and mouse_type not in constants.HT_KVM_VALID_MOUSE_TYPES: + raise errors.HypervisorError(\ + "Invalid usb mouse type %s specified for the KVM hypervisor. Please" + " choose one of %s" % + utils.CommaJoin(constants.HT_KVM_VALID_MOUSE_TYPES)) + def ValidateParameters(self, hvparams): """Check the given parameters for validity. @@ -658,10 +767,26 @@ class KVMHypervisor(hv_base.BaseHypervisor): super(KVMHypervisor, self).ValidateParameters(hvparams) kernel_path = hvparams[constants.HV_KERNEL_PATH] - if not os.path.isfile(kernel_path): + if kernel_path and not os.path.isfile(kernel_path): raise errors.HypervisorError("Instance kernel '%s' not found or" " not a file" % kernel_path) initrd_path = hvparams[constants.HV_INITRD_PATH] if initrd_path and not os.path.isfile(initrd_path): raise errors.HypervisorError("Instance initrd '%s' not found or" " not a file" % initrd_path) + + vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS] + if vnc_bind_address and not utils.IsValidIP(vnc_bind_address) and \ + not os.path.isdir(vnc_bind_address): + raise errors.HypervisorError("Instance vnc bind address must be either" + " an ip address or an existing directory") + + vnc_x509 = hvparams[constants.HV_VNC_X509] + if vnc_x509 and not os.path.isdir(vnc_x509): + raise errors.HypervisorError("Instance vnc x509 path '%s' not found" + " or not a directory" % vnc_x509) + + iso_path = hvparams[constants.HV_CDROM_IMAGE_PATH] + if iso_path and not os.path.isfile(iso_path): + raise errors.HypervisorError("Instance cdrom image '%s' not found or" + " not a file" % iso_path)