This patch adds a new feature test to check if the host libvirt version supports memory devices attachment. This support is provided since libvirt 1.2.14 and is the base to make memory hotplug work. When libvirt does not support memory devices, it is going to fail when we try to attach it, raising the libvirt.libvirtError: "unsupported configuration: unknown device type 'memory'" Signed-off-by: Rodrigo Trujillo <rodrigo.trujillo@linux.vnet.ibm.com> --- src/kimchi/model/config.py | 3 +++ src/kimchi/model/featuretests.py | 43 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/src/kimchi/model/config.py b/src/kimchi/model/config.py index e567ffc..5fca1a2 100644 --- a/src/kimchi/model/config.py +++ b/src/kimchi/model/config.py @@ -55,6 +55,7 @@ class CapabilitiesModel(object): self.fc_host_support = False self.metadata_support = False self.kernel_vfio = False + self.mem_hotplug_support = False # Subscribe function to set host capabilities to be run when cherrypy # server is up @@ -91,6 +92,7 @@ class CapabilitiesModel(object): self.fc_host_support = FeatureTests.libvirt_support_fc_host(conn) self.metadata_support = FeatureTests.has_metadata_support(conn) self.kernel_vfio = FeatureTests.kernel_support_vfio() + self.mem_hotplug_support = FeatureTests.has_mem_hotplug_support(conn) self.libvirt_stream_protocols = [] for p in ['http', 'https', 'ftp', 'ftps', 'tftp']: @@ -139,6 +141,7 @@ class CapabilitiesModel(object): 'auth': kconfig.get("authentication", "method"), 'kernel_vfio': self.kernel_vfio, 'nm_running': FeatureTests.is_nm_running(), + 'mem_hotplug_support': self.mem_hotplug_support } diff --git a/src/kimchi/model/featuretests.py b/src/kimchi/model/featuretests.py index 9400151..86e918a 100644 --- a/src/kimchi/model/featuretests.py +++ b/src/kimchi/model/featuretests.py @@ -63,6 +63,25 @@ SIMPLE_VM_XML = """ </os> </domain>""" +MAXMEM_VM_XML = """ +<domain type='%(domain)s'> + <name>%(name)s</name> + <maxMemory slots='1' unit='KiB'>20480</maxMemory> + <memory unit='KiB'>10240</memory> + <os> + <type arch='%(arch)s'>hvm</type> + <boot dev='hd'/> + </os> +</domain>""" + +DEV_MEM_XML = """ +<memory model='dimm'> + <target> + <size unit='KiB'>10240</size> + <node>0</node> + </target> +</memory>""" + SCSI_FC_XML = """ <pool type='scsi'> <name>%(name)s</name> @@ -207,3 +226,27 @@ class FeatureTests(object): return False return True + + @staticmethod + def has_mem_hotplug_support(conn): + ''' + A memory device can be hot-plugged or hot-unplugged since libvirt + version 1.2.14. + ''' + with RollbackContext() as rollback: + FeatureTests.disable_libvirt_error_logging() + rollback.prependDefer(FeatureTests.enable_libvirt_error_logging) + conn_type = conn.getType().lower() + domain_type = 'test' if conn_type == 'test' else 'kvm' + arch = 'i686' if conn_type == 'test' else platform.machine() + arch = 'ppc64' if arch == 'ppc64le' else arch + dom = conn.defineXML(MAXMEM_VM_XML % {'name': FEATURETEST_VM_NAME, + 'domain': domain_type, + 'arch': arch}) + rollback.prependDefer(dom.undefine) + try: + dom.attachDeviceFlags(DEV_MEM_XML, + libvirt.VIR_DOMAIN_MEM_CONFIG) + return True + except libvirt.libvirtError: + return False -- 2.1.0

