include/sysemu/tpm_backend.h

   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
  13 #ifndef TPM_BACKEND_H
  14 #define TPM_BACKEND_H
  15
  16 #include "qom/object.h"
  17 #include "qemu-common.h"
  18 #include "qapi-types.h"
  19 #include "qemu/option.h"
  20 #include "sysemu/tpm.h"
  21
  22 #define TYPE_TPM_BACKEND "tpm-backend"
  23 #define TPM_BACKEND(obj) \
  24     OBJECT_CHECK(TPMBackend, (obj), TYPE_TPM_BACKEND)
  25 #define TPM_BACKEND_GET_CLASS(obj) \
  26     OBJECT_GET_CLASS(TPMBackendClass, (obj), TYPE_TPM_BACKEND)
  27 #define TPM_BACKEND_CLASS(klass) \
  28     OBJECT_CLASS_CHECK(TPMBackendClass, (klass), TYPE_TPM_BACKEND)
  29
  30 typedef struct TPMBackendClass TPMBackendClass;
  31 typedef struct TPMBackend TPMBackend;
  32
  33 typedef struct TPMDriverOps TPMDriverOps;
  34
  35 struct TPMBackendClass {
  36     ObjectClass parent_class;
  37
  38     const TPMDriverOps *ops;
  39
  40     void (*opened)(TPMBackend *s, Error **errp);
  41 };
  42
  43 struct TPMBackend {
  44     Object parent;
  45
  46     /*< protected >*/
  47     bool opened;
  48
  49     char *id;
  50     enum TpmModel fe_model;
  51     char *path;
  52     char *cancel_path;
  53     const TPMDriverOps *ops;
  54
  55     QLIST_ENTRY(TPMBackend) list;
  56 };
  57
  58 typedef void (TPMRecvDataCB)(TPMState *, uint8_t locty, bool selftest_done);
  59
  60 typedef struct TPMSizedBuffer {
  61     uint32_t size;
  62     uint8_t  *buffer;
  63 } TPMSizedBuffer;
  64
  65 struct TPMDriverOps {
  66     enum TpmType type;
  67     const QemuOptDesc *opts;
  68     /* get a descriptive text of the backend to display to the user */
  69     const char *(*desc)(void);
  70
  71     TPMBackend *(*create)(QemuOpts *opts, const char *id);
  72     void (*destroy)(TPMBackend *t);
  73
  74     /* initialize the backend */
  75     int (*init)(TPMBackend *t, TPMState *s, TPMRecvDataCB *datacb);
  76     /* start up the TPM on the backend */
  77     int (*startup_tpm)(TPMBackend *t);
  78     /* returns true if nothing will ever answer TPM requests */
  79     bool (*had_startup_error)(TPMBackend *t);
  80
  81     size_t (*realloc_buffer)(TPMSizedBuffer *sb);
  82
  83     void (*deliver_request)(TPMBackend *t);
  84
  85     void (*reset)(TPMBackend *t);
  86
  87     void (*cancel_cmd)(TPMBackend *t);
  88
  89     bool (*get_tpm_established_flag)(TPMBackend *t);
  90
  91     int (*reset_tpm_established_flag)(TPMBackend *t, uint8_t locty);
  92
  93     TPMVersion (*get_tpm_version)(TPMBackend *t);
  94 };
  95
  96
  97 /**
  98  * tpm_backend_get_type:
  99  * @s: the backend
 100  *
 101  * Returns the TpmType of the backend.
 102  */
 103 enum TpmType tpm_backend_get_type(TPMBackend *s);
 104
 105 /**
 106  * tpm_backend_get_desc:
 107  * @s: the backend
 108  *
 109  * Returns a human readable description of the backend.
 110  */
 111 const char *tpm_backend_get_desc(TPMBackend *s);
 112
 113 /**
 114  * tpm_backend_destroy:
 115  * @s: the backend to destroy
 116  */
 117 void tpm_backend_destroy(TPMBackend *s);
 118
 119 /**
 120  * tpm_backend_init:
 121  * @s: the backend to initialized
 122  * @state: TPMState
 123  * @datacb: callback for sending data to frontend
 124  *
 125  * Initialize the backend with the given variables.
 126  *
 127  * Returns 0 on success.
 128  */
 129 int tpm_backend_init(TPMBackend *s, TPMState *state,
 130                      TPMRecvDataCB *datacb);
 131
 132 /**
 133  * tpm_backend_startup_tpm:
 134  * @s: the backend whose TPM support is to be started
 135  *
 136  * Returns 0 on success.
 137  */
 138 int tpm_backend_startup_tpm(TPMBackend *s);
 139
 140 /**
 141  * tpm_backend_had_startup_error:
 142  * @s: the backend to query for a statup error
 143  *
 144  * Check whether the backend had an error during startup. Returns
 145  * false if no error occurred and the backend can be used, true
 146  * otherwise.
 147  */
 148 bool tpm_backend_had_startup_error(TPMBackend *s);
 149
 150 /**
 151  * tpm_backend_realloc_buffer:
 152  * @s: the backend
 153  * @sb: the TPMSizedBuffer to re-allocated to the size suitable for the
 154  *      backend.
 155  *
 156  * This function returns the size of the allocated buffer
 157  */
 158 size_t tpm_backend_realloc_buffer(TPMBackend *s, TPMSizedBuffer *sb);
 159
 160 /**
 161  * tpm_backend_deliver_request:
 162  * @s: the backend to send the request to
 163  *
 164  * Send a request to the backend. The backend will then send the request
 165  * to the TPM implementation.
 166  */
 167 void tpm_backend_deliver_request(TPMBackend *s);
 168
 169 /**
 170  * tpm_backend_reset:
 171  * @s: the backend to reset
 172  *
 173  * Reset the backend into a well defined state with all previous errors
 174  * reset.
 175  */
 176 void tpm_backend_reset(TPMBackend *s);
 177
 178 /**
 179  * tpm_backend_cancel_cmd:
 180  * @s: the backend
 181  *
 182  * Cancel any ongoing command being processed by the TPM implementation
 183  * on behalf of the QEMU guest.
 184  */
 185 void tpm_backend_cancel_cmd(TPMBackend *s);
 186
 187 /**
 188  * tpm_backend_get_tpm_established_flag:
 189  * @s: the backend
 190  *
 191  * Get the TPM establishment flag. This function may be called very
 192  * frequently by the frontend since for example in the TIS implementation
 193  * this flag is part of a register.
 194  */
 195 bool tpm_backend_get_tpm_established_flag(TPMBackend *s);
 196
 197 /**
 198  * tpm_backend_reset_tpm_established_flag:
 199  * @s: the backend
 200  * @locty: the locality number
 201  *
 202  * Reset the TPM establishment flag.
 203  */
 204 int tpm_backend_reset_tpm_established_flag(TPMBackend *s, uint8_t locty);
 205
 206 /**
 207  * tpm_backend_open:
 208  * @s: the backend to open
 209  * @errp: a pointer to return the #Error object if an error occurs.
 210  *
 211  * This function will open the backend if it is not already open.  Calling this
 212  * function on an already opened backend will not result in an error.
 213  */
 214 void tpm_backend_open(TPMBackend *s, Error **errp);
 215
 216 /**
 217  * tpm_backend_get_tpm_version:
 218  * @s: the backend to call into
 219  *
 220  * Get the TPM Version that is emulated at the backend.
 221  *
 222  * Returns TPMVersion.
 223  */
 224 TPMVersion tpm_backend_get_tpm_version(TPMBackend *s);
 225
 226 TPMBackend *qemu_find_tpm(const char *id);
 227
 228 const TPMDriverOps *tpm_get_backend_driver(const char *type);
 229 int tpm_register_model(enum TpmModel model);
 230 int tpm_register_driver(const TPMDriverOps *tdo);
 231
 232 #endif