Update vtpm driver following the recent changes to the

xenbus driver and its semantics.

Signed-off-by: Stefan Berger <stefanb@us.ibm.com>

15 files changed, 653 insertions, 367 deletions

diff --git a/docs/misc/vtpm.txt b/docs/misc/vtpm.txt
index d6be99d024..f9532e9c7d 100644
--- a/docs/misc/vtpm.txt
+++ b/docs/misc/vtpm.txt
@@ -73,7 +73,14 @@ information about the domain where the virtual TPM is running and
 where the TPM backend has been compiled into - this has to be 
 domain 0  at the moment - and which TPM instance the user domain
 is supposed to talk to. Note that each running VM must use a 
-different instance and that using instance 0 is NOT allowed.
+different instance and that using instance 0 is NOT allowed. The
+instance parameter is taken as the desired instance number, but
+the actual instance number that is assigned to the virtual machine
+can be different. This is the case if for example that particular
+instance is already used by another virtual machine. The association
+of which TPM instance number is used by which virtual machine is
+kept in the file /etc/xen/vtpm.db. Associations are maintained by
+domain name and instance number.
 
 Note: If you do not want TPM functionality for your user domain simply
 leave out the 'vtpm' line in the configuration file.
diff --git a/linux-2.6-xen-sparse/drivers/char/tpm/Kconfig b/linux-2.6-xen-sparse/drivers/char/tpm/Kconfig
index 03826ecf16..28f6e82b66 100644
--- a/linux-2.6-xen-sparse/drivers/char/tpm/Kconfig
+++ b/linux-2.6-xen-sparse/drivers/char/tpm/Kconfig
@@ -18,15 +18,6 @@ config TCG_TPM
 	  compile this driver as a module, choose M here; the module 
 	  will be called tpm. If unsure, say N.
 
-config TCG_TIS
-	tristate "TPM Interface Specification 1.2 Interface"
-	depends on TCG_TPM
-	---help---
-	  If you have a TPM security chip that is compliant with the
-	  TCG TIS 1.2 TPM specification say Yes and it will be accessible
-	  from within Linux.  To compile this driver as a module, choose
-	  M here; the module will be called tpm_tis.
-
 config TCG_NSC
 	tristate "National Semiconductor TPM Interface"
 	depends on TCG_TPM
diff --git a/linux-2.6-xen-sparse/drivers/xen/tpmback/common.h b/linux-2.6-xen-sparse/drivers/xen/tpmback/common.h
index 25a1bbea25..e12d25a1dd 100644
--- a/linux-2.6-xen-sparse/drivers/xen/tpmback/common.h
+++ b/linux-2.6-xen-sparse/drivers/xen/tpmback/common.h
@@ -28,7 +28,7 @@
 #endif
 
 typedef struct tpmif_st {
-        struct list_head tpmif_list;
+	struct list_head tpmif_list;
 	/* Unique identifier for this interface. */
 	domid_t domid;
 	unsigned int handle;
@@ -83,6 +83,11 @@ extern int num_frontends;
 
 #define MMAP_VADDR(t,_req) ((t)->mmap_vstart + ((_req) * PAGE_SIZE))
 
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
 #endif /* __TPMIF__BACKEND__COMMON_H__ */
 
 /*
diff --git a/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c b/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c
index 98d0b37689..df33db9bfe 100644
--- a/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c
+++ b/linux-2.6-xen-sparse/drivers/xen/tpmback/interface.c
@@ -127,6 +127,10 @@ tpmif_map(tpmif_t *tpmif, unsigned long shared_page, unsigned int evtchn)
 		.u.bind_interdomain.remote_dom = tpmif->domid,
 		.u.bind_interdomain.remote_port = evtchn };
 
+        if (tpmif->irq) {
+                return 0;
+        }
+
 	if ((tpmif->tx_area = alloc_vm_area(PAGE_SIZE)) == NULL)
 		return -ENOMEM;
 
@@ -149,7 +153,6 @@ tpmif_map(tpmif_t *tpmif, unsigned long shared_page, unsigned int evtchn)
 
 	tpmif->irq = bind_evtchn_to_irqhandler(
 		tpmif->evtchn, tpmif_be_int, 0, "tpmif-backend", tpmif);
-	tpmif->status = CONNECTED;
 	tpmif->shmem_ref = shared_page;
 	tpmif->active = 1;
 
diff --git a/linux-2.6-xen-sparse/drivers/xen/tpmback/xenbus.c b/linux-2.6-xen-sparse/drivers/xen/tpmback/xenbus.c
index 5fd19de6d8..c1ce6f7a61 100644
--- a/linux-2.6-xen-sparse/drivers/xen/tpmback/xenbus.c
+++ b/linux-2.6-xen-sparse/drivers/xen/tpmback/xenbus.c
@@ -1,4 +1,5 @@
 /*  Xenbus code for tpmif backend
+    Copyright (C) 2005 IBM Corporation
     Copyright (C) 2005 Rusty Russell <rusty@rustcorp.com.au>
 
     This program is free software; you can redistribute it and/or modify
@@ -29,72 +30,189 @@ struct backend_info
 
 	long int frontend_id;
 	long int instance; // instance of TPM
+	u8 is_instance_set;// whether instance number has been set
 
 	/* watch front end for changes */
 	struct xenbus_watch backend_watch;
-
-	struct xenbus_watch watch;
-	char * frontpath;
+	XenbusState frontend_state;
 };
 
