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