xen-project/xen
1
0 Fork 1
mirror of https://github.com/xen-project/xen.git synced 2026-10-29 18:50:05 +01:00
Code Issues Activity

xend: Remove old vtpm support from xm

Browse Source 
Signed-off-by: Matthew Fioravante <matthew.fioravante@jhuapl.edu>
Acked-by: Ian Campbell <ian.campbell@citrix.com>
Committed-by: Ian Campbell <ian.campbell@citrix.com>
This commit is contained in:
Matthew Fioravante committed 2012-11-19 12:59:48 +00:00
1 parent a338016154
commit aaa9ddeec8
17 files changed
+4 -518
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

docs/man/xm.pod.1
-11
View File
@@ -977,17 +977,6 @@ formatted as a list or as an S-Expression if the B<--long> option was given.
=back
=head2 VIRTUAL TPM DEVICES
=over 4
=item B<vtpm-list> [B<-l>|B<--long>] I<domain-id>
Show the virtual TPM device for a domain. The returned output is
formatted as a list or as an S-Expression if the B<--long> option was given.
=back
=head1 SEE ALSO
B<xmdomain.cfg>(5), B<xentop>(1)
tools/python/README.XendConfig
-2
View File
@@ -71,8 +71,6 @@ vbds !(devices.vbds)
- io_read_kbs
- io_write_kbs
tpm_instance tpm.instance
tpm_backend tpm.backend
bios_boot image.boot?
platform_std_VGA image.stdvga
platform_serial image.serial
tools/python/README.sxpcfg
-4
View File
@@ -105,10 +105,6 @@ io
- from
- to
tpm
- pref_instance
- instance
pciquirk
- pci_ids
- pci_config_space_fields
tools/python/scripts/xapi.py
-20
View File
@@ -58,7 +58,6 @@ COMMANDS = {
'vdi-rename': ('<vdi_uuid> <new_name>', 'Rename VDI'),
'vdi-destroy': ('<vdi_uuid>', 'Delete VDI'),
'vif-create': ('<domname> <pycfg>', 'Create VIF attached to domname'),
'vtpm-create' : ('<domname> <pycfg>', 'Create VTPM attached to domname'),
'vm-create': ('<pycfg>', 'Create VM with python config'),
'vm-destroy': ('<domname>', 'Delete VM'),
@@ -284,22 +283,16 @@ def xapi_vm_list(args, async = False):
if is_long:
vbds = vm_info['VBDs']
vifs = vm_info['VIFs']
vtpms = vm_info['VTPMs']
vif_infos = []
vbd_infos = []
vtpm_infos = []
for vbd in vbds:
vbd_info = execute(server, 'VBD.get_record', (session, vbd))
vbd_infos.append(vbd_info)
for vif in vifs:
vif_info = execute(server, 'VIF.get_record', (session, vif))
vif_infos.append(vif_info)
for vtpm in vtpms:
vtpm_info = execute(server, 'VTPM.get_record', (session, vtpm))
vtpm_infos.append(vtpm_info)
vm_info['VBDs'] = vbd_infos
vm_info['VIFs'] = vif_infos
vm_info['VTPMs'] = vtpm_infos
pprint(vm_info)
else:
print VM_LIST_FORMAT % _stringify(vm_info)
@@ -661,19 +654,6 @@ def xapi_vdi_rename(args, async = False):
print 'Done.'
def xapi_vtpm_create(args, async = False):
server, session = connect()
domname = args[0]
cfg = _read_python_cfg(args[1])
vm_uuid = resolve_vm(server, session, domname)
cfg['VM'] = vm_uuid
print "Creating vTPM with cfg = %s" % cfg
vtpm_uuid = execute(server, 'VTPM.create', (session, cfg))
print "Done. (%s)" % vtpm_uuid
def xapi_pif_list(args, async = False):
server, session = connect()
pif_uuids = execute(server, 'PIF.get_all', (session,))
tools/python/xen/xend/XendAPI.py
-128
View File
@@ -377,17 +377,6 @@ def valid_vdi(func):
_check_ref(XendNode.instance().is_valid_vdi,
'VDI', func, *args, **kwargs)
def valid_vtpm(func):
"""Decorator to verify if vtpm_ref is valid before calling method.
@param func: function with params: (self, session, vtpm_ref, ...)
@rtype: callable object
"""
return lambda *args, **kwargs: \
_check_ref(lambda r: XendDomain.instance().is_valid_dev('vtpm', r),
'VTPM', func, *args, **kwargs)
def valid_console(func):
"""Decorator to verify if console_ref is valid before calling method.
@@ -481,7 +470,6 @@ classes = {
'VIF' : valid_vif,
'VIF_metrics' : valid_vif_metrics,
'VDI' : valid_vdi,
'VTPM' : valid_vtpm,
'console' : valid_console,
'SR' : valid_sr,
'task' : valid_task,
@@ -1293,7 +1281,6 @@ class XendAPI(object):
'consoles',
'VIFs',
'VBDs',
'VTPMs',
'DPCIs',
'DSCSIs',
'DSCSI_HBAs',
@@ -1436,10 +1423,6 @@ class XendAPI(object):
dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
return xen_api_success(dom.get_vbds())
def VM_get_VTPMs(self, session, vm_ref):
dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
return xen_api_success(dom.get_vtpms())
def VM_get_consoles(self, session, vm_ref):
dom = XendDomain.instance().get_vm_by_uuid(vm_ref)
return xen_api_success(dom.get_consoles())
@@ -1851,7 +1834,6 @@ class XendAPI(object):
'consoles': xeninfo.get_consoles(),
'VIFs': xeninfo.get_vifs(),
'VBDs': xeninfo.get_vbds(),
'VTPMs': xeninfo.get_vtpms(),
'DPCIs': xeninfo.get_dpcis(),
'DSCSIs': xeninfo.get_dscsis(),
'DSCSI_HBAs': xeninfo.get_dscsi_HBAs(),
@@ -2537,116 +2519,6 @@ class XendAPI(object):
vdi = XendNode.instance().get_vdi_by_uuid(vdi_ref)
return xen_api_success(vdi.get_security_label())
# Xen API: Class VTPM
# ----------------------------------------------------------------
VTPM_attr_rw = ['other_config']
VTPM_attr_ro = ['VM',
'backend',
'runtime_properties' ]
VTPM_attr_inst = VTPM_attr_rw
VTPM_methods = [('destroy', None)]
VTPM_funcs = [('create', 'VTPM')]
def VTPM_get_other_config(self, session, vtpm_ref):
xendom = XendDomain.instance()
return xen_api_success(xendom.get_dev_property_by_uuid('vtpm',
vtpm_ref,
'other_config'))
def VTPM_set_other_config(self, session, vtpm_ref, other_config):
xendom = XendDomain.instance()
xendom.set_dev_property_by_uuid('vtpm',
vtpm_ref,
'other_config',
other_config)
return xen_api_success_void()
# object methods
def VTPM_get_record(self, session, vtpm_ref):
xendom = XendDomain.instance()
vm = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
if not vm:
return xen_api_error(['HANDLE_INVALID', 'VTPM', vtpm_ref])
cfg = vm.get_dev_xenapi_config('vtpm', vtpm_ref)
if not cfg:
return xen_api_error(['HANDLE_INVALID', 'VTPM', vtpm_ref])
valid_vtpm_keys = self.VTPM_attr_ro + self.VTPM_attr_rw + \
self.Base_attr_ro + self.Base_attr_rw
return_cfg = {}
for k in cfg.keys():
if k in valid_vtpm_keys:
return_cfg[k] = cfg[k]
return xen_api_success(return_cfg)
# Class Functions
def VTPM_get_backend(self, session, vtpm_ref):
xendom = XendDomain.instance()
vm = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
if not vm:
return xen_api_error(['HANDLE_INVALID', 'VTPM', vtpm_ref])
cfg = vm.get_dev_xenapi_config('vtpm', vtpm_ref)
if not cfg:
return xen_api_error(['HANDLE_INVALID', 'VTPM', vtpm_ref])
if not cfg.has_key('backend'):
return xen_api_error(['INTERNAL_ERROR', 'VTPM backend not set'])
return xen_api_success(cfg['backend'])
def VTPM_get_VM(self, session, vtpm_ref):
xendom = XendDomain.instance()
return xen_api_success(xendom.get_dev_property_by_uuid('vtpm',
vtpm_ref, 'VM'))
def VTPM_destroy(self, session, vtpm_ref):
xendom = XendDomain.instance()
dom = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
if dom:
if dom.state != XEN_API_VM_POWER_STATE_HALTED:
vm_ref = dom.get_dev_property('vtpm', vtpm_ref, 'VM')
return xen_api_error(['VM_BAD_POWER_STATE', vm_ref,
XendDomain.POWER_STATE_NAMES[XEN_API_VM_POWER_STATE_HALTED],
XendDomain.POWER_STATE_NAMES[dom.state]])
from xen.xend.server import tpmif
tpmif.destroy_vtpmstate(dom.getName())
return xen_api_success_void()
else:
return xen_api_error(['HANDLE_INVALID', 'VTPM', vtpm_ref])
# class methods
def VTPM_create(self, session, vtpm_struct):
xendom = XendDomain.instance()
if xendom.is_valid_vm(vtpm_struct['VM']):
dom = xendom.get_vm_by_uuid(vtpm_struct['VM'])
try:
vtpm_ref = dom.create_vtpm(vtpm_struct)
xendom.managed_config_save(dom)
return xen_api_success(vtpm_ref)
except XendError, exn:
return xen_api_error(['INTERNAL_ERROR', str(exn)])
else:
return xen_api_error(['HANDLE_INVALID', 'VM', vtpm_struct['VM']])
def VTPM_get_all(self, session):
xendom = XendDomain.instance()
vtpms = [d.get_vtpms() for d in XendDomain.instance().list('all')]
vtpms = reduce(lambda x, y: x + y, vtpms)
return xen_api_success(vtpms)
def VTPM_get_runtime_properties(self, _, vtpm_ref):
xendom = XendDomain.instance()
dominfo = xendom.get_vm_with_dev_uuid('vtpm', vtpm_ref)
device = dominfo.get_dev_config_by_uuid('vtpm', vtpm_ref)
try:
device_sxps = dominfo.getDeviceSxprs('vtpm')
device_dict = dict(device_sxps[0][1])
return xen_api_success(device_dict)
except:
return xen_api_success({})
# Xen API: Class console
# ----------------------------------------------------------------
tools/python/xen/xend/XendConfig.py
+2 -17
View File
@@ -417,7 +417,6 @@ class XendConfig(dict):
'console_refs': [],
'vif_refs': [],
'vbd_refs': [],
'vtpm_refs': [],
'other_config': {},
'platform': {},
'target': 0,
@@ -937,7 +936,6 @@ class XendConfig(dict):
self['console_refs'] = cfg.get('console_refs', [])
self['vif_refs'] = cfg.get('vif_refs', [])
self['vbd_refs'] = cfg.get('vbd_refs', [])
self['vtpm_refs'] = cfg.get('vtpm_refs', [])
# coalesce hvm vnc frame buffer with vfb config
if self.is_hvm() and int(self['platform'].get('vnc', 0)) != 0:
@@ -1488,7 +1486,7 @@ class XendConfig(dict):
# store dev references by uuid for certain device types
target['devices'][dev_uuid] = (dev_type, dev_info)
if dev_type in ('vif', 'vbd', 'vtpm'):
if dev_type in ('vif', 'vbd'):
param = '%s_refs' % dev_type
if param not in target:
target[param] = []
@@ -1630,18 +1628,6 @@ class XendConfig(dict):
target['devices'][dev_uuid] = (dev_type, dev_info)
target['vbd_refs'].append(dev_uuid)
elif dev_type == 'vtpm':
if cfg_xenapi.get('type'):
dev_info['type'] = cfg_xenapi.get('type')
dev_uuid = cfg_xenapi.get('uuid', None)
if not dev_uuid:
dev_uuid = uuid.createString()
dev_info['uuid'] = dev_uuid
dev_info['other_config'] = cfg_xenapi.get('other_config', {})
target['devices'][dev_uuid] = (dev_type, dev_info)
target['vtpm_refs'].append(dev_uuid)
elif dev_type == 'console':
dev_uuid = cfg_xenapi.get('uuid', None)
if not dev_uuid:
@@ -2078,8 +2064,7 @@ class XendConfig(dict):
result.extend(target.get('console_refs', []) +
target.get('vbd_refs', []) +
target.get('vif_refs', []) +
target.get('vtpm_refs', []))
target.get('vif_refs', []))
result.extend([u for u in target['devices'].keys() if u not in result])
return result
tools/python/xen/xend/XendConstants.py
+1 -7
View File
@@ -115,7 +115,7 @@ TRIGGER_TYPE = {
}
#
# Device migration stages (eg. XendDomainInfo, XendCheckpoint, server.tpmif)
# Device migration stages (eg. XendDomainInfo, XendCheckpoint)
#
DEV_MIGRATE_TEST = 0
@@ -123,12 +123,6 @@ DEV_MIGRATE_STEP1 = 1
DEV_MIGRATE_STEP2 = 2
DEV_MIGRATE_STEP3 = 3
#
# VTPM-related constants
#
VTPM_DELETE_SCRIPT = auxbin.scripts_dir() + '/vtpm-delete'
#
# Xenstore Constants
#
tools/python/xen/xend/XendDevices.py
+1 -3
View File
@@ -19,7 +19,7 @@
# A collection of DevControllers
#
from xen.xend.server import blkif, netif, tpmif, pciif, iopif, irqif, vfbif, vscsiif, netif2, vusbif
from xen.xend.server import blkif, netif, pciif, iopif, irqif, vfbif, vscsiif, netif2, vusbif
from xen.xend.server.BlktapController import BlktapController, Blktap2Controller
from xen.xend.server.ConsoleController import ConsoleController
@@ -38,7 +38,6 @@ class XendDevices:
'vbd': blkif.BlkifController,
'vif': netif.NetifController,
'vif2': netif2.NetifController2,
'vtpm': tpmif.TPMifController,
'pci': pciif.PciController,
'ioports': iopif.IOPortsController,
'irq': irqif.IRQController,
@@ -82,6 +81,5 @@ class XendDevices:
@type domain: XendDomainInfo
"""
from xen.xend.XendLogging import log
tpmif.destroy_vtpmstate(domain.info.get('vtpm_refs'))
destroy_device_state = classmethod(destroy_device_state)
tools/python/xen/xend/XendDomainInfo.py
-29
View File
@@ -3908,12 +3908,6 @@ class XendDomainInfo:
else:
config['mode'] = 'RW'
if dev_class == 'vtpm':
if not config.has_key('type'):
config['type'] = 'paravirtualised' # TODO
if not config.has_key('backend'):
config['backend'] = "00000000-0000-0000-0000-000000000000"
return config
def get_dev_property(self, dev_class, dev_uuid, field):
@@ -3945,9 +3939,6 @@ class XendDomainInfo:
def get_vbds(self):
return self.info.get('vbd_refs', [])
def get_vtpms(self):
return self.info.get('vtpm_refs', [])
def get_dpcis(self):
return XendDPCI.get_by_VM(self.info.get('uuid'))
@@ -4046,23 +4037,6 @@ class XendDomainInfo:
return dev_uuid
def create_vtpm(self, xenapi_vtpm):
"""Create a VTPM device from the passed struct in Xen API format.
@return: uuid of the device
@rtype: string
"""
if self._stateGet() not in (DOM_STATE_HALTED,):
raise VmError("Can only add vTPM to a halted domain.")
if self.get_vtpms() != []:
raise VmError('Domain already has a vTPM.')
dev_uuid = self.info.device_add('vtpm', cfg_xenapi = xenapi_vtpm)
if not dev_uuid:
raise XendError('Failed to create device')
return dev_uuid
def create_console(self, xenapi_console):
""" Create a console device from a Xen API struct.
@@ -4301,9 +4275,6 @@ class XendDomainInfo:
def destroy_vif(self, dev_uuid):
self.destroy_device_by_uuid('vif', dev_uuid)
def destroy_vtpm(self, dev_uuid):
self.destroy_device_by_uuid('vtpm', dev_uuid)
def destroy_dpci(self, dev_uuid):
dpci = XendAPIStore.get(dev_uuid, 'DPCI')
tools/python/xen/xend/XendError.py
-1
View File
@@ -246,7 +246,6 @@ XEND_ERROR_UNSUPPORTED = ('EUNSUPPORTED', 'Method Unsupported')
XEND_ERROR_VM_INVALID = ('EVMINVALID', 'VM Invalid')
XEND_ERROR_VBD_INVALID = ('EVBDINVALID', 'VBD Invalid')
XEND_ERROR_VIF_INVALID = ('EVIFINVALID', 'VIF Invalid')
XEND_ERROR_VTPM_INVALID = ('EVTPMINVALID', 'VTPM Invalid')
XEND_ERROR_VDI_INVALID = ('EVDIINVALID', 'VDI Invalid')
XEND_ERROR_SR_INVALID = ('ESRINVALID', 'SR Invalid')
XEND_ERROR_XSPOLICY_INVALID = ('EXSPOLICYINVALID', 'XS Invalid')
tools/python/xen/xend/XendOptions.py
-4
View File
@@ -349,10 +349,6 @@ class XendOptions:
else:
return None
def get_external_migration_tool(self):
"""@return the name of the tool to handle virtual TPM migration."""
return self.get_config_string('external-migration-tool', self.external_migration_tool_default)
def get_enable_dump(self):
return self.get_config_bool('enable-dump', 'no')
tools/python/xen/xend/server/tpmif.py
-141
View File
@@ -1,141 +0,0 @@
#============================================================================
# This library is free software; you can redistribute it and/or
# modify it under the terms of version 2.1 of the GNU Lesser General Public
# License as published by the Free Software Foundation.
#
# 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#============================================================================
# Copyright (C) 2004 Mike Wray <mike.wray@hp.com>
# Copyright (C) 2005 IBM Corporation
# Author: Stefan Berger, stefanb@us.ibm.com
# Copyright (C) 2005 XenSource Ltd
#============================================================================
"""Support for virtual TPM interfaces."""
from xen.xend import XendOptions
from xen.xend.XendLogging import log
from xen.xend.XendError import XendError
from xen.xend.XendConstants import DEV_MIGRATE_TEST, VTPM_DELETE_SCRIPT
from xen.xend.server.DevController import DevController
import os
import re
xoptions = XendOptions.instance()
def destroy_vtpmstate(uuids):
if os.path.exists(VTPM_DELETE_SCRIPT):
for uuid in uuids:
os.system(VTPM_DELETE_SCRIPT + " " + uuid)
class TPMifController(DevController):
"""TPM interface controller. Handles all TPM devices for a domain.
"""
def __init__(self, vm):
DevController.__init__(self, vm)
def getDeviceDetails(self, config):
"""@see DevController.getDeviceDetails"""
devid = self.allocateDeviceID()
inst = int(config.get('pref_instance', -1))
if inst == -1:
inst = int(config.get('instance', 0))
typ = config.get('type')
uuid = config.get('uuid')
log.info("The domain has a TPM with pref. instance %d and devid %d.",
inst, devid)
back = { 'pref_instance' : "%i" % inst,
'resume' : "%s" % (self.vm.getResume()) }
if typ:
back['type'] = typ
if uuid:
back['uuid'] = uuid
data = self.vm.info['devices'].get(uuid)
if data:
other = data[1].get('other_config')
if type(other) == dict:
for key, item in other.items():
back['oc_' + key] = item
front = { 'handle' : "%i" % devid }
return (devid, back, front)
def getDeviceConfiguration(self, devid, transaction = None):
"""Returns the configuration of a device"""
result = DevController.getDeviceConfiguration(self, devid, transaction)
(instance, uuid, type) = \
self.readBackend(devid, 'instance',
'uuid',
'type')
if instance:
result['instance'] = instance
if uuid:
result['uuid'] = uuid
if type:
result['type'] = type
if uuid:
data = self.vm.info['devices'].get(uuid)
if data:
other = data[1].get('other_config')
if other:
result['other_config'] = other
return result
def migrate(self, deviceConfig, network, dst, step, domName):
"""@see DevContoller.migrate"""
if network:
tool = xoptions.get_external_migration_tool()
if tool != '':
log.info("Request to network-migrate device to %s. step=%d.",
dst, step)
if step == DEV_MIGRATE_TEST:
"""Assuming for now that everything is ok and migration
with the given tool can proceed.
"""
return 0
else:
fd = os.popen("%s -type vtpm -step %d -host %s -domname %s" %
(tool, step, dst, domName),
'r')
for line in fd.readlines():
mo = re.search('Error', line)
if mo:
raise XendError("vtpm: Fatal error in migration step %d: %s" %
(step, line))
return 0
else:
log.debug("External migration tool not in configuration.")
return -1
return 0
def recover_migrate(self, deviceConfig, network, dst, step, domName):
"""@see DevContoller.recover_migrate"""
if network:
tool = xoptions.get_external_migration_tool()
if tool != '':
log.info("Request to recover network-migrated device. last good step=%d.",
step)
fd = os.popen("%s -type vtpm -step %d -host %s -domname %s -recover" %
(tool, step, dst, domName),
'r')
return 0
tools/python/xen/xend/tests/xend-config.sxp
-2
View File
@@ -127,5 +127,3 @@
# Whether to enable core-dumps when domains crash.
#(enable-dump no)
# The tool used for initiating virtual TPM migration
#(external-migration-tool '')
tools/python/xen/xm/create.dtd
-4
View File
@@ -38,7 +38,6 @@
memory,
vbd*,
vif*,
vtpm*,
pci*,
vscsi*,
console*,
@@ -82,9 +81,6 @@
network CDATA #IMPLIED
security_label CDATA #IMPLIED>
<!ELEMENT vtpm (name*)>
<!ATTLIST vtpm backend CDATA #REQUIRED>
<!ELEMENT pci (pci_opt*)>
<!ATTLIST pci domain CDATA #REQUIRED
bus CDATA #REQUIRED
tools/python/xen/xm/create.py
-69
View File
@@ -324,10 +324,6 @@ gopts.var('netif', val='no|yes',
fn=set_bool, default=0,
use="Make the domain a network interface backend.")
gopts.var('tpmif', val='no|yes',
fn=append_value, default=0,
use="Make the domain a TPM interface backend.")
gopts.var('disk', val='phy:DEV,VDEV,MODE[,DOM]',
fn=append_value, default=[],
use="""Add a disk device to a domain. The physical device is DEV,
@@ -419,20 +415,6 @@ gopts.var('vif2', val="front_mac=MAC,back_mac=MAC,backend=DOM,pdev=PDEV,max_bypa
and backend MAC addresses. Randomly generated
addresses will be used if either address is missing.""")
gopts.var('vtpm', val="instance=INSTANCE,backend=DOM,type=TYPE",
fn=append_value, default=[],
use="""Add a TPM interface. On the backend side use the given
instance as virtual TPM instance. The given number is merely the
preferred instance number. The hotplug script will determine
which instance number will actually be assigned to the domain.
The associtation between virtual machine and the TPM instance
number can be found in /etc/xen/vtpm.db. Use the backend in the
given domain.
The type parameter can be used to select a specific driver type
that the VM can use. To prevent a fully virtualized domain (HVM)
from being able to access an emulated device model, you may specify
'paravirtualized' here.""")
gopts.var('access_control', val="policy=POLICY,label=LABEL",
fn=append_value, default=[],
use="""Add a security label and the security policy reference that defines it.
@@ -997,37 +979,6 @@ def configure_mem_prot(config_image, vals):
"""
config_image.append(['s3_integrity', vals.s3_integrity])
def configure_vtpm(config_devs, vals):
"""Create the config for virtual TPM interfaces.
"""
vtpm = vals.vtpm
if len(vtpm) > 0:
d = vtpm[0]
instance = d.get('instance')
uuid = d.get('uuid')
if instance == "VTPMD":
instance = "0"
else:
if instance != None:
try:
if int(instance) == 0:
err('VM config error: vTPM instance must not be 0.')
except ValueError:
err('Vm config error: could not parse instance number.')
backend = d.get('backend')
typ = d.get('type')
config_vtpm = ['vtpm']
if instance:
config_vtpm.append(['pref_instance', instance])
if backend:
config_vtpm.append(['backend', backend])
if typ:
config_vtpm.append(['type', typ])
if uuid:
config_vtpm.append(['uuid', uuid])
config_devs.append(['device', config_vtpm])
def configure_vifs(config_devs, vals):
"""Create the config for virtual network interfaces.
"""
@@ -1160,8 +1111,6 @@ def make_config(vals):
config.append(['backend', ['blkif']])
if vals.netif:
config.append(['backend', ['netif']])
if vals.tpmif:
config.append(['backend', ['tpmif']])
if vals.localtime:
config.append(['localtime', vals.localtime])
if vals.oos:
@@ -1193,7 +1142,6 @@ def make_config(vals):
configure_ioports(config_devs, vals)
configure_irq(config_devs, vals)
configure_vifs(config_devs, vals)
configure_vtpm(config_devs, vals)
configure_vfbs(config_devs, vals)
configure_security(config, vals)
config += config_devs
@@ -1307,22 +1255,6 @@ def preprocess_irq(vals):
irq.append(d)
vals.irq = irq
def preprocess_vtpm(vals):
if not vals.vtpm: return
vtpms = []
for vtpm in vals.vtpm:
d = {}
a = vtpm.split(',')
for b in a:
(k, v) = b.strip().split('=', 1)
k = k.strip()
v = v.strip()
if k not in ['backend', 'instance', 'uuid']:
err('Invalid vtpm specifier: ' + vtpm)
d[k] = v
vtpms.append(d)
vals.vtpm = vtpms
def preprocess_access_control(vals):
if not vals.access_control:
return
@@ -1401,7 +1333,6 @@ def preprocess(vals):
preprocess_ip(vals)
preprocess_irq(vals)
preprocess_nfs(vals)
preprocess_vtpm(vals)
preprocess_access_control(vals)
preprocess_cpuid(vals, 'cpuid')
preprocess_cpuid(vals, 'cpuid_check')
tools/python/xen/xm/main.py
-37
View File
@@ -204,7 +204,6 @@ SUBCOMMAND_HELP = {
'vnet-create' : ('<ConfigFile>','Create a vnet from ConfigFile.'),
'vnet-delete' : ('<VnetId>', 'Delete a Vnet.'),
'vnet-list' : ('[-l|--long]', 'List Vnets.'),
'vtpm-list' : ('<Domain> [--long]', 'List virtual TPM devices.'),
'pci-attach' : ('[-o|--options=<opt>] <Domain> <domain:bus:slot.func> [virtual slot]',
'Insert a new pass-through pci device.'),
'pci-detach' : ('<Domain> <domain:bus:slot.func>',
@@ -469,7 +468,6 @@ device_commands = [
"network2-attach",
"network2-detach",
"network2-list",
"vtpm-list",
"pci-attach",
"pci-detach",
"pci-list",
@@ -2392,39 +2390,6 @@ def xm_block_list(args):
"%(be-path)-30s "
% ni)
def xm_vtpm_list(args):
(use_long, params) = arg_check_for_resource_list(args, "vtpm-list")
dom = params[0]
if serverType == SERVER_XEN_API:
vtpm_refs = server.xenapi.VM.get_VTPMs(get_single_vm(dom))
vtpm_properties = \
map(server.xenapi.VTPM.get_runtime_properties, vtpm_refs)
devs = map(lambda (handle, properties): [handle, map2sxp(properties)],
zip(range(len(vtpm_properties)), vtpm_properties))
else:
devs = server.xend.domain.getDeviceSxprs(dom, 'vtpm')
if use_long:
map(PrettyPrint.prettyprint, devs)
else:
hdr = 0
for x in devs:
if hdr == 0:
print 'Idx BE handle state evt-ch ring-ref BE-path'
hdr = 1
ni = parse_dev_info(x[1])
ni['idx'] = int(x[0])
print ("%(idx)-3d "
"%(backend-id)-3d "
"%(handle)-3d "
"%(state)-3d "
"%(event-ch)-3d "
"%(ring-ref)-5d "
"%(be-path)-30s "
% ni)
def attached_pci_dict_bin(dom):
devs = []
if serverType == SERVER_XEN_API:
@@ -3854,8 +3819,6 @@ commands = {
"vnet-list": xm_vnet_list,
"vnet-create": xm_vnet_create,
"vnet-delete": xm_vnet_delete,
# vtpm
"vtpm-list": xm_vtpm_list,
#pci
"pci-attach": xm_pci_attach,
"pci-detach": xm_pci_detach,
tools/python/xen/xm/xenapi_create.py
-39
View File
@@ -375,12 +375,6 @@ class xenapi_create:
self.create_vifs(vm_ref, vifs, networks)
# Now create vtpms
vtpms = vm.getElementsByTagName("vtpm")
self.create_vtpms(vm_ref, vtpms)
# Now create consoles
consoles = vm.getElementsByTagName("console")
@@ -488,21 +482,6 @@ class xenapi_create:
self._network_refs = server.xenapi.network.get_all()
return self._network_refs.pop(0)
def create_vtpms(self, vm_ref, vtpms):
if len(vtpms) > 1:
vtpms = [ vtpms[0] ]
log(DEBUG, "create_vtpms")
return map(lambda vtpm: self.create_vtpm(vm_ref, vtpm), vtpms)
def create_vtpm(self, vm_ref, vtpm):
vtpm_record = {
"VM":
vm_ref,
"backend":
vtpm.attributes["backend"].value
}
return server.xenapi.VTPM.create(vtpm_record)
def create_consoles(self, vm_ref, consoles):
log(DEBUG, "create_consoles")
return map(lambda console: self.create_console(vm_ref, console),
@@ -633,9 +612,6 @@ class sxp2xml:
vifs_sxp = map(lambda x: x[1], [device for device in devices
if device[1][0] == "vif"])
vtpms_sxp = map(lambda x: x[1], [device for device in devices
if device[1][0] == "vtpm"])
vfbs_sxp = map(lambda x: x[1], [device for device in devices
if device[1][0] == "vfb"])
@@ -780,12 +756,6 @@ class sxp2xml:
map(vm.appendChild, vifs)
# And now the vTPMs
vtpms = map(lambda vtpm: self.extract_vtpm(vtpm, document), vtpms_sxp)
map(vm.appendChild, vtpms)
# And now the pcis
pcis = self.extract_pcis(pcis_sxp, document)
@@ -923,15 +893,6 @@ class sxp2xml:
return vif
def extract_vtpm(self, vtpm_sxp, document):
vtpm = document.createElement("vtpm")
vtpm.attributes["backend"] \
= get_child_by_name(vtpm_sxp, "backend", "0")
return vtpm
def extract_vfb(self, vfb_sxp, document):
vfb = document.createElement("console")
Reference in new issue
xen-project/xen
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.

The note is not visible to the blocked user.