+static void maybe_connect(struct backend_info *be);
+static void connect(struct backend_info *be);
+static int connect_ring(struct backend_info *be);
+static void backend_changed(struct xenbus_watch *watch,
+                            const char **vec, unsigned int len);
+static void frontend_changed(struct xenbus_device *dev,
+                             XenbusState frontend_state);
+
 static int tpmback_remove(struct xenbus_device *dev)
 {
 	struct backend_info *be = dev->data;
 
-	if (be->watch.node)
-		unregister_xenbus_watch(&be->watch);
-	unregister_xenbus_watch(&be->backend_watch);
+	if (be->backend_watch.node) {
+		unregister_xenbus_watch(&be->backend_watch);
+		kfree(be->backend_watch.node);
+		be->backend_watch.node = NULL;
+	}
+	if (be->tpmif) {
+		tpmif_put(be->tpmif);
+		be->tpmif = NULL;
+	}
+	kfree(be);
+	dev->data = NULL;
+	return 0;
+}
+
+static int tpmback_probe(struct xenbus_device *dev,
+                         const struct xenbus_device_id *id)
+{
+	int err;
+	struct backend_info *be = kmalloc(sizeof(struct backend_info),
+	                                  GFP_KERNEL);
 
-	tpmif_vtpm_close(be->instance);
+	if (!be) {
+		xenbus_dev_fatal(dev, -ENOMEM,
+		                 "allocating backend structure");
+		return -ENOMEM;
+	}
 
-	if (be->tpmif)
-		tpmif_put(be->tpmif);
+	memset(be, 0, sizeof(*be));
 
-	kfree(be->frontpath);
-	kfree(be);
+	be->is_instance_set = FALSE;
+	be->dev = dev;
+	dev->data = be;
+
+	err = xenbus_watch_path2(dev, dev->nodename,
+	                        "instance", &be->backend_watch,
+	                        backend_changed);
+	if (err) {
+		goto fail;
+	}
+
+	err = xenbus_switch_state(dev, NULL, XenbusStateInitWait);
+	if (err) {
+		goto fail;
+	}
 	return 0;
+fail:
+	tpmback_remove(dev);
+	return err;
 }
 
 
-static void frontend_changed(struct xenbus_watch *watch,
-			     const char **vec, unsigned int len)
+static void backend_changed(struct xenbus_watch *watch,
+                            const char **vec, unsigned int len)
 {
-	unsigned long ringref;
-	unsigned int evtchn;
-	unsigned long ready = 1;
 	int err;
-	struct xenbus_transaction *xbt;
+	long instance;
 	struct backend_info *be
-		= container_of(watch, struct backend_info, watch);
+		= container_of(watch, struct backend_info, backend_watch);
+	struct xenbus_device *dev = be->dev;
 
-	/* If other end is gone, delete ourself. */
-	if (vec && !xenbus_exists(NULL, be->frontpath, "")) {
-		xenbus_rm(NULL, be->dev->nodename, "");
-		device_unregister(&be->dev->dev);
+	err = xenbus_scanf(NULL, dev->nodename,
+	                   "instance","%li", &instance);
+	if (XENBUS_EXIST_ERR(err)) {
 		return;
 	}
 
-	if (be->tpmif == NULL || be->tpmif->status == CONNECTED)
+	if (err != 1) {
+		xenbus_dev_fatal(dev, err, "reading instance");
 		return;
+	}
 
-	err = xenbus_gather(NULL, be->frontpath,
-	                    "ring-ref", "%lu", &ringref,
-			    "event-channel", "%u", &evtchn, NULL);
-	if (err) {
-		xenbus_dev_error(be->dev, err,
-				 "reading %s/ring-ref and event-channel",
-				 be->frontpath);
+	if (be->is_instance_set != FALSE && be->instance != instance) {
+		printk(KERN_WARNING
+		       "tpmback: changing instance (from %ld to %ld) "
+		       "not allowed.\n",
+		       be->instance, instance);
 		return;
 	}
 
-	err = tpmif_map(be->tpmif, ringref, evtchn);
-	if (err) {
-		xenbus_dev_error(be->dev, err,
-				 "mapping shared-frame %lu port %u",
-				 ringref, evtchn);
-		return;
+	if (be->is_instance_set == FALSE) {
+		be->tpmif = tpmif_find(dev->otherend_id,
+		                       instance);
+		if (IS_ERR(be->tpmif)) {
+			err = PTR_ERR(be->tpmif);
+			be->tpmif = NULL;
+			xenbus_dev_fatal(dev,err,"creating block interface");
+			return;
+		}
+		be->instance = instance;
+		be->is_instance_set = TRUE;
+
+		/*
+		 * There's an unfortunate problem:
+		 * Sometimes after a suspend/resume the
+		 * state switch to XenbusStateInitialised happens
+		 * *before* I get to this point here. Since then
+		 * the connect_ring() must have failed (be->tpmif is
+		 * still NULL), I just call it here again indirectly.
+		 */
+		if (be->frontend_state == XenbusStateInitialised) {
+			frontend_changed(dev, be->frontend_state);
+		}
 	}
+}
+
+
+static void frontend_changed(struct xenbus_device *dev,
+                             XenbusState frontend_state)
+{
+	struct backend_info *be = dev->data;
+	int err;
+
+	be->frontend_state = frontend_state;
+
+	switch (frontend_state) {
+	case XenbusStateInitialising:
+	case XenbusStateConnected:
+		break;
+
+	case XenbusStateInitialised:
+		err = connect_ring(be);
+		if (err) {
+			return;
+		}
+		maybe_connect(be);
+		break;
+
+	case XenbusStateClosing:
+		xenbus_switch_state(dev, NULL, XenbusStateClosing);
+		break;
+
+	case XenbusStateClosed:
+		/*
+		 * Notify the vTPM manager about the front-end
+		 * having left.
+		 */
+		tpmif_vtpm_close(be->instance);
+		device_unregister(&be->dev->dev);
+		break;
+
+	case XenbusStateUnknown:
+	case XenbusStateInitWait:
+	default:
+		xenbus_dev_fatal(dev, -EINVAL,
+		                 "saw state %d at frontend",
+		                 frontend_state);
+		break;
+	}
+}
+
+
+
+static void maybe_connect(struct backend_info *be)
+{
+	int err;
+
+	if (be->tpmif == NULL || be->tpmif->status == CONNECTED)
+		return;
+
+	connect(be);
 
+	/*
+	 * Notify the vTPM manager about a new front-end.
+	 */
 	err = tpmif_vtpm_open(be->tpmif,
 	                      be->frontend_id,
 	                      be->instance);
@@ -107,157 +225,75 @@ static void frontend_changed(struct xenbus_watch *watch,
 		 */
 		return;
 	}
+}
+
+
+static void connect(struct backend_info *be)
+{
+	struct xenbus_transaction *xbt;
+	int err;
+	struct xenbus_device *dev = be->dev;
+	unsigned long ready = 1;
 
-	/*
-	 * Tell the front-end that we are ready to go -
-	 * unless something bad happens
-	 */
 again:
 	xbt = xenbus_transaction_start();
 	if (IS_ERR(xbt)) {
-		xenbus_dev_error(be->dev, err, "starting transaction");
+		err = PTR_ERR(xbt);
+		xenbus_dev_fatal(be->dev, err, "starting transaction");
 		return;
 	}
 
 	err = xenbus_printf(xbt, be->dev->nodename,
 	                    "ready", "%lu", ready);
 	if (err) {
-		xenbus_dev_error(be->dev, err, "writing 'ready'");
+		xenbus_dev_fatal(be->dev, err, "writing 'ready'");
 		goto abort;
 	}
 
+	err = xenbus_switch_state(dev, xbt, XenbusStateConnected);
+	if (err)
+		goto abort;
+
+	be->tpmif->status = CONNECTED;
+
 	err = xenbus_transaction_end(xbt, 0);
 	if (err == -EAGAIN)
 		goto again;
 	if (err) {
-		xenbus_dev_error(be->dev, err, "end of transaction");
-		goto abort;
+		xenbus_dev_fatal(be->dev, err, "end of transaction");
 	}
-
-	xenbus_dev_ok(be->dev);
 	return;
 abort:
 	xenbus_transaction_end(xbt, 1);
 }
 
 
-static void backend_changed(struct xenbus_watch *watch,
-			    const char **vec, unsigned int len)
+static int connect_ring(struct backend_info *be)
 {
-	int err;
-	long int instance;
-	struct backend_info *be
-		= container_of(watch, struct backend_info, backend_watch);
 	struct xenbus_device *dev = be->dev;
-
-	err = xenbus_scanf(NULL, dev->nodename, "instance", "%li", &instance);
-	if (XENBUS_EXIST_ERR(err))
-		return;
-	if (err < 0) {
-		xenbus_dev_error(dev, err, "reading 'instance' variable");
-		return;
-	}
-
-	if (be->instance != -1 && be->instance != instance) {
-		printk(KERN_WARNING
-		       "cannot change the instance\n");
-		return;
-	}
-	be->instance = instance;
-
-	if (be->tpmif == NULL) {
-		unsigned int len = max(XS_WATCH_PATH, XS_WATCH_TOKEN) + 1;
-		const char *vec[len];
-
-		be->tpmif = tpmif_find(be->frontend_id,
-		                       instance);
-		if (IS_ERR(be->tpmif)) {
-			err = PTR_ERR(be->tpmif);
-			be->tpmif = NULL;
-			xenbus_dev_error(dev, err, "creating interface");
-			return;
-		}
-
-		vec[XS_WATCH_PATH] = be->frontpath;
-		vec[XS_WATCH_TOKEN] = NULL;
-
-		/* Pass in NULL node to skip exist test. */
-		frontend_changed(&be->watch, vec, len);
-	}
-}
-
-
-static int tpmback_probe(struct xenbus_device *dev,
-			 const struct xenbus_device_id *id)
-{
-	struct backend_info *be;
-	char *frontend;
+	unsigned long ring_ref;
+	unsigned int evtchn;
 	int err;
 
-	be = kmalloc(sizeof(*be), GFP_KERNEL);
-	if (!be) {
-		xenbus_dev_error(dev, -ENOMEM, "allocating backend structure");
-		err = -ENOMEM;
-	}
-
-	memset(be, 0, sizeof(*be));
-
-	frontend = NULL;
-	err = xenbus_gather(NULL, dev->nodename,
-			    "frontend-id", "%li", &be->frontend_id,
-			    "frontend", NULL, &frontend,
-			    NULL);
-	if (XENBUS_EXIST_ERR(err))
-		goto free_be;
-	if (err < 0) {
-		xenbus_dev_error(dev, err,
-				 "reading %s/frontend or frontend-id",
-				 dev->nodename);
-		goto free_be;
-	}
-	if (strlen(frontend) == 0 || !xenbus_exists(NULL, frontend, "")) {
-		/* If we can't get a frontend path and a frontend-id,
-		 * then our bus-id is no longer valid and we need to
-		 * destroy the backend device.
-		 */
-		err = -ENOENT;
-		goto free_be;
-	}
-
-	be->dev = dev;
-	be->backend_watch.node     = dev->nodename;
-	/* Implicitly calls backend_changed() once. */
-	be->backend_watch.callback = backend_changed;
-	be->instance = -1;
-	err = register_xenbus_watch(&be->backend_watch);
-	if (err) {
-		be->backend_watch.node = NULL;
-		xenbus_dev_error(dev, err, "adding backend watch on %s",
-				 dev->nodename);
-		goto free_be;
-	}
-
-	be->frontpath = frontend;
-	be->watch.node = be->frontpath;
-	be->watch.callback = frontend_changed;
-	err = register_xenbus_watch(&be->watch);
+	err = xenbus_gather(NULL, dev->otherend,
+	                    "ring-ref", "%lu", &ring_ref,
+			    "event-channel", "%u", &evtchn, NULL);
 	if (err) {
-		be->watch.node = NULL;
 		xenbus_dev_error(dev, err,
-				 "adding frontend watch on %s",
-				 be->frontpath);
-		goto free_be;
+				 "reading %s/ring-ref and event-channel",
+				 dev->otherend);
+		return err;
 	}
-
-	dev->data = be;
-	return err;
-
-free_be:
-	if (be->backend_watch.node)
-		unregister_xenbus_watch(&be->backend_watch);
-	kfree(frontend);
-	kfree(be);
-	return err;
+	if (be->tpmif != NULL) {
+		err = tpmif_map(be->tpmif, ring_ref, evtchn);
+		if (err) {
+			xenbus_dev_error(dev, err,
+			    	         "mapping shared-frame %lu port %u",
+				         ring_ref, evtchn);
+			return err;
+		}
+	}
+	return 0;
 }
 
 
@@ -273,6 +309,7 @@ static struct xenbus_driver tpmback = {
 	.ids = tpmback_ids,
 	.probe = tpmback_probe,
 	.remove = tpmback_remove,
+	.otherend_changed = frontend_changed,
 };
 
 
diff --git a/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.c b/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.c
index c7e58493cd..84a31717eb 100644
--- a/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.c
+++ b/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.c
@@ -73,7 +73,8 @@ static void tpmif_rx_action(unsigned long unused);
 static void tpmif_connect(u16 evtchn, domid_t domid);
 static DECLARE_TASKLET(tpmif_rx_tasklet, tpmif_rx_action, 0);
 static int tpm_allocate_buffers(struct tpm_private *tp);
-static void tpmif_set_connected_state(struct tpm_private *tp, int newstate);
+static void tpmif_set_connected_state(struct tpm_private *tp,
+                                      u8 newstate);
 static int tpm_xmit(struct tpm_private *tp,
                     const u8 * buf, size_t count, int userbuffer,
                     void *remember);
@@ -212,87 +213,46 @@ static int tpm_fe_send_upperlayer(const u8 * buf, size_t count,
  XENBUS support code
 **************************************************************/
 
-static void watch_for_status(struct xenbus_watch *watch,
-			     const char **vec, unsigned int len)
-{
-	struct tpmfront_info *info;
-	int err;
-	unsigned long ready;
-	struct tpm_private *tp = &my_private;
-	const char *node = vec[XS_WATCH_PATH];
-
-	info = container_of(watch, struct tpmfront_info, watch);
-	node += strlen(watch->node);
-
-	if (tp->connected)
-		return;
-
-	err = xenbus_gather(NULL, watch->node,
-	                    "ready", "%lu", &ready,
-	                    NULL);
-	if (err) {
-		xenbus_dev_error(info->dev, err, "reading 'ready' field");
-		return;
-	}
-
-	tpmif_set_connected_state(tp, 1);
-
-	xenbus_dev_ok(info->dev);
-}
-
-
 static int setup_tpmring(struct xenbus_device *dev,
-                         struct tpmfront_info * info,
-                         domid_t backend_id)
+                         struct tpmfront_info * info)
 {
 	tpmif_tx_interface_t *sring;
 	struct tpm_private *tp = &my_private;
 	int err;
-	evtchn_op_t op = {
-		.cmd = EVTCHNOP_alloc_unbound,
-		.u.alloc_unbound.dom = DOMID_SELF,
-		.u.alloc_unbound.remote_dom = backend_id } ;
 
 	sring = (void *)__get_free_page(GFP_KERNEL);
 	if (!sring) {
-		xenbus_dev_error(dev, -ENOMEM, "allocating shared ring");
+		xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring");
 		return -ENOMEM;
 	}
 	tp->tx = sring;
 
 	tpm_allocate_buffers(tp);
 
-	err = gnttab_grant_foreign_access(backend_id,
-					  (virt_to_machine(tp->tx) >> PAGE_SHIFT),
-					  0);
-
-	if (err == -ENOSPC) {
+	err = xenbus_grant_ring(dev, virt_to_mfn(tp->tx));
+	if (err < 0) {
 		free_page((unsigned long)sring);
 		tp->tx = NULL;
-		xenbus_dev_error(dev, err, "allocating grant reference");
-		return err;
+		xenbus_dev_fatal(dev, err, "allocating grant reference");
+		goto fail;
 	}
 	info->ring_ref = err;
 
-	err = HYPERVISOR_event_channel_op(&op);
-	if (err) {
-		gnttab_end_foreign_access(info->ring_ref, 0,
-					  (unsigned long)sring);
-		tp->tx = NULL;
-		xenbus_dev_error(dev, err, "allocating event channel");
-		return err;
-	}
+	err = xenbus_alloc_evtchn(dev, &tp->evtchn);
+	if (err)
+		goto fail;
 
-	tpmif_connect(op.u.alloc_unbound.port, backend_id);
+	tpmif_connect(tp->evtchn, dev->otherend_id);
 
 	return 0;
+fail:
+	return err;
 }
 
 
 static void destroy_tpmring(struct tpmfront_info *info, struct tpm_private *tp)
 {
-	tpmif_set_connected_state(tp,0);
-
+	tpmif_set_connected_state(tp, FALSE);
 	if ( tp->tx != NULL ) {
 		gnttab_end_foreign_access(info->ring_ref, 0,
 					  (unsigned long)tp->tx);
@@ -308,42 +268,20 @@ static void destroy_tpmring(struct tpmfront_info *info, struct tpm_private *tp)
 static int talk_to_backend(struct xenbus_device *dev,
                            struct tpmfront_info *info)
 {
-	char *backend;
-	const char *message;
+	const char *message = NULL;
 	int err;
-	int backend_id;
 	struct xenbus_transaction *xbt;
 
-	backend = NULL;
-	err = xenbus_gather(NULL, dev->nodename,
-			    "backend-id", "%i", &backend_id,
-			    "backend", NULL, &backend,
-			    NULL);
-	if (XENBUS_EXIST_ERR(err))
-		goto out;
-	if (backend && strlen(backend) == 0) {
-		err = -ENOENT;
-		goto out;
-	}
-	if (err < 0) {
-		xenbus_dev_error(dev, err, "reading %s/backend or backend-id",
-				 dev->nodename);
-		goto out;
-	}
-
-	info->backend_id      = backend_id;
-	my_private.backend_id = backend_id;
-
-	err = setup_tpmring(dev, info, backend_id);
+	err = setup_tpmring(dev, info);
 	if (err) {
-		xenbus_dev_error(dev, err, "setting up ring");
+		xenbus_dev_fatal(dev, err, "setting up ring");
 		goto out;
 	}
 
 again:
 	xbt = xenbus_transaction_start();
 	if (IS_ERR(xbt)) {
-		xenbus_dev_error(dev, err, "starting transaction");
+		xenbus_dev_fatal(dev, err, "starting transaction");
 		goto destroy_tpmring;
 	}
 
@@ -361,36 +299,62 @@ again:
 		goto abort_transaction;
 	}
 
-	err = xenbus_transaction_end(xbt, 0);
-	if (err == -EAGAIN)
-		goto again;
+	err = xenbus_switch_state(dev, xbt, XenbusStateInitialised);
 	if (err) {
-		xenbus_dev_error(dev, err, "completing transaction");
-		goto destroy_tpmring;
+		goto abort_transaction;
 	}
 
-	info->watch.node = backend;
-	info->watch.callback = watch_for_status;
-	err = register_xenbus_watch(&info->watch);
+	err = xenbus_transaction_end(xbt, 0);
+	if (err == -EAGAIN)
+		goto again;
 	if (err) {
-		xenbus_dev_error(dev, err, "registering watch on backend");
+		xenbus_dev_fatal(dev, err, "completing transaction");
 		goto destroy_tpmring;
 	}
-
-	info->backend = backend;
-
 	return 0;
 
 abort_transaction:
 	xenbus_transaction_end(xbt, 1);
-	xenbus_dev_error(dev, err, "%s", message);
+	if (message)
+		xenbus_dev_error(dev, err, "%s", message);
 destroy_tpmring:
 	destroy_tpmring(info, &my_private);
 out:
-	kfree(backend);
 	return err;
 }
 
+/**
+ * Callback received when the backend's state changes.
+ */
+static void backend_changed(struct xenbus_device *dev,
+			    XenbusState backend_state)
+{
+	struct tpm_private *tp = &my_private;
+	DPRINTK("\n");
+
+	switch (backend_state) {
+	case XenbusStateInitialising:
+	case XenbusStateInitWait:
+	case XenbusStateInitialised:
+	case XenbusStateUnknown:
+		break;
+
+	case XenbusStateConnected:
+		tpmif_set_connected_state(tp, TRUE);
+		break;
+
+	case XenbusStateClosing:
+		tpmif_set_connected_state(tp, FALSE);
+		break;
+
+	case XenbusStateClosed:
+        	if (tp->is_suspended == FALSE) {
+        	        device_unregister(&dev->dev);
+        	}
+	        break;
+	}
+}
+
 
 static int tpmfront_probe(struct xenbus_device *dev,
                           const struct xenbus_device_id *id)
@@ -398,8 +362,6 @@ static int tpmfront_probe(struct xenbus_device *dev,
 	int err;
 	struct tpmfront_info *info;
 	int handle;
-	int len = max(XS_WATCH_PATH, XS_WATCH_TOKEN) + 1;
-	const char *vec[len];
 
 	err = xenbus_scanf(NULL, dev->nodename,
 	                   "handle", "%i", &handle);
@@ -407,19 +369,19 @@ static int tpmfront_probe(struct xenbus_device *dev,
 		return err;
 
 	if (err < 0) {
-		xenbus_dev_error(dev,err,"reading virtual-device");
+		xenbus_dev_fatal(dev,err,"reading virtual-device");
 		return err;
 	}
 
 	info = kmalloc(sizeof(*info), GFP_KERNEL);
 	if (!info) {
-		xenbus_dev_error(dev,err,"allocating info structure");
+		err = -ENOMEM;
+		xenbus_dev_fatal(dev,err,"allocating info structure");
 		return err;
 	}
 	memset(info, 0x0, sizeof(*info));
 
 	info->dev = dev;
-	info->handle = handle;
 	dev->data = info;
 
 	err = talk_to_backend(dev, info);
@@ -428,41 +390,33 @@ static int tpmfront_probe(struct xenbus_device *dev,
 		dev->data = NULL;
 		return err;
 	}
-
-	vec[XS_WATCH_PATH]  = info->watch.node;
-	vec[XS_WATCH_TOKEN] = NULL;
-	watch_for_status(&info->watch, vec, len);
-
 	return 0;
 }
 
+
 static int tpmfront_remove(struct xenbus_device *dev)
 {
 	struct tpmfront_info *info = dev->data;
-	if (info->backend)
-		unregister_xenbus_watch(&info->watch);
 
 	destroy_tpmring(info, &my_private);
 
-	kfree(info->backend);
 	kfree(info);
-
 	return 0;
 }
 
 static int
 tpmfront_suspend(struct xenbus_device *dev)
 {
-	struct tpmfront_info *info = dev->data;
 	struct tpm_private *tp = &my_private;
 	u32 ctr = 0;
 
 	/* lock, so no app can send */
 	down(&suspend_lock);
+	tp->is_suspended = TRUE;
 
 	while (atomic_read(&tp->tx_busy) && ctr <= 25) {
-	        if ((ctr % 10) == 0)
-			printk("INFO: Waiting for outstanding request.\n");
+		if ((ctr % 10) == 0)
+			printk("TPM-FE [INFO]: Waiting for outstanding request.\n");
 		/*
 		 * Wait for a request to be responded to.
 		 */
@@ -474,15 +428,10 @@ tpmfront_suspend(struct xenbus_device *dev)
 		/*
 		 * A temporary work-around.
 		 */
-		printk("WARNING: Resetting busy flag.");
+		printk("TPM-FE [WARNING]: Resetting busy flag.");
 		atomic_set(&tp->tx_busy, 0);
 	}
 
-	unregister_xenbus_watch(&info->watch);
-
-	kfree(info->backend);
-	info->backend = NULL;
-
 	return 0;
 }
 
@@ -492,8 +441,6 @@ tpmfront_resume(struct xenbus_device *dev)
 	struct tpmfront_info *info = dev->data;
 	int err = talk_to_backend(dev, info);
 
-	/* unlock, so apps can resume sending */
-	up(&suspend_lock);
 
 	return err;
 }
@@ -530,12 +477,13 @@ static struct xenbus_driver tpmfront = {
 	.probe = tpmfront_probe,
 	.remove =  tpmfront_remove,
 	.resume = tpmfront_resume,
+	.otherend_changed = backend_changed,
 	.suspend = tpmfront_suspend,
 };
 
 static void __init init_tpm_xenbus(void)
 {
-	xenbus_register_driver(&tpmfront);
+	xenbus_register_frontend(&tpmfront);
 }
 
 
@@ -628,12 +576,13 @@ tpm_xmit(struct tpm_private *tp,
 	spin_lock_irq(&tp->tx_lock);
 
 	if (unlikely(atomic_read(&tp->tx_busy))) {
-		printk("There's an outstanding request/response on the way!\n");
+		printk("tpm_xmit: There's an outstanding request/response "
+		       "on the way!\n");
 		spin_unlock_irq(&tp->tx_lock);
 		return -EBUSY;
 	}
 
-	if (tp->connected != 1) {
+	if (tp->is_connected != TRUE) {
 		spin_unlock_irq(&tp->tx_lock);
 		return -EIO;
 	}
@@ -705,24 +654,40 @@ static void tpmif_notify_upperlayer(struct tpm_private *tp)
 	down(&upperlayer_lock);
 
 	if (upperlayer_tpmfe != NULL) {
-		switch (tp->connected) {
-			case 1:
-				upperlayer_tpmfe->status(TPMFE_STATUS_CONNECTED);
-			break;
-
-			default:
-				upperlayer_tpmfe->status(0);
-			break;
+		if (tp->is_connected) {
+			upperlayer_tpmfe->status(TPMFE_STATUS_CONNECTED);
+		} else {
+			upperlayer_tpmfe->status(0);
 		}
 	}
 	up(&upperlayer_lock);
 }
 
 
-static void tpmif_set_connected_state(struct tpm_private *tp, int newstate)
+static void tpmif_set_connected_state(struct tpm_private *tp, u8 is_connected)
 {
-	if (newstate != tp->connected) {
-		tp->connected = newstate;
+	/*
+	 * Don't notify upper layer if we are in suspend mode and
+	 * should disconnect - assumption is that we will resume
+	 * The semaphore keeps apps from sending.
+	 */
+	if (is_connected == FALSE && tp->is_suspended == TRUE) {
+		return;
+	}
+
+	/*
+	 * Unlock the semaphore if we are connected again
+	 * after being suspended - now resuming.
+	 * This also removes the suspend state.
+	 */
+	if (is_connected == TRUE && tp->is_suspended == TRUE) {
+		tp->is_suspended = FALSE;
+		/* unlock, so apps can resume sending */
+		up(&suspend_lock);
+	}
+
+	if (is_connected != tp->is_connected) {
+		tp->is_connected = is_connected;
 		tpmif_notify_upperlayer(tp);
 	}
 }
diff --git a/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.h b/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.h
index f5ddea0cbf..0eb5bf0d3e 100644
--- a/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.h
+++ b/linux-2.6-xen-sparse/drivers/xen/tpmfront/tpmfront.h
@@ -1,12 +1,17 @@
 #ifndef TPM_FRONT_H
 #define TPM_FRONT_H
 
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
 
-struct tpm_private
-{
+struct tpm_private {
 	tpmif_tx_interface_t *tx;
-	unsigned int evtchn, irq;
-	int connected;
+	unsigned int evtchn;
+	unsigned int irq;
+	u8 is_connected;
+	u8 is_suspended;
 
 	spinlock_t tx_lock;
 
@@ -16,25 +21,18 @@ struct tpm_private
 	void *tx_remember;
 	domid_t backend_id;
 	wait_queue_head_t wait_q;
-};
 
+};
 
-struct tpmfront_info
-{
-	struct xenbus_watch watch;
-	int handle;
+struct tpmfront_info {
 	struct xenbus_device *dev;
-	char *backend;
 	int ring_ref;
-	domid_t backend_id;
 };
 
-
-struct tx_buffer
-{
+struct tx_buffer {
 	unsigned int size;	// available space in data
 	unsigned int len;	// used space in data
-	unsigned char *data;    // pointer to a page
+	unsigned char *data;	// pointer to a page
 };
 
 #endif
diff --git a/tools/examples/Makefile b/tools/examples/Makefile
index 39223bd41d..6c542aeae3 100644
--- a/tools/examples/Makefile
+++ b/tools/examples/Makefile
@@ -26,9 +26,10 @@ XEN_SCRIPTS += network-route vif-route
 XEN_SCRIPTS += network-nat vif-nat
 XEN_SCRIPTS += block
 XEN_SCRIPTS += block-enbd block-nbd
+XEN_SCRIPTS += vtpm
 XEN_SCRIPT_DATA = xen-script-common.sh
 XEN_SCRIPT_DATA += xen-hotplug-common.sh xen-network-common.sh vif-common.sh
-XEN_SCRIPT_DATA += block-common.sh
+XEN_SCRIPT_DATA += block-common.sh vtpm-common.sh
 
 XEN_HOTPLUG_DIR = /etc/hotplug
 XEN_HOTPLUG_SCRIPTS = xen-backend.agent
diff --git a/tools/examples/vtpm b/tools/examples/vtpm
new file mode 100644
index 0000000000..bc8b64d974
--- /dev/null
+++ b/tools/examples/vtpm
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+dir=$(dirname "$0")
+. "$dir/vtpm-common.sh"
+
+
+case "$command" in
+    online | offline)
+        exit 0
+        ;;
+esac
+
+case "$command" in
+  add)
+    vtpm_create_instance
+  ;;
+  remove)
+    vtpm_remove_instance
+  ;;
+esac
+
+log debug "Successful vTPM operation '$command'."
+success
diff --git a/tools/examples/vtpm-common.sh b/tools/examples/vtpm-common.sh
new file mode 100644
index 0000000000..4c90558ef8
--- /dev/null
+++ b/tools/examples/vtpm-common.sh
@@ -0,0 +1,281 @@
+#
+# Copyright (c) 2005 IBM Corporation
+# Copyright (c) 2005 XenSource Ltd.
+#
+# 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
+#
+
+dir=$(dirname "$0")
+. "$dir/xen-hotplug-common.sh"
+
+findCommand "$@"
+if [ "$command" != "online" ]  &&
+   [ "$command" != "offline" ] &&
+   [ "$command" != "add" ]     &&
+   [ "$command" != "remove" ]
+then
+	log err "Invalid command: $command"
+	exit 1
+fi
+
+
+XENBUS_PATH="${XENBUS_PATH:?}"
+
+
+VTPMDB="/etc/xen/vtpm.db"
+
+#In the vtpm-impl file some commands should be defined:
+#      vtpm_create, vtpm_setup, vtpm_reset, etc. (see below)
+#This should be indicated by setting VTPM_IMPL_DEFINED.
+if [ -r "$dir/vtpm-impl" ]; then
+	. "$dir/vtpm-impl"
+fi
+
+if [ -z "$VTPM_IMPL_DEFINED" ]; then
+	function vtpm_create () {
+		true
+	}
+	function vtpm_setup() {
+		true
+	}
+	function vtpm_reset() {
+		true
+	}
+	function vtpm_suspend() {
+		true
+	}
+	function vtpm_resume() {
+		true
+	}
+fi
+
+#Find the instance number for the vtpm given the name of the domain
+# Parameters
+# - vmname : the name of the vm
+# Return value
+#  Returns '0' if instance number could not be found, otherwise
+#  it returns the instance number in the variable 'instance'
+function find_instance () {
+	local vmname=$1
+	local ret=0
+	instance=`cat $VTPMDB |                    \
+	          awk -vvmname=$vmname             \
+	          '{                               \
+	             if ( 1 != index($1,"#")) {    \
+	               if ( $1 == vmname ) {       \
+	                 print $2;                 \
+	                 exit;                     \
+	               }                           \
+	             }                             \
+	           }'`
+	if [ "$instance" != "" ]; then
+		ret=1
+	fi
+	return $ret
+}
+
+
+# Check whether a particular instance number is still available
+# returns '1' if it is available
+function is_free_instancenum () {
+	local instance=$1
+	local avail=1
+
+	#Allowed instance number range: 1-255
+	if [ $instance -eq 0 -o $instance -gt 255 ]; then
+		avail=0
+	else
+		instances=`cat $VTPMDB |                 \
+		           gawk                          \
+		           '{                            \
+		               if (1 != index($1,"#")) { \
+		                 printf("%s ",$2);       \
+		               }                         \
+		            }'`
+		for i in $instances; do
+			if [ $i -eq $instance ]; then
+				avail=0
+				break
+			fi
+		done
+	fi
+	return $avail
+}
+
+
+# Get an available instance number given the database
+# Returns an unused instance number
+function get_free_instancenum () {
+	local ctr
+	local instances
+	local don
+	instances=`cat $VTPMDB |                 \
+	           gawk                          \
+	           '{                            \
+	               if (1 != index($1,"#")) { \
+	                 printf("%s ",$2);       \
+	               }                         \
+	            }'`
+	ctr=1
+	don=0
+	while [ $don -eq 0 ]; do
+		local found
+		found=0
+		for i in $instances; do
+			if [ $i -eq $ctr ]; then
+				found=1;
+				break;
+			fi
+		done
+
+		if [ $found -eq 0 ]; then
+			don=1
+			break
+		fi
+		let ctr=ctr+1
+	done
+	let instance=$ctr
+}
+
+
+# Add a domain name and instance number to the DB file
+function add_instance () {
+	local vmname=$1
+	local inst=$2
+
+	if [ ! -f $VTPMDB ]; then
+		echo "#Database for VM to vTPM association" > $VTPMDB
+		echo "#1st column: domain name" >> $VTPMDB
+		echo "#2nd column: TPM instance number" >> $VTPMDB
+	fi
+	validate_entry $vmname $inst
+	if [ $? -eq 0 ]; then
+		echo "$vmname $inst" >> $VTPMDB
+	fi
+}
+
+
+#Validate whether an entry is the same as passed to this
+#function
+function validate_entry () {
+	local rc=0
+	local vmname=$1
+	local inst=$2
+	local res
+	res=`cat $VTPMDB |             \
+	     gawk -vvmname=$vmname     \
+	          -vinst=$inst         \
+	     '{                        \
+	         if ( 1 == index($1,"#")) {\
+	         } else                \
+	         if ( $1 == vmname &&  \
+	              $2 == inst) {    \
+	            printf("1");       \
+	            exit;              \
+	         } else                \
+	         if ( $1 == vmname ||  \
+	              $2 == inst) {    \
+	            printf("2");       \
+	            exit;              \
+	         }                     \
+	     }'`
+
+	if [ "$res" == "1" ]; then
+		let rc=1
+	elif [ "$res" == "2" ]; then
+		let rc=2
+	fi
+	return $rc
+}
+
+
+#Remove an entry from the vTPM database given its domain name
+function remove_entry () {
+	local vmname=$1
+	local VTPMDB_TMP="$VTPMDB".tmp
+	`cat $VTPMDB |             \
+	 gawk -vvmname=$vmname     \
+	 '{                        \
+	    if ( $1 != vmname ) {  \
+	      print $0;            \
+	    }                      \
+	 '} > $VTPMDB_TMP`
+	if [ -e $VTPMDB_TMP ]; then
+		mv -f $VTPMDB_TMP $VTPMDB
+	else
+		log err "Error creating temporary file '$VTPMDB_TMP'."
+	fi
+}
+
+
+#Create a vTPM instance
+# If no entry in the TPM database is found, the instance is
+# created and an entry added to the database.
+function vtpm_create_instance () {
+	local domname=$(xenstore_read "$XENBUS_PATH"/domain)
+	local res
+	set +e
+	find_instance $domname
+	res=$?
+	if [ $res -eq 0 ]; then
+		#Try to give the preferred instance to the domain
+		instance=$(xenstore_read "$XENBUS_PATH"/pref_instance)
+		if [ "$instance" != "" ]; then
+			is_free_instancenum $instance
+			res=$?
+			if [ $res -eq 0 ]; then
+				get_free_instancenum
+			fi
+		else
+			get_free_instancenum
+		fi
+		add_instance $domname $instance
+		if [ "$REASON" == "create" ]; then
+			vtpm_create $instance
+		elif [ "$REASON" == "hibernate" ]; then
+			vtpm_resume $instance $domname
+		else
+			#default case for 'now'
+			vtpm_create $instance
+		fi
+	fi
+	if [ "$REASON" == "create" ]; then
+		vtpm_reset $instance
+	elif [ "$REASON" == "hibernate" ]; then
+		vtpm_setup $instance
+	else
+		#default case for 'now'
+		vtpm_reset $instance
+	fi
+	xenstore_write $XENBUS_PATH/instance $instance
+	set -e
+}
+
+
+#Remove an instance
+function vtpm_remove_instance () {
+	local domname=$(xenstore_read "$XENBUS_PATH"/domain)
+	set +e
+	find_instance $domname
+	res=$?
+	if [ $res -eq 0 ]; then
+		#Something is really wrong with the DB
+		log err "vTPM DB file $VTPMDB has no entry for '$domname'"
+	else
+		if [ "$REASON" == "hibernate" ]; then
+			vtpm_suspend $instance
+		fi
+	fi
+	set -e
+}
diff --git a/tools/examples/xen-backend.agent b/tools/examples/xen-backend.agent
index 37827b0386..3c83489f1f 100755
--- a/tools/examples/xen-backend.agent
+++ b/tools/examples/xen-backend.agent
@@ -6,6 +6,9 @@ case "$XENBUS_TYPE" in
   vbd)
     /etc/xen/scripts/block "$ACTION"
     ;;
+  vtpm)
+    /etc/xen/scripts/vtpm "$ACTION"
+    ;;
   vif)
     [ -n "$script" ] && $script "$ACTION"
     ;;
diff --git a/tools/examples/xen-backend.rules b/tools/examples/xen-backend.rules
index 8114594cc1..aec5c46121 100644
--- a/tools/examples/xen-backend.rules
+++ b/tools/examples/xen-backend.rules
@@ -1,4 +1,5 @@
 SUBSYSTEM=="xen-backend", KERNEL=="vbd*", RUN+="/etc/xen/scripts/block $env{ACTION}"
+SUBSYSTEM=="xen-backend", KERNEL=="vtpm*", RUN+="/etc/xen/scripts/vtpm $env{ACTION}"
 SUBSYSTEM=="xen-backend", KERNEL=="vif*", ACTION=="online", RUN+="$env{script} online"
 SUBSYSTEM=="xen-backend", KERNEL=="vif*", ACTION=="offline", RUN+="$env{script} offline"
 SUBSYSTEM=="xen-backend", ACTION=="remove", RUN+="/bin/bash -c '/usr/bin/xenstore-rm -t $$(/usr/bin/xenstore-read $env{XENBUS_PATH}/frontend)'"
diff --git a/tools/python/xen/xend/image.py b/tools/python/xen/xend/image.py
index 0cc32ad977..966584815b 100644
--- a/tools/python/xen/xend/image.py
+++ b/tools/python/xen/xend/image.py
@@ -293,7 +293,7 @@ class VmxImageHandler(ImageHandler):
                ret.append("-bridge")
                ret.append("%s" % bridge)
             if name == 'vtpm':
-               instance = sxp.child_value(info, 'instance')
+               instance = sxp.child_value(info, 'pref_instance')
                ret.append("-instance")
                ret.append("%s" % instance)
         return ret
diff --git a/tools/python/xen/xend/server/tpmif.py b/tools/python/xen/xend/server/tpmif.py
index ee96f7bb44..57ac520527 100644
--- a/tools/python/xen/xend/server/tpmif.py
+++ b/tools/python/xen/xend/server/tpmif.py
@@ -38,10 +38,10 @@ class TPMifController(DevController):
     def getDeviceDetails(self, config):
         """@see DevController.getDeviceDetails"""
 
-        devid = int(sxp.child_value(config, 'instance', '0'))
+        devid = int(sxp.child_value(config, 'pref_instance', '0'))
         log.info("The domain has a TPM with instance %d." % devid)
 
-        back  = { 'instance' : "%i" % devid }
+        back  = { 'pref_instance' : "%i" % devid }
         front = { 'handle' : "%i" % devid }
 
         return (devid, back, front)
diff --git a/tools/python/xen/xm/create.py b/tools/python/xen/xm/create.py
index 8bf3c5f6ef..d3756d3adc 100644
--- a/tools/python/xen/xm/create.py
+++ b/tools/python/xen/xm/create.py
@@ -220,11 +220,9 @@ gopts.var('netif', val='no|yes',
           fn=set_bool, default=0,
           use="Make the domain a network interface backend.")
 
-gopts.var('tpmif', val='frontend=DOM',
-          fn=append_value, default=[],
-          use="""Make the domain a TPM interface backend. If frontend is given,
-          the frontend in that domain is connected to this backend (not
-          completely implemented, yet)""")
+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=[],
@@ -273,9 +271,13 @@ gopts.var('vif', val="type=TYPE,mac=MAC,be_mac=MAC,bridge=BRIDGE,script=SCRIPT,b
 
 gopts.var('vtpm', val="instance=INSTANCE,backend=DOM",
           fn=append_value, default=[],
-          use="""Add a tpm interface. On the backend side us the the given
-          instance as virtual TPM instance. Use the backend in the given
-          domain.""")
+          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.""")
 
 gopts.var('nics', val="NUM",
           fn=set_int, default=1,
@@ -465,34 +467,20 @@ def configure_vtpm(config_devs, vals):
             if instance == "VTPMD":
                 instance = "0"
             else:
-                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.')
+                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')
             config_vtpm = ['vtpm']
             if instance:
-                config_vtpm.append(['instance', instance])
+                config_vtpm.append(['pref_instance', instance])
             if backend:
                 config_vtpm.append(['backend', backend])
             config_devs.append(['device', config_vtpm])
 
-def configure_tpmif(config_devs, vals):
-    """Create the config for virtual TPM interfaces.
-    """
-    tpmif = vals.tpmif
-    tpmif_n = 1
-    for idx in range(0, tpmif_n):
-        if idx < len(tpmif):
-            d = tpmif[idx]
-            frontend = d.get('frontend')
-            config_tpmif = ['tpmif']
-            if frontend:
-                config_tpmif.append(['frontend', frontend])
-            config_devs.append(['device', config_tpmif])
-
-
 def configure_vifs(config_devs, vals):
     """Create the config for virtual network interfaces.
     """
@@ -685,22 +673,6 @@ def preprocess_vtpm(vals):
         vtpms.append(d)
     vals.vtpm = vtpms
 
-def preprocess_tpmif(vals):
-    if not vals.tpmif: return
-    tpmifs = []
-    for tpmif in vals.tpmif:
-        d = {}
-        a = tpmif.split(',')
-        for b in a:
-            (k, v) = b.strip().split('=', 1)
-            k = k.strip()
-            v = v.strip()
-            if k not in ['frontend']:
-                err('Invalid tpmif specifier: ' + vtpm)
-            d[k] = v
-        tpmifs.append(d)
-    vals.tpmif = tpmifs
-
 def preprocess_ip(vals):
     if vals.ip or vals.dhcp != 'off':
         dummy_nfs_server = '1.2.3.4'
@@ -791,7 +763,6 @@ def preprocess(vals):
     preprocess_nfs(vals)
     preprocess_vnc(vals)
     preprocess_vtpm(vals)
-    preprocess_tpmif(vals)
          
 def make_domain(opts, config):
     """Create, build and start a domain.