From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([140.186.70.92]:54439) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Qt145-0006sa-7k for qemu-devel@nongnu.org; Mon, 15 Aug 2011 13:35:07 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Qt143-0004Or-0I for qemu-devel@nongnu.org; Mon, 15 Aug 2011 13:35:05 -0400 Received: from e3.ny.us.ibm.com ([32.97.182.143]:46580) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Qt142-0004NY-Sg for qemu-devel@nongnu.org; Mon, 15 Aug 2011 13:35:02 -0400 Received: from d01relay07.pok.ibm.com (d01relay07.pok.ibm.com [9.56.227.147]) by e3.ny.us.ibm.com (8.14.4/8.13.1) with ESMTP id p7FHAjuf002228 for ; Mon, 15 Aug 2011 13:10:45 -0400 Received: from d01av02.pok.ibm.com (d01av02.pok.ibm.com [9.56.224.216]) by d01relay07.pok.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id p7FHYsrN2727990 for ; Mon, 15 Aug 2011 13:34:55 -0400 Received: from d01av02.pok.ibm.com (loopback [127.0.0.1]) by d01av02.pok.ibm.com (8.14.4/8.13.1/NCO v10.0 AVout) with ESMTP id p7FHYsQ8024723 for ; Mon, 15 Aug 2011 14:34:54 -0300 Received: from [9.59.241.154] (d941e-10.watson.ibm.com [9.59.241.154]) by d01av02.pok.ibm.com (8.14.4/8.13.1/NCO v10.0 AVin) with ESMTP id p7FHYppU024361 for ; Mon, 15 Aug 2011 14:34:52 -0300 Message-ID: <4E4958BB.1000603@linux.vnet.ibm.com> Date: Mon, 15 Aug 2011 13:34:51 -0400 From: Stefan Berger MIME-Version: 1.0 References: <1313163072-15152-1-git-send-email-andreas.niederl@iaik.tugraz.at> In-Reply-To: <1313163072-15152-1-git-send-email-andreas.niederl@iaik.tugraz.at> Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Subject: Re: [Qemu-devel] [PATCH] Add a TPM Passthrough backend driver implementation List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org On 08/12/2011 11:31 AM, Andreas Niederl wrote: > This patch is based of off version 7 of Stefan Berger's patch series > "Qemu Trusted Platform Module (TPM) integration" > and adds a new backend driver for it. > > This patch adds a passthrough backend driver for passing commands sent to the > emulated TPM device directly to a TPM device opened on the host machine. > > Thus it is possible to use a hardware TPM device in a system running on QEMU, > providing the ability to access a TPM in a special state (e.g. after a Trusted > Boot). > > This functionality is being used in the acTvSM Trusted Virtualization Platform > which is available on [1]. > > Usage example: > qemu-system-x86_64 -tpmdev passthrough,id=tpm0,path=/dev/tpm0 \ > -device tpm-tis,tpmdev=tpm0 \ > -cdrom test.iso -boot d > The code looks good to me. Though hopefully nothing on the host is using the TPM in this case so that all PCRs are cleared once the VM starts -- this may otherwise create problems with attestation. Also, this device may need to be marked as unmigratable -- I am not sure how to do this though. There is an API in savevm.c to register a device as unmigratable, but I don't think we can call it (register_device_unmigratable()). It may either require some rearranging of code in tpm_tis where the VMStateDescription structure also has a field to mark a device as unmigratable (used by usb emulators for example) or the introduction of a new API call that allows a device to be marked as unmigratable after it has been registered. Regards, Stefan > Regards, > Andreas Niederl > > [1] http://trustedjava.sourceforge.net/ > > Signed-off-by: Andreas Niederl > --- > Makefile.target | 2 +- > hw/tpm_passthrough.c | 450 ++++++++++++++++++++++++++++++++++++++++++++++++++ > tpm.c | 1 + > tpm.h | 1 + > 4 files changed, 453 insertions(+), 1 deletions(-) > create mode 100644 hw/tpm_passthrough.c > > diff --git a/Makefile.target b/Makefile.target > index f4d42d4..7f19f28 100644 > --- a/Makefile.target > +++ b/Makefile.target > @@ -233,7 +233,7 @@ obj-i386-y += debugcon.o multiboot.o > obj-i386-y += pc_piix.o > obj-i386-$(CONFIG_KVM) += kvmclock.o > obj-i386-$(CONFIG_SPICE) += qxl.o qxl-logger.o qxl-render.o > -obj-i386-$(CONFIG_TPM) += tpm_tis.o sha1.o tpm_null.o > +obj-i386-$(CONFIG_TPM) += tpm_tis.o sha1.o tpm_null.o tpm_passthrough.o > obj-i386-$(CONFIG_TPM_BUILTIN) += tpm_builtin.o > > ifdef CONFIG_TPM_BUILTIN > diff --git a/hw/tpm_passthrough.c b/hw/tpm_passthrough.c > new file mode 100644 > index 0000000..aabfea2 > --- /dev/null > +++ b/hw/tpm_passthrough.c > @@ -0,0 +1,450 @@ > +/* > + * passthrough TPM driver > + * > + * Copyright (c) 2010, 2011 IBM Corporation > + * Copyright (c) 2010, 2011 Stefan Berger > + * > + * Copyright (C) 2011 IAIK, Graz University of Technology > + * Author: Andreas Niederl > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2 of the License, or (at your option) any later version. > + * > + * This library is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library; if not, see > + */ > + > +#include "qemu-common.h" > +#include "tpm.h" > +#include "hw/hw.h" > +#include "hw/tpm_tis.h" > +#include "hw/pc.h" > + > + > +//#define DEBUG_TPM > +//#define DEBUG_TPM_SR /* suspend - resume */ > + > + > +/* data structures */ > + > +typedef struct ThreadParams { > + TPMState *tpm_state; > + > + TPMRecvDataCB *recv_data_callback; > + > + int fd; > +} ThreadParams; > + > + > +/* local variables */ > + > +static QemuThread thread; > + > +static bool thread_terminate = false; > +static bool thread_running = false; > + > +static ThreadParams tpm_thread_params; > + > +static const unsigned char tpm_std_fatal_error_response[10] = { > + 0x00, 0xc4, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x09 /* TPM_FAIL */ > +}; > + > +static char dev_description[80]; > + > +static char tpm_dev[255]; > +static int tpmfd = -1; > + > +static bool had_startup_error = false; > + > + > +/* borrowed from qemu-char.c */ > +static int unix_write(int fd, const uint8_t *buf, uint32_t len) > +{ > + int ret, len1; > + > + len1 = len; > + while (len1> 0) { > + ret = write(fd, buf, len1); > + if (ret< 0) { > + if (errno != EINTR&& errno != EAGAIN) > + return -1; > + } else if (ret == 0) { > + break; > + } else { > + buf += ret; > + len1 -= ret; > + } > + } > + return len - len1; > +} > + > +static int unix_read(int fd, uint8_t *buf, uint32_t len) > +{ > + int ret, len1; > + uint8_t *buf1; > + > + len1 = len; > + buf1 = buf; > + while ((len1> 0)&& (ret = read(fd, buf1, len1)) != 0) { > + if (ret< 0) { > + if (errno != EINTR&& errno != EAGAIN) > + return -1; > + } else { > + buf1 += ret; > + len1 -= ret; > + } > + } > + return len - len1; > +} > + > + > +static void tpm_write_std_fatal_error_response(uint8_t *out, > + uint8_t *in, uint32_t in_len) > +{ > + memcpy(out, tpm_std_fatal_error_response, > + sizeof(tpm_std_fatal_error_response)); > + out[1] = (in_len> 2&& in[1]>= 0xc1&& in[1]<= 0xc3) > + ? in[1] + 3 > + : 0xc4; > +} > + > +static void *tpm_passthrough_main_loop(void *d) > +{ > + ThreadParams *thr_parms = d; > + uint32_t in_len, out_len; > + uint8_t *in, *out; > + uint8_t locty; > + int ret; > + > +#ifdef DEBUG_TPM > + fprintf(stderr, "tpm: THREAD IS STARTING\n"); > +#endif > + > + /* start command processing */ > + while (!thread_terminate) { > + /* receive and handle commands */ > + in_len = 0; > + do { > +#ifdef DEBUG_TPM > + fprintf(stderr, "tpm: waiting for commands...\n"); > +#endif > + > + if (thread_terminate) { > + break; > + } > + > + qemu_mutex_lock(&thr_parms->tpm_state->state_lock); > + > + /* in case we were to slow and missed the signal, the > + to_tpm_execute boolean tells us about a pending command */ > + if (!thr_parms->tpm_state->to_tpm_execute) { > + qemu_cond_wait(&thr_parms->tpm_state->to_tpm_cond, > +&thr_parms->tpm_state->state_lock); > + } > + > + thr_parms->tpm_state->to_tpm_execute = false; > + > + qemu_mutex_unlock(&thr_parms->tpm_state->state_lock); > + > + if (thread_terminate) { > + break; > + } > + > + locty = thr_parms->tpm_state->command_locty; > + > + in = thr_parms->tpm_state->loc[locty].w_buffer.buffer; > + in_len = thr_parms->tpm_state->loc[locty].w_offset; > + out = thr_parms->tpm_state->loc[locty].r_buffer.buffer; > + out_len = thr_parms->tpm_state->loc[locty].r_buffer.size; > + > + ret = unix_write(tpmfd, in, in_len); > + if (ret< 0) { > + fprintf(stderr, "tpm: error while transmitting data to host tpm" > + ": %s (%i)\n", > + strerror(errno), errno); > + tpm_write_std_fatal_error_response(out, in, in_len); > + continue; > + } > + > + ret = unix_read(tpmfd, out, out_len); > + if (ret< 0) { > + fprintf(stderr, "tpm: error while reading data from host tpm" > + ": %s (%i)\n", > + strerror(errno), errno); > + tpm_write_std_fatal_error_response(out, in, in_len); > + continue; > + } > + > + thr_parms->recv_data_callback(thr_parms->tpm_state, locty); > + } while (in_len> 0); > + } > + > +#ifdef DEBUG_TPM > + fprintf(stderr, "tpm: THREAD IS ENDING\n"); > +#endif > + > + thread_running = false; > + > + return NULL; > +} > + > + > +static void tpm_passthrough_terminate_tpm_thread(void) > +{ > + if (!thread_running) { > + return; > + } > + > +#if defined DEBUG_TPM || defined DEBUG_TPM_SR > + fprintf(stderr, "tpm: TERMINATING RUNNING TPM THREAD\n"); > +#endif > + > + if (!thread_terminate) { > + thread_terminate = true; > + > + qemu_mutex_lock (&tpm_thread_params.tpm_state->state_lock); > + qemu_cond_signal (&tpm_thread_params.tpm_state->to_tpm_cond); > + qemu_mutex_unlock(&tpm_thread_params.tpm_state->state_lock); > + > + while (thread_running) { > + usleep(100000); > + } > + memset(&thread, 0, sizeof(thread)); > + } > +} > + > + > +static void tpm_passthrough_tpm_atexit(void) > +{ > + tpm_passthrough_terminate_tpm_thread(); > + > + close(tpmfd); > + tpmfd = -1; > +} > + > + > +/** > + * Start the TPM (thread). If it had been started before, then terminate > + * and start it again. > + */ > +static int tpm_passthrough_startup_tpm(void) > +{ > + /* terminate a running TPM */ > + tpm_passthrough_terminate_tpm_thread(); > + > + /* reset the flag so the thread keeps on running */ > + thread_terminate = false; > + > + qemu_thread_create(&thread, tpm_passthrough_main_loop,&tpm_thread_params); > + > + thread_running = true; > + > + return 0; > +} > + > + > +static int tpm_passthrough_do_startup_tpm(void) > +{ > + int rc; > + > + rc = tpm_passthrough_startup_tpm(); > + if (rc) { > + had_startup_error = true; > + } > + return rc; > +} > + > + > +static int tpm_passthrough_early_startup_tpm(void) > +{ > + return tpm_passthrough_do_startup_tpm(); > +} > + > + > +static int tpm_passthrough_late_startup_tpm(void) > +{ > + return tpm_passthrough_do_startup_tpm(); > +} > + > + > +static void tpm_passthrough_reset(void) > +{ > +#if defined DEBUG_TPM || defined DEBUG_TPM_SR > + fprintf(stderr, "tpm: CALL TO TPM_RESET!\n"); > +#endif > + > + tpm_passthrough_terminate_tpm_thread(); > + > + had_startup_error = false; > +} > + > + > +/* > + * Since the null driver does not have much persistent storage > + * there is not much to do here... > + */ > +static int tpm_passthrough_instantiate_with_volatile_data(TPMState *s) > +{ > + if (thread_running) { > +#ifdef DEBUG_TPM_SR > + fprintf(stderr, "tpm: This is resume of a SNAPSHOT\n"); > +#endif > + tis_reset_for_snapshot_resume(s); > + } > + > + return 0; > +} > + > + > +static int tpm_passthrough_init(TPMState *s, TPMRecvDataCB *recv_data_cb) > +{ > + tpm_thread_params.tpm_state = s; > + tpm_thread_params.recv_data_callback = recv_data_cb; > + > + tpmfd = open(tpm_dev, O_RDWR); > + if (tpmfd< 0) { > + fprintf(stderr, > + "Cannot open device '%s' from tpm's path option.\n", > + tpm_dev); > + goto err_exit; > + } > + > + atexit(tpm_passthrough_tpm_atexit); > + > + return 0; > + > +err_exit: > + if (tpmfd>= 0) { > + close(tpmfd); > + tpmfd = -1; > + } > + return 1; > +} > + > + > +static bool tpm_passthrough_get_tpm_established_flag(void) > +{ > + return false; > +} > + > + > +static bool tpm_passthrough_get_startup_error(void) > +{ > + return had_startup_error; > +} > + > + > +/** > + * This function is called by tpm_tis.c once the TPM has processed > + * the last command and returned the response to the TIS. > + */ > +static int tpm_passthrough_save_volatile_data(void) > +{ > + return 0; > +} > + > + > +static size_t tpm_passthrough_realloc_buffer(TPMSizedBuffer *sb) > +{ > + size_t wanted_size = 4096; > + > + if (sb->size != wanted_size) { > + sb->buffer = qemu_realloc(sb->buffer, wanted_size); > + if (sb->buffer != NULL) { > + sb->size = wanted_size; > + } else { > + sb->size = 0; > + } > + } > + return sb->size; > +} > + > + > +static const char *tpm_passthrough_create_desc(void) > +{ > + static int done; > + > + if (!done) { > + snprintf(dev_description, sizeof(dev_description), > + "Passthrough TPM backend driver"); > + done = 1; > + } > + > + return dev_description; > +} > + > + > +static TPMBackend *tpm_passthrough_create(QemuOpts *opts, const char *id, > + const char *model) > +{ > + TPMBackend *driver; > + const char *value; > + > + driver = qemu_malloc(sizeof(TPMBackend)); > + if (!driver) { > + fprintf(stderr, "Could not allocate memory.\n"); > + return NULL; > + } > + driver->id = qemu_strdup(id); > + driver->model = NULL; > + if (model) > + driver->model = qemu_strdup(model); > + driver->ops =&tpm_passthrough_driver; > + > + value = qemu_opt_get(opts, "path"); > + if (value) { > + if (access(value, R_OK|W_OK)) { > + fprintf(stderr, > + "Cannot access device '%s' from tpm's path option.\n", > + value); > + goto err_exit; > + } > + strncpy(tpm_dev, value, sizeof(tpm_dev)); > + } else { > + fprintf(stderr, "-tpm is missing path= parameter\n"); > + goto err_exit; > + } > + > + return driver; > + > +err_exit: > + qemu_free(driver->id); > + if (driver->model) > + qemu_free(driver->model); > + qemu_free(driver); > + return NULL; > +} > + > + > +static void tpm_passthrough_destroy(TPMBackend *driver) > +{ > + qemu_free(driver->id); > + if (driver->model) > + qemu_free(driver->model); > + qemu_free(driver); > +} > + > + > +TPMDriverOps tpm_passthrough_driver = { > + .id = "passthrough", > + .desc = tpm_passthrough_create_desc, > + .job_for_main_thread = NULL, > + .create = tpm_passthrough_create, > + .destroy = tpm_passthrough_destroy, > + .init = tpm_passthrough_init, > + .early_startup_tpm = tpm_passthrough_early_startup_tpm, > + .late_startup_tpm = tpm_passthrough_late_startup_tpm, > + .realloc_buffer = tpm_passthrough_realloc_buffer, > + .reset = tpm_passthrough_reset, > + .had_startup_error = tpm_passthrough_get_startup_error, > + .save_volatile_data = tpm_passthrough_save_volatile_data, > + .load_volatile_data = tpm_passthrough_instantiate_with_volatile_data, > + .get_tpm_established_flag = tpm_passthrough_get_tpm_established_flag, > +}; > diff --git a/tpm.c b/tpm.c > index b75fe5c..edcbfe7 100644 > --- a/tpm.c > +++ b/tpm.c > @@ -28,6 +28,7 @@ static const TPMDriverOps *bes[] = { > #ifdef CONFIG_TPM_BUILTIN > &tpm_builtin, > #endif > +&tpm_passthrough_driver, > NULL, > }; > > diff --git a/tpm.h b/tpm.h > index d00e599..01cae9a 100644 > --- a/tpm.h > +++ b/tpm.h > @@ -143,5 +143,6 @@ void tpm_measure_buffer(const void *buffer, long length, > > extern TPMDriverOps tpm_null_driver; > extern TPMDriverOps tpm_builtin; > +extern TPMDriverOps tpm_passthrough_driver; > > #endif /* _HW_TPM_CONFIG_H */