X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/622533d5539f892c08a99c9035e81c6d3979f9b9..9d9bded1ab0e8ee7d224abbb307fa0f064c9a14f:/lib/hypervisor/hv_xen.py diff --git a/lib/hypervisor/hv_xen.py b/lib/hypervisor/hv_xen.py index 9779e51..7274240 100644 --- a/lib/hypervisor/hv_xen.py +++ b/lib/hypervisor/hv_xen.py @@ -1,7 +1,7 @@ # # -# Copyright (C) 2006, 2007, 2008 Google Inc. +# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 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 @@ -23,9 +23,6 @@ """ -import os -import os.path -import time import logging from cStringIO import StringIO @@ -33,6 +30,15 @@ from ganeti import constants from ganeti import errors from ganeti import utils from ganeti.hypervisor import hv_base +from ganeti import netutils +from ganeti import objects +from ganeti import pathutils + + +XEND_CONFIG_FILE = "/etc/xen/xend-config.sxp" +XL_CONFIG_FILE = "/etc/xen/xl.conf" +VIF_BRIDGE_SCRIPT = "/etc/xen/scripts/vif-bridge" +_DOM0_NAME = "Domain-0" class XenHypervisor(hv_base.BaseHypervisor): @@ -42,11 +48,33 @@ class XenHypervisor(hv_base.BaseHypervisor): all the functionality that is identical for both. """ + CAN_MIGRATE = True REBOOT_RETRY_COUNT = 60 REBOOT_RETRY_INTERVAL = 10 + ANCILLARY_FILES = [ + XEND_CONFIG_FILE, + XL_CONFIG_FILE, + VIF_BRIDGE_SCRIPT, + ] + ANCILLARY_FILES_OPT = [ + XL_CONFIG_FILE, + ] + + @staticmethod + def _ConfigFileName(instance_name): + """Get the config file name for an instance. + + @param instance_name: instance name + @type instance_name: str + @return: fully qualified path to instance config file + @rtype: str + + """ + return "/etc/xen/%s" % instance_name + @classmethod - def _WriteConfigFile(cls, instance, block_devices): + def _WriteConfigFile(cls, instance, startup_memory, block_devices): """Write the Xen config file for the instance. """ @@ -59,7 +87,14 @@ class XenHypervisor(hv_base.BaseHypervisor): This version of the function just writes the config file from static data. """ - utils.WriteFile("/etc/xen/%s" % instance_name, data=data) + # just in case it exists + utils.RemoveFile("/etc/xen/auto/%s" % instance_name) + cfg_file = XenHypervisor._ConfigFileName(instance_name) + try: + utils.WriteFile(cfg_file, data=data) + except EnvironmentError, err: + raise errors.HypervisorError("Cannot write Xen instance configuration" + " file %s: %s" % (cfg_file, err)) @staticmethod def _ReadConfigFile(instance_name): @@ -67,7 +102,8 @@ class XenHypervisor(hv_base.BaseHypervisor): """ try: - file_content = utils.ReadFile("/etc/xen/%s" % instance_name) + file_content = utils.ReadFile( + XenHypervisor._ConfigFileName(instance_name)) except EnvironmentError, err: raise errors.HypervisorError("Failed to load Xen config file: %s" % err) return file_content @@ -77,10 +113,57 @@ class XenHypervisor(hv_base.BaseHypervisor): """Remove the xen configuration file. """ - utils.RemoveFile("/etc/xen/%s" % instance_name) + utils.RemoveFile(XenHypervisor._ConfigFileName(instance_name)) + + @classmethod + def _CreateConfigCpus(cls, cpu_mask): + """Create a CPU config string that's compatible with Xen's + configuration file. + + """ + # Convert the string CPU mask to a list of list of int's + cpu_list = utils.ParseMultiCpuMask(cpu_mask) + + if len(cpu_list) == 1: + all_cpu_mapping = cpu_list[0] + if all_cpu_mapping == constants.CPU_PINNING_OFF: + # If CPU pinning has 1 entry that's "all", then remove the + # parameter from the config file + return None + else: + # If CPU pinning has one non-all entry, mapping all vCPUS (the entire + # VM) to one physical CPU, using format 'cpu = "C"' + return "cpu = \"%s\"" % ",".join(map(str, all_cpu_mapping)) + else: + def _GetCPUMap(vcpu): + if vcpu[0] == constants.CPU_PINNING_ALL_VAL: + cpu_map = constants.CPU_PINNING_ALL_XEN + else: + cpu_map = ",".join(map(str, vcpu)) + return "\"%s\"" % cpu_map + + # build the result string in format 'cpus = [ "c", "c", "c" ]', + # where each c is a physical CPU number, a range, a list, or any + # combination + return "cpus = [ %s ]" % ", ".join(map(_GetCPUMap, cpu_list)) @staticmethod - def _GetXMList(include_node): + def _RunXmList(xmlist_errors): + """Helper function for L{_GetXMList} to run "xm list". + + """ + result = utils.RunCmd([constants.XEN_CMD, "list"]) + if result.failed: + logging.error("xm list failed (%s): %s", result.fail_reason, + result.output) + xmlist_errors.append(result) + raise utils.RetryAgain() + + # skip over the heading + return result.stdout.splitlines()[1:] + + @classmethod + def _GetXMList(cls, include_node): """Return the list of running instances. If the include_node argument is True, then we return information @@ -89,21 +172,20 @@ class XenHypervisor(hv_base.BaseHypervisor): @return: list of (name, id, memory, vcpus, state, time spent) """ - for dummy in range(5): - result = utils.RunCmd(["xm", "list"]) - if not result.failed: - break - logging.error("xm list failed (%s): %s", result.fail_reason, - result.output) - time.sleep(1) + xmlist_errors = [] + try: + lines = utils.Retry(cls._RunXmList, 1, 5, args=(xmlist_errors, )) + except utils.RetryTimeout: + if xmlist_errors: + xmlist_result = xmlist_errors.pop() - if result.failed: - raise errors.HypervisorError("xm list failed, retries" - " exceeded (%s): %s" % - (result.fail_reason, result.output)) + errmsg = ("xm list failed, timeout exceeded (%s): %s" % + (xmlist_result.fail_reason, xmlist_result.output)) + else: + errmsg = "xm list failed" + + raise errors.HypervisorError(errmsg) - # skip over the heading - lines = result.stdout.splitlines()[1:] result = [] for line in lines: # The format of lines is: @@ -118,12 +200,12 @@ class XenHypervisor(hv_base.BaseHypervisor): data[2] = int(data[2]) data[3] = int(data[3]) data[5] = float(data[5]) - except ValueError, err: + except (TypeError, ValueError), err: raise errors.HypervisorError("Can't parse output of xm list," " line: %s, error: %s" % (line, err)) # skip the Domain-0 (optional) - if include_node or data[0] != 'Domain-0': + if include_node or data[0] != _DOM0_NAME: result.append(data) return result @@ -144,7 +226,7 @@ class XenHypervisor(hv_base.BaseHypervisor): @return: tuple (name, id, memory, vcpus, stat, times) """ - xm_list = self._GetXMList(instance_name=="Domain-0") + xm_list = self._GetXMList(instance_name == _DOM0_NAME) result = None for data in xm_list: if data[0] == instance_name: @@ -161,62 +243,97 @@ class XenHypervisor(hv_base.BaseHypervisor): xm_list = self._GetXMList(False) return xm_list - def StartInstance(self, instance, block_devices): + def StartInstance(self, instance, block_devices, startup_paused): """Start an instance. """ - self._WriteConfigFile(instance, block_devices) - result = utils.RunCmd(["xm", "create", instance.name]) + startup_memory = self._InstanceStartupMemory(instance) + self._WriteConfigFile(instance, startup_memory, block_devices) + cmd = [constants.XEN_CMD, "create"] + if startup_paused: + cmd.extend(["-p"]) + cmd.extend([self._ConfigFileName(instance.name)]) + result = utils.RunCmd(cmd) if result.failed: raise errors.HypervisorError("Failed to start instance %s: %s (%s)" % (instance.name, result.fail_reason, result.output)) - def StopInstance(self, instance, force=False): + def StopInstance(self, instance, force=False, retry=False, name=None): """Stop an instance. """ - self._RemoveConfigFile(instance.name) + if name is None: + name = instance.name + self._RemoveConfigFile(name) if force: - command = ["xm", "destroy", instance.name] + command = [constants.XEN_CMD, "destroy", name] else: - command = ["xm", "shutdown", instance.name] + command = [constants.XEN_CMD, "shutdown", name] result = utils.RunCmd(command) if result.failed: raise errors.HypervisorError("Failed to stop instance %s: %s, %s" % - (instance.name, result.fail_reason, - result.output)) + (name, result.fail_reason, result.output)) def RebootInstance(self, instance): """Reboot an instance. """ ini_info = self.GetInstanceInfo(instance.name) - result = utils.RunCmd(["xm", "reboot", instance.name]) + if ini_info is None: + raise errors.HypervisorError("Failed to reboot instance %s," + " not running" % instance.name) + + result = utils.RunCmd([constants.XEN_CMD, "reboot", instance.name]) if result.failed: raise errors.HypervisorError("Failed to reboot instance %s: %s, %s" % (instance.name, result.fail_reason, result.output)) - done = False - retries = self.REBOOT_RETRY_COUNT - while retries > 0: + + def _CheckInstance(): new_info = self.GetInstanceInfo(instance.name) - # check if the domain ID has changed or the run time has - # decreased - if new_info[1] != ini_info[1] or new_info[5] < ini_info[5]: - done = True - break - time.sleep(self.REBOOT_RETRY_INTERVAL) - retries -= 1 - if not done: + # check if the domain ID has changed or the run time has decreased + if (new_info is not None and + (new_info[1] != ini_info[1] or new_info[5] < ini_info[5])): + return + + raise utils.RetryAgain() + + try: + utils.Retry(_CheckInstance, self.REBOOT_RETRY_INTERVAL, + self.REBOOT_RETRY_INTERVAL * self.REBOOT_RETRY_COUNT) + except utils.RetryTimeout: raise errors.HypervisorError("Failed to reboot instance %s: instance" " did not reboot in the expected interval" % (instance.name, )) + def BalloonInstanceMemory(self, instance, mem): + """Balloon an instance memory to a certain value. + + @type instance: L{objects.Instance} + @param instance: instance to be accepted + @type mem: int + @param mem: actual memory size to use for instance runtime + + """ + cmd = [constants.XEN_CMD, "mem-set", instance.name, mem] + result = utils.RunCmd(cmd) + if result.failed: + raise errors.HypervisorError("Failed to balloon instance %s: %s (%s)" % + (instance.name, result.fail_reason, + result.output)) + cmd = ["sed", "-ie", "s/^memory.*$/memory = %s/" % mem] + cmd.append(XenHypervisor._ConfigFileName(instance.name)) + result = utils.RunCmd(cmd) + if result.failed: + raise errors.HypervisorError("Failed to update memory for %s: %s (%s)" % + (instance.name, result.fail_reason, + result.output)) + def GetNodeInfo(self): """Return information about the node. @@ -227,10 +344,10 @@ class XenHypervisor(hv_base.BaseHypervisor): - nr_cpus: total number of CPUs - nr_nodes: in a NUMA system, the number of domains - nr_sockets: the number of physical CPU sockets in the node + - hv_version: the hypervisor version in the form (major, minor) """ - # note: in xen 3, memory has changed to total_memory - result = utils.RunCmd(["xm", "info"]) + result = utils.RunCmd([constants.XEN_CMD, "info"]) if result.failed: logging.error("Can't run 'xm info' (%s): %s", result.fail_reason, result.output) @@ -239,42 +356,73 @@ class XenHypervisor(hv_base.BaseHypervisor): xmoutput = result.stdout.splitlines() result = {} cores_per_socket = threads_per_core = nr_cpus = None + xen_major, xen_minor = None, None + memory_total = None + memory_free = None + for line in xmoutput: splitfields = line.split(":", 1) if len(splitfields) > 1: key = splitfields[0].strip() val = splitfields[1].strip() - if key == 'memory' or key == 'total_memory': - result['memory_total'] = int(val) - elif key == 'free_memory': - result['memory_free'] = int(val) - elif key == 'nr_cpus': - nr_cpus = result['cpu_total'] = int(val) - elif key == 'nr_nodes': - result['cpu_nodes'] = int(val) - elif key == 'cores_per_socket': + + # note: in xen 3, memory has changed to total_memory + if key == "memory" or key == "total_memory": + memory_total = int(val) + elif key == "free_memory": + memory_free = int(val) + elif key == "nr_cpus": + nr_cpus = result["cpu_total"] = int(val) + elif key == "nr_nodes": + result["cpu_nodes"] = int(val) + elif key == "cores_per_socket": cores_per_socket = int(val) - elif key == 'threads_per_core': + elif key == "threads_per_core": threads_per_core = int(val) + elif key == "xen_major": + xen_major = int(val) + elif key == "xen_minor": + xen_minor = int(val) + + if None not in [cores_per_socket, threads_per_core, nr_cpus]: + result["cpu_sockets"] = nr_cpus / (cores_per_socket * threads_per_core) + + total_instmem = 0 + for (name, _, mem, vcpus, _, _) in self._GetXMList(True): + if name == _DOM0_NAME: + result["memory_dom0"] = mem + result["dom0_cpus"] = vcpus + + # Include Dom0 in total memory usage + total_instmem += mem - if (cores_per_socket is not None and - threads_per_core is not None and nr_cpus is not None): - result['cpu_sockets'] = nr_cpus / (cores_per_socket * threads_per_core) + if memory_free is not None: + result["memory_free"] = memory_free - dom0_info = self.GetInstanceInfo("Domain-0") - if dom0_info is not None: - result['memory_dom0'] = dom0_info[2] + if memory_total is not None: + result["memory_total"] = memory_total + + # Calculate memory used by hypervisor + if None not in [memory_total, memory_free, total_instmem]: + result["memory_hv"] = memory_total - memory_free - total_instmem + + if not (xen_major is None or xen_minor is None): + result[constants.HV_NODEINFO_KEY_VERSION] = (xen_major, xen_minor) return result @classmethod - def GetShellCommandForConsole(cls, instance, hvparams, beparams): + def GetInstanceConsole(cls, instance, hvparams, beparams): """Return a command for connecting to the console of an instance. """ - return "xm console %s" % instance.name - + return objects.InstanceConsole(instance=instance.name, + kind=constants.CONS_SSH, + host=instance.primary_node, + user=constants.GANETI_RUNAS, + command=[pathutils.XM_CONSOLE_WRAPPER, + instance.name]) def Verify(self): """Verify the hypervisor. @@ -282,21 +430,22 @@ class XenHypervisor(hv_base.BaseHypervisor): For Xen, this verifies that the xend process is running. """ - result = utils.RunCmd(["xm", "info"]) + result = utils.RunCmd([constants.XEN_CMD, "info"]) if result.failed: return "'xm info' failed: %s, %s" % (result.fail_reason, result.output) @staticmethod - def _GetConfigFileDiskData(disk_template, block_devices): + def _GetConfigFileDiskData(block_devices, blockdev_prefix): """Get disk directive for xen config file. This method builds the xen config disk directive according to the given disk_template and block_devices. - @param disk_template: string containing instance disk template @param block_devices: list of tuples (cfdev, rldev): - cfdev: dict containing ganeti config disk part - rldev: ganeti.bdev.BlockDev object + @param blockdev_prefix: a string containing blockdevice prefix, + e.g. "sd" for /dev/sda @return: string containing disk directive for xen instance config file @@ -309,9 +458,7 @@ class XenHypervisor(hv_base.BaseHypervisor): if len(block_devices) > 24: # 'z' - 'a' = 24 raise errors.HypervisorError("Too many disks") - # FIXME: instead of this hardcoding here, each of PVM/HVM should - # directly export their info (currently HVM will just sed this info) - namespace = ["sd" + chr(i + ord('a')) for i in range(24)] + namespace = [blockdev_prefix + chr(i + ord("a")) for i in range(24)] for sd_name, (cfdev, dev_path) in zip(namespace, block_devices): if cfdev.mode == constants.DISK_RDWR: mode = "w" @@ -350,14 +497,14 @@ class XenHypervisor(hv_base.BaseHypervisor): """ pass - def FinalizeMigration(self, instance, info, success): + def FinalizeMigrationDst(self, instance, info, success): """Finalize an instance migration. After a successful migration we write the xen config file. We do nothing on a failure, as we did not change anything at accept time. @type instance: L{objects.Instance} - @param instance: instance whose migration is being aborted + @param instance: instance whose migration is being finalized @type info: string @param info: content of the xen config file on the source node @type success: boolean @@ -373,89 +520,119 @@ class XenHypervisor(hv_base.BaseHypervisor): The migration will not be attempted if the instance is not currently running. - @type instance: string - @param instance: instance name + @type instance: L{objects.Instance} + @param instance: the instance to be migrated @type target: string @param target: ip address of the target node @type live: boolean @param live: perform a live migration """ - if self.GetInstanceInfo(instance) is None: + if self.GetInstanceInfo(instance.name) is None: raise errors.HypervisorError("Instance not running, cannot migrate") - args = ["xm", "migrate"] - if live: - args.append("-l") - args.extend([instance, target]) + + port = instance.hvparams[constants.HV_MIGRATION_PORT] + + if not netutils.TcpPing(target, port, live_port_needed=True): + raise errors.HypervisorError("Remote host %s not listening on port" + " %s, cannot migrate" % (target, port)) + + # FIXME: migrate must be upgraded for transitioning to "xl" (xen 4.1). + # This should be reworked in Ganeti 2.7 + # ssh must recognize the key of the target host for the migration + args = [constants.XEN_CMD, "migrate"] + if constants.XEN_CMD == constants.XEN_CMD_XM: + args.extend(["-p", "%d" % port]) + if live: + args.append("-l") + elif constants.XEN_CMD == constants.XEN_CMD_XL: + args.extend(["-C", self._ConfigFileName(instance.name)]) + else: + raise errors.HypervisorError("Unsupported xen command: %s" % + constants.XEN_CMD) + + args.extend([instance.name, target]) result = utils.RunCmd(args) if result.failed: raise errors.HypervisorError("Failed to migrate instance %s: %s" % - (instance, result.output)) - # remove old xen file after migration succeeded - try: - self._RemoveConfigFile(instance) - except EnvironmentError: - logging.exception("Failure while removing instance config file") + (instance.name, result.output)) + def FinalizeMigrationSource(self, instance, success, live): + """Finalize the instance migration on the source node. -class XenPvmHypervisor(XenHypervisor): - """Xen PVM hypervisor interface""" + @type instance: L{objects.Instance} + @param instance: the instance that was migrated + @type success: bool + @param success: whether the migration succeeded or not + @type live: bool + @param live: whether the user requested a live migration or not - PARAMETERS = [ - constants.HV_KERNEL_PATH, - constants.HV_INITRD_PATH, - constants.HV_ROOT_PATH, - constants.HV_KERNEL_ARGS, - ] + """ + # pylint: disable=W0613 + if success: + # remove old xen file after migration succeeded + try: + self._RemoveConfigFile(instance.name) + except EnvironmentError: + logging.exception("Failure while removing instance config file") - @classmethod - def CheckParameterSyntax(cls, hvparams): - """Check the given parameters for validity. + def GetMigrationStatus(self, instance): + """Get the migration status - For the PVM hypervisor, this only check the existence of the - kernel. + As MigrateInstance for Xen is still blocking, if this method is called it + means that MigrateInstance has completed successfully. So we can safely + assume that the migration was successful and notify this fact to the client. - @type hvparams: dict - @param hvparams: dictionary with parameter names/value - @raise errors.HypervisorError: when a parameter is not valid + @type instance: L{objects.Instance} + @param instance: the instance that is being migrated + @rtype: L{objects.MigrationStatus} + @return: the status of the current migration (one of + L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional + progress info that can be retrieved from the hypervisor """ - super(XenPvmHypervisor, cls).CheckParameterSyntax(hvparams) + return objects.MigrationStatus(status=constants.HV_MIGRATION_COMPLETED) - 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") - - if not hvparams[constants.HV_ROOT_PATH]: - raise errors.HypervisorError("Need a root partition for the instance") + @classmethod + def PowercycleNode(cls): + """Xen-specific powercycle. - 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" - ", if defined") + This first does a Linux reboot (which triggers automatically a Xen + reboot), and if that fails it tries to do a Xen reboot. The reason + we don't try a Xen reboot first is that the xen reboot launches an + external command which connects to the Xen hypervisor, and that + won't work in case the root filesystem is broken and/or the xend + daemon is not working. - def ValidateParameters(self, hvparams): - """Check the given parameters for validity. + """ + try: + cls.LinuxPowercycle() + finally: + utils.RunCmd([constants.XEN_CMD, "debug", "R"]) - For the PVM hypervisor, this only check the existence of the - kernel. - """ - super(XenPvmHypervisor, self).ValidateParameters(hvparams) +class XenPvmHypervisor(XenHypervisor): + """Xen PVM hypervisor interface""" - kernel_path = hvparams[constants.HV_KERNEL_PATH] - if 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) + PARAMETERS = { + constants.HV_USE_BOOTLOADER: hv_base.NO_CHECK, + constants.HV_BOOTLOADER_PATH: hv_base.OPT_FILE_CHECK, + constants.HV_BOOTLOADER_ARGS: hv_base.NO_CHECK, + constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK, + constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK, + constants.HV_ROOT_PATH: hv_base.NO_CHECK, + constants.HV_KERNEL_ARGS: hv_base.NO_CHECK, + constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK, + constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK, + # TODO: Add a check for the blockdev prefix (matching [a-z:] or similar). + constants.HV_BLOCKDEV_PREFIX: hv_base.NO_CHECK, + constants.HV_REBOOT_BEHAVIOR: + hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS), + constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK, + } @classmethod - def _WriteConfigFile(cls, instance, block_devices): + def _WriteConfigFile(cls, instance, startup_memory, block_devices): """Write the Xen config file for the instance. """ @@ -463,46 +640,66 @@ class XenPvmHypervisor(XenHypervisor): config = StringIO() config.write("# this is autogenerated by Ganeti, please do not edit\n#\n") - # kernel handling - kpath = hvp[constants.HV_KERNEL_PATH] - config.write("kernel = '%s'\n" % kpath) + # if bootloader is True, use bootloader instead of kernel and ramdisk + # parameters. + if hvp[constants.HV_USE_BOOTLOADER]: + # bootloader handling + bootloader_path = hvp[constants.HV_BOOTLOADER_PATH] + if bootloader_path: + config.write("bootloader = '%s'\n" % bootloader_path) + else: + raise errors.HypervisorError("Bootloader enabled, but missing" + " bootloader path") + + bootloader_args = hvp[constants.HV_BOOTLOADER_ARGS] + if bootloader_args: + config.write("bootargs = '%s'\n" % bootloader_args) + else: + # kernel handling + kpath = hvp[constants.HV_KERNEL_PATH] + config.write("kernel = '%s'\n" % kpath) - # initrd handling - initrd_path = hvp[constants.HV_INITRD_PATH] - if initrd_path: - config.write("ramdisk = '%s'\n" % initrd_path) + # initrd handling + initrd_path = hvp[constants.HV_INITRD_PATH] + if initrd_path: + config.write("ramdisk = '%s'\n" % initrd_path) # rest of the settings - config.write("memory = %d\n" % instance.beparams[constants.BE_MEMORY]) + config.write("memory = %d\n" % startup_memory) + config.write("maxmem = %d\n" % instance.beparams[constants.BE_MAXMEM]) config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS]) + cpu_pinning = cls._CreateConfigCpus(hvp[constants.HV_CPU_MASK]) + if cpu_pinning: + config.write("%s\n" % cpu_pinning) + config.write("name = '%s'\n" % instance.name) vif_data = [] for nic in instance.nics: - nic_str = "mac=%s, bridge=%s" % (nic.mac, nic.bridge) + nic_str = "mac=%s" % (nic.mac) ip = getattr(nic, "ip", None) if ip is not None: nic_str += ", ip=%s" % ip + if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED: + nic_str += ", bridge=%s" % nic.nicparams[constants.NIC_LINK] vif_data.append("'%s'" % nic_str) + disk_data = cls._GetConfigFileDiskData(block_devices, + hvp[constants.HV_BLOCKDEV_PREFIX]) + config.write("vif = [%s]\n" % ",".join(vif_data)) - config.write("disk = [%s]\n" % ",".join( - cls._GetConfigFileDiskData(instance.disk_template, - block_devices))) + config.write("disk = [%s]\n" % ",".join(disk_data)) - config.write("root = '%s'\n" % hvp[constants.HV_ROOT_PATH]) + if hvp[constants.HV_ROOT_PATH]: + config.write("root = '%s'\n" % hvp[constants.HV_ROOT_PATH]) config.write("on_poweroff = 'destroy'\n") - config.write("on_reboot = 'restart'\n") + if hvp[constants.HV_REBOOT_BEHAVIOR] == constants.INSTANCE_REBOOT_ALLOWED: + config.write("on_reboot = 'restart'\n") + else: + config.write("on_reboot = 'destroy'\n") config.write("on_crash = 'restart'\n") config.write("extra = '%s'\n" % hvp[constants.HV_KERNEL_ARGS]) - # just in case it exists - utils.RemoveFile("/etc/xen/auto/%s" % instance.name) - try: - utils.WriteFile("/etc/xen/%s" % instance.name, data=config.getvalue()) - except EnvironmentError, err: - raise errors.HypervisorError("Cannot write Xen instance confile" - " file /etc/xen/%s: %s" % - (instance.name, err)) + cls._WriteConfigFileStatic(instance.name, config.getvalue()) return True @@ -510,103 +707,45 @@ class XenPvmHypervisor(XenHypervisor): class XenHvmHypervisor(XenHypervisor): """Xen HVM hypervisor interface""" - PARAMETERS = [ - constants.HV_ACPI, - constants.HV_BOOT_ORDER, - constants.HV_CDROM_IMAGE_PATH, - constants.HV_DISK_TYPE, - constants.HV_NIC_TYPE, - constants.HV_PAE, - constants.HV_VNC_BIND_ADDRESS, - constants.HV_KERNEL_PATH, - constants.HV_DEVICE_MODEL, + ANCILLARY_FILES = XenHypervisor.ANCILLARY_FILES + [ + pathutils.VNC_PASSWORD_FILE, + ] + ANCILLARY_FILES_OPT = XenHypervisor.ANCILLARY_FILES_OPT + [ + pathutils.VNC_PASSWORD_FILE, ] - @classmethod - def CheckParameterSyntax(cls, hvparams): - """Check the given parameter syntax. - - """ - super(XenHvmHypervisor, cls).CheckParameterSyntax(hvparams) - # boot order verification - boot_order = hvparams[constants.HV_BOOT_ORDER] - if not boot_order or len(boot_order.strip("acdn")) != 0: - raise errors.HypervisorError("Invalid boot order '%s' specified," - " must be one or more of [acdn]" % - boot_order) - # device type checks - nic_type = hvparams[constants.HV_NIC_TYPE] - if nic_type not in constants.HT_HVM_VALID_NIC_TYPES: - raise errors.HypervisorError(\ - "Invalid NIC type %s specified for the Xen" - " HVM hypervisor. Please choose one of: %s" - % (nic_type, utils.CommaJoin(constants.HT_HVM_VALID_NIC_TYPES))) - disk_type = hvparams[constants.HV_DISK_TYPE] - if disk_type not in constants.HT_HVM_VALID_DISK_TYPES: - raise errors.HypervisorError(\ - "Invalid disk type %s specified for the Xen" - " HVM hypervisor. Please choose one of: %s" - % (disk_type, utils.CommaJoin(constants.HT_HVM_VALID_DISK_TYPES))) - # vnc_bind_address verification - vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS] - if vnc_bind_address: - if not utils.IsValidIP(vnc_bind_address): - raise errors.OpPrereqError("given VNC bind address '%s' doesn't look" - " like a valid IP address" % - vnc_bind_address) - - 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 HVM CDROM image must" - " be an absolute path or None, not %s" % - iso_path) - - 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") - - if not hvparams[constants.HV_DEVICE_MODEL]: - raise errors.HypervisorError("Need a device model for the instance") - - if not os.path.isabs(hvparams[constants.HV_DEVICE_MODEL]): - raise errors.HypervisorError("The device model must be an absolute path") - - - def ValidateParameters(self, hvparams): - """Check the given parameters for validity. - - For the PVM 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 - - """ - super(XenHvmHypervisor, self).ValidateParameters(hvparams) - - # hvm_cdrom_image_path verification - iso_path = hvparams[constants.HV_CDROM_IMAGE_PATH] - if iso_path and not os.path.isfile(iso_path): - raise errors.HypervisorError("The HVM CDROM image must either be a" - " regular file or a symlink pointing to" - " an existing regular file, not %s" % - iso_path) - - kernel_path = hvparams[constants.HV_KERNEL_PATH] - if not os.path.isfile(kernel_path): - raise errors.HypervisorError("Instance kernel '%s' not found or" - " not a file" % kernel_path) - - device_model = hvparams[constants.HV_DEVICE_MODEL] - if not os.path.isfile(device_model): - raise errors.HypervisorError("Device model '%s' not found or" - " not a file" % device_model) + PARAMETERS = { + constants.HV_ACPI: hv_base.NO_CHECK, + constants.HV_BOOT_ORDER: (True, ) + + (lambda x: x and len(x.strip("acdn")) == 0, + "Invalid boot order specified, must be one or more of [acdn]", + None, None), + constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK, + constants.HV_DISK_TYPE: + hv_base.ParamInSet(True, constants.HT_HVM_VALID_DISK_TYPES), + constants.HV_NIC_TYPE: + hv_base.ParamInSet(True, constants.HT_HVM_VALID_NIC_TYPES), + constants.HV_PAE: hv_base.NO_CHECK, + constants.HV_VNC_BIND_ADDRESS: + (False, netutils.IP4Address.IsValid, + "VNC bind address is not a valid IP address", None, None), + constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK, + constants.HV_DEVICE_MODEL: hv_base.REQ_FILE_CHECK, + constants.HV_VNC_PASSWORD_FILE: hv_base.REQ_FILE_CHECK, + constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK, + constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK, + constants.HV_USE_LOCALTIME: hv_base.NO_CHECK, + # TODO: Add a check for the blockdev prefix (matching [a-z:] or similar). + constants.HV_BLOCKDEV_PREFIX: hv_base.NO_CHECK, + # Add PCI passthrough + constants.HV_PASSTHROUGH: hv_base.NO_CHECK, + constants.HV_REBOOT_BEHAVIOR: + hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS), + constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK, + } @classmethod - def _WriteConfigFile(cls, instance, block_devices): + def _WriteConfigFile(cls, instance, startup_memory, block_devices): """Create a Xen 3.1 HVM config file. """ @@ -620,8 +759,13 @@ class XenHvmHypervisor(XenHypervisor): config.write("kernel = '%s'\n" % kpath) config.write("builder = 'hvm'\n") - config.write("memory = %d\n" % instance.beparams[constants.BE_MEMORY]) + config.write("memory = %d\n" % startup_memory) + config.write("maxmem = %d\n" % instance.beparams[constants.BE_MAXMEM]) config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS]) + cpu_pinning = cls._CreateConfigCpus(hvp[constants.HV_CPU_MASK]) + if cpu_pinning: + config.write("%s\n" % cpu_pinning) + config.write("name = '%s'\n" % instance.name) if hvp[constants.HV_PAE]: config.write("pae = 1\n") @@ -651,16 +795,18 @@ class XenHvmHypervisor(XenHypervisor): config.write("# vncdisplay = 1\n") config.write("vncunused = 1\n") + vnc_pwd_file = hvp[constants.HV_VNC_PASSWORD_FILE] try: - password = utils.ReadFile(constants.VNC_PASSWORD_FILE) + password = utils.ReadFile(vnc_pwd_file) except EnvironmentError, err: raise errors.HypervisorError("Failed to open VNC password file %s: %s" % - (constants.VNC_PASSWORD_FILE, err)) + (vnc_pwd_file, err)) config.write("vncpasswd = '%s'\n" % password.rstrip()) config.write("serial = 'pty'\n") - config.write("localtime = 1\n") + if hvp[constants.HV_USE_LOCALTIME]: + config.write("localtime = 1\n") vif_data = [] nic_type = hvp[constants.HV_NIC_TYPE] @@ -672,39 +818,37 @@ class XenHvmHypervisor(XenHypervisor): else: nic_type_str = ", model=%s, type=ioemu" % nic_type for nic in instance.nics: - nic_str = "mac=%s, bridge=%s%s" % (nic.mac, nic.bridge, nic_type_str) + nic_str = "mac=%s%s" % (nic.mac, nic_type_str) ip = getattr(nic, "ip", None) if ip is not None: nic_str += ", ip=%s" % ip + if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED: + nic_str += ", bridge=%s" % nic.nicparams[constants.NIC_LINK] vif_data.append("'%s'" % nic_str) config.write("vif = [%s]\n" % ",".join(vif_data)) - disk_data = cls._GetConfigFileDiskData(instance.disk_template, - block_devices) - disk_type = hvp[constants.HV_DISK_TYPE] - if disk_type in (None, constants.HT_DISK_IOEMU): - replacement = ",ioemu:hd" - else: - replacement = ",hd" - disk_data = [line.replace(",sd", replacement) for line in disk_data] + + disk_data = cls._GetConfigFileDiskData(block_devices, + hvp[constants.HV_BLOCKDEV_PREFIX]) + iso_path = hvp[constants.HV_CDROM_IMAGE_PATH] if iso_path: iso = "'file:%s,hdc:cdrom,r'" % iso_path disk_data.append(iso) config.write("disk = [%s]\n" % (",".join(disk_data))) - + # Add PCI passthrough + pci_pass_arr = [] + pci_pass = hvp[constants.HV_PASSTHROUGH] + if pci_pass: + pci_pass_arr = pci_pass.split(";") + config.write("pci = %s\n" % pci_pass_arr) config.write("on_poweroff = 'destroy'\n") - config.write("on_reboot = 'restart'\n") + if hvp[constants.HV_REBOOT_BEHAVIOR] == constants.INSTANCE_REBOOT_ALLOWED: + config.write("on_reboot = 'restart'\n") + else: + config.write("on_reboot = 'destroy'\n") config.write("on_crash = 'restart'\n") - # just in case it exists - utils.RemoveFile("/etc/xen/auto/%s" % instance.name) - try: - utils.WriteFile("/etc/xen/%s" % instance.name, - data=config.getvalue()) - except EnvironmentError, err: - raise errors.HypervisorError("Cannot write Xen instance confile" - " file /etc/xen/%s: %s" % - (instance.name, err)) + cls._WriteConfigFileStatic(instance.name, config.getvalue()) return True