tpm.c

   1 /*
   2  * TPM configuration
   3  *
   4  * Copyright (C) 2011-2013 IBM Corporation
   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 net.c
  13  */
  14 #include "qemu/osdep.h"
  15
  16 #include "qapi/qmp/qerror.h"
  17 #include "sysemu/tpm_backend.h"
  18 #include "sysemu/tpm.h"
  19 #include "qemu/config-file.h"
  20 #include "qemu/error-report.h"
  21 #include "qmp-commands.h"
  22
  23 static QLIST_HEAD(, TPMBackend) tpm_backends =
  24     QLIST_HEAD_INITIALIZER(tpm_backends);
  25
  26 static TPMDriverOps const *be_drivers[TPM_TYPE__MAX];
  27 static bool tpm_models[TPM_MODEL__MAX];
  28
  29 void tpm_register_model(enum TpmModel model)
  30 {
  31     tpm_models[model] = true;
  32 }
  33
  34 static const TPMDriverOps *tpm_get_backend_driver(const char *type)
  35 {
  36     int i = qapi_enum_parse(&TpmType_lookup, type, -1, NULL);
  37
  38     return i >= 0 ? be_drivers[i] : NULL;
  39 }
  40
  41 #ifdef CONFIG_TPM
  42
  43 void tpm_register_driver(const TPMDriverOps *tdo)
  44 {
  45     assert(!be_drivers[tdo->type]);
  46
  47     be_drivers[tdo->type] = tdo;
  48 }
  49
  50 static const TPMDriverOps *
  51 tpm_driver_find_by_type(enum TpmType type)
  52 {
  53     ObjectClass *oc;
  54     TPMBackendClass *bc;
  55     char *typename = g_strdup_printf("tpm-%s", TpmType_str(type));
  56
  57     oc = object_class_by_name(typename);
  58     g_free(typename);
  59
  60     if (!object_class_dynamic_cast(oc, TYPE_TPM_BACKEND)) {
  61         return NULL;
  62     }
  63
  64     bc = TPM_BACKEND_CLASS(oc);
  65     return bc->ops;
  66 }
  67
  68 /*
  69  * Walk the list of available TPM backend drivers and display them on the
  70  * screen.
  71  */
  72 static void tpm_display_backend_drivers(void)
  73 {
  74     int i;
  75
  76     fprintf(stderr, "Supported TPM types (choose only one):\n");
  77
  78     for (i = 0; i < TPM_TYPE__MAX; i++) {
  79         const TPMDriverOps *ops = tpm_driver_find_by_type(i);
  80         if (!ops) {
  81             continue;
  82         }
  83         fprintf(stderr, "%12s   %s\n", TpmType_str(i), ops->desc);
  84     }
  85     fprintf(stderr, "\n");
  86 }
  87
  88 /*
  89  * Find the TPM with the given Id
  90  */
  91 TPMBackend *qemu_find_tpm(const char *id)
  92 {
  93     TPMBackend *drv;
  94
  95     if (id) {
  96         QLIST_FOREACH(drv, &tpm_backends, list) {
  97             if (!strcmp(drv->id, id)) {
  98                 return drv;
  99             }
 100         }
 101     }
 102
 103     return NULL;
 104 }
 105
 106 static int configure_tpm(QemuOpts *opts)
 107 {
 108     const char *value;
 109     const char *id;
 110     const TPMDriverOps *be;
 111     TPMBackend *drv;
 112     Error *local_err = NULL;
 113
 114     if (!QLIST_EMPTY(&tpm_backends)) {
 115         error_report("Only one TPM is allowed.");
 116         return 1;
 117     }
 118
 119     id = qemu_opts_id(opts);
 120     if (id == NULL) {
 121         error_report(QERR_MISSING_PARAMETER, "id");
 122         return 1;
 123     }
 124
 125     value = qemu_opt_get(opts, "type");
 126     if (!value) {
 127         error_report(QERR_MISSING_PARAMETER, "type");
 128         tpm_display_backend_drivers();
 129         return 1;
 130     }
 131
 132     be = tpm_get_backend_driver(value);
 133     if (be == NULL) {
 134         error_report(QERR_INVALID_PARAMETER_VALUE,
 135                      "type", "a TPM backend type");
 136         tpm_display_backend_drivers();
 137         return 1;
 138     }
 139
 140     /* validate backend specific opts */
 141     qemu_opts_validate(opts, be->opts, &local_err);
 142     if (local_err) {
 143         error_report_err(local_err);
 144         return 1;
 145     }
 146
 147     drv = be->create(opts, id);
 148     if (!drv) {
 149         return 1;
 150     }
 151
 152     tpm_backend_open(drv, &local_err);
 153     if (local_err) {
 154         error_report_err(local_err);
 155         return 1;
 156     }
 157
 158     QLIST_INSERT_HEAD(&tpm_backends, drv, list);
 159
 160     return 0;
 161 }
 162
 163 static int tpm_init_tpmdev(void *dummy, QemuOpts *opts, Error **errp)
 164 {
 165     return configure_tpm(opts);
 166 }
 167
 168 /*
 169  * Walk the list of TPM backend drivers that are in use and call their
 170  * destroy function to have them cleaned up.
 171  */
 172 void tpm_cleanup(void)
 173 {
 174     TPMBackend *drv, *next;
 175
 176     QLIST_FOREACH_SAFE(drv, &tpm_backends, list, next) {
 177         QLIST_REMOVE(drv, list);
 178         object_unref(OBJECT(drv));
 179     }
 180 }
 181
 182 /*
 183  * Initialize the TPM. Process the tpmdev command line options describing the
 184  * TPM backend.
 185  */
 186 int tpm_init(void)
 187 {
 188     if (qemu_opts_foreach(qemu_find_opts("tpmdev"),
 189                           tpm_init_tpmdev, NULL, NULL)) {
 190         return -1;
 191     }
 192
 193     return 0;
 194 }
 195
 196 /*
 197  * Parse the TPM configuration options.
 198  * To display all available TPM backends the user may use '-tpmdev help'
 199  */
 200 int tpm_config_parse(QemuOptsList *opts_list, const char *optarg)
 201 {
 202     QemuOpts *opts;
 203
 204     if (!strcmp(optarg, "help")) {
 205         tpm_display_backend_drivers();
 206         return -1;
 207     }
 208     opts = qemu_opts_parse_noisily(opts_list, optarg, true);
 209     if (!opts) {
 210         return -1;
 211     }
 212     return 0;
 213 }
 214
 215 #endif /* CONFIG_TPM */
 216
 217 /*
 218  * Walk the list of active TPM backends and collect information about them
 219  * following the schema description in qapi-schema.json.
 220  */
 221 TPMInfoList *qmp_query_tpm(Error **errp)
 222 {
 223     TPMBackend *drv;
 224     TPMInfoList *info, *head = NULL, *cur_item = NULL;
 225
 226     QLIST_FOREACH(drv, &tpm_backends, list) {
 227         if (!tpm_models[drv->fe_model]) {
 228             continue;
 229         }
 230         info = g_new0(TPMInfoList, 1);
 231         info->value = tpm_backend_query_tpm(drv);
 232
 233         if (!cur_item) {
 234             head = cur_item = info;
 235         } else {
 236             cur_item->next = info;
 237             cur_item = info;
 238         }
 239     }
 240
 241     return head;
 242 }
 243
 244 TpmTypeList *qmp_query_tpm_types(Error **errp)
 245 {
 246     unsigned int i = 0;
 247     TpmTypeList *head = NULL, *prev = NULL, *cur_item;
 248
 249     for (i = 0; i < TPM_TYPE__MAX; i++) {
 250         if (!tpm_driver_find_by_type(i)) {
 251             continue;
 252         }
 253         cur_item = g_new0(TpmTypeList, 1);
 254         cur_item->value = i;
 255
 256         if (prev) {
 257             prev->next = cur_item;
 258         }
 259         if (!head) {
 260             head = cur_item;
 261         }
 262         prev = cur_item;
 263     }
 264
 265     return head;
 266 }
 267
 268 TpmModelList *qmp_query_tpm_models(Error **errp)
 269 {
 270     unsigned int i = 0;
 271     TpmModelList *head = NULL, *prev = NULL, *cur_item;
 272
 273     for (i = 0; i < TPM_MODEL__MAX; i++) {
 274         if (!tpm_models[i]) {
 275             continue;
 276         }
 277         cur_item = g_new0(TpmModelList, 1);
 278         cur_item->value = i;
 279
 280         if (prev) {
 281             prev->next = cur_item;
 282         }
 283         if (!head) {
 284             head = cur_item;
 285         }
 286         prev = cur_item;
 287     }
 288
 289     return head;
 290 }