This patch creates new colletion and resource of memory devices. They are subnodes of a given VM resource, that means the user is going to use the VM url/api to add or fetch the memory devices, such as: http://<HOST>/vms/<YOUR_VM>/memdevices (GET) -> to list memory devs http://<HOST>/vms/<YOUR_VM>/memdevices (POST) -> to add a memory dev http://<HOST>/vms/<YOUR_VM>/memdevices/<SLOT> (GET) -> to retrieve a given memory device in SLOT This patch does not give support do DELETE or UPDATE a memory device Signed-off-by: Rodrigo Trujillo <rodrigo.trujillo@linux.vnet.ibm.com> --- src/kimchi/control/vm/memdevices.py | 47 +++++++++++++++++++ src/kimchi/i18n.py | 2 + src/kimchi/model/vmmemdevices.py | 94 +++++++++++++++++++++++++++++++++++++ 3 files changed, 143 insertions(+) create mode 100644 src/kimchi/control/vm/memdevices.py create mode 100644 src/kimchi/model/vmmemdevices.py diff --git a/src/kimchi/control/vm/memdevices.py b/src/kimchi/control/vm/memdevices.py new file mode 100644 index 0000000..2d96104 --- /dev/null +++ b/src/kimchi/control/vm/memdevices.py @@ -0,0 +1,47 @@ +# +# Project Kimchi +# +# Copyright IBM, Corp. 2015 +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library 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 +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +from kimchi.control.base import Collection, Resource +from kimchi.control.utils import UrlSubNode + + +@UrlSubNode("memdevices") +class VMMemDevices(Collection): + def __init__(self, model, vm): + super(VMMemDevices, self).__init__(model) + self.admin_methods = ['GET', 'POST'] + self.resource = VMMemDevice + self.vm = vm + self.resource_args = [self.vm, ] + self.model_args = [self.vm, ] + + +class VMMemDevice(Resource): + def __init__(self, model, vm, ident): + super(VMMemDevice, self).__init__(model, ident) + self.admin_methods = ['GET'] + self.vm = vm + self.ident = ident + self.info = {} + self.model_args = [self.vm, self.ident] + self.uri_fmt = '/vms/%s/memdevices/%s' + + @property + def data(self): + return self.info diff --git a/src/kimchi/i18n.py b/src/kimchi/i18n.py index 9f169ab..7085530 100644 --- a/src/kimchi/i18n.py +++ b/src/kimchi/i18n.py @@ -340,4 +340,6 @@ messages = { "KCHCPUINF0002E": _("Invalid vCPU/topology combination."), "KCHCPUINF0003E": _("This host (or current configuration) does not allow CPU topology."), + "KCHMEMDEV0001E": _("Host's libvirt version does not support memory devices. Libvirt must be >= 1.2.14"), + "KCHMEMDEV0002E": _("Error attaching memory device. Details: %(error)s"), } diff --git a/src/kimchi/model/vmmemdevices.py b/src/kimchi/model/vmmemdevices.py new file mode 100644 index 0000000..016aa8d --- /dev/null +++ b/src/kimchi/model/vmmemdevices.py @@ -0,0 +1,94 @@ +# +# Project Kimchi +# +# Copyright IBM, Corp. 2015 +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library 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 +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +from libvirt import VIR_DOMAIN_MEM_CONFIG, VIR_DOMAIN_MEM_LIVE +from lxml import etree, objectify +from lxml.builder import E + + +from kimchi.exception import InvalidOperation, OperationFailed +from kimchi.model.config import CapabilitiesModel + + +def _get_all_memory_devices(conn, vm_name): + # Return all memory devices from a given guest + dom = conn.get().lookupByName(vm_name) + devs = objectify.fromstring(dom.XMLDesc(0)).devices + return devs.findall('memory') + + +class VMMemDevicesModel(object): + def __init__(self, **kargs): + self.conn = kargs['conn'] + self.objstore = kargs['objstore'] + self.caps = CapabilitiesModel(**kargs) + + def create(self, vm_name, params): + # Check if host supports memory device + if not self.caps.mem_hotplug_support: + raise InvalidOperation("KCHMEMDEV0001E") + + dom = self.conn.get().lookupByName(vm_name) + # Setting flags, depending if machine is running or not + flags = VIR_DOMAIN_MEM_CONFIG + if dom.isActive(): + flags = flags | VIR_DOMAIN_MEM_LIVE + + # Create memory device xml + mem_dev_xml = etree.tostring( + E.memory( + E.target( + E.size('1', unit='GiB'), + E.node('0')), + model='dimm' + ) + ) + # Add chunks of 1G of memory + for i in range(params['amount']): + try: + dom.attachDeviceFlags(mem_dev_xml, flags) + except Exception as e: + raise OperationFailed("KCHMEMDEV0002E", {'error': e.message}) + return len(_get_all_memory_devices(self.conn, vm_name)) - 1 + + def get_list(self, vm_name): + # Memory devices do not have an ID or something similar in the XML, so + # lets return the positions of all memory devices in the XML. + return [str(i) for i in range(len( + _get_all_memory_devices(self.conn, vm_name)))] + + +class VMMemDeviceModel(object): + def __init__(self, **kargs): + self.conn = kargs['conn'] + self.objstore = kargs['objstore'] + self.caps = CapabilitiesModel(**kargs) + + def lookup(self, vm_name, dev_slot): + # We are considering the memory device position in the XML, which + # can also be considered the slot position + try: + memdev = _get_all_memory_devices(self.conn, vm_name)[int(dev_slot)] + return { + 'slot': dev_slot, + 'size': str(memdev.xpath('./target/size')[0] / 1024 / 1024) + 'G', + 'node': str(memdev.xpath('./target/node')[0]) + } + except IndexError: + return {} -- 2.1.0

