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)
  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) : 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 TPMInfo *tpm_backend_query_tpm(TPMBackend *s)
 143 {
 144     TPMInfo *info = g_new0(TPMInfo, 1);
 145     TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
 146     TPMIfClass *tic = TPM_IF_GET_CLASS(s->tpmif);
 147
 148     info->id = g_strdup(s->id);
 149     info->model = tic->model;
 150     info->options = k->get_tpm_options(s);
 151
 152     return info;
 153 }
 154
 155 static void tpm_backend_instance_init(Object *obj)
 156 {
 157     TPMBackend *s = TPM_BACKEND(obj);
 158
 159     s->bh = qemu_bh_new(tpm_backend_request_completed_bh, s);
 160 }
 161
 162 static void tpm_backend_instance_finalize(Object *obj)
 163 {
 164     TPMBackend *s = TPM_BACKEND(obj);
 165
 166     object_unref(OBJECT(s->tpmif));
 167     g_free(s->id);
 168     tpm_backend_thread_end(s);
 169     qemu_bh_delete(s->bh);
 170 }
 171
 172 static const TypeInfo tpm_backend_info = {
 173     .name = TYPE_TPM_BACKEND,
 174     .parent = TYPE_OBJECT,
 175     .instance_size = sizeof(TPMBackend),
 176     .instance_init = tpm_backend_instance_init,
 177     .instance_finalize = tpm_backend_instance_finalize,
 178     .class_size = sizeof(TPMBackendClass),
 179     .abstract = true,
 180 };
 181
 182 static const TypeInfo tpm_if_info = {
 183     .name = TYPE_TPM_IF,
 184     .parent = TYPE_INTERFACE,
 185     .class_size = sizeof(TPMIfClass),
 186 };
 187
 188 static void register_types(void)
 189 {
 190     type_register_static(&tpm_backend_info);
 191     type_register_static(&tpm_if_info);
 192 }
 193
 194 type_init(register_types);