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 /* 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 92 93 /** 94 * tpm_backend_get_type: 95 * @s: the backend 96 * 97 * Returns the TpmType of the backend. 98 */ 99 enum TpmType tpm_backend_get_type(TPMBackend *s); 100 101 /** 102 * tpm_backend_get_desc: 103 * @s: the backend 104 * 105 * Returns a human readable description of the backend. 106 */ 107 const char *tpm_backend_get_desc(TPMBackend *s); 108 109 /** 110 * tpm_backend_destroy: 111 * @s: the backend to destroy 112 */ 113 void tpm_backend_destroy(TPMBackend *s); 114 115 /** 116 * tpm_backend_init: 117 * @s: the backend to initialized 118 * @state: TPMState 119 * @datacb: callback for sending data to frontend 120 * 121 * Initialize the backend with the given variables. 122 * 123 * Returns 0 on success. 124 */ 125 int tpm_backend_init(TPMBackend *s, TPMState *state, 126 TPMRecvDataCB *datacb); 127 128 /** 129 * tpm_backend_startup_tpm: 130 * @s: the backend whose TPM support is to be started 131 * 132 * Returns 0 on success. 133 */ 134 int tpm_backend_startup_tpm(TPMBackend *s); 135 136 /** 137 * tpm_backend_had_startup_error: 138 * @s: the backend to query for a statup error 139 * 140 * Check whether the backend had an error during startup. Returns 141 * false if no error occurred and the backend can be used, true 142 * otherwise. 143 */ 144 bool tpm_backend_had_startup_error(TPMBackend *s); 145 146 /** 147 * tpm_backend_realloc_buffer: 148 * @s: the backend 149 * @sb: the TPMSizedBuffer to re-allocated to the size suitable for the 150 * backend. 151 * 152 * This function returns the size of the allocated buffer 153 */ 154 size_t tpm_backend_realloc_buffer(TPMBackend *s, TPMSizedBuffer *sb); 155 156 /** 157 * tpm_backend_deliver_request: 158 * @s: the backend to send the request to 159 * 160 * Send a request to the backend. The backend will then send the request 161 * to the TPM implementation. 162 */ 163 void tpm_backend_deliver_request(TPMBackend *s); 164 165 /** 166 * tpm_backend_reset: 167 * @s: the backend to reset 168 * 169 * Reset the backend into a well defined state with all previous errors 170 * reset. 171 */ 172 void tpm_backend_reset(TPMBackend *s); 173 174 /** 175 * tpm_backend_cancel_cmd: 176 * @s: the backend 177 * 178 * Cancel any ongoing command being processed by the TPM implementation 179 * on behalf of the QEMU guest. 180 */ 181 void tpm_backend_cancel_cmd(TPMBackend *s); 182 183 /** 184 * tpm_backend_get_tpm_established_flag: 185 * @s: the backend 186 * 187 * Get the TPM establishment flag. This function may be called very 188 * frequently by the frontend since for example in the TIS implementation 189 * this flag is part of a register. 190 */ 191 bool tpm_backend_get_tpm_established_flag(TPMBackend *s); 192 193 /** 194 * tpm_backend_open: 195 * @s: the backend to open 196 * @errp: a pointer to return the #Error object if an error occurs. 197 * 198 * This function will open the backend if it is not already open. Calling this 199 * function on an already opened backend will not result in an error. 200 */ 201 void tpm_backend_open(TPMBackend *s, Error **errp); 202 203 TPMBackend *qemu_find_tpm(const char *id); 204 205 const TPMDriverOps *tpm_get_backend_driver(const char *type); 206 int tpm_register_model(enum TpmModel model); 207 int tpm_register_driver(const TPMDriverOps *tdo); 208 209 #endif 210