def _delete_affected_pci_devices(self, dom, dev_name, pci_devs):
dev_model = DeviceModel(conn=self.conn)
try:
dev_model.lookup(dev_name)
except NotFoundError:
return
affected_names = set(
DevicesModel(conn=self.conn).get_list(
_passthrough_affected_by=dev_name))
for pci_name, e in pci_devs:
if pci_name in affected_names:
xmlstr = etree.tostring(e)
dom.detachDeviceFlags(xmlstr,
get_vm_config_flag(dom, mode='all'))
def _delete_affected_pci_devices(self, dom, dev_name, pci_devs):
dev_model = DeviceModel(conn=self.conn)
try:
dev_model.lookup(dev_name)
except NotFoundError:
return
affected_names = set(
DevicesModel(
conn=self.conn).get_list(_passthrough_affected_by=dev_name))
for pci_name, e in pci_devs:
if pci_name in affected_names:
xmlstr = etree.tostring(e)
dom.detachDeviceFlags(
xmlstr, get_vm_config_flag(dom, mode='all'))
def lookup(self, vmid, dev_name):
dom = VMModel.get_vm(vmid, self.conn)
xmlstr = dom.XMLDesc(0)
root = objectify.fromstring(xmlstr)
try:
hostdev = root.devices.hostdev
except AttributeError:
raise NotFoundError('KCHVMHDEV0001E', {
'vmid': vmid,
'dev_name': dev_name
})
dev_model = DeviceModel(conn=self.conn)
for e in hostdev:
deduced_name = DeviceModel.deduce_dev_name(e, self.conn)
if deduced_name == dev_name:
dev_info = dev_model.lookup(dev_name)
return {
'name': dev_name,
'type': e.attrib['type'],
'product': dev_info.get('product', None),
'vendor': dev_info.get('vendor', None)
}
raise NotFoundError('KCHVMHDEV0001E', {
'vmid': vmid,
'dev_name': dev_name
})
def _attach_pci_device(self, vmid, dev_info):
self._validate_pci_passthrough_env()
dom = VMModel.get_vm(vmid, self.conn)
# Due to libvirt limitation, we don't support live assigne device to
# vfio driver.
driver = ('vfio' if DOM_STATE_MAP[dom.info()[0]] == "shutoff" and
self.caps.kernel_vfio else 'kvm')
# on powerkvm systems it must be vfio driver.
distro, _, _ = platform.linux_distribution()
if distro == 'IBM_PowerKVM':
driver = 'vfio'
# Attach all PCI devices in the same IOMMU group
dev_model = DeviceModel(conn=self.conn)
devs_model = DevicesModel(conn=self.conn)
affected_names = devs_model.get_list(
_passthrough_affected_by=dev_info['name'])
passthrough_names = devs_model.get_list(
_cap='pci', _passthrough='true')
group_names = list(set(affected_names) & set(passthrough_names))
pci_infos = [dev_model.lookup(dev_name) for dev_name in group_names]
pci_infos.append(dev_info)
# all devices in the group that is going to be attached to the vm
# must be detached from the host first
with RollbackContext() as rollback:
for pci_info in pci_infos:
try:
dev = self.conn.get().nodeDeviceLookupByName(
pci_info['name'])
dev.dettach()
except Exception:
raise OperationFailed('KCHVMHDEV0005E',
{'name': pci_info['name']})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
device_flags = get_vm_config_flag(dom, mode='all')
with RollbackContext() as rollback:
for pci_info in pci_infos:
pci_info['detach_driver'] = driver
xmlstr = self._get_pci_device_xml(pci_info)
try:
dom.attachDeviceFlags(xmlstr, device_flags)
except libvirt.libvirtError:
kimchi_log.error(
'Failed to attach host device %s to VM %s: \n%s',
pci_info['name'], vmid, xmlstr)
raise
rollback.prependDefer(dom.detachDeviceFlags,
xmlstr, device_flags)
rollback.commitAll()
return dev_info['name']
def _attach_pci_device(self, vmid, dev_info):
self._validate_pci_passthrough_env()
dom = VMModel.get_vm(vmid, self.conn)
# Due to libvirt limitation, we don't support live assigne device to
# vfio driver.
driver = ('vfio' if DOM_STATE_MAP[dom.info()[0]] == "shutoff"
and self.caps.kernel_vfio else 'kvm')
# on powerkvm systems it must be vfio driver.
distro, _, _ = platform.linux_distribution()
if distro == 'IBM_PowerKVM':
driver = 'vfio'
# Attach all PCI devices in the same IOMMU group
dev_model = DeviceModel(conn=self.conn)
devs_model = DevicesModel(conn=self.conn)
affected_names = devs_model.get_list(
_passthrough_affected_by=dev_info['name'])
passthrough_names = devs_model.get_list(_cap='pci',
_passthrough='true')
group_names = list(set(affected_names) & set(passthrough_names))
pci_infos = [dev_model.lookup(dev_name) for dev_name in group_names]
pci_infos.append(dev_info)
# all devices in the group that is going to be attached to the vm
# must be detached from the host first
with RollbackContext() as rollback:
for pci_info in pci_infos:
try:
dev = self.conn.get().nodeDeviceLookupByName(
pci_info['name'])
dev.dettach()
except Exception:
raise OperationFailed('KCHVMHDEV0005E',
{'name': pci_info['name']})
else:
rollback.prependDefer(dev.reAttach)
rollback.commitAll()
device_flags = get_vm_config_flag(dom, mode='all')
with RollbackContext() as rollback:
for pci_info in pci_infos:
pci_info['detach_driver'] = driver
xmlstr = self._get_pci_device_xml(pci_info)
try:
dom.attachDeviceFlags(xmlstr, device_flags)
except libvirt.libvirtError:
kimchi_log.error(
'Failed to attach host device %s to VM %s: \n%s',
pci_info['name'], vmid, xmlstr)
raise
rollback.prependDefer(dom.detachDeviceFlags, xmlstr,
device_flags)
rollback.commitAll()
return dev_info['name']
def lookup(self, vmid, dev_name):
dom = VMModel.get_vm(vmid, self.conn)
xmlstr = dom.XMLDesc(0)
root = objectify.fromstring(xmlstr)
try:
hostdev = root.devices.hostdev
except AttributeError:
raise NotFoundError('KCHVMHDEV0001E',
{'vmid': vmid, 'dev_name': dev_name})
dev_model = DeviceModel(conn=self.conn)
for e in hostdev:
deduced_name = DeviceModel.deduce_dev_name(e, self.conn)
if deduced_name == dev_name:
dev_info = dev_model.lookup(dev_name)
return {'name': dev_name,
'type': e.attrib['type'],
'product': dev_info.get('product', None),
'vendor': dev_info.get('vendor', None)}
raise NotFoundError('KCHVMHDEV0001E',
{'vmid': vmid, 'dev_name': dev_name})
def _attach_pci_device(self, vmid, dev_info):
self._validate_pci_passthrough_env()
dom = VMModel.get_vm(vmid, self.conn)
# Due to libvirt limitation, we don't support live assigne device to
# vfio driver.
driver = ('vfio' if DOM_STATE_MAP[dom.info()[0]] == "shutoff"
and self.caps.kernel_vfio else 'kvm')
# Attach all PCI devices in the same IOMMU group
dev_model = DeviceModel(conn=self.conn)
devs_model = DevicesModel(conn=self.conn)
affected_names = devs_model.get_list(
_passthrough_affected_by=dev_info['name'])
passthrough_names = devs_model.get_list(_cap='pci',
_passthrough='true')
group_names = list(set(affected_names) & set(passthrough_names))
pci_infos = [dev_model.lookup(dev_name) for dev_name in group_names]
pci_infos.append(dev_info)
device_flags = get_vm_config_flag(dom, mode='all')
with RollbackContext() as rollback:
for pci_info in pci_infos:
pci_info['detach_driver'] = driver
xmlstr = self._get_pci_device_xml(pci_info)
try:
dom.attachDeviceFlags(xmlstr, device_flags)
except libvirt.libvirtError:
kimchi_log.error(
'Failed to attach host device %s to VM %s: \n%s',
pci_info['name'], vmid, xmlstr)
raise
rollback.prependDefer(dom.detachDeviceFlags, xmlstr,
device_flags)
rollback.commitAll()
return dev_info['name']
def _attach_pci_device(self, vmid, dev_info):
self._validate_pci_passthrough_env()
dom = VMModel.get_vm(vmid, self.conn)
# Due to libvirt limitation, we don't support live assigne device to
# vfio driver.
driver = ('vfio' if DOM_STATE_MAP[dom.info()[0]] == "shutoff" and
CapabilitiesModel().kernel_vfio else 'kvm')
# Attach all PCI devices in the same IOMMU group
dev_model = DeviceModel(conn=self.conn)
devs_model = DevicesModel(conn=self.conn)
affected_names = devs_model.get_list(
_passthrough_affected_by=dev_info['name'])
passthrough_names = devs_model.get_list(
_cap='pci', _passthrough='true')
group_names = list(set(affected_names) & set(passthrough_names))
pci_infos = [dev_model.lookup(dev_name) for dev_name in group_names]
pci_infos.append(dev_info)
device_flags = get_vm_config_flag(dom, mode='all')
with RollbackContext() as rollback:
for pci_info in pci_infos:
pci_info['detach_driver'] = driver
xmlstr = self._get_pci_device_xml(pci_info)
try:
dom.attachDeviceFlags(xmlstr, device_flags)
except libvirt.libvirtError:
kimchi_log.error(
'Failed to attach host device %s to VM %s: \n%s',
pci_info['name'], vmid, xmlstr)
raise
rollback.prependDefer(dom.detachDeviceFlags,
xmlstr, device_flags)
rollback.commitAll()
return dev_info['name']
class StoragePoolsModel(object):
def __init__(self, **kargs):
self.conn = kargs['conn']
self.objstore = kargs['objstore']
self.scanner = Scanner(self._clean_scan)
self.scanner.delete()
self.caps = CapabilitiesModel()
self.device = DeviceModel(**kargs)
def get_list(self):
try:
conn = self.conn.get()
names = conn.listStoragePools()
names += conn.listDefinedStoragePools()
return sorted(map(lambda x: x.decode('utf-8'), names))
except libvirt.libvirtError as e:
raise OperationFailed("KCHPOOL0006E",
{'err': e.get_error_message()})
def create(self, params):
task_id = None
conn = self.conn.get()
try:
name = params['name']
if name == ISO_POOL_NAME:
raise InvalidOperation("KCHPOOL0031E")
# The user may want to create a logical pool with the same name
# used before but a volume group will already exist with this name
# So check the volume group does not exist to create the pool
if params['type'] == 'logical':
vgdisplay_cmd = ['vgdisplay', name]
output, error, returncode = run_command(vgdisplay_cmd)
# From vgdisplay error codes:
# 1 error reading VGDA
# 2 volume group doesn't exist
# 3 not all physical volumes of volume group online
# 4 volume group not found
# 5 no volume groups found at all
# 6 error reading VGDA from lvmtab
if returncode not in [2, 4, 5]:
raise InvalidOperation("KCHPOOL0036E", {'name': name})
if params['type'] == 'kimchi-iso':
task_id = self._do_deep_scan(params)
if params['type'] == 'scsi':
adapter_name = params['source']['adapter_name']
extra_params = self.device.lookup(adapter_name)
# Adds name, adapter_type, wwpn and wwnn to source information
params['source'].update(extra_params)
params['fc_host_support'] = self.caps.fc_host_support
poolDef = StoragePoolDef.create(params)
poolDef.prepare(conn)
xml = poolDef.xml.encode("utf-8")
except KeyError, item:
raise MissingParameter("KCHPOOL0004E",
{'item': str(item), 'name': name})
if name in self.get_list():
raise InvalidOperation("KCHPOOL0001E", {'name': name})
try:
if task_id:
# Create transient pool for deep scan
conn.storagePoolCreateXML(xml, 0)
return name
pool = conn.storagePoolDefineXML(xml, 0)
if params['type'] in ['logical', 'dir', 'netfs', 'scsi']:
pool.build(libvirt.VIR_STORAGE_POOL_BUILD_NEW)
# autostart dir, logical, netfs and scsi storage pools created
# from kimchi
pool.setAutostart(1)
else:
# disable autostart for others
pool.setAutostart(0)
except libvirt.libvirtError as e:
kimchi_log.error("Problem creating Storage Pool: %s", e)
raise OperationFailed("KCHPOOL0007E",
{'name': name, 'err': e.get_error_message()})
if params['type'] == 'netfs':
output, error, returncode = run_command(['setsebool', '-P',
'virt_use_nfs=1'])
if error or returncode:
kimchi_log.error("Unable to set virt_use_nfs=1. If you use "
"SELinux, this may prevent NFS pools from "
"being used.")
return name
class StoragePoolsModel(object):
def __init__(self, **kargs):
self.conn = kargs['conn']
self.objstore = kargs['objstore']
self.scanner = Scanner(self._clean_scan)
self.scanner.delete()
self.caps = CapabilitiesModel(**kargs)
self.device = DeviceModel(**kargs)
def get_list(self):
try:
conn = self.conn.get()
names = conn.listStoragePools()
names += conn.listDefinedStoragePools()
return sorted(map(lambda x: x.decode('utf-8'), names))
except libvirt.libvirtError as e:
raise OperationFailed("KCHPOOL0006E",
{'err': e.get_error_message()})
def create(self, params):
task_id = None
conn = self.conn.get()
try:
name = params['name']
if name == ISO_POOL_NAME:
raise InvalidOperation("KCHPOOL0031E")
# The user may want to create a logical pool with the same name
# used before but a volume group will already exist with this name
# So check the volume group does not exist to create the pool
if params['type'] == 'logical':
vgdisplay_cmd = ['vgdisplay', name.encode('utf-8')]
output, error, returncode = run_command(vgdisplay_cmd)
# From vgdisplay error codes:
# 1 error reading VGDA
# 2 volume group doesn't exist
# 3 not all physical volumes of volume group online
# 4 volume group not found
# 5 no volume groups found at all
# 6 error reading VGDA from lvmtab
if returncode not in [2, 4, 5]:
raise InvalidOperation("KCHPOOL0036E", {'name': name})
if params['type'] == 'kimchi-iso':
task_id = self._do_deep_scan(params)
if params['type'] == 'scsi':
adapter_name = params['source']['adapter_name']
extra_params = self.device.lookup(adapter_name)
# Adds name, adapter_type, wwpn and wwnn to source information
params['source'].update(extra_params)
params['fc_host_support'] = self.caps.fc_host_support
poolDef = StoragePoolDef.create(params)
poolDef.prepare(conn)
xml = poolDef.xml.encode("utf-8")
except KeyError, item:
raise MissingParameter("KCHPOOL0004E", {
'item': str(item),
'name': name
})
if name in self.get_list():
raise InvalidOperation("KCHPOOL0001E", {'name': name})
try:
if task_id:
# Create transient pool for deep scan
conn.storagePoolCreateXML(xml, 0)
return name
pool = conn.storagePoolDefineXML(xml, 0)
if params['type'] in ['logical', 'dir', 'netfs', 'scsi']:
pool.build(libvirt.VIR_STORAGE_POOL_BUILD_NEW)
# autostart dir, logical, netfs and scsi storage pools created
# from kimchi
pool.setAutostart(1)
else:
# disable autostart for others
pool.setAutostart(0)
except libvirt.libvirtError as e:
kimchi_log.error("Problem creating Storage Pool: %s", e)
raise OperationFailed("KCHPOOL0007E", {
'name': name,
'err': e.get_error_message()
})
if params['type'] == 'netfs':
output, error, returncode = run_command(
['setsebool', '-P', 'virt_use_nfs=1'])
if error or returncode:
kimchi_log.error("Unable to set virt_use_nfs=1. If you use "
"SELinux, this may prevent NFS pools from "
"being used.")
return name
class StoragePoolsModel(object):
def __init__(self, **kargs):
self.conn = kargs['conn']
self.objstore = kargs['objstore']
self.scanner = Scanner(self._clean_scan)
self.scanner.delete()
self.caps = CapabilitiesModel()
self.device = DeviceModel(**kargs)
def get_list(self):
try:
conn = self.conn.get()
names = conn.listStoragePools()
names += conn.listDefinedStoragePools()
return sorted(map(lambda x: x.decode('utf-8'), names))
except libvirt.libvirtError as e:
raise OperationFailed("KCHPOOL0006E",
{'err': e.get_error_message()})
def create(self, params):
task_id = None
conn = self.conn.get()
try:
name = params['name']
if name == ISO_POOL_NAME:
raise InvalidOperation("KCHPOOL0031E")
if params['type'] == 'kimchi-iso':
task_id = self._do_deep_scan(params)
if params['type'] == 'scsi':
adapter_name = params['source']['adapter_name']
extra_params = self.device.lookup(adapter_name)
# Adds name, adapter_type, wwpn and wwnn to source information
params['source'].update(extra_params)
params['fc_host_support'] = self.caps.fc_host_support
poolDef = StoragePoolDef.create(params)
poolDef.prepare(conn)
xml = poolDef.xml.encode("utf-8")
except KeyError, item:
raise MissingParameter("KCHPOOL0004E",
{'item': str(item), 'name': name})
if name in self.get_list():
raise InvalidOperation("KCHPOOL0001E", {'name': name})
try:
if task_id:
# Create transient pool for deep scan
conn.storagePoolCreateXML(xml, 0)
return name
pool = conn.storagePoolDefineXML(xml, 0)
if params['type'] in ['logical', 'dir', 'netfs', 'scsi']:
pool.build(libvirt.VIR_STORAGE_POOL_BUILD_NEW)
# autostart dir, logical, netfs and scsi storage pools created
# from kimchi
pool.setAutostart(1)
else:
# disable autostart for others
pool.setAutostart(0)
except libvirt.libvirtError as e:
kimchi_log.error("Problem creating Storage Pool: %s", e)
raise OperationFailed("KCHPOOL0007E",
{'name': name, 'err': e.get_error_message()})
return name
class StoragePoolsModel(object):
def __init__(self, **kargs):
self.conn = kargs['conn']
self.objstore = kargs['objstore']
self.scanner = Scanner(self._clean_scan)
self.scanner.delete()
self.caps = CapabilitiesModel()
self.device = DeviceModel(**kargs)
def get_list(self):
try:
conn = self.conn.get()
names = conn.listStoragePools()
names += conn.listDefinedStoragePools()
return sorted(map(lambda x: x.decode('utf-8'), names))
except libvirt.libvirtError as e:
raise OperationFailed("KCHPOOL0006E",
{'err': e.get_error_message()})
def create(self, params):
task_id = None
conn = self.conn.get()
try:
name = params['name']
if name == ISO_POOL_NAME:
raise InvalidOperation("KCHPOOL0031E")
if params['type'] == 'kimchi-iso':
task_id = self._do_deep_scan(params)
if params['type'] == 'scsi':
adapter_name = params['source']['adapter_name']
extra_params = self.device.lookup(adapter_name)
# Adds name, adapter_type, wwpn and wwnn to source information
params['source'].update(extra_params)
params['fc_host_support'] = self.caps.fc_host_support
poolDef = StoragePoolDef.create(params)
poolDef.prepare(conn)
xml = poolDef.xml.encode("utf-8")
except KeyError, item:
raise MissingParameter("KCHPOOL0004E", {
'item': str(item),
'name': name
})
if name in self.get_list():
raise InvalidOperation("KCHPOOL0001E", {'name': name})
try:
if task_id:
# Create transient pool for deep scan
conn.storagePoolCreateXML(xml, 0)
return name
pool = conn.storagePoolDefineXML(xml, 0)
if params['type'] in ['logical', 'dir', 'netfs', 'scsi']:
pool.build(libvirt.VIR_STORAGE_POOL_BUILD_NEW)
# autostart dir, logical, netfs and scsi storage pools created
# from kimchi
pool.setAutostart(1)
else:
# disable autostart for others
pool.setAutostart(0)
except libvirt.libvirtError as e:
kimchi_log.error("Problem creating Storage Pool: %s", e)
raise OperationFailed("KCHPOOL0007E", {
'name': name,
'err': e.get_error_message()
})
return name
