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 "qapi/qmp/qerror.h"
  19 #include "sysemu/tpm.h"
  20 #include "qemu/thread.h"
  21 #include "qemu/main-loop.h"
  22
  23 static void tpm_backend_request_completed_bh(void *opaque)
  24 {
  25     TPMBackend *s = TPM_BACKEND(opaque);
  26     TPMIfClass *tic = TPM_IF_GET_CLASS(s->tpmif);
  27
  28     tic->request_completed(s->tpmif);
  29 }
  30
  31 static void tpm_backend_worker_thread(gpointer data, gpointer user_data)
  32 {
  33     TPMBackend *s = TPM_BACKEND(user_data);
  34     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
  35
  36     k->handle_request(s, (TPMBackendCmd *)data);
  37
  38     qemu_bh_schedule(s->bh);
  39 }
  40
  41 static void tpm_backend_thread_end(TPMBackend *s)
  42 {
  43     if (s->thread_pool) {
  44         g_thread_pool_free(s->thread_pool, FALSE, TRUE);
  45         s->thread_pool = NULL;
  46     }
  47 }
  48
  49 enum TpmType tpm_backend_get_type(TPMBackend *s)
  50 {
  51     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
  52
  53     return k->type;
  54 }
  55
  56 int tpm_backend_init(TPMBackend *s, TPMIf *tpmif, Error **errp)
  57 {
  58     if (s->tpmif) {
  59         error_setg(errp, "TPM backend '%s' is already initialized", s->id);
  60         return -1;
  61     }
  62
  63     s->tpmif = tpmif;
  64     object_ref(OBJECT(tpmif));
  65
  66     s->had_startup_error = false;
  67
  68     return 0;
  69 }
  70
  71 int tpm_backend_startup_tpm(TPMBackend *s, size_t buffersize)
  72 {
  73     int res = 0;
  74     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
  75
  76     /* terminate a running TPM */
  77     tpm_backend_thread_end(s);
  78
  79     s->thread_pool = g_thread_pool_new(tpm_backend_worker_thread, s, 1, TRUE,
  80                                        NULL);
  81
  82     res = k->startup_tpm ? k->startup_tpm(s, buffersize) : 0;
  83
  84     s->had_startup_error = (res != 0);
  85
  86     return res;
  87 }
  88
  89 bool tpm_backend_had_startup_error(TPMBackend *s)
  90 {
  91     return s->had_startup_error;
  92 }
  93
  94 void tpm_backend_deliver_request(TPMBackend *s, TPMBackendCmd *cmd)
  95 {
  96     g_thread_pool_push(s->thread_pool, cmd, NULL);
  97 }
  98
  99 void tpm_backend_reset(TPMBackend *s)
 100 {
 101     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 102
 103     if (k->reset) {
 104         k->reset(s);
 105     }
 106
 107     tpm_backend_thread_end(s);
 108
 109     s->had_startup_error = false;
 110 }
 111
 112 void tpm_backend_cancel_cmd(TPMBackend *s)
 113 {
 114     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 115
 116     k->cancel_cmd(s);
 117 }
 118
 119 bool tpm_backend_get_tpm_established_flag(TPMBackend *s)
 120 {
 121     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 122
 123     return k->get_tpm_established_flag ?
 124            k->get_tpm_established_flag(s) : false;
 125 }
 126
 127 int tpm_backend_reset_tpm_established_flag(TPMBackend *s, uint8_t locty)
 128 {
 129     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 130
 131     return k->reset_tpm_established_flag ?
 132            k->reset_tpm_established_flag(s, locty) : 0;
 133 }
 134
 135 TPMVersion tpm_backend_get_tpm_version(TPMBackend *s)
 136 {
 137     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 138
 139     return k->get_tpm_version(s);
 140 }
 141
 142 size_t tpm_backend_get_buffer_size(TPMBackend *s)
 143 {
 144     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 145
 146     return k->get_buffer_size(s);
 147 }
 148
 149 TPMInfo *tpm_backend_query_tpm(TPMBackend *s)
 150 {
 151     TPMInfo *info = g_new0(TPMInfo, 1);
 152     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 153     TPMIfClass *tic = TPM_IF_GET_CLASS(s->tpmif);
 154
 155     info->id = g_strdup(s->id);
 156     info->model = tic->model;
 157     info->options = k->get_tpm_options(s);
 158
 159     return info;
 160 }
 161
 162 static void tpm_backend_instance_init(Object *obj)
 163 {
 164     TPMBackend *s = TPM_BACKEND(obj);
 165
 166     s->bh = qemu_bh_new(tpm_backend_request_completed_bh, s);
 167 }
 168
 169 static void tpm_backend_instance_finalize(Object *obj)
 170 {
 171     TPMBackend *s = TPM_BACKEND(obj);
 172
 173     object_unref(OBJECT(s->tpmif));
 174     g_free(s->id);
 175     tpm_backend_thread_end(s);
 176     qemu_bh_delete(s->bh);
 177 }
 178
 179 static const TypeInfo tpm_backend_info = {
 180     .name = TYPE_TPM_BACKEND,
 181     .parent = TYPE_OBJECT,
 182     .instance_size = sizeof(TPMBackend),
 183     .instance_init = tpm_backend_instance_init,
 184     .instance_finalize = tpm_backend_instance_finalize,
 185     .class_size = sizeof(TPMBackendClass),
 186     .abstract = true,
 187 };
 188
 189 static const TypeInfo tpm_if_info = {
 190     .name = TYPE_TPM_IF,
 191     .parent = TYPE_INTERFACE,
 192     .class_size = sizeof(TPMIfClass),
 193 };
 194
 195 static void register_types(void)
 196 {
 197     type_register_static(&tpm_backend_info);
 198     type_register_static(&tpm_if_info);
 199 }
 200
 201 type_init(register_types);