backends/tpm.c

   1 /*
   2  * QEMU TPM Backend
   3  *
   4  * Copyright IBM, Corp. 2013
   5  *
   6  * Authors:
   7  *  Stefan Berger   <stefanb@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  *
  12  * Based on backends/rng.c by Anthony Liguori
  13  */
  14
  15 #include "qemu/osdep.h"
  16 #include "sysemu/tpm_backend.h"
  17 #include "qapi/error.h"
  18 #include "sysemu/tpm.h"
  19 #include "qemu/thread.h"
  20 #include "qemu/main-loop.h"
  21 #include "qemu/module.h"
  22 #include "block/thread-pool.h"
  23 #include "qemu/error-report.h"
  24
  25 static void tpm_backend_request_completed(void *opaque, int ret)
  26 {
  27     TPMBackend *s = TPM_BACKEND(opaque);
  28     TPMIfClass *tic = TPM_IF_GET_CLASS(s->tpmif);
  29
  30     tic->request_completed(s->tpmif, ret);
  31
  32     /* no need for atomic, as long the BQL is taken */
  33     s->cmd = NULL;
  34     object_unref(OBJECT(s));
  35 }
  36
  37 static int tpm_backend_worker_thread(gpointer data)
  38 {
  39     TPMBackend *s = TPM_BACKEND(data);
  40     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
  41     Error *err = NULL;
  42
  43     k->handle_request(s, s->cmd, &err);
  44     if (err) {
  45         error_report_err(err);
  46         return -1;
  47     }
  48
  49     return 0;
  50 }
  51
  52 void tpm_backend_finish_sync(TPMBackend *s)
  53 {
  54     while (s->cmd) {
  55         aio_poll(qemu_get_aio_context(), true);
  56     }
  57 }
  58
  59 enum TpmType tpm_backend_get_type(TPMBackend *s)
  60 {
  61     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
  62
  63     return k->type;
  64 }
  65
  66 int tpm_backend_init(TPMBackend *s, TPMIf *tpmif, Error **errp)
  67 {
  68     if (s->tpmif) {
  69         error_setg(errp, "TPM backend '%s' is already initialized", s->id);
  70         return -1;
  71     }
  72
  73     s->tpmif = tpmif;
  74     object_ref(OBJECT(tpmif));
  75
  76     s->had_startup_error = false;
  77
  78     return 0;
  79 }
  80
  81 int tpm_backend_startup_tpm(TPMBackend *s, size_t buffersize)
  82 {
  83     int res = 0;
  84     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
  85
  86     /* terminate a running TPM */
  87     tpm_backend_finish_sync(s);
  88
  89     res = k->startup_tpm ? k->startup_tpm(s, buffersize) : 0;
  90
  91     s->had_startup_error = (res != 0);
  92
  93     return res;
  94 }
  95
  96 bool tpm_backend_had_startup_error(TPMBackend *s)
  97 {
  98     return s->had_startup_error;
  99 }
 100
 101 void tpm_backend_deliver_request(TPMBackend *s, TPMBackendCmd *cmd)
 102 {
 103     ThreadPool *pool = aio_get_thread_pool(qemu_get_aio_context());
 104
 105     if (s->cmd != NULL) {
 106         error_report("There is a TPM request pending");
 107         return;
 108     }
 109
 110     s->cmd = cmd;
 111     object_ref(OBJECT(s));
 112     thread_pool_submit_aio(pool, tpm_backend_worker_thread, s,
 113                            tpm_backend_request_completed, s);
 114 }
 115
 116 void tpm_backend_reset(TPMBackend *s)
 117 {
 118     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 119
 120     if (k->reset) {
 121         k->reset(s);
 122     }
 123
 124     tpm_backend_finish_sync(s);
 125
 126     s->had_startup_error = false;
 127 }
 128
 129 void tpm_backend_cancel_cmd(TPMBackend *s)
 130 {
 131     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 132
 133     k->cancel_cmd(s);
 134 }
 135
 136 bool tpm_backend_get_tpm_established_flag(TPMBackend *s)
 137 {
 138     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 139
 140     return k->get_tpm_established_flag ?
 141            k->get_tpm_established_flag(s) : false;
 142 }
 143
 144 int tpm_backend_reset_tpm_established_flag(TPMBackend *s, uint8_t locty)
 145 {
 146     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 147
 148     return k->reset_tpm_established_flag ?
 149            k->reset_tpm_established_flag(s, locty) : 0;
 150 }
 151
 152 TPMVersion tpm_backend_get_tpm_version(TPMBackend *s)
 153 {
 154     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 155
 156     return k->get_tpm_version(s);
 157 }
 158
 159 size_t tpm_backend_get_buffer_size(TPMBackend *s)
 160 {
 161     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 162
 163     return k->get_buffer_size(s);
 164 }
 165
 166 TPMInfo *tpm_backend_query_tpm(TPMBackend *s)
 167 {
 168     TPMInfo *info = g_new0(TPMInfo, 1);
 169     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 170     TPMIfClass *tic = TPM_IF_GET_CLASS(s->tpmif);
 171
 172     info->id = g_strdup(s->id);
 173     info->model = tic->model;
 174     info->options = k->get_tpm_options(s);
 175
 176     return info;
 177 }
 178
 179 static void tpm_backend_instance_finalize(Object *obj)
 180 {
 181     TPMBackend *s = TPM_BACKEND(obj);
 182
 183     object_unref(OBJECT(s->tpmif));
 184     g_free(s->id);
 185 }
 186
 187 static const TypeInfo tpm_backend_info = {
 188     .name = TYPE_TPM_BACKEND,
 189     .parent = TYPE_OBJECT,
 190     .instance_size = sizeof(TPMBackend),
 191     .instance_finalize = tpm_backend_instance_finalize,
 192     .class_size = sizeof(TPMBackendClass),
 193     .abstract = true,
 194 };
 195
 196 static const TypeInfo tpm_if_info = {
 197     .name = TYPE_TPM_IF,
 198     .parent = TYPE_INTERFACE,
 199     .class_size = sizeof(TPMIfClass),
 200 };
 201
 202 static void register_types(void)
 203 {
 204     type_register_static(&tpm_backend_info);
 205     type_register_static(&tpm_if_info);
 206 }
 207
 208 type_init(register_types);