This patch changes the current memory update process, the static update, allowed when the guest is offline. Now, the update creates the new xml elements that will allow to hotplug memory, if necessary (MAXMEMORY, CPU, NUMA, NODE, etc.). It also introduce some tests to avoid errors if user sets more memory then the allowed in the server. The memory device slots count and assignment was changed to avoid erros, like negative or zero slots. Slots counting will have the number updated as the static memory is changed. Signed-off-by: Rodrigo Trujillo <rodrigo.trujillo@linux.vnet.ibm.com> --- src/kimchi/i18n.py | 1 + src/kimchi/model/vms.py | 79 +++++++++++++++++++++++++++++++++++++----------- src/kimchi/vmtemplate.py | 11 +++++++ 3 files changed, 74 insertions(+), 17 deletions(-) diff --git a/src/kimchi/i18n.py b/src/kimchi/i18n.py index e6e00b8..1779597 100644 --- a/src/kimchi/i18n.py +++ b/src/kimchi/i18n.py @@ -111,6 +111,7 @@ messages = { "KCHVM0038E": _("Unable to suspend VM '%(name)s'. Details: %(err)s"), "KCHVM0039E": _("Cannot resume VM '%(name)s' because it is not paused."), "KCHVM0040E": _("Unable to resume VM '%(name)s'. Details: %(err)s"), + "KCHVM0041E": _("Memory assigned is higher then the maximum allowed in the host."), "KCHVMHDEV0001E": _("VM %(vmid)s does not contain directly assigned host device %(dev_name)s."), "KCHVMHDEV0002E": _("The host device %(dev_name)s is not allowed to directly assign to VM."), diff --git a/src/kimchi/model/vms.py b/src/kimchi/model/vms.py index dc7f91f..2c3a667 100644 --- a/src/kimchi/model/vms.py +++ b/src/kimchi/model/vms.py @@ -59,8 +59,7 @@ DOM_STATE_MAP = {0: 'nostate', 7: 'pmsuspended'} VM_STATIC_UPDATE_PARAMS = {'name': './name', - 'cpus': './vcpu', - 'memory': './memory'} + 'cpus': './vcpu'} VM_LIVE_UPDATE_PARAMS = {} XPATH_DOMAIN_DISK = "/domain/devices/disk[@device='disk']/source/@file" @@ -73,6 +72,7 @@ XPATH_DOMAIN_MEMORY = '/domain/memory' XPATH_DOMAIN_MEMORY_UNIT = '/domain/memory/@unit' XPATH_DOMAIN_UUID = '/domain/uuid' +XPATH_NUMA_CELL = './cpu/numa/cell' class VMsModel(object): def __init__(self, **kargs): @@ -95,12 +95,9 @@ class VMsModel(object): vm_overrides['storagepool'] = pool_uri vm_overrides['fc_host_support'] = self.caps.fc_host_support - # Setting maxMemory and slots parameter values - # getInfo memory value comes in MiB, so dividing by 1024 integer, - # gives the interger maximum number of slots to use in chunks of - # 1 GB + # Setting maxMemory of the VM, which will be equal the Host memory. + # Host memory comes in MiB, so transform in KiB vm_overrides['max_memory'] = self.conn.get().getInfo()[1] * 1024 - vm_overrides['slots'] = self.conn.get().getInfo()[1] / 1024 t = TemplateModel.get_template(t_name, self.objstore, self.conn, vm_overrides) @@ -659,15 +656,15 @@ class VMModel(object): for key, val in params.items(): if key in VM_STATIC_UPDATE_PARAMS: - if key == 'memory': - # Libvirt saves memory in KiB. Retrieved xml has memory - # in KiB too, so new valeu must be in KiB here - val = val * 1024 if type(val) == int: val = str(val) xpath = VM_STATIC_UPDATE_PARAMS[key] new_xml = xml_item_update(new_xml, xpath, val) + # Updating memory and adds NUMA if necessary + if 'memory' in params: + new_xml = self._update_memory(new_xml, params) + if 'graphics' in params: new_xml = self._update_graphics(dom, new_xml, params) @@ -695,12 +692,7 @@ class VMModel(object): # Undefine old vm, only if name is going to change dom.undefine() - root = ET.fromstring(new_xml) - currentMem = root.find('.currentMemory') - if currentMem is not None: - root.remove(currentMem) - - dom = conn.defineXML(ET.tostring(root, encoding="utf-8")) + dom = conn.defineXML(new_xml) if 'name' in params: self._redefine_snapshots(dom, snapshots_info) except libvirt.libvirtError as e: @@ -712,6 +704,59 @@ class VMModel(object): 'err': e.get_error_message()}) return dom + def _update_memory(self, xml, params): + # Checks if NUMA memory is already configured, if not, checks if CPU + # element is already configured (topology). Then add NUMA element as + # apropriated + root = ET.fromstring(xml) + numa_mem = xpath_get_text(xml, XPATH_NUMA_CELL + '/@memory') + if numa_mem == []: + vcpus = xpath_get_text(xml, VM_STATIC_UPDATE_PARAMS['cpus']) + numa_xml = E.numa(E.cell( + id='0', + cpus='0-' + str(vcpus - 1) if vcpus > 1 else '0', + unit='MiB')) + cpu = root.find('./cpu') + if cpu is None: + root.insert(0, E.cpu(numa_xml)) + else: + cpu.insert(0, numa_xml) + + # Remove currentMemory and Memory, automatically set later by libvirt + currentMem = root.find('.currentMemory') + if currentMem is not None: + root.remove(currentMem) + memory = root.find('.memory') + if memory is not None: + root.remove(memory) + # Update/Adds maxMemory accordingly + if self.caps.mem_hotplug_support: + maxMem = root.find('.maxMemory') + host_mem = self.conn.get().getInfo()[1] + slots = (host_mem - params['memory']) / 1024 + # Libvirt does not accepts slots <= 1 + if slots < 0: + raise OperationFailed("KCHVM0041E") + elif slots == 0: + slots = 1 + if maxMem is None: + max_mem_xml = E.maxMemory( + host_mem * 1024, + unit='Kib', + slots=str(slots)) + root.insert(0, max_mem_xml) + new_xml = ET.tostring(root, encoding="utf-8") + else: + # Update slots only + new_xml = xml_item_update(ET.tostring(root, encoding="utf-8"), + './maxMemory', + str(slots), + attr='slots') + # Finally update the memory value in numa cell + new_xml = xml_item_update(new_xml, XPATH_NUMA_CELL, + str(params['memory'] * 1024), attr='memory') + return new_xml + def _live_vm_update(self, dom, params): self._vm_update_access_metadata(dom, params) diff --git a/src/kimchi/vmtemplate.py b/src/kimchi/vmtemplate.py index ffb56be..f7dd5e4 100644 --- a/src/kimchi/vmtemplate.py +++ b/src/kimchi/vmtemplate.py @@ -316,6 +316,17 @@ class VMTemplate(object): else: params['cdroms'] = cdrom_xml + # Setting maximum number of slots to avoid errors when hotplug memory + # Number of slots are the numbers of chunks of 1GB that fit inside + # the max_memory of the host minus memory assigned to the VM + params['slots'] = ((params['max_memory'] / 1024) - + params['memory']) / 1024 + + if params['slots'] < 0: + raise OperationFailed("KCHVM0041E") + elif params['slots'] == 0: + params['slots'] = 1 + xml = """ <domain type='%(domain)s'> %(qemu-stream-cmdline)s -- 2.1.0