* [Qemu-devel] [PATCH v4 1/4] Provide support for the CUSE TPM
2015-06-08 11:17 [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Stefan Berger
@ 2015-06-08 11:17 ` Stefan Berger
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 2/4] Introduce condition to notify waiters of completed command Stefan Berger
` (4 subsequent siblings)
5 siblings, 0 replies; 12+ messages in thread
From: Stefan Berger @ 2015-06-08 11:17 UTC (permalink / raw)
To: mst, qemu-devel; +Cc: stefanb, quan.xu, Stefan Berger
Rather than integrating TPM functionality into QEMU directly
using the TPM emulation of libtpms, we now integrate an external
emulated TPM device. This device is expected to implement a Linux
CUSE interface (CUSE = character device in userspace).
QEMU talks to the CUSE TPM using much functionality of the
passthrough driver. For example, the TPM commands and responses
are sent to the CUSE TPM using the read()/write() interface.
However, some out-of-band control needs to be done using the CUSE
TPM's ioctls. The CUSE TPM currently defines and implements 15
different ioctls for controlling certain life-cycle aspects of
the emulated TPM. The ioctls can be regarded as a replacement for
direct function calls to a TPM emulator if the TPM were to be
directly integrated into QEMU.
One of the ioctls allows to get a bitmask of supported capabilities.
Each returned bit indicates which capabilities have been implemented.
An include file defining the various ioctls is added to QEMU.
The CUSE TPM and associated tools can be found here:
https://github.com/stefanberger/swtpm
(please use the latest version)
To use the external CUSE TPM, the CUSE TPM should be started as follows:
# terminate previously started CUSE TPM
/usr/bin/swtpm_ioctl -s /dev/vtpm-test
# start CUSE TPM
/usr/bin/swtpm_cuse -n vtpm-test
QEMU can then be started using the following parameters:
qemu-system-x86_64 \
[...] \
-tpmdev cuse-tpm,id=tpm0,cancel-path=/dev/null,path=/dev/vtpm-test \
-device tpm-tis,id=tpm0,tpmdev=tpm0 \
[...]
Signed-off-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
Cc: Eric Blake <eblake@redhat.com>
---
hmp.c | 6 ++
hw/tpm/tpm_int.h | 1 +
hw/tpm/tpm_ioctl.h | 209 ++++++++++++++++++++++++++++++++++++
hw/tpm/tpm_passthrough.c | 274 +++++++++++++++++++++++++++++++++++++++++++++--
qapi-schema.json | 18 +++-
qemu-options.hx | 21 +++-
qmp-commands.hx | 2 +-
tpm.c | 11 +-
8 files changed, 524 insertions(+), 18 deletions(-)
create mode 100644 hw/tpm/tpm_ioctl.h
diff --git a/hmp.c b/hmp.c
index 514f22f..c1b9843 100644
--- a/hmp.c
+++ b/hmp.c
@@ -837,6 +837,12 @@ void hmp_info_tpm(Monitor *mon, const QDict *qdict)
tpo->has_cancel_path ? ",cancel-path=" : "",
tpo->has_cancel_path ? tpo->cancel_path : "");
break;
+ case TPM_TYPE_OPTIONS_KIND_CUSE_TPM:
+ tpo = ti->options->passthrough;
+ monitor_printf(mon, "%s%s",
+ tpo->has_path ? ",path=" : "",
+ tpo->has_path ? tpo->path : "");
+ break;
case TPM_TYPE_OPTIONS_KIND_MAX:
break;
}
diff --git a/hw/tpm/tpm_int.h b/hw/tpm/tpm_int.h
index f2f285b..6b2c9c9 100644
--- a/hw/tpm/tpm_int.h
+++ b/hw/tpm/tpm_int.h
@@ -61,6 +61,7 @@ struct tpm_resp_hdr {
#define TPM_TAG_RSP_AUTH1_COMMAND 0xc5
#define TPM_TAG_RSP_AUTH2_COMMAND 0xc6
+#define TPM_SUCCESS 0
#define TPM_FAIL 9
#define TPM_ORD_ContinueSelfTest 0x53
diff --git a/hw/tpm/tpm_ioctl.h b/hw/tpm/tpm_ioctl.h
new file mode 100644
index 0000000..cec49d5
--- /dev/null
+++ b/hw/tpm/tpm_ioctl.h
@@ -0,0 +1,209 @@
+/*
+ * tpm_ioctl.h
+ *
+ * (c) Copyright IBM Corporation 2014, 2015.
+ *
+ * This file is licensed 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.
+ */
+
+#include <stdint.h>
+#include <sys/uio.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+/*
+ * Every response from a command involving a TPM command execution must hold
+ * the ptm_res as the first element.
+ * ptm_res corresponds to the error code of a command executed by the TPM.
+ */
+
+typedef uint32_t ptm_res;
+
+/* PTM_GET_TPMESTABLISHED */
+struct ptm_est {
+ ptm_res tpm_result;
+ unsigned char bit; /* TPM established bit */
+};
+
+/* PTM_RESET_PTMESTABLISHED: reset establishment bit */
+struct ptm_reset_est {
+ union {
+ struct {
+ uint8_t loc; /* locality to use */
+ } req;
+ struct {
+ ptm_res tpm_result;
+ } resp;
+ } u;
+};
+
+/* PTM_INIT */
+struct ptm_init {
+ union {
+ struct {
+ uint32_t init_flags; /* see definitions below */
+ } req;
+ struct {
+ ptm_res tpm_result;
+ } resp;
+ } u;
+};
+
+/* above init_flags */
+#define INIT_FLAG_DELETE_VOLATILE (1 << 0)
+ /* delete volatile state file after reading it */
+
+/* PTM_SET_LOCALITY */
+struct ptm_loc {
+ union {
+ struct {
+ uint8_t loc; /* locality to set */
+ } req;
+ struct {
+ ptm_res tpm_result;
+ } resp;
+ } u;
+};
+
+/* PTM_HASH_DATA: hash given data */
+struct ptm_hdata {
+ union {
+ struct {
+ uint32_t length;
+ uint8_t data[4096];
+ } req;
+ struct {
+ ptm_res tpm_result;
+ } resp;
+ } u;
+};
+
+/*
+ * size of the TPM state blob to transfer; x86_64 can handle 8k,
+ * ppc64le only ~7k; keep the response below a 4k page size
+ */
+#define STATE_BLOB_SIZE (3 * 1024)
+
+/*
+ * The following is the data structure to get state blobs from the TPM.
+ * If the size of the state blob exceeds the STATE_BLOB_SIZE, multiple reads
+ * with this ioctl and with adjusted offset are necessary. All bytes
+ * must be transferred and the transfer is done once the last byte has been
+ * returned.
+ * It is possible to use the read() interface for reading the data; however,
+ * the first bytes of the state blob will be part of the response to the ioctl();
+ * a subsequent read() is only necessary if the total length (totlength) exceeds
+ * the number of received bytes. seek() is not supported.
+ */
+struct ptm_getstate {
+ union {
+ struct {
+ uint32_t state_flags; /* may be: STATE_FLAG_DECRYPTED */
+ uint32_t type; /* which blob to pull */
+ uint32_t offset; /* offset from where to read */
+ } req;
+ struct {
+ ptm_res tpm_result;
+ uint32_t state_flags; /* may be: STATE_FLAG_ENCRYPTED */
+ uint32_t totlength; /* total length that will be transferred */
+ uint32_t length; /* number of bytes in following buffer */
+ uint8_t data[STATE_BLOB_SIZE];
+ } resp;
+ } u;
+};
+
+/* TPM state blob types */
+#define PTM_BLOB_TYPE_PERMANENT 1
+#define PTM_BLOB_TYPE_VOLATILE 2
+#define PTM_BLOB_TYPE_SAVESTATE 3
+
+/* state_flags above : */
+#define STATE_FLAG_DECRYPTED 1 /* on input: get decrypted state */
+#define STATE_FLAG_ENCRYPTED 2 /* on output: state is encrypted */
+
+/*
+ * The following is the data structure to set state blobs in the TPM.
+ * If the size of the state blob exceeds the STATE_BLOB_SIZE, multiple
+ * 'writes' using this ioctl are necessary. The last packet is indicated
+ * by the length being smaller than the STATE_BLOB_SIZE.
+ * The very first packet may have a length indicator of '0' enabling
+ * a write() with all the bytes from a buffer. If the write() interface
+ * is used, a final ioctl with a non-full buffer must be made to indicate
+ * that all data were transferred (a write with 0 bytes would not work).
+ */
+struct ptm_setstate {
+ union {
+ struct {
+ uint32_t state_flags; /* may be STATE_FLAG_ENCRYPTED */
+ uint32_t type; /* which blob to set */
+ uint32_t length; /* length of the data;
+ use 0 on the first packet to
+ transfer using write() */
+ uint8_t data[STATE_BLOB_SIZE];
+ } req;
+ struct {
+ ptm_res tpm_result;
+ } resp;
+ } u;
+};
+
+/*
+ * PTM_GET_CONFIG: Data structure to get runtime configuration information
+ * such as which keys are applied.
+ */
+struct ptm_getconfig {
+ union {
+ struct {
+ ptm_res tpm_result;
+ uint32_t flags;
+ } resp;
+ } u;
+};
+
+#define CONFIG_FLAG_FILE_KEY 0x1
+#define CONFIG_FLAG_MIGRATION_KEY 0x2
+
+
+typedef uint64_t ptm_cap;
+typedef struct ptm_est ptm_est;
+typedef struct ptm_reset_est ptm_reset_est;
+typedef struct ptm_loc ptm_loc;
+typedef struct ptm_hdata ptm_hdata;
+typedef struct ptm_init ptm_init;
+typedef struct ptm_getstate ptm_getstate;
+typedef struct ptm_setstate ptm_setstate;
+typedef struct ptm_getconfig ptm_getconfig;
+
+/* capability flags returned by PTM_GET_CAPABILITY */
+#define PTM_CAP_INIT (1)
+#define PTM_CAP_SHUTDOWN (1<<1)
+#define PTM_CAP_GET_TPMESTABLISHED (1<<2)
+#define PTM_CAP_SET_LOCALITY (1<<3)
+#define PTM_CAP_HASHING (1<<4)
+#define PTM_CAP_CANCEL_TPM_CMD (1<<5)
+#define PTM_CAP_STORE_VOLATILE (1<<6)
+#define PTM_CAP_RESET_TPMESTABLISHED (1<<7)
+#define PTM_CAP_GET_STATEBLOB (1<<8)
+#define PTM_CAP_SET_STATEBLOB (1<<9)
+#define PTM_CAP_STOP (1<<10)
+#define PTM_CAP_GET_CONFIG (1<<11)
+
+enum {
+ PTM_GET_CAPABILITY = _IOR('P', 0, ptm_cap),
+ PTM_INIT = _IOWR('P', 1, ptm_init),
+ PTM_SHUTDOWN = _IOR('P', 2, ptm_res),
+ PTM_GET_TPMESTABLISHED = _IOR('P', 3, ptm_est),
+ PTM_SET_LOCALITY = _IOWR('P', 4, ptm_loc),
+ PTM_HASH_START = _IOR('P', 5, ptm_res),
+ PTM_HASH_DATA = _IOWR('P', 6, ptm_hdata),
+ PTM_HASH_END = _IOR('P', 7, ptm_res),
+ PTM_CANCEL_TPM_CMD = _IOR('P', 8, ptm_res),
+ PTM_STORE_VOLATILE = _IOR('P', 9, ptm_res),
+ PTM_RESET_TPMESTABLISHED = _IOWR('P', 10, ptm_reset_est),
+ PTM_GET_STATEBLOB = _IOWR('P', 11, ptm_getstate),
+ PTM_SET_STATEBLOB = _IOWR('P', 12, ptm_setstate),
+ PTM_STOP = _IOR('P', 13, ptm_res),
+ PTM_GET_CONFIG = _IOR('P', 14, ptm_getconfig),
+};
diff --git a/hw/tpm/tpm_passthrough.c b/hw/tpm/tpm_passthrough.c
index 8d8523a..68cb5e7 100644
--- a/hw/tpm/tpm_passthrough.c
+++ b/hw/tpm/tpm_passthrough.c
@@ -34,6 +34,7 @@
#include "sysemu/tpm_backend_int.h"
#include "tpm_tis.h"
#include "tpm_util.h"
+#include "tpm_ioctl.h"
#define DEBUG_TPM 0
@@ -46,6 +47,7 @@
#define TYPE_TPM_PASSTHROUGH "tpm-passthrough"
#define TPM_PASSTHROUGH(obj) \
OBJECT_CHECK(TPMPassthruState, (obj), TYPE_TPM_PASSTHROUGH)
+#define TYPE_TPM_CUSE "tpm-cuse"
static const TPMDriverOps tpm_passthrough_driver;
@@ -72,12 +74,18 @@ struct TPMPassthruState {
bool had_startup_error;
TPMVersion tpm_version;
+ ptm_cap cuse_cap; /* capabilities of the CUSE TPM */
+ uint8_t cur_locty_number; /* last set locality */
};
typedef struct TPMPassthruState TPMPassthruState;
#define TPM_PASSTHROUGH_DEFAULT_DEVICE "/dev/tpm0"
+#define TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt) (tpm_pt->cuse_cap != 0)
+
+#define TPM_CUSE_IMPLEMENTS_ALL(S, cap) (((S)->cuse_cap & (cap)) == (cap))
+
/* functions */
static void tpm_passthrough_cancel_cmd(TPMBackend *tb);
@@ -124,7 +132,28 @@ static bool tpm_passthrough_is_selftest(const uint8_t *in, uint32_t in_len)
return false;
}
+static int tpm_passthrough_set_locality(TPMPassthruState *tpm_pt,
+ uint8_t locty_number)
+{
+ ptm_loc loc;
+
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ if (tpm_pt->cur_locty_number != locty_number) {
+ loc.u.req.loc = locty_number;
+ if (ioctl(tpm_pt->tpm_fd, PTM_SET_LOCALITY, &loc) < 0) {
+ error_report("tpm_cuse: could not set locality on "
+ "CUSE TPM: %s",
+ strerror(errno));
+ return -1;
+ }
+ tpm_pt->cur_locty_number = locty_number;
+ }
+ }
+ return 0;
+}
+
static int tpm_passthrough_unix_tx_bufs(TPMPassthruState *tpm_pt,
+ uint8_t locality_number,
const uint8_t *in, uint32_t in_len,
uint8_t *out, uint32_t out_len,
bool *selftest_done)
@@ -133,6 +162,11 @@ static int tpm_passthrough_unix_tx_bufs(TPMPassthruState *tpm_pt,
bool is_selftest;
const struct tpm_resp_hdr *hdr;
+ ret = tpm_passthrough_set_locality(tpm_pt, locality_number);
+ if (ret < 0) {
+ goto err_exit;
+ }
+
tpm_pt->tpm_op_canceled = false;
tpm_pt->tpm_executing = true;
*selftest_done = false;
@@ -183,10 +217,12 @@ err_exit:
}
static int tpm_passthrough_unix_transfer(TPMPassthruState *tpm_pt,
+ uint8_t locality_number,
const TPMLocality *locty_data,
bool *selftest_done)
{
return tpm_passthrough_unix_tx_bufs(tpm_pt,
+ locality_number,
locty_data->w_buffer.buffer,
locty_data->w_offset,
locty_data->r_buffer.buffer,
@@ -207,6 +243,7 @@ static void tpm_passthrough_worker_thread(gpointer data,
switch (cmd) {
case TPM_BACKEND_CMD_PROCESS_CMD:
tpm_passthrough_unix_transfer(tpm_pt,
+ thr_parms->tpm_state->locty_number,
thr_parms->tpm_state->locty_data,
&selftest_done);
@@ -223,6 +260,93 @@ static void tpm_passthrough_worker_thread(gpointer data,
}
/*
+ * Gracefully shut down the external CUSE TPM
+ */
+static void tpm_passthrough_shutdown(TPMPassthruState *tpm_pt)
+{
+ ptm_res res;
+
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ if (ioctl(tpm_pt->tpm_fd, PTM_SHUTDOWN, &res) < 0) {
+ error_report("tpm_cuse: Could not cleanly shut down "
+ "the CUSE TPM: %s",
+ strerror(errno));
+ }
+ }
+}
+
+/*
+ * Probe for the CUSE TPM by sending an ioctl() requesting its
+ * capability flags.
+ */
+static int tpm_passthrough_cuse_probe(TPMPassthruState *tpm_pt)
+{
+ int rc = 0;
+
+ if (ioctl(tpm_pt->tpm_fd, PTM_GET_CAPABILITY, &tpm_pt->cuse_cap) < 0) {
+ error_report("Error: CUSE TPM was requested, but probing failed");
+ rc = -1;
+ }
+
+ return rc;
+}
+
+static int tpm_passthrough_cuse_check_caps(TPMPassthruState *tpm_pt)
+{
+ int rc = 0;
+ ptm_cap caps = 0;
+ const char *tpm = NULL;
+
+ /* check for min. required capabilities */
+ switch (tpm_pt->tpm_version) {
+ case TPM_VERSION_1_2:
+ caps = PTM_CAP_INIT | PTM_CAP_SHUTDOWN | PTM_CAP_GET_TPMESTABLISHED |
+ PTM_CAP_SET_LOCALITY;
+ tpm = "1.2";
+ break;
+ case TPM_VERSION_2_0:
+ caps = PTM_CAP_INIT | PTM_CAP_SHUTDOWN | PTM_CAP_GET_TPMESTABLISHED |
+ PTM_CAP_SET_LOCALITY | PTM_CAP_RESET_TPMESTABLISHED;
+ tpm = "2";
+ break;
+ case TPM_VERSION_UNSPEC:
+ error_report("tpm_cuse: %s: TPM version has not been set",
+ __func__);
+ return -1;
+ }
+
+ if (!TPM_CUSE_IMPLEMENTS_ALL(tpm_pt, caps)) {
+ error_report("tpm_cuse: TPM does not implement minimum set of required "
+ "capabilities for TPM %s (0x%x)", tpm, (int)caps);
+ rc = -1;
+ }
+
+ return rc;
+}
+
+/*
+ * Initialize the external CUSE TPM
+ */
+static int tpm_passthrough_cuse_init(TPMPassthruState *tpm_pt)
+{
+ int rc = 0;
+ ptm_init init = {
+ .u.req.init_flags = INIT_FLAG_DELETE_VOLATILE,
+ };
+
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ if (ioctl(tpm_pt->tpm_fd, PTM_INIT, &init) < 0) {
+ error_report("tpm_cuse: Detected CUSE TPM but could not "
+ "send INIT: %s",
+ strerror(errno));
+ rc = -1;
+ }
+ }
+
+ return rc;
+}
+
+/*
* Start the TPM (thread). If it had been started before, then terminate
* and start it again.
*/
@@ -237,6 +361,8 @@ static int tpm_passthrough_startup_tpm(TPMBackend *tb)
tpm_passthrough_worker_thread,
&tpm_pt->tpm_thread_params);
+ tpm_passthrough_cuse_init(tpm_pt);
+
return 0;
}
@@ -267,14 +393,43 @@ static int tpm_passthrough_init(TPMBackend *tb, TPMState *s,
static bool tpm_passthrough_get_tpm_established_flag(TPMBackend *tb)
{
+ TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
+ ptm_est est;
+
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ if (ioctl(tpm_pt->tpm_fd, PTM_GET_TPMESTABLISHED, &est) < 0) {
+ error_report("tpm_cuse: Could not get the TPM established "
+ "flag from the CUSE TPM: %s",
+ strerror(errno));
+ return false;
+ }
+ return (est.bit != 0);
+ }
return false;
}
static int tpm_passthrough_reset_tpm_established_flag(TPMBackend *tb,
uint8_t locty)
{
+ TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
+ int rc = 0;
+ ptm_reset_est ptmreset_est;
+
/* only a TPM 2.0 will support this */
- return 0;
+ if (tpm_pt->tpm_version == TPM_VERSION_2_0) {
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ ptmreset_est.u.req.loc = tpm_pt->cur_locty_number;
+
+ if (ioctl(tpm_pt->tpm_fd, PTM_RESET_TPMESTABLISHED,
+ &ptmreset_est) < 0) {
+ error_report("tpm_cuse: Could not reset the establishment bit "
+ "failed: %s",
+ strerror(errno));
+ rc = -1;
+ }
+ }
+ }
+ return rc;
}
static bool tpm_passthrough_get_startup_error(TPMBackend *tb)
@@ -305,7 +460,8 @@ static void tpm_passthrough_deliver_request(TPMBackend *tb)
static void tpm_passthrough_cancel_cmd(TPMBackend *tb)
{
TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
- int n;
+ ptm_res res;
+ static bool error_printed;
/*
* As of Linux 3.7 the tpm_tis driver does not properly cancel
@@ -314,17 +470,34 @@ static void tpm_passthrough_cancel_cmd(TPMBackend *tb)
* command, e.g., a command executed on the host.
*/
if (tpm_pt->tpm_executing) {
- if (tpm_pt->cancel_fd >= 0) {
- n = write(tpm_pt->cancel_fd, "-", 1);
- if (n != 1) {
- error_report("Canceling TPM command failed: %s",
- strerror(errno));
- } else {
- tpm_pt->tpm_op_canceled = true;
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ if (TPM_CUSE_IMPLEMENTS_ALL(tpm_pt, PTM_CAP_CANCEL_TPM_CMD)) {
+ if (ioctl(tpm_pt->tpm_fd, PTM_CANCEL_TPM_CMD, &res) < 0) {
+ error_report("tpm_cuse: Could not cancel command on "
+ "CUSE TPM: %s",
+ strerror(errno));
+ } else if (res != TPM_SUCCESS) {
+ if (!error_printed) {
+ error_report("TPM error code from command "
+ "cancellation of CUSE TPM: 0x%x", res);
+ error_printed = true;
+ }
+ } else {
+ tpm_pt->tpm_op_canceled = true;
+ }
}
} else {
- error_report("Cannot cancel TPM command due to missing "
- "TPM sysfs cancel entry");
+ if (tpm_pt->cancel_fd >= 0) {
+ if (write(tpm_pt->cancel_fd, "-", 1) != 1) {
+ error_report("Canceling TPM command failed: %s",
+ strerror(errno));
+ } else {
+ tpm_pt->tpm_op_canceled = true;
+ }
+ } else {
+ error_report("Cannot cancel TPM command due to missing "
+ "TPM sysfs cancel entry");
+ }
}
}
}
@@ -354,6 +527,11 @@ static int tpm_passthrough_open_sysfs_cancel(TPMBackend *tb)
char *dev;
char path[PATH_MAX];
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ /* not needed, but so we have a fd */
+ return qemu_open("/dev/null", O_WRONLY);
+ }
+
if (tb->cancel_path) {
fd = qemu_open(tb->cancel_path, O_WRONLY);
if (fd < 0) {
@@ -388,12 +566,22 @@ static int tpm_passthrough_handle_device_opts(QemuOpts *opts, TPMBackend *tb)
{
TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
const char *value;
+ bool have_cuse = false;
+
+ value = qemu_opt_get(opts, "type");
+ if (value != NULL && !strcmp("cuse-tpm", value)) {
+ have_cuse = true;
+ }
value = qemu_opt_get(opts, "cancel-path");
tb->cancel_path = g_strdup(value);
value = qemu_opt_get(opts, "path");
if (!value) {
+ if (have_cuse) {
+ error_report("Missing path to access CUSE TPM");
+ goto err_free_parameters;
+ }
value = TPM_PASSTHROUGH_DEFAULT_DEVICE;
}
@@ -408,15 +596,36 @@ static int tpm_passthrough_handle_device_opts(QemuOpts *opts, TPMBackend *tb)
goto err_free_parameters;
}
+ tpm_pt->cur_locty_number = ~0;
+
+ if (have_cuse) {
+ if (tpm_passthrough_cuse_probe(tpm_pt)) {
+ goto err_close_tpmdev;
+ }
+ /* init TPM for probing */
+ if (tpm_passthrough_cuse_init(tpm_pt)) {
+ goto err_close_tpmdev;
+ }
+ }
+
if (tpm_util_test_tpmdev(tpm_pt->tpm_fd, &tpm_pt->tpm_version)) {
error_report("'%s' is not a TPM device.",
tpm_pt->tpm_dev);
goto err_close_tpmdev;
}
+ if (have_cuse) {
+ if (tpm_passthrough_cuse_check_caps(tpm_pt)) {
+ goto err_close_tpmdev;
+ }
+ }
+
+
return 0;
err_close_tpmdev:
+ tpm_passthrough_shutdown(tpm_pt);
+
qemu_close(tpm_pt->tpm_fd);
tpm_pt->tpm_fd = -1;
@@ -467,6 +676,8 @@ static void tpm_passthrough_destroy(TPMBackend *tb)
tpm_backend_thread_end(&tpm_pt->tbt);
+ tpm_passthrough_shutdown(tpm_pt);
+
qemu_close(tpm_pt->tpm_fd);
qemu_close(tpm_pt->cancel_fd);
@@ -540,3 +751,44 @@ static void tpm_passthrough_register(void)
}
type_init(tpm_passthrough_register)
+
+/* CUSE TPM */
+static const char *tpm_passthrough_cuse_create_desc(void)
+{
+ return "CUSE TPM backend driver";
+}
+
+static const TPMDriverOps tpm_cuse_driver = {
+ .type = TPM_TYPE_CUSE_TPM,
+ .opts = tpm_passthrough_cmdline_opts,
+ .desc = tpm_passthrough_cuse_create_desc,
+ .create = tpm_passthrough_create,
+ .destroy = tpm_passthrough_destroy,
+ .init = tpm_passthrough_init,
+ .startup_tpm = tpm_passthrough_startup_tpm,
+ .realloc_buffer = tpm_passthrough_realloc_buffer,
+ .reset = tpm_passthrough_reset,
+ .had_startup_error = tpm_passthrough_get_startup_error,
+ .deliver_request = tpm_passthrough_deliver_request,
+ .cancel_cmd = tpm_passthrough_cancel_cmd,
+ .get_tpm_established_flag = tpm_passthrough_get_tpm_established_flag,
+ .reset_tpm_established_flag = tpm_passthrough_reset_tpm_established_flag,
+ .get_tpm_version = tpm_passthrough_get_tpm_version,
+};
+
+static const TypeInfo tpm_cuse_info = {
+ .name = TYPE_TPM_CUSE,
+ .parent = TYPE_TPM_BACKEND,
+ .instance_size = sizeof(TPMPassthruState),
+ .class_init = tpm_passthrough_class_init,
+ .instance_init = tpm_passthrough_inst_init,
+ .instance_finalize = tpm_passthrough_inst_finalize,
+};
+
+static void tpm_cuse_register(void)
+{
+ type_register_static(&tpm_cuse_info);
+ tpm_register_driver(&tpm_cuse_driver);
+}
+
+type_init(tpm_cuse_register)
diff --git a/qapi-schema.json b/qapi-schema.json
index 6e17a5c..3652760 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -3114,10 +3114,12 @@
# An enumeration of TPM types
#
# @passthrough: TPM passthrough type
+# @cuse-tpm: CUSE TPM type
+# Since: 2.4
#
# Since: 1.5
##
-{ 'enum': 'TpmType', 'data': [ 'passthrough' ] }
+{ 'enum': 'TpmType', 'data': [ 'passthrough', 'cuse-tpm' ] }
##
# @query-tpm-types:
@@ -3146,6 +3148,17 @@
'*cancel-path' : 'str'} }
##
+# @TPMCuseOptions:
+#
+# Information about the CUSE TPM type
+#
+# @path: string describing the path used for accessing the TPM device
+#
+# Since: 2.4
+##
+{ 'struct': 'TPMCuseOptions', 'data': { 'path' : 'str'}}
+
+##
# @TpmTypeOptions:
#
# A union referencing different TPM backend types' configuration options
@@ -3155,7 +3168,8 @@
# Since: 1.5
##
{ 'union': 'TpmTypeOptions',
- 'data': { 'passthrough' : 'TPMPassthroughOptions' } }
+ 'data': { 'passthrough' : 'TPMPassthroughOptions',
+ 'cuse-tpm' : 'TPMCuseOptions' } }
##
# @TpmInfo:
diff --git a/qemu-options.hx b/qemu-options.hx
index b3db6cb..70a924d 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -2553,7 +2553,10 @@ DEF("tpmdev", HAS_ARG, QEMU_OPTION_tpmdev, \
"-tpmdev passthrough,id=id[,path=path][,cancel-path=path]\n"
" use path to provide path to a character device; default is /dev/tpm0\n"
" use cancel-path to provide path to TPM's cancel sysfs entry; if\n"
- " not provided it will be searched for in /sys/class/misc/tpm?/device\n",
+ " not provided it will be searched for in /sys/class/misc/tpm?/device\n"
+ "-tpmdev cuse-tpm,id=id,path=path\n"
+ " use path to provide path to a character device to talk to the\n"
+ " TPM emulator providing a CUSE interface\n",
QEMU_ARCH_ALL)
STEXI
@@ -2562,8 +2565,8 @@ The general form of a TPM device option is:
@item -tpmdev @var{backend} ,id=@var{id} [,@var{options}]
@findex -tpmdev
-Backend type must be:
-@option{passthrough}.
+Backend type must be either one of the following:
+@option{passthrough}, @option{cuse-tpm}.
The specific backend type will determine the applicable options.
The @code{-tpmdev} option creates the TPM backend and requires a
@@ -2613,6 +2616,18 @@ To create a passthrough TPM use the following two options:
Note that the @code{-tpmdev} id is @code{tpm0} and is referenced by
@code{tpmdev=tpm0} in the device option.
+@item -tpmdev cuse-tpm, id=@var{id}, path=@var{path}
+
+(Linux-host only) Enable access to a TPM emulator with a CUSE interface.
+
+@option{path} specifies the path to the CUSE TPM character device.
+
+To create a backend device accessing the CUSE TPM emulator using /dev/vtpm
+use the following two options:
+@example
+-tpmdev cuse-tpm,id=tpm0,path=/dev/vtpm -device tpm-tis,tpmdev=tpm0
+@end example
+
@end table
ETEXI
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 867a21f..54b60d1 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -3677,7 +3677,7 @@ Arguments: None
Example:
-> { "execute": "query-tpm-types" }
-<- { "return": [ "passthrough" ] }
+<- { "return": [ "passthrough", "cuse-tpm" ] }
EQMP
diff --git a/tpm.c b/tpm.c
index 963b7ee..5443b7b 100644
--- a/tpm.c
+++ b/tpm.c
@@ -25,7 +25,7 @@ static QLIST_HEAD(, TPMBackend) tpm_backends =
#define TPM_MAX_MODELS 1
-#define TPM_MAX_DRIVERS 1
+#define TPM_MAX_DRIVERS 2
static TPMDriverOps const *be_drivers[TPM_MAX_DRIVERS] = {
NULL,
@@ -273,6 +273,15 @@ static TPMInfo *qmp_query_tpm_inst(TPMBackend *drv)
tpo->has_cancel_path = true;
}
break;
+ case TPM_TYPE_CUSE_TPM:
+ res->options->kind = TPM_TYPE_OPTIONS_KIND_CUSE_TPM;
+ tpo = g_new0(TPMPassthroughOptions, 1);
+ res->options->passthrough = tpo;
+ if (drv->path) {
+ tpo->path = g_strdup(drv->path);
+ tpo->has_path = true;
+ }
+ break;
case TPM_TYPE_MAX:
break;
}
--
1.9.3
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH v4 2/4] Introduce condition to notify waiters of completed command
2015-06-08 11:17 [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Stefan Berger
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 1/4] Provide support for the CUSE TPM Stefan Berger
@ 2015-06-08 11:17 ` Stefan Berger
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 3/4] Introduce condition in TPM backend for notification Stefan Berger
` (3 subsequent siblings)
5 siblings, 0 replies; 12+ messages in thread
From: Stefan Berger @ 2015-06-08 11:17 UTC (permalink / raw)
To: mst, qemu-devel; +Cc: stefanb, quan.xu, Stefan Berger
Introduce a lock and a condition to notify anyone waiting for the completion
of the execution of a TPM command by the backend (thread). The backend
uses the condition to signal anyone waiting for command completion.
We need to place the condition in two locations: one is invoked by the
backend thread, the other by the bottom half thread.
We will use the signalling to wait for command completion before VM
suspend.
Signed-off-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
---
hw/tpm/tpm_int.h | 3 +++
hw/tpm/tpm_tis.c | 14 ++++++++++++++
2 files changed, 17 insertions(+)
diff --git a/hw/tpm/tpm_int.h b/hw/tpm/tpm_int.h
index 6b2c9c9..70be1ad 100644
--- a/hw/tpm/tpm_int.h
+++ b/hw/tpm/tpm_int.h
@@ -30,6 +30,9 @@ struct TPMState {
char *backend;
TPMBackend *be_driver;
TPMVersion be_tpm_version;
+
+ QemuMutex state_lock;
+ QemuCond cmd_complete;
};
#define TPM(obj) OBJECT_CHECK(TPMState, (obj), TYPE_TPM_TIS)
diff --git a/hw/tpm/tpm_tis.c b/hw/tpm/tpm_tis.c
index 0806b5f..4f6b6bc 100644
--- a/hw/tpm/tpm_tis.c
+++ b/hw/tpm/tpm_tis.c
@@ -366,6 +366,8 @@ static void tpm_tis_receive_bh(void *opaque)
TPMTISEmuState *tis = &s->s.tis;
uint8_t locty = s->locty_number;
+ qemu_mutex_lock(&s->state_lock);
+
tpm_tis_sts_set(&tis->loc[locty],
TPM_TIS_STS_VALID | TPM_TIS_STS_DATA_AVAILABLE);
tis->loc[locty].state = TPM_TIS_STATE_COMPLETION;
@@ -382,6 +384,10 @@ static void tpm_tis_receive_bh(void *opaque)
tpm_tis_raise_irq(s, locty,
TPM_TIS_INT_DATA_AVAILABLE | TPM_TIS_INT_STS_VALID);
#endif
+
+ /* notify of completed command */
+ qemu_cond_signal(&s->cmd_complete);
+ qemu_mutex_unlock(&s->state_lock);
}
/*
@@ -401,6 +407,11 @@ static void tpm_tis_receive_cb(TPMState *s, uint8_t locty,
}
}
+ qemu_mutex_lock(&s->state_lock);
+ /* notify of completed command */
+ qemu_cond_signal(&s->cmd_complete);
+ qemu_mutex_unlock(&s->state_lock);
+
qemu_bh_schedule(tis->bh);
}
@@ -1070,6 +1081,9 @@ static void tpm_tis_initfn(Object *obj)
memory_region_init_io(&s->mmio, OBJECT(s), &tpm_tis_memory_ops,
s, "tpm-tis-mmio",
TPM_TIS_NUM_LOCALITIES << TPM_TIS_LOCALITY_SHIFT);
+
+ qemu_mutex_init(&s->state_lock);
+ qemu_cond_init(&s->cmd_complete);
}
static void tpm_tis_class_init(ObjectClass *klass, void *data)
--
1.9.3
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH v4 3/4] Introduce condition in TPM backend for notification
2015-06-08 11:17 [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Stefan Berger
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 1/4] Provide support for the CUSE TPM Stefan Berger
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 2/4] Introduce condition to notify waiters of completed command Stefan Berger
@ 2015-06-08 11:17 ` Stefan Berger
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 4/4] Add support for VM suspend/resume for TPM TIS Stefan Berger
` (2 subsequent siblings)
5 siblings, 0 replies; 12+ messages in thread
From: Stefan Berger @ 2015-06-08 11:17 UTC (permalink / raw)
To: mst, qemu-devel; +Cc: stefanb, quan.xu, Stefan Berger
TPM backends will suspend independently of the frontends. Also
here we need to be able to wait for the TPM command to have been
completely processed.
Signed-off-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
---
hw/tpm/tpm_passthrough.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/hw/tpm/tpm_passthrough.c b/hw/tpm/tpm_passthrough.c
index 68cb5e7..89c77c8 100644
--- a/hw/tpm/tpm_passthrough.c
+++ b/hw/tpm/tpm_passthrough.c
@@ -76,6 +76,10 @@ struct TPMPassthruState {
TPMVersion tpm_version;
ptm_cap cuse_cap; /* capabilities of the CUSE TPM */
uint8_t cur_locty_number; /* last set locality */
+
+ QemuMutex state_lock;
+ QemuCond cmd_complete; /* singnaled once tpm_busy is false */
+ bool tpm_busy;
};
typedef struct TPMPassthruState TPMPassthruState;
@@ -250,6 +254,11 @@ static void tpm_passthrough_worker_thread(gpointer data,
thr_parms->recv_data_callback(thr_parms->tpm_state,
thr_parms->tpm_state->locty_number,
selftest_done);
+ /* result delivered */
+ qemu_mutex_lock(&tpm_pt->state_lock);
+ tpm_pt->tpm_busy = false;
+ qemu_cond_signal(&tpm_pt->cmd_complete);
+ qemu_mutex_unlock(&tpm_pt->state_lock);
break;
case TPM_BACKEND_CMD_INIT:
case TPM_BACKEND_CMD_END:
@@ -377,6 +386,7 @@ static void tpm_passthrough_reset(TPMBackend *tb)
tpm_backend_thread_end(&tpm_pt->tbt);
tpm_pt->had_startup_error = false;
+ tpm_pt->tpm_busy = false;
}
static int tpm_passthrough_init(TPMBackend *tb, TPMState *s,
@@ -454,6 +464,11 @@ static void tpm_passthrough_deliver_request(TPMBackend *tb)
{
TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
+ /* TPM considered busy once TPM Request scheduled for processing */
+ qemu_mutex_lock(&tpm_pt->state_lock);
+ tpm_pt->tpm_busy = true;
+ qemu_mutex_unlock(&tpm_pt->state_lock);
+
tpm_backend_thread_deliver_request(&tpm_pt->tbt);
}
@@ -722,6 +737,11 @@ static const TPMDriverOps tpm_passthrough_driver = {
static void tpm_passthrough_inst_init(Object *obj)
{
+ TPMBackend *tb = TPM_BACKEND(obj);
+ TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
+
+ qemu_mutex_init(&tpm_pt->state_lock);
+ qemu_cond_init(&tpm_pt->cmd_complete);
}
static void tpm_passthrough_inst_finalize(Object *obj)
--
1.9.3
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH v4 4/4] Add support for VM suspend/resume for TPM TIS
2015-06-08 11:17 [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Stefan Berger
` (2 preceding siblings ...)
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 3/4] Introduce condition in TPM backend for notification Stefan Berger
@ 2015-06-08 11:17 ` Stefan Berger
2015-06-23 5:26 ` [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Michael S. Tsirkin
2015-06-23 13:52 ` Michael S. Tsirkin
5 siblings, 0 replies; 12+ messages in thread
From: Stefan Berger @ 2015-06-08 11:17 UTC (permalink / raw)
To: mst, qemu-devel; +Cc: stefanb, quan.xu, Stefan Berger
Extend the TPM TIS code to support suspend/resume. In case a command
is being processed by the external TPM when suspending, wait for the command
to complete to catch the result. In case the bottom half did not run,
run the one function the bottom half is supposed to run. This then
makes the resume operation work.
The passthrough backend does not support suspend/resume operation
and is therefore blocked from suspend/resume and migration.
The CUSE TPM's supported capabilities are tested and if sufficient
capabilities are implemented, suspend/resume, snapshotting and
migration are supported by the CUSE TPM.
Signed-off-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
---
hw/tpm/tpm_passthrough.c | 129 +++++++++++++++++++++++--
hw/tpm/tpm_tis.c | 137 +++++++++++++++++++++++++-
hw/tpm/tpm_tis.h | 2 +
hw/tpm/tpm_util.c | 223 +++++++++++++++++++++++++++++++++++++++++++
hw/tpm/tpm_util.h | 7 ++
include/sysemu/tpm_backend.h | 12 +++
6 files changed, 502 insertions(+), 8 deletions(-)
diff --git a/hw/tpm/tpm_passthrough.c b/hw/tpm/tpm_passthrough.c
index 89c77c8..04edf00 100644
--- a/hw/tpm/tpm_passthrough.c
+++ b/hw/tpm/tpm_passthrough.c
@@ -35,6 +35,7 @@
#include "tpm_tis.h"
#include "tpm_util.h"
#include "tpm_ioctl.h"
+#include "migration/migration.h"
#define DEBUG_TPM 0
@@ -50,6 +51,7 @@
#define TYPE_TPM_CUSE "tpm-cuse"
static const TPMDriverOps tpm_passthrough_driver;
+static const VMStateDescription vmstate_tpm_cuse;
/* data structures */
typedef struct TPMPassthruThreadParams {
@@ -80,6 +82,10 @@ struct TPMPassthruState {
QemuMutex state_lock;
QemuCond cmd_complete; /* singnaled once tpm_busy is false */
bool tpm_busy;
+
+ Error *migration_blocker;
+
+ TPMBlobBuffers tpm_blobs;
};
typedef struct TPMPassthruState TPMPassthruState;
@@ -282,6 +288,10 @@ static void tpm_passthrough_shutdown(TPMPassthruState *tpm_pt)
strerror(errno));
}
}
+ if (tpm_pt->migration_blocker) {
+ migrate_del_blocker(tpm_pt->migration_blocker);
+ error_free(tpm_pt->migration_blocker);
+ }
}
/*
@@ -336,12 +346,14 @@ static int tpm_passthrough_cuse_check_caps(TPMPassthruState *tpm_pt)
/*
* Initialize the external CUSE TPM
*/
-static int tpm_passthrough_cuse_init(TPMPassthruState *tpm_pt)
+static int tpm_passthrough_cuse_init(TPMPassthruState *tpm_pt,
+ bool is_resume)
{
int rc = 0;
- ptm_init init = {
- .u.req.init_flags = INIT_FLAG_DELETE_VOLATILE,
- };
+ ptm_init init;
+ if (is_resume) {
+ init.u.req.init_flags = INIT_FLAG_DELETE_VOLATILE;
+ }
if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
if (ioctl(tpm_pt->tpm_fd, PTM_INIT, &init) < 0) {
@@ -370,7 +382,7 @@ static int tpm_passthrough_startup_tpm(TPMBackend *tb)
tpm_passthrough_worker_thread,
&tpm_pt->tpm_thread_params);
- tpm_passthrough_cuse_init(tpm_pt);
+ tpm_passthrough_cuse_init(tpm_pt, false);
return 0;
}
@@ -442,6 +454,32 @@ static int tpm_passthrough_reset_tpm_established_flag(TPMBackend *tb,
return rc;
}
+static int tpm_cuse_get_state_blobs(TPMBackend *tb,
+ bool decrypted_blobs,
+ TPMBlobBuffers *tpm_blobs)
+{
+ TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
+
+ assert(TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt));
+
+ return tpm_util_cuse_get_state_blobs(tpm_pt->tpm_fd, decrypted_blobs,
+ tpm_blobs);
+}
+
+static int tpm_cuse_set_state_blobs(TPMBackend *tb,
+ TPMBlobBuffers *tpm_blobs)
+{
+ TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
+
+ assert(TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt));
+
+ if (tpm_util_cuse_set_state_blobs(tpm_pt->tpm_fd, tpm_blobs)) {
+ return 1;
+ }
+
+ return tpm_passthrough_cuse_init(tpm_pt, true);
+}
+
static bool tpm_passthrough_get_startup_error(TPMBackend *tb)
{
TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
@@ -464,7 +502,7 @@ static void tpm_passthrough_deliver_request(TPMBackend *tb)
{
TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
- /* TPM considered busy once TPM Request scheduled for processing */
+ /* TPM considered busy once TPM request scheduled for processing */
qemu_mutex_lock(&tpm_pt->state_lock);
tpm_pt->tpm_busy = true;
qemu_mutex_unlock(&tpm_pt->state_lock);
@@ -577,6 +615,25 @@ static int tpm_passthrough_open_sysfs_cancel(TPMBackend *tb)
return fd;
}
+static void tpm_passthrough_block_migration(TPMPassthruState *tpm_pt)
+{
+ ptm_cap caps;
+
+ if (TPM_PASSTHROUGH_USES_CUSE_TPM(tpm_pt)) {
+ caps = PTM_CAP_GET_STATEBLOB | PTM_CAP_SET_STATEBLOB |
+ PTM_CAP_STOP;
+ if (!TPM_CUSE_IMPLEMENTS_ALL(tpm_pt, caps)) {
+ error_setg(&tpm_pt->migration_blocker,
+ "Migration disabled: CUSE TPM lacks necessary capabilities");
+ migrate_add_blocker(tpm_pt->migration_blocker);
+ }
+ } else {
+ error_setg(&tpm_pt->migration_blocker,
+ "Migration disabled: Passthrough TPM does not support migration");
+ migrate_add_blocker(tpm_pt->migration_blocker);
+ }
+}
+
static int tpm_passthrough_handle_device_opts(QemuOpts *opts, TPMBackend *tb)
{
TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
@@ -618,7 +675,7 @@ static int tpm_passthrough_handle_device_opts(QemuOpts *opts, TPMBackend *tb)
goto err_close_tpmdev;
}
/* init TPM for probing */
- if (tpm_passthrough_cuse_init(tpm_pt)) {
+ if (tpm_passthrough_cuse_init(tpm_pt, false)) {
goto err_close_tpmdev;
}
}
@@ -635,6 +692,7 @@ static int tpm_passthrough_handle_device_opts(QemuOpts *opts, TPMBackend *tb)
}
}
+ tpm_passthrough_block_migration(tpm_pt);
return 0;
@@ -742,10 +800,13 @@ static void tpm_passthrough_inst_init(Object *obj)
qemu_mutex_init(&tpm_pt->state_lock);
qemu_cond_init(&tpm_pt->cmd_complete);
+
+ vmstate_register(NULL, -1, &vmstate_tpm_cuse, obj);
}
static void tpm_passthrough_inst_finalize(Object *obj)
{
+ vmstate_unregister(NULL, &vmstate_tpm_cuse, obj);
}
static void tpm_passthrough_class_init(ObjectClass *klass, void *data)
@@ -778,6 +839,60 @@ static const char *tpm_passthrough_cuse_create_desc(void)
return "CUSE TPM backend driver";
}
+static void tpm_cuse_pre_save(void *opaque)
+{
+ TPMPassthruState *tpm_pt = opaque;
+ TPMBackend *tb = &tpm_pt->parent;
+
+ qemu_mutex_lock(&tpm_pt->state_lock);
+ /* wait for TPM to finish processing */
+ if (tpm_pt->tpm_busy) {
+ qemu_cond_wait(&tpm_pt->cmd_complete, &tpm_pt->state_lock);
+ }
+ qemu_mutex_unlock(&tpm_pt->state_lock);
+
+ /* get the decrypted state blobs from the TPM */
+ tpm_cuse_get_state_blobs(tb, TRUE, &tpm_pt->tpm_blobs);
+}
+
+static int tpm_cuse_post_load(void *opaque,
+ int version_id __attribute__((unused)))
+{
+ TPMPassthruState *tpm_pt = opaque;
+ TPMBackend *tb = &tpm_pt->parent;
+
+ return tpm_cuse_set_state_blobs(tb, &tpm_pt->tpm_blobs);
+}
+
+static const VMStateDescription vmstate_tpm_cuse = {
+ .name = "cuse-tpm",
+ .version_id = 1,
+ .minimum_version_id = 0,
+ .minimum_version_id_old = 0,
+ .pre_save = tpm_cuse_pre_save,
+ .post_load = tpm_cuse_post_load,
+ .fields = (VMStateField[]) {
+ VMSTATE_UINT32(tpm_blobs.permanent_flags, TPMPassthruState),
+ VMSTATE_UINT32(tpm_blobs.permanent.size, TPMPassthruState),
+ VMSTATE_VBUFFER_ALLOC_UINT32(tpm_blobs.permanent.buffer,
+ TPMPassthruState, 1, NULL, 0,
+ tpm_blobs.permanent.size),
+
+ VMSTATE_UINT32(tpm_blobs.volatil_flags, TPMPassthruState),
+ VMSTATE_UINT32(tpm_blobs.volatil.size, TPMPassthruState),
+ VMSTATE_VBUFFER_ALLOC_UINT32(tpm_blobs.volatil.buffer,
+ TPMPassthruState, 1, NULL, 0,
+ tpm_blobs.volatil.size),
+
+ VMSTATE_UINT32(tpm_blobs.savestate_flags, TPMPassthruState),
+ VMSTATE_UINT32(tpm_blobs.savestate.size, TPMPassthruState),
+ VMSTATE_VBUFFER_ALLOC_UINT32(tpm_blobs.savestate.buffer,
+ TPMPassthruState, 1, NULL, 0,
+ tpm_blobs.savestate.size),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
static const TPMDriverOps tpm_cuse_driver = {
.type = TPM_TYPE_CUSE_TPM,
.opts = tpm_passthrough_cmdline_opts,
diff --git a/hw/tpm/tpm_tis.c b/hw/tpm/tpm_tis.c
index 4f6b6bc..6393411 100644
--- a/hw/tpm/tpm_tis.c
+++ b/hw/tpm/tpm_tis.c
@@ -366,6 +366,8 @@ static void tpm_tis_receive_bh(void *opaque)
TPMTISEmuState *tis = &s->s.tis;
uint8_t locty = s->locty_number;
+ tis->bh_scheduled = false;
+
qemu_mutex_lock(&s->state_lock);
tpm_tis_sts_set(&tis->loc[locty],
@@ -413,6 +415,8 @@ static void tpm_tis_receive_cb(TPMState *s, uint8_t locty,
qemu_mutex_unlock(&s->state_lock);
qemu_bh_schedule(tis->bh);
+
+ tis->bh_scheduled = true;
}
/*
@@ -1028,9 +1032,140 @@ static void tpm_tis_reset(DeviceState *dev)
tpm_tis_do_startup_tpm(s);
}
+
+/* persistent state handling */
+
+static void tpm_tis_pre_save(void *opaque)
+{
+ TPMState *s = opaque;
+ TPMTISEmuState *tis = &s->s.tis;
+ uint8_t locty = tis->active_locty;
+
+ DPRINTF("tpm_tis: suspend: locty = %d : r_offset = %d, w_offset = %d\n",
+ locty, tis->loc[0].r_offset, tis->loc[0].w_offset);
+#ifdef DEBUG_TIS
+ tpm_tis_dump_state(opaque, 0);
+#endif
+
+ qemu_mutex_lock(&s->state_lock);
+
+ /* wait for outstanding request to complete */
+ if (TPM_TIS_IS_VALID_LOCTY(locty) &&
+ tis->loc[locty].state == TPM_TIS_STATE_EXECUTION) {
+ /*
+ * If we get here when the bh is scheduled but did not run,
+ * we won't get notified...
+ */
+ if (!tis->bh_scheduled) {
+ /* backend thread to notify us */
+ qemu_cond_wait(&s->cmd_complete, &s->state_lock);
+ }
+ if (tis->loc[locty].state == TPM_TIS_STATE_EXECUTION) {
+ /* bottom half did not run - run its function */
+ qemu_mutex_unlock(&s->state_lock);
+ tpm_tis_receive_bh(opaque);
+ qemu_mutex_lock(&s->state_lock);
+ }
+ }
+
+ qemu_mutex_unlock(&s->state_lock);
+
+ /* copy current active read or write buffer into the buffer
+ written to disk */
+ if (TPM_TIS_IS_VALID_LOCTY(locty)) {
+ switch (tis->loc[locty].state) {
+ case TPM_TIS_STATE_RECEPTION:
+ memcpy(tis->buf,
+ tis->loc[locty].w_buffer.buffer,
+ MIN(sizeof(tis->buf),
+ tis->loc[locty].w_buffer.size));
+ tis->offset = tis->loc[locty].w_offset;
+ break;
+ case TPM_TIS_STATE_COMPLETION:
+ memcpy(tis->buf,
+ tis->loc[locty].r_buffer.buffer,
+ MIN(sizeof(tis->buf),
+ tis->loc[locty].r_buffer.size));
+ tis->offset = tis->loc[locty].r_offset;
+ break;
+ default:
+ /* leak nothing */
+ memset(tis->buf, 0x0, sizeof(tis->buf));
+ break;
+ }
+ }
+}
+
+static int tpm_tis_post_load(void *opaque,
+ int version_id __attribute__((unused)))
+{
+ TPMState *s = opaque;
+ TPMTISEmuState *tis = &s->s.tis;
+
+ uint8_t locty = tis->active_locty;
+
+ if (TPM_TIS_IS_VALID_LOCTY(locty)) {
+ switch (tis->loc[locty].state) {
+ case TPM_TIS_STATE_RECEPTION:
+ memcpy(tis->loc[locty].w_buffer.buffer,
+ tis->buf,
+ MIN(sizeof(tis->buf),
+ tis->loc[locty].w_buffer.size));
+ tis->loc[locty].w_offset = tis->offset;
+ break;
+ case TPM_TIS_STATE_COMPLETION:
+ memcpy(tis->loc[locty].r_buffer.buffer,
+ tis->buf,
+ MIN(sizeof(tis->buf),
+ tis->loc[locty].r_buffer.size));
+ tis->loc[locty].r_offset = tis->offset;
+ break;
+ default:
+ break;
+ }
+ }
+
+ DPRINTF("tpm_tis: resume : locty = %d : r_offset = %d, w_offset = %d\n",
+ locty, tis->loc[0].r_offset, tis->loc[0].w_offset);
+
+ return 0;
+}
+
+static const VMStateDescription vmstate_locty = {
+ .name = "loc",
+ .version_id = 1,
+ .minimum_version_id = 0,
+ .minimum_version_id_old = 0,
+ .fields = (VMStateField[]) {
+ VMSTATE_UINT32(state, TPMLocality),
+ VMSTATE_UINT32(inte, TPMLocality),
+ VMSTATE_UINT32(ints, TPMLocality),
+ VMSTATE_UINT8(access, TPMLocality),
+ VMSTATE_UINT32(sts, TPMLocality),
+ VMSTATE_UINT32(iface_id, TPMLocality),
+ VMSTATE_END_OF_LIST(),
+ }
+};
+
static const VMStateDescription vmstate_tpm_tis = {
.name = "tpm",
- .unmigratable = 1,
+ .version_id = 1,
+ .minimum_version_id = 0,
+ .minimum_version_id_old = 0,
+ .pre_save = tpm_tis_pre_save,
+ .post_load = tpm_tis_post_load,
+ .fields = (VMStateField[]) {
+ VMSTATE_UINT32(s.tis.offset, TPMState),
+ VMSTATE_BUFFER(s.tis.buf, TPMState),
+ VMSTATE_UINT8(s.tis.active_locty, TPMState),
+ VMSTATE_UINT8(s.tis.aborting_locty, TPMState),
+ VMSTATE_UINT8(s.tis.next_locty, TPMState),
+
+ VMSTATE_STRUCT_ARRAY(s.tis.loc, TPMState, TPM_TIS_NUM_LOCALITIES, 1,
+ vmstate_locty, TPMLocality),
+
+ VMSTATE_END_OF_LIST()
+ }
};
static Property tpm_tis_properties[] = {
diff --git a/hw/tpm/tpm_tis.h b/hw/tpm/tpm_tis.h
index a1df41f..b7fc0ea 100644
--- a/hw/tpm/tpm_tis.h
+++ b/hw/tpm/tpm_tis.h
@@ -54,6 +54,8 @@ typedef struct TPMLocality {
typedef struct TPMTISEmuState {
QEMUBH *bh;
+ bool bh_scheduled; /* bh scheduled but did not run yet */
+
uint32_t offset;
uint8_t buf[TPM_TIS_BUFFER_MAX];
diff --git a/hw/tpm/tpm_util.c b/hw/tpm/tpm_util.c
index 4ace585..580a86c 100644
--- a/hw/tpm/tpm_util.c
+++ b/hw/tpm/tpm_util.c
@@ -21,6 +21,17 @@
#include "tpm_util.h"
#include "tpm_int.h"
+#include "tpm_ioctl.h"
+#include "qemu/error-report.h"
+
+#define DEBUG_TPM 1
+
+#define DPRINTF(fmt, ...) do { \
+ if (DEBUG_TPM) { \
+ fprintf(stderr, fmt, ## __VA_ARGS__); \
+ } \
+} while (0)
+
/*
* A basic test of a TPM device. We expect a well formatted response header
@@ -124,3 +135,215 @@ int tpm_util_test_tpmdev(int tpm_fd, TPMVersion *tpm_version)
return 1;
}
+
+static void tpm_sized_buffer_reset(TPMSizedBuffer *tsb)
+{
+ g_free(tsb->buffer);
+ tsb->buffer = NULL;
+ tsb->size = 0;
+}
+
+/*
+ * Transfer a TPM state blob from the TPM into a provided buffer.
+ *
+ * @fd: file descriptor to talk to the CUSE TPM
+ * @type: the type of blob to transfer
+ * @decrypted_blob: whether we request to receive decrypted blobs
+ * @tsb: the TPMSizeBuffer to fill with the blob
+ * @flags: the flags to return to the caller
+ */
+static int tpm_util_cuse_get_state_blob(int fd,
+ uint8_t type,
+ bool decrypted_blob,
+ TPMSizedBuffer *tsb,
+ uint32_t *flags)
+{
+ ptm_getstate pgs;
+ uint16_t offset = 0;
+ ptm_res res;
+ ssize_t n;
+ size_t to_read;
+
+ tpm_sized_buffer_reset(tsb);
+
+ pgs.u.req.state_flags = (decrypted_blob) ? STATE_FLAG_DECRYPTED : 0;
+ pgs.u.req.type = type;
+ pgs.u.req.offset = offset;
+
+ if (ioctl(fd, PTM_GET_STATEBLOB, &pgs) < 0) {
+ error_report("CUSE TPM PTM_GET_STATEBLOB ioctl failed: %s",
+ strerror(errno));
+ goto err_exit;
+ }
+ res = pgs.u.resp.tpm_result;
+ if (res != 0 && (res & 0x800) == 0) {
+ error_report("Getting the stateblob (type %d) failed with a TPM "
+ "error 0x%x", type, res);
+ goto err_exit;
+ }
+
+ *flags = pgs.u.resp.state_flags;
+
+ tsb->buffer = g_malloc(pgs.u.resp.totlength);
+ memcpy(tsb->buffer, pgs.u.resp.data, pgs.u.resp.length);
+ tsb->size = pgs.u.resp.length;
+
+ /* if there are bytes left to get use read() interface */
+ while (tsb->size < pgs.u.resp.totlength) {
+ to_read = pgs.u.resp.totlength - tsb->size;
+ if (unlikely(to_read > SSIZE_MAX)) {
+ to_read = SSIZE_MAX;
+ }
+
+ n = read(fd, &tsb->buffer[tsb->size], to_read);
+ if (n != to_read) {
+ error_report("Could not read stateblob (type %d) : %s",
+ type, strerror(errno));
+ goto err_exit;
+ }
+ tsb->size += to_read;
+ }
+
+ DPRINTF("tpm_util: got state blob type %d, %d bytes, flags 0x%08x, "
+ "decrypted=%d\n", type, tsb->size, *flags, decrypted_blob);
+
+ return 0;
+
+err_exit:
+ return 1;
+}
+
+int tpm_util_cuse_get_state_blobs(int tpm_fd,
+ bool decrypted_blobs,
+ TPMBlobBuffers *tpm_blobs)
+{
+ if (tpm_util_cuse_get_state_blob(tpm_fd, PTM_BLOB_TYPE_PERMANENT,
+ decrypted_blobs,
+ &tpm_blobs->permanent,
+ &tpm_blobs->permanent_flags) ||
+ tpm_util_cuse_get_state_blob(tpm_fd, PTM_BLOB_TYPE_VOLATILE,
+ decrypted_blobs,
+ &tpm_blobs->volatil,
+ &tpm_blobs->volatil_flags) ||
+ tpm_util_cuse_get_state_blob(tpm_fd, PTM_BLOB_TYPE_SAVESTATE,
+ decrypted_blobs,
+ &tpm_blobs->savestate,
+ &tpm_blobs->savestate_flags)) {
+ goto err_exit;
+ }
+
+ return 0;
+
+ err_exit:
+ tpm_sized_buffer_reset(&tpm_blobs->volatil);
+ tpm_sized_buffer_reset(&tpm_blobs->permanent);
+ tpm_sized_buffer_reset(&tpm_blobs->savestate);
+
+ return 1;
+}
+
+static int tpm_util_cuse_do_set_stateblob_ioctl(int fd,
+ uint32_t flags,
+ uint32_t type,
+ uint32_t length)
+{
+ ptm_setstate pss;
+
+ pss.u.req.state_flags = flags;
+ pss.u.req.type = type;
+ pss.u.req.length = length;
+
+ if (ioctl(fd, PTM_SET_STATEBLOB, &pss) < 0) {
+ error_report("CUSE TPM PTM_SET_STATEBLOB ioctl failed: %s",
+ strerror(errno));
+ return 1;
+ }
+
+ if (pss.u.resp.tpm_result != 0) {
+ error_report("Setting the stateblob (type %d) failed with a TPM "
+ "error 0x%x", type, pss.u.resp.tpm_result);
+ return 1;
+ }
+
+ return 0;
+}
+
+
+/*
+ * Transfer a TPM state blob to the CUSE TPM.
+ *
+ * @fd: file descriptor to talk to the CUSE TPM
+ * @type: the type of TPM state blob to transfer
+ * @tsb: TPMSizeBuffer containing the TPM state blob
+ * @flags: Flags describing the (encryption) state of the TPM state blob
+ */
+static int tpm_util_cuse_set_state_blob(int fd,
+ uint32_t type,
+ TPMSizedBuffer *tsb,
+ uint32 flags)
+{
+ uint32_t offset = 0;
+ ssize_t n;
+ size_t to_write;
+
+ /* initiate the transfer to the CUSE TPM */
+ if (tpm_util_cuse_do_set_stateblob_ioctl(fd, flags, type, 0)) {
+ return 1;
+ }
+
+ /* use the write() interface for transferring the state blob */
+ while (offset < tsb->size) {
+ to_write = tsb->size - offset;
+ if (unlikely(to_write > SSIZE_MAX)) {
+ to_write = SSIZE_MAX;
+ }
+
+ n = write(fd, &tsb->buffer[offset], to_write);
+ if (n != to_write) {
+ error_report("Writing the stateblob (type %d) failed: %s",
+ type, strerror(errno));
+ goto err_exit;
+ }
+ offset += to_write;
+ }
+
+ /* inidicate that the transfer is finished */
+ if (tpm_util_cuse_do_set_stateblob_ioctl(fd, flags, type, 0)) {
+ goto err_exit;
+ }
+
+ DPRINTF("tpm_util: set the state blob type %d, %d bytes, flags 0x%08x\n",
+ type, tsb->size, flags);
+
+ return 0;
+
+err_exit:
+ return 1;
+}
+
+int tpm_util_cuse_set_state_blobs(int tpm_fd,
+ TPMBlobBuffers *tpm_blobs)
+{
+ ptm_res res;
+
+ if (ioctl(tpm_fd, PTM_STOP, &res) < 0) {
+ error_report("tpm_passthrough: Could not stop "
+ "the CUSE TPM: %s (%i)",
+ strerror(errno), errno);
+ return 1;
+ }
+
+ if (tpm_util_cuse_set_state_blob(tpm_fd, PTM_BLOB_TYPE_PERMANENT,
+ &tpm_blobs->permanent,
+ tpm_blobs->permanent_flags) ||
+ tpm_util_cuse_set_state_blob(tpm_fd, PTM_BLOB_TYPE_VOLATILE,
+ &tpm_blobs->volatil,
+ tpm_blobs->volatil_flags) ||
+ tpm_util_cuse_set_state_blob(tpm_fd, PTM_BLOB_TYPE_SAVESTATE,
+ &tpm_blobs->savestate,
+ tpm_blobs->savestate_flags)) {
+ return 1;
+ }
+
+ return 0;
+}
diff --git a/hw/tpm/tpm_util.h b/hw/tpm/tpm_util.h
index e7f354a..04f5afd 100644
--- a/hw/tpm/tpm_util.h
+++ b/hw/tpm/tpm_util.h
@@ -25,4 +25,11 @@
int tpm_util_test_tpmdev(int tpm_fd, TPMVersion *tpm_version);
+int tpm_util_cuse_get_state_blobs(int tpm_fd,
+ bool decrypted_blobs,
+ TPMBlobBuffers *tpm_blobs);
+
+int tpm_util_cuse_set_state_blobs(int tpm_fd,
+ TPMBlobBuffers *tpm_blobs);
+
#endif /* TPM_TPM_UTILS_H */
diff --git a/include/sysemu/tpm_backend.h b/include/sysemu/tpm_backend.h
index 0a366be..92bc3e4 100644
--- a/include/sysemu/tpm_backend.h
+++ b/include/sysemu/tpm_backend.h
@@ -63,6 +63,18 @@ typedef struct TPMSizedBuffer {
uint8_t *buffer;
} TPMSizedBuffer;
+/* blobs from the TPM; part of VM state when migrating */
+typedef struct TPMBlobBuffers {
+ uint32_t permanent_flags;
+ TPMSizedBuffer permanent;
+
+ uint32_t volatil_flags;
+ TPMSizedBuffer volatil;
+
+ uint32_t savestate_flags;
+ TPMSizedBuffer savestate;
+} TPMBlobBuffers;
+
struct TPMDriverOps {
enum TpmType type;
const QemuOptDesc *opts;
--
1.9.3
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
2015-06-08 11:17 [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Stefan Berger
` (3 preceding siblings ...)
2015-06-08 11:17 ` [Qemu-devel] [PATCH v4 4/4] Add support for VM suspend/resume for TPM TIS Stefan Berger
@ 2015-06-23 5:26 ` Michael S. Tsirkin
2015-06-23 12:07 ` Stefan Berger
2015-06-23 13:52 ` Michael S. Tsirkin
5 siblings, 1 reply; 12+ messages in thread
From: Michael S. Tsirkin @ 2015-06-23 5:26 UTC (permalink / raw)
To: Stefan Berger; +Cc: stefanb, qemu-devel, quan.xu
On Mon, Jun 08, 2015 at 07:17:33AM -0400, Stefan Berger wrote:
> The following series of patches extends TPM support with an
> external TPM that offers a Linux CUSE (character device in userspace)
> interface. This TPM lets each VM access its own private vTPM.
> The CUSE TPM supports suspend/resume and migration. Much
> out-of-band functionality necessary to control the CUSE TPM is
> implemented using ioctls.
I was hoping this can get a wider discussion, but apparently no one
noticed this.
This needs some thought: how do we decide which ioctls we support?
It's easier with kernel since we know distros ship it, but
will they do so with this tpm? We do want to reuse system components
but we don't want random parts of QEMU delegated to a random
out of tree module.
Couldn't you re-use in-kernel interfaces for the CUSE module?
Then existing pass-through in QEMU would more or less just work with it -
merely open a different chardev.
> Stefan Berger (4):
> Provide support for the CUSE TPM
> Introduce condition to notify waiters of completed command
> Introduce condition in TPM backend for notification
> Add support for VM suspend/resume for TPM TIS
>
> hmp.c | 6 +
> hw/tpm/tpm_int.h | 4 +
> hw/tpm/tpm_ioctl.h | 209 ++++++++++++++++++++++
> hw/tpm/tpm_passthrough.c | 409 +++++++++++++++++++++++++++++++++++++++++--
> hw/tpm/tpm_tis.c | 151 +++++++++++++++-
> hw/tpm/tpm_tis.h | 2 +
> hw/tpm/tpm_util.c | 223 +++++++++++++++++++++++
> hw/tpm/tpm_util.h | 7 +
> include/sysemu/tpm_backend.h | 12 ++
> qapi-schema.json | 18 +-
> qemu-options.hx | 21 ++-
> qmp-commands.hx | 2 +-
> tpm.c | 11 +-
> 13 files changed, 1056 insertions(+), 19 deletions(-)
> create mode 100644 hw/tpm/tpm_ioctl.h
>
> --
> 1.9.3
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
2015-06-23 5:26 ` [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Michael S. Tsirkin
@ 2015-06-23 12:07 ` Stefan Berger
2015-06-23 13:11 ` Michael S. Tsirkin
0 siblings, 1 reply; 12+ messages in thread
From: Stefan Berger @ 2015-06-23 12:07 UTC (permalink / raw)
To: Q Michael S. Tsirkin; +Cc: qemu-devel, quan.xu, Stefan Berger
[-- Attachment #1: Type: text/plain, Size: 3820 bytes --]
"Michael S. Tsirkin" <mst@redhat.com> wrote on 06/23/2015 01:26:13 AM:
> From: "Michael S. Tsirkin" <mst@redhat.com>
> To: Stefan Berger <stefanb@linux.vnet.ibm.com>
> Cc: qemu-devel@nongnu.org, quan.xu@intel.com, Stefan
Berger/Watson/IBM@IBMUS
> Date: 06/23/2015 01:26 AM
> Subject: Re: [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
>
> On Mon, Jun 08, 2015 at 07:17:33AM -0400, Stefan Berger wrote:
> > The following series of patches extends TPM support with an
> > external TPM that offers a Linux CUSE (character device in userspace)
> > interface. This TPM lets each VM access its own private vTPM.
> > The CUSE TPM supports suspend/resume and migration. Much
> > out-of-band functionality necessary to control the CUSE TPM is
> > implemented using ioctls.
>
> I was hoping this can get a wider discussion, but apparently no one
> noticed this.
>
> This needs some thought: how do we decide which ioctls we support?
The ioctls the patches are currently using support all necessary aspects
for controlling that
external TPM following interaction with the TPM TIS emulation (tpm_tis.c)
and
virtual machine migration. [Excluding support for DRTM]
There's an ioctl that returns a bitfield of supported features. The
patches use the ioctl
to determine whether enough features are supported to for example support
migration.
A supported feature then means supporting its corresponding ioctl and
associated data structure.
> It's easier with kernel since we know distros ship it, but
> will they do so with this tpm? We do want to reuse system components
I haven't packaged the swtpm for Fedora (for example) yet. I wanted to
delay the tagging of version 0.1
of swtpm until the code that's using it is in QEMU.
> but we don't want random parts of QEMU delegated to a random
> out of tree module.
It's hopefully not that random. There's nothing comparable out there. Just
having the TPM passthrough
isn't useful. Usefulness comes with the CUSE TPM driver and external CUSE
TPM, since this provides a
private and fully functional TPM to each QEMU VM.
>
> Couldn't you re-use in-kernel interfaces for the CUSE module?
The CUSE TPM uses the ioctl's for out-of-band control. The out-of-band
control happens on a different
level than what is out there in the kernel right now, since we are
implementing a layer that is
typically implemented in hardware. Otherwise I am not sure what re-use of
in-kernel interfaces you
are referring to.
> Then existing pass-through in QEMU would more or less just work with it
-
> merely open a different chardev.
Having implemented 10+ ioctls for out-of-band control shows a necessity
for out-of-band control.
It is not enough to support a read()/write() interface where we can send
TPM request through.
Stefan
>
>
> > Stefan Berger (4):
> > Provide support for the CUSE TPM
> > Introduce condition to notify waiters of completed command
> > Introduce condition in TPM backend for notification
> > Add support for VM suspend/resume for TPM TIS
> >
> > hmp.c | 6 +
> > hw/tpm/tpm_int.h | 4 +
> > hw/tpm/tpm_ioctl.h | 209 ++++++++++++++++++++++
> > hw/tpm/tpm_passthrough.c | 409 ++++++++++++++++++++++++++++++
> +++++++++++--
> > hw/tpm/tpm_tis.c | 151 +++++++++++++++-
> > hw/tpm/tpm_tis.h | 2 +
> > hw/tpm/tpm_util.c | 223 +++++++++++++++++++++++
> > hw/tpm/tpm_util.h | 7 +
> > include/sysemu/tpm_backend.h | 12 ++
> > qapi-schema.json | 18 +-
> > qemu-options.hx | 21 ++-
> > qmp-commands.hx | 2 +-
> > tpm.c | 11 +-
> > 13 files changed, 1056 insertions(+), 19 deletions(-)
> > create mode 100644 hw/tpm/tpm_ioctl.h
> >
> > --
> > 1.9.3
>
[-- Attachment #2: Type: text/html, Size: 5843 bytes --]
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
2015-06-23 12:07 ` Stefan Berger
@ 2015-06-23 13:11 ` Michael S. Tsirkin
0 siblings, 0 replies; 12+ messages in thread
From: Michael S. Tsirkin @ 2015-06-23 13:11 UTC (permalink / raw)
To: Stefan Berger; +Cc: qemu-devel, quan.xu, Stefan Berger
On Tue, Jun 23, 2015 at 08:07:16AM -0400, Stefan Berger wrote:
> "Michael S. Tsirkin" <mst@redhat.com> wrote on 06/23/2015 01:26:13 AM:
>
> > From: "Michael S. Tsirkin" <mst@redhat.com>
> > To: Stefan Berger <stefanb@linux.vnet.ibm.com>
> > Cc: qemu-devel@nongnu.org, quan.xu@intel.com, Stefan Berger/Watson/IBM@IBMUS
> > Date: 06/23/2015 01:26 AM
> > Subject: Re: [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
> >
> > On Mon, Jun 08, 2015 at 07:17:33AM -0400, Stefan Berger wrote:
> > > The following series of patches extends TPM support with an
> > > external TPM that offers a Linux CUSE (character device in userspace)
> > > interface. This TPM lets each VM access its own private vTPM.
> > > The CUSE TPM supports suspend/resume and migration. Much
> > > out-of-band functionality necessary to control the CUSE TPM is
> > > implemented using ioctls.
> >
> > I was hoping this can get a wider discussion, but apparently no one
> > noticed this.
> >
> > This needs some thought: how do we decide which ioctls we support?
>
> The ioctls the patches are currently using support all necessary aspects for
> controlling that
> external TPM following interaction with the TPM TIS emulation (tpm_tis.c) and
> virtual machine migration. [Excluding support for DRTM]
>
> There's an ioctl that returns a bitfield of supported features. The patches use
> the ioctl
> to determine whether enough features are supported to for example support
> migration.
> A supported feature then means supporting its corresponding ioctl and
> associated data structure.
>
> > It's easier with kernel since we know distros ship it, but
> > will they do so with this tpm? We do want to reuse system components
>
> I haven't packaged the swtpm for Fedora (for example) yet. I wanted to delay
> the tagging of version 0.1
> of swtpm until the code that's using it is in QEMU.
>
Yes, and it's a bit of a chicken and egg problem.
Aren't there other uses besides QEMU?
> > but we don't want random parts of QEMU delegated to a random
> > out of tree module.
>
> It's hopefully not that random. There's nothing comparable out there. Just
> having the TPM passthrough
> isn't useful. Usefulness comes with the CUSE TPM driver and external CUSE TPM,
> since this provides a
> private and fully functional TPM to each QEMU VM.
>
> >
> > Couldn't you re-use in-kernel interfaces for the CUSE module?
>
> The CUSE TPM uses the ioctl's for out-of-band control. The out-of-band control
> happens on a different
> level than what is out there in the kernel right now, since we are implementing
> a layer that is
> typically implemented in hardware. Otherwise I am not sure what re-use of
> in-kernel interfaces you
> are referring to.
>
I don't really know :( I was just trying to help. If you could reuse
an existing interface that is already supported by some system,
it would be easier.
> > Then existing pass-through in QEMU would more or less just work with it -
> > merely open a different chardev.
>
> Having implemented 10+ ioctls for out-of-band control shows a necessity for
> out-of-band control.
> It is not enough to support a read()/write() interface where we can send TPM
> request through.
>
> Stefan
It was just a thought. I was looking for an interface that's useful
outside VM.
> >
> >
> > > Stefan Berger (4):
> > > Provide support for the CUSE TPM
> > > Introduce condition to notify waiters of completed command
> > > Introduce condition in TPM backend for notification
> > > Add support for VM suspend/resume for TPM TIS
> > >
> > > hmp.c | 6 +
> > > hw/tpm/tpm_int.h | 4 +
> > > hw/tpm/tpm_ioctl.h | 209 ++++++++++++++++++++++
> > > hw/tpm/tpm_passthrough.c | 409 ++++++++++++++++++++++++++++++
> > +++++++++++--
> > > hw/tpm/tpm_tis.c | 151 +++++++++++++++-
> > > hw/tpm/tpm_tis.h | 2 +
> > > hw/tpm/tpm_util.c | 223 +++++++++++++++++++++++
> > > hw/tpm/tpm_util.h | 7 +
> > > include/sysemu/tpm_backend.h | 12 ++
> > > qapi-schema.json | 18 +-
> > > qemu-options.hx | 21 ++-
> > > qmp-commands.hx | 2 +-
> > > tpm.c | 11 +-
> > > 13 files changed, 1056 insertions(+), 19 deletions(-)
> > > create mode 100644 hw/tpm/tpm_ioctl.h
> > >
> > > --
> > > 1.9.3
> >
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
2015-06-08 11:17 [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Stefan Berger
` (4 preceding siblings ...)
2015-06-23 5:26 ` [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM Michael S. Tsirkin
@ 2015-06-23 13:52 ` Michael S. Tsirkin
2015-06-23 15:37 ` Stefan Berger
5 siblings, 1 reply; 12+ messages in thread
From: Michael S. Tsirkin @ 2015-06-23 13:52 UTC (permalink / raw)
To: Stefan Berger; +Cc: stefanb, qemu-devel, quan.xu
On Mon, Jun 08, 2015 at 07:17:33AM -0400, Stefan Berger wrote:
> The following series of patches extends TPM support with an
> external TPM that offers a Linux CUSE (character device in userspace)
> interface. This TPM lets each VM access its own private vTPM.
> The CUSE TPM supports suspend/resume and migration. Much
> out-of-band functionality necessary to control the CUSE TPM is
> implemented using ioctls.
So the problem is really review. I feel to judge this
adequately I'd have to review cuse code too (since
no one else did). And unfortunately I don't have the
time to do this anytime soon.
As far as I'm concerned, if anyone wants to review
and merge these patches, pls go ahead, I have nothing
against them.
--
MST
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
2015-06-23 13:52 ` Michael S. Tsirkin
@ 2015-06-23 15:37 ` Stefan Berger
2015-06-23 15:42 ` Michael S. Tsirkin
0 siblings, 1 reply; 12+ messages in thread
From: Stefan Berger @ 2015-06-23 15:37 UTC (permalink / raw)
To: Michael S. Tsirkin; +Cc: qemu-devel, quan.xu, Stefan Berger
[-- Attachment #1: Type: text/plain, Size: 1209 bytes --]
"Michael S. Tsirkin" <mst@redhat.com> wrote on 06/23/2015 09:52:34 AM:
> From: "Michael S. Tsirkin" <mst@redhat.com>
> To: Stefan Berger <stefanb@linux.vnet.ibm.com>
> Cc: qemu-devel@nongnu.org, quan.xu@intel.com, Stefan
Berger/Watson/IBM@IBMUS
> Date: 06/23/2015 09:52 AM
> Subject: Re: [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
>
> On Mon, Jun 08, 2015 at 07:17:33AM -0400, Stefan Berger wrote:
> > The following series of patches extends TPM support with an
> > external TPM that offers a Linux CUSE (character device in userspace)
> > interface. This TPM lets each VM access its own private vTPM.
> > The CUSE TPM supports suspend/resume and migration. Much
> > out-of-band functionality necessary to control the CUSE TPM is
> > implemented using ioctls.
>
> So the problem is really review. I feel to judge this
> adequately I'd have to review cuse code too (since
> no one else did). And unfortunately I don't have the
> time to do this anytime soon.
You mean the CUSE code in the kernel and client library?
>
> As far as I'm concerned, if anyone wants to review
> and merge these patches, pls go ahead, I have nothing
> against them.
Sounds good.
Stefan
>
> --
> MST
>
[-- Attachment #2: Type: text/html, Size: 1815 bytes --]
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
2015-06-23 15:37 ` Stefan Berger
@ 2015-06-23 15:42 ` Michael S. Tsirkin
2015-07-02 11:45 ` Stefan Berger
0 siblings, 1 reply; 12+ messages in thread
From: Michael S. Tsirkin @ 2015-06-23 15:42 UTC (permalink / raw)
To: Stefan Berger; +Cc: qemu-devel, quan.xu, Stefan Berger
On Tue, Jun 23, 2015 at 11:37:02AM -0400, Stefan Berger wrote:
> "Michael S. Tsirkin" <mst@redhat.com> wrote on 06/23/2015 09:52:34 AM:
>
> > From: "Michael S. Tsirkin" <mst@redhat.com>
> > To: Stefan Berger <stefanb@linux.vnet.ibm.com>
> > Cc: qemu-devel@nongnu.org, quan.xu@intel.com, Stefan Berger/Watson/IBM@IBMUS
> > Date: 06/23/2015 09:52 AM
> > Subject: Re: [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
> >
> > On Mon, Jun 08, 2015 at 07:17:33AM -0400, Stefan Berger wrote:
> > > The following series of patches extends TPM support with an
> > > external TPM that offers a Linux CUSE (character device in userspace)
> > > interface. This TPM lets each VM access its own private vTPM.
> > > The CUSE TPM supports suspend/resume and migration. Much
> > > out-of-band functionality necessary to control the CUSE TPM is
> > > implemented using ioctls.
> >
> > So the problem is really review. I feel to judge this
> > adequately I'd have to review cuse code too (since
> > no one else did). And unfortunately I don't have the
> > time to do this anytime soon.
>
> You mean the CUSE code in the kernel and client library?
I mean swtpm in your tree.
> >
> > As far as I'm concerned, if anyone wants to review
> > and merge these patches, pls go ahead, I have nothing
> > against them.
>
> Sounds good.
>
> Stefan
>
> >
> > --
> > MST
> >
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
2015-06-23 15:42 ` Michael S. Tsirkin
@ 2015-07-02 11:45 ` Stefan Berger
0 siblings, 0 replies; 12+ messages in thread
From: Stefan Berger @ 2015-07-02 11:45 UTC (permalink / raw)
To: Michael S. Tsirkin, Stefan Berger; +Cc: qemu-devel, quan.xu
On 06/23/2015 11:42 AM, Michael S. Tsirkin wrote:
> On Tue, Jun 23, 2015 at 11:37:02AM -0400, Stefan Berger wrote:
>> "Michael S. Tsirkin" <mst@redhat.com> wrote on 06/23/2015 09:52:34 AM:
>>
>>> From: "Michael S. Tsirkin" <mst@redhat.com>
>>> To: Stefan Berger <stefanb@linux.vnet.ibm.com>
>>> Cc: qemu-devel@nongnu.org, quan.xu@intel.com, Stefan Berger/Watson/IBM@IBMUS
>>> Date: 06/23/2015 09:52 AM
>>> Subject: Re: [PATCH v4 0/4] Extend TPM support with a QEMU-external TPM
>>>
>>> On Mon, Jun 08, 2015 at 07:17:33AM -0400, Stefan Berger wrote:
>>>> The following series of patches extends TPM support with an
>>>> external TPM that offers a Linux CUSE (character device in userspace)
>>>> interface. This TPM lets each VM access its own private vTPM.
>>>> The CUSE TPM supports suspend/resume and migration. Much
>>>> out-of-band functionality necessary to control the CUSE TPM is
>>>> implemented using ioctls.
>>> So the problem is really review. I feel to judge this
>>> adequately I'd have to review cuse code too (since
>>> no one else did). And unfortunately I don't have the
>>> time to do this anytime soon.
>> You mean the CUSE code in the kernel and client library?
> I mean swtpm in your tree.
>
>>> As far as I'm concerned, if anyone wants to review
>>> and merge these patches, pls go ahead, I have nothing
>>> against them.
>> Sounds good.
Michael,
can you pick up these patches here for upstreaming?
Regards,
Stefan
^ permalink raw reply [flat|nested] 12+ messages in thread