1ca64b086SPhilippe Mathieu-Daudé /*
2ca64b086SPhilippe Mathieu-Daudé * Emulator TPM driver
3ca64b086SPhilippe Mathieu-Daudé *
4ca64b086SPhilippe Mathieu-Daudé * Copyright (c) 2017 Intel Corporation
5ca64b086SPhilippe Mathieu-Daudé * Author: Amarnath Valluri <amarnath.valluri@intel.com>
6ca64b086SPhilippe Mathieu-Daudé *
7ca64b086SPhilippe Mathieu-Daudé * Copyright (c) 2010 - 2013, 2018 IBM Corporation
8ca64b086SPhilippe Mathieu-Daudé * Authors:
9ca64b086SPhilippe Mathieu-Daudé * Stefan Berger <stefanb@us.ibm.com>
10ca64b086SPhilippe Mathieu-Daudé *
11ca64b086SPhilippe Mathieu-Daudé * Copyright (C) 2011 IAIK, Graz University of Technology
12ca64b086SPhilippe Mathieu-Daudé * Author: Andreas Niederl
13ca64b086SPhilippe Mathieu-Daudé *
14ca64b086SPhilippe Mathieu-Daudé * This library is free software; you can redistribute it and/or
15ca64b086SPhilippe Mathieu-Daudé * modify it under the terms of the GNU Lesser General Public
16ca64b086SPhilippe Mathieu-Daudé * License as published by the Free Software Foundation; either
17eac2fce9SChetan Pant * version 2.1 of the License, or (at your option) any later version.
18ca64b086SPhilippe Mathieu-Daudé *
19ca64b086SPhilippe Mathieu-Daudé * This library is distributed in the hope that it will be useful,
20ca64b086SPhilippe Mathieu-Daudé * but WITHOUT ANY WARRANTY; without even the implied warranty of
21ca64b086SPhilippe Mathieu-Daudé * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22ca64b086SPhilippe Mathieu-Daudé * Lesser General Public License for more details.
23ca64b086SPhilippe Mathieu-Daudé *
24ca64b086SPhilippe Mathieu-Daudé * You should have received a copy of the GNU Lesser General Public
25ca64b086SPhilippe Mathieu-Daudé * License along with this library; if not, see <http://www.gnu.org/licenses/>
26ca64b086SPhilippe Mathieu-Daudé *
27ca64b086SPhilippe Mathieu-Daudé */
28ca64b086SPhilippe Mathieu-Daudé
29ca64b086SPhilippe Mathieu-Daudé #include "qemu/osdep.h"
30ca64b086SPhilippe Mathieu-Daudé #include "qemu/error-report.h"
31ca64b086SPhilippe Mathieu-Daudé #include "qemu/module.h"
32ca64b086SPhilippe Mathieu-Daudé #include "qemu/sockets.h"
33bf5dcf8fSPhilippe Mathieu-Daudé #include "qemu/lockable.h"
34ca64b086SPhilippe Mathieu-Daudé #include "io/channel-socket.h"
35a0bcec03SRoss Lagerwall #include "sysemu/runstate.h"
36ca64b086SPhilippe Mathieu-Daudé #include "sysemu/tpm_backend.h"
37ca64b086SPhilippe Mathieu-Daudé #include "sysemu/tpm_util.h"
38ca64b086SPhilippe Mathieu-Daudé #include "tpm_int.h"
39ca64b086SPhilippe Mathieu-Daudé #include "tpm_ioctl.h"
40ca64b086SPhilippe Mathieu-Daudé #include "migration/blocker.h"
41ca64b086SPhilippe Mathieu-Daudé #include "migration/vmstate.h"
42ca64b086SPhilippe Mathieu-Daudé #include "qapi/error.h"
43ca64b086SPhilippe Mathieu-Daudé #include "qapi/clone-visitor.h"
44ca64b086SPhilippe Mathieu-Daudé #include "qapi/qapi-visit-tpm.h"
45ca64b086SPhilippe Mathieu-Daudé #include "chardev/char-fe.h"
46ca64b086SPhilippe Mathieu-Daudé #include "trace.h"
47db1015e9SEduardo Habkost #include "qom/object.h"
48ca64b086SPhilippe Mathieu-Daudé
49ca64b086SPhilippe Mathieu-Daudé #define TYPE_TPM_EMULATOR "tpm-emulator"
508063396bSEduardo Habkost OBJECT_DECLARE_SIMPLE_TYPE(TPMEmulator, TPM_EMULATOR)
51ca64b086SPhilippe Mathieu-Daudé
52ca64b086SPhilippe Mathieu-Daudé #define TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(S, cap) (((S)->caps & (cap)) == (cap))
53ca64b086SPhilippe Mathieu-Daudé
54ca64b086SPhilippe Mathieu-Daudé /* data structures */
55ca64b086SPhilippe Mathieu-Daudé
56ca64b086SPhilippe Mathieu-Daudé /* blobs from the TPM; part of VM state when migrating */
57ca64b086SPhilippe Mathieu-Daudé typedef struct TPMBlobBuffers {
58ca64b086SPhilippe Mathieu-Daudé uint32_t permanent_flags;
59ca64b086SPhilippe Mathieu-Daudé TPMSizedBuffer permanent;
60ca64b086SPhilippe Mathieu-Daudé
61ca64b086SPhilippe Mathieu-Daudé uint32_t volatil_flags;
62ca64b086SPhilippe Mathieu-Daudé TPMSizedBuffer volatil;
63ca64b086SPhilippe Mathieu-Daudé
64ca64b086SPhilippe Mathieu-Daudé uint32_t savestate_flags;
65ca64b086SPhilippe Mathieu-Daudé TPMSizedBuffer savestate;
66ca64b086SPhilippe Mathieu-Daudé } TPMBlobBuffers;
67ca64b086SPhilippe Mathieu-Daudé
68db1015e9SEduardo Habkost struct TPMEmulator {
69ca64b086SPhilippe Mathieu-Daudé TPMBackend parent;
70ca64b086SPhilippe Mathieu-Daudé
71ca64b086SPhilippe Mathieu-Daudé TPMEmulatorOptions *options;
72ca64b086SPhilippe Mathieu-Daudé CharBackend ctrl_chr;
73ca64b086SPhilippe Mathieu-Daudé QIOChannel *data_ioc;
74ca64b086SPhilippe Mathieu-Daudé TPMVersion tpm_version;
75ca64b086SPhilippe Mathieu-Daudé ptm_cap caps; /* capabilities of the TPM */
76ca64b086SPhilippe Mathieu-Daudé uint8_t cur_locty_number; /* last set locality */
77ca64b086SPhilippe Mathieu-Daudé Error *migration_blocker;
78ca64b086SPhilippe Mathieu-Daudé
79ca64b086SPhilippe Mathieu-Daudé QemuMutex mutex;
80ca64b086SPhilippe Mathieu-Daudé
81ca64b086SPhilippe Mathieu-Daudé unsigned int established_flag:1;
82ca64b086SPhilippe Mathieu-Daudé unsigned int established_flag_cached:1;
83ca64b086SPhilippe Mathieu-Daudé
84ca64b086SPhilippe Mathieu-Daudé TPMBlobBuffers state_blobs;
8599bdcd2cSStefan Berger
8699bdcd2cSStefan Berger bool relock_storage;
8799bdcd2cSStefan Berger VMChangeStateEntry *vmstate;
88db1015e9SEduardo Habkost };
89ca64b086SPhilippe Mathieu-Daudé
90ca64b086SPhilippe Mathieu-Daudé struct tpm_error {
91ca64b086SPhilippe Mathieu-Daudé uint32_t tpm_result;
92ca64b086SPhilippe Mathieu-Daudé const char *string;
93ca64b086SPhilippe Mathieu-Daudé };
94ca64b086SPhilippe Mathieu-Daudé
95ca64b086SPhilippe Mathieu-Daudé static const struct tpm_error tpm_errors[] = {
96ca64b086SPhilippe Mathieu-Daudé /* TPM 1.2 error codes */
97ca64b086SPhilippe Mathieu-Daudé { TPM_BAD_PARAMETER , "a parameter is bad" },
98ca64b086SPhilippe Mathieu-Daudé { TPM_FAIL , "operation failed" },
99ca64b086SPhilippe Mathieu-Daudé { TPM_KEYNOTFOUND , "key could not be found" },
100ca64b086SPhilippe Mathieu-Daudé { TPM_BAD_PARAM_SIZE , "bad parameter size"},
101ca64b086SPhilippe Mathieu-Daudé { TPM_ENCRYPT_ERROR , "encryption error" },
102ca64b086SPhilippe Mathieu-Daudé { TPM_DECRYPT_ERROR , "decryption error" },
103ca64b086SPhilippe Mathieu-Daudé { TPM_BAD_KEY_PROPERTY, "bad key property" },
104ca64b086SPhilippe Mathieu-Daudé { TPM_BAD_MODE , "bad (encryption) mode" },
105ca64b086SPhilippe Mathieu-Daudé { TPM_BAD_VERSION , "bad version identifier" },
106ca64b086SPhilippe Mathieu-Daudé { TPM_BAD_LOCALITY , "bad locality" },
107ca64b086SPhilippe Mathieu-Daudé /* TPM 2 error codes */
108ca64b086SPhilippe Mathieu-Daudé { TPM_RC_FAILURE , "operation failed" },
109ca64b086SPhilippe Mathieu-Daudé { TPM_RC_LOCALITY , "bad locality" },
110ca64b086SPhilippe Mathieu-Daudé { TPM_RC_INSUFFICIENT, "insufficient amount of data" },
111ca64b086SPhilippe Mathieu-Daudé };
112ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_strerror(uint32_t tpm_result)113ca64b086SPhilippe Mathieu-Daudé static const char *tpm_emulator_strerror(uint32_t tpm_result)
114ca64b086SPhilippe Mathieu-Daudé {
115ca64b086SPhilippe Mathieu-Daudé size_t i;
116ca64b086SPhilippe Mathieu-Daudé
117ca64b086SPhilippe Mathieu-Daudé for (i = 0; i < ARRAY_SIZE(tpm_errors); i++) {
118ca64b086SPhilippe Mathieu-Daudé if (tpm_errors[i].tpm_result == tpm_result) {
119ca64b086SPhilippe Mathieu-Daudé return tpm_errors[i].string;
120ca64b086SPhilippe Mathieu-Daudé }
121ca64b086SPhilippe Mathieu-Daudé }
122ca64b086SPhilippe Mathieu-Daudé return "";
123ca64b086SPhilippe Mathieu-Daudé }
124ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_ctrlcmd(TPMEmulator * tpm,unsigned long cmd,void * msg,size_t msg_len_in,size_t msg_len_out)125ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_ctrlcmd(TPMEmulator *tpm, unsigned long cmd, void *msg,
126ca64b086SPhilippe Mathieu-Daudé size_t msg_len_in, size_t msg_len_out)
127ca64b086SPhilippe Mathieu-Daudé {
128ca64b086SPhilippe Mathieu-Daudé CharBackend *dev = &tpm->ctrl_chr;
129ca64b086SPhilippe Mathieu-Daudé uint32_t cmd_no = cpu_to_be32(cmd);
130ca64b086SPhilippe Mathieu-Daudé ssize_t n = sizeof(uint32_t) + msg_len_in;
131ca64b086SPhilippe Mathieu-Daudé uint8_t *buf = NULL;
132ca64b086SPhilippe Mathieu-Daudé
133bf5dcf8fSPhilippe Mathieu-Daudé WITH_QEMU_LOCK_GUARD(&tpm->mutex) {
134ca64b086SPhilippe Mathieu-Daudé buf = g_alloca(n);
135ca64b086SPhilippe Mathieu-Daudé memcpy(buf, &cmd_no, sizeof(cmd_no));
136ca64b086SPhilippe Mathieu-Daudé memcpy(buf + sizeof(cmd_no), msg, msg_len_in);
137ca64b086SPhilippe Mathieu-Daudé
138ca64b086SPhilippe Mathieu-Daudé n = qemu_chr_fe_write_all(dev, buf, n);
139ca64b086SPhilippe Mathieu-Daudé if (n <= 0) {
140bf5dcf8fSPhilippe Mathieu-Daudé return -1;
141ca64b086SPhilippe Mathieu-Daudé }
142ca64b086SPhilippe Mathieu-Daudé
143ca64b086SPhilippe Mathieu-Daudé if (msg_len_out != 0) {
144ca64b086SPhilippe Mathieu-Daudé n = qemu_chr_fe_read_all(dev, msg, msg_len_out);
145ca64b086SPhilippe Mathieu-Daudé if (n <= 0) {
146bf5dcf8fSPhilippe Mathieu-Daudé return -1;
147bf5dcf8fSPhilippe Mathieu-Daudé }
148ca64b086SPhilippe Mathieu-Daudé }
149ca64b086SPhilippe Mathieu-Daudé }
150ca64b086SPhilippe Mathieu-Daudé
151bf5dcf8fSPhilippe Mathieu-Daudé return 0;
152ca64b086SPhilippe Mathieu-Daudé }
153ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_unix_tx_bufs(TPMEmulator * tpm_emu,const uint8_t * in,uint32_t in_len,uint8_t * out,uint32_t out_len,bool * selftest_done,Error ** errp)154ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_unix_tx_bufs(TPMEmulator *tpm_emu,
155ca64b086SPhilippe Mathieu-Daudé const uint8_t *in, uint32_t in_len,
156ca64b086SPhilippe Mathieu-Daudé uint8_t *out, uint32_t out_len,
157ca64b086SPhilippe Mathieu-Daudé bool *selftest_done,
158ca64b086SPhilippe Mathieu-Daudé Error **errp)
159ca64b086SPhilippe Mathieu-Daudé {
160ca64b086SPhilippe Mathieu-Daudé ssize_t ret;
161ca64b086SPhilippe Mathieu-Daudé bool is_selftest = false;
162ca64b086SPhilippe Mathieu-Daudé
163ca64b086SPhilippe Mathieu-Daudé if (selftest_done) {
164ca64b086SPhilippe Mathieu-Daudé *selftest_done = false;
165ca64b086SPhilippe Mathieu-Daudé is_selftest = tpm_util_is_selftest(in, in_len);
166ca64b086SPhilippe Mathieu-Daudé }
167ca64b086SPhilippe Mathieu-Daudé
168ca64b086SPhilippe Mathieu-Daudé ret = qio_channel_write_all(tpm_emu->data_ioc, (char *)in, in_len, errp);
169ca64b086SPhilippe Mathieu-Daudé if (ret != 0) {
170ca64b086SPhilippe Mathieu-Daudé return -1;
171ca64b086SPhilippe Mathieu-Daudé }
172ca64b086SPhilippe Mathieu-Daudé
173ca64b086SPhilippe Mathieu-Daudé ret = qio_channel_read_all(tpm_emu->data_ioc, (char *)out,
174ca64b086SPhilippe Mathieu-Daudé sizeof(struct tpm_resp_hdr), errp);
175ca64b086SPhilippe Mathieu-Daudé if (ret != 0) {
176ca64b086SPhilippe Mathieu-Daudé return -1;
177ca64b086SPhilippe Mathieu-Daudé }
178ca64b086SPhilippe Mathieu-Daudé
179ca64b086SPhilippe Mathieu-Daudé ret = qio_channel_read_all(tpm_emu->data_ioc,
180ca64b086SPhilippe Mathieu-Daudé (char *)out + sizeof(struct tpm_resp_hdr),
181ca64b086SPhilippe Mathieu-Daudé tpm_cmd_get_size(out) - sizeof(struct tpm_resp_hdr), errp);
182ca64b086SPhilippe Mathieu-Daudé if (ret != 0) {
183ca64b086SPhilippe Mathieu-Daudé return -1;
184ca64b086SPhilippe Mathieu-Daudé }
185ca64b086SPhilippe Mathieu-Daudé
186ca64b086SPhilippe Mathieu-Daudé if (is_selftest) {
187ca64b086SPhilippe Mathieu-Daudé *selftest_done = tpm_cmd_get_errcode(out) == 0;
188ca64b086SPhilippe Mathieu-Daudé }
189ca64b086SPhilippe Mathieu-Daudé
190ca64b086SPhilippe Mathieu-Daudé return 0;
191ca64b086SPhilippe Mathieu-Daudé }
192ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_set_locality(TPMEmulator * tpm_emu,uint8_t locty_number,Error ** errp)193ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_set_locality(TPMEmulator *tpm_emu, uint8_t locty_number,
194ca64b086SPhilippe Mathieu-Daudé Error **errp)
195ca64b086SPhilippe Mathieu-Daudé {
196ca64b086SPhilippe Mathieu-Daudé ptm_loc loc;
197ca64b086SPhilippe Mathieu-Daudé
198ca64b086SPhilippe Mathieu-Daudé if (tpm_emu->cur_locty_number == locty_number) {
199ca64b086SPhilippe Mathieu-Daudé return 0;
200ca64b086SPhilippe Mathieu-Daudé }
201ca64b086SPhilippe Mathieu-Daudé
202ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_set_locality(locty_number);
203ca64b086SPhilippe Mathieu-Daudé
204ca64b086SPhilippe Mathieu-Daudé memset(&loc, 0, sizeof(loc));
205ca64b086SPhilippe Mathieu-Daudé loc.u.req.loc = locty_number;
206ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_SET_LOCALITY, &loc,
207ca64b086SPhilippe Mathieu-Daudé sizeof(loc), sizeof(loc)) < 0) {
208ca64b086SPhilippe Mathieu-Daudé error_setg(errp, "tpm-emulator: could not set locality : %s",
209ca64b086SPhilippe Mathieu-Daudé strerror(errno));
210ca64b086SPhilippe Mathieu-Daudé return -1;
211ca64b086SPhilippe Mathieu-Daudé }
212ca64b086SPhilippe Mathieu-Daudé
213ca64b086SPhilippe Mathieu-Daudé loc.u.resp.tpm_result = be32_to_cpu(loc.u.resp.tpm_result);
214ca64b086SPhilippe Mathieu-Daudé if (loc.u.resp.tpm_result != 0) {
215ca64b086SPhilippe Mathieu-Daudé error_setg(errp, "tpm-emulator: TPM result for set locality : 0x%x",
216ca64b086SPhilippe Mathieu-Daudé loc.u.resp.tpm_result);
217ca64b086SPhilippe Mathieu-Daudé return -1;
218ca64b086SPhilippe Mathieu-Daudé }
219ca64b086SPhilippe Mathieu-Daudé
220ca64b086SPhilippe Mathieu-Daudé tpm_emu->cur_locty_number = locty_number;
221ca64b086SPhilippe Mathieu-Daudé
222ca64b086SPhilippe Mathieu-Daudé return 0;
223ca64b086SPhilippe Mathieu-Daudé }
224ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_handle_request(TPMBackend * tb,TPMBackendCmd * cmd,Error ** errp)225ca64b086SPhilippe Mathieu-Daudé static void tpm_emulator_handle_request(TPMBackend *tb, TPMBackendCmd *cmd,
226ca64b086SPhilippe Mathieu-Daudé Error **errp)
227ca64b086SPhilippe Mathieu-Daudé {
228ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
229ca64b086SPhilippe Mathieu-Daudé
230ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_handle_request();
231ca64b086SPhilippe Mathieu-Daudé
232ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_set_locality(tpm_emu, cmd->locty, errp) < 0 ||
233ca64b086SPhilippe Mathieu-Daudé tpm_emulator_unix_tx_bufs(tpm_emu, cmd->in, cmd->in_len,
234ca64b086SPhilippe Mathieu-Daudé cmd->out, cmd->out_len,
235ca64b086SPhilippe Mathieu-Daudé &cmd->selftest_done, errp) < 0) {
236ca64b086SPhilippe Mathieu-Daudé tpm_util_write_fatal_error_response(cmd->out, cmd->out_len);
237ca64b086SPhilippe Mathieu-Daudé }
238ca64b086SPhilippe Mathieu-Daudé }
239ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_probe_caps(TPMEmulator * tpm_emu)240ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_probe_caps(TPMEmulator *tpm_emu)
241ca64b086SPhilippe Mathieu-Daudé {
242ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_GET_CAPABILITY,
243ca64b086SPhilippe Mathieu-Daudé &tpm_emu->caps, 0, sizeof(tpm_emu->caps)) < 0) {
244ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: probing failed : %s", strerror(errno));
245ca64b086SPhilippe Mathieu-Daudé return -1;
246ca64b086SPhilippe Mathieu-Daudé }
247ca64b086SPhilippe Mathieu-Daudé
248ca64b086SPhilippe Mathieu-Daudé tpm_emu->caps = be64_to_cpu(tpm_emu->caps);
249ca64b086SPhilippe Mathieu-Daudé
250ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_probe_caps(tpm_emu->caps);
251ca64b086SPhilippe Mathieu-Daudé
252ca64b086SPhilippe Mathieu-Daudé return 0;
253ca64b086SPhilippe Mathieu-Daudé }
254ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_check_caps(TPMEmulator * tpm_emu)255ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_check_caps(TPMEmulator *tpm_emu)
256ca64b086SPhilippe Mathieu-Daudé {
257ca64b086SPhilippe Mathieu-Daudé ptm_cap caps = 0;
258ca64b086SPhilippe Mathieu-Daudé const char *tpm = NULL;
259ca64b086SPhilippe Mathieu-Daudé
260ca64b086SPhilippe Mathieu-Daudé /* check for min. required capabilities */
261ca64b086SPhilippe Mathieu-Daudé switch (tpm_emu->tpm_version) {
262ca64b086SPhilippe Mathieu-Daudé case TPM_VERSION_1_2:
263ca64b086SPhilippe Mathieu-Daudé caps = PTM_CAP_INIT | PTM_CAP_SHUTDOWN | PTM_CAP_GET_TPMESTABLISHED |
264ca64b086SPhilippe Mathieu-Daudé PTM_CAP_SET_LOCALITY | PTM_CAP_SET_DATAFD | PTM_CAP_STOP |
265ca64b086SPhilippe Mathieu-Daudé PTM_CAP_SET_BUFFERSIZE;
266ca64b086SPhilippe Mathieu-Daudé tpm = "1.2";
267ca64b086SPhilippe Mathieu-Daudé break;
268ca64b086SPhilippe Mathieu-Daudé case TPM_VERSION_2_0:
269ca64b086SPhilippe Mathieu-Daudé caps = PTM_CAP_INIT | PTM_CAP_SHUTDOWN | PTM_CAP_GET_TPMESTABLISHED |
270ca64b086SPhilippe Mathieu-Daudé PTM_CAP_SET_LOCALITY | PTM_CAP_RESET_TPMESTABLISHED |
271ca64b086SPhilippe Mathieu-Daudé PTM_CAP_SET_DATAFD | PTM_CAP_STOP | PTM_CAP_SET_BUFFERSIZE;
272ca64b086SPhilippe Mathieu-Daudé tpm = "2";
273ca64b086SPhilippe Mathieu-Daudé break;
274ca64b086SPhilippe Mathieu-Daudé case TPM_VERSION_UNSPEC:
275ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: TPM version has not been set");
276ca64b086SPhilippe Mathieu-Daudé return -1;
277ca64b086SPhilippe Mathieu-Daudé }
278ca64b086SPhilippe Mathieu-Daudé
279ca64b086SPhilippe Mathieu-Daudé if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu, caps)) {
280ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: TPM does not implement minimum set of "
281ca64b086SPhilippe Mathieu-Daudé "required capabilities for TPM %s (0x%x)", tpm, (int)caps);
282ca64b086SPhilippe Mathieu-Daudé return -1;
283ca64b086SPhilippe Mathieu-Daudé }
284ca64b086SPhilippe Mathieu-Daudé
285ca64b086SPhilippe Mathieu-Daudé return 0;
286ca64b086SPhilippe Mathieu-Daudé }
287ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_stop_tpm(TPMBackend * tb)288ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_stop_tpm(TPMBackend *tb)
289ca64b086SPhilippe Mathieu-Daudé {
290ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
291ca64b086SPhilippe Mathieu-Daudé ptm_res res;
292ca64b086SPhilippe Mathieu-Daudé
293ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_STOP, &res, 0, sizeof(res)) < 0) {
294ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Could not stop TPM: %s",
295ca64b086SPhilippe Mathieu-Daudé strerror(errno));
296ca64b086SPhilippe Mathieu-Daudé return -1;
297ca64b086SPhilippe Mathieu-Daudé }
298ca64b086SPhilippe Mathieu-Daudé
299ca64b086SPhilippe Mathieu-Daudé res = be32_to_cpu(res);
300ca64b086SPhilippe Mathieu-Daudé if (res) {
301ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: TPM result for CMD_STOP: 0x%x %s", res,
302ca64b086SPhilippe Mathieu-Daudé tpm_emulator_strerror(res));
303ca64b086SPhilippe Mathieu-Daudé return -1;
304ca64b086SPhilippe Mathieu-Daudé }
305ca64b086SPhilippe Mathieu-Daudé
306ca64b086SPhilippe Mathieu-Daudé return 0;
307ca64b086SPhilippe Mathieu-Daudé }
308ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_lock_storage(TPMEmulator * tpm_emu)30999bdcd2cSStefan Berger static int tpm_emulator_lock_storage(TPMEmulator *tpm_emu)
31099bdcd2cSStefan Berger {
31199bdcd2cSStefan Berger ptm_lockstorage pls;
31299bdcd2cSStefan Berger
31399bdcd2cSStefan Berger if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu, PTM_CAP_LOCK_STORAGE)) {
31499bdcd2cSStefan Berger trace_tpm_emulator_lock_storage_cmd_not_supt();
31599bdcd2cSStefan Berger return 0;
31699bdcd2cSStefan Berger }
31799bdcd2cSStefan Berger
31899bdcd2cSStefan Berger /* give failing side 300 * 10ms time to release lock */
31999bdcd2cSStefan Berger pls.u.req.retries = cpu_to_be32(300);
32099bdcd2cSStefan Berger if (tpm_emulator_ctrlcmd(tpm_emu, CMD_LOCK_STORAGE, &pls,
32199bdcd2cSStefan Berger sizeof(pls.u.req), sizeof(pls.u.resp)) < 0) {
32299bdcd2cSStefan Berger error_report("tpm-emulator: Could not lock storage within 3 seconds: "
32399bdcd2cSStefan Berger "%s", strerror(errno));
32499bdcd2cSStefan Berger return -1;
32599bdcd2cSStefan Berger }
32699bdcd2cSStefan Berger
32799bdcd2cSStefan Berger pls.u.resp.tpm_result = be32_to_cpu(pls.u.resp.tpm_result);
32899bdcd2cSStefan Berger if (pls.u.resp.tpm_result != 0) {
32999bdcd2cSStefan Berger error_report("tpm-emulator: TPM result for CMD_LOCK_STORAGE: 0x%x %s",
33099bdcd2cSStefan Berger pls.u.resp.tpm_result,
33199bdcd2cSStefan Berger tpm_emulator_strerror(pls.u.resp.tpm_result));
33299bdcd2cSStefan Berger return -1;
33399bdcd2cSStefan Berger }
33499bdcd2cSStefan Berger
33599bdcd2cSStefan Berger return 0;
33699bdcd2cSStefan Berger }
33799bdcd2cSStefan Berger
tpm_emulator_set_buffer_size(TPMBackend * tb,size_t wanted_size,size_t * actual_size)338ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_set_buffer_size(TPMBackend *tb,
339ca64b086SPhilippe Mathieu-Daudé size_t wanted_size,
340ca64b086SPhilippe Mathieu-Daudé size_t *actual_size)
341ca64b086SPhilippe Mathieu-Daudé {
342ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
343ca64b086SPhilippe Mathieu-Daudé ptm_setbuffersize psbs;
344ca64b086SPhilippe Mathieu-Daudé
345ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_stop_tpm(tb) < 0) {
346ca64b086SPhilippe Mathieu-Daudé return -1;
347ca64b086SPhilippe Mathieu-Daudé }
348ca64b086SPhilippe Mathieu-Daudé
349ca64b086SPhilippe Mathieu-Daudé psbs.u.req.buffersize = cpu_to_be32(wanted_size);
350ca64b086SPhilippe Mathieu-Daudé
351ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_SET_BUFFERSIZE, &psbs,
352ca64b086SPhilippe Mathieu-Daudé sizeof(psbs.u.req), sizeof(psbs.u.resp)) < 0) {
353ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Could not set buffer size: %s",
354ca64b086SPhilippe Mathieu-Daudé strerror(errno));
355ca64b086SPhilippe Mathieu-Daudé return -1;
356ca64b086SPhilippe Mathieu-Daudé }
357ca64b086SPhilippe Mathieu-Daudé
358ca64b086SPhilippe Mathieu-Daudé psbs.u.resp.tpm_result = be32_to_cpu(psbs.u.resp.tpm_result);
359ca64b086SPhilippe Mathieu-Daudé if (psbs.u.resp.tpm_result != 0) {
360ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: TPM result for set buffer size : 0x%x %s",
361ca64b086SPhilippe Mathieu-Daudé psbs.u.resp.tpm_result,
362ca64b086SPhilippe Mathieu-Daudé tpm_emulator_strerror(psbs.u.resp.tpm_result));
363ca64b086SPhilippe Mathieu-Daudé return -1;
364ca64b086SPhilippe Mathieu-Daudé }
365ca64b086SPhilippe Mathieu-Daudé
366ca64b086SPhilippe Mathieu-Daudé if (actual_size) {
367ca64b086SPhilippe Mathieu-Daudé *actual_size = be32_to_cpu(psbs.u.resp.buffersize);
368ca64b086SPhilippe Mathieu-Daudé }
369ca64b086SPhilippe Mathieu-Daudé
370ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_set_buffer_size(
371ca64b086SPhilippe Mathieu-Daudé be32_to_cpu(psbs.u.resp.buffersize),
372ca64b086SPhilippe Mathieu-Daudé be32_to_cpu(psbs.u.resp.minsize),
373ca64b086SPhilippe Mathieu-Daudé be32_to_cpu(psbs.u.resp.maxsize));
374ca64b086SPhilippe Mathieu-Daudé
375ca64b086SPhilippe Mathieu-Daudé return 0;
376ca64b086SPhilippe Mathieu-Daudé }
377ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_startup_tpm_resume(TPMBackend * tb,size_t buffersize,bool is_resume)378ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_startup_tpm_resume(TPMBackend *tb, size_t buffersize,
379ca64b086SPhilippe Mathieu-Daudé bool is_resume)
380ca64b086SPhilippe Mathieu-Daudé {
381ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
382ca64b086SPhilippe Mathieu-Daudé ptm_init init = {
383ca64b086SPhilippe Mathieu-Daudé .u.req.init_flags = 0,
384ca64b086SPhilippe Mathieu-Daudé };
385ca64b086SPhilippe Mathieu-Daudé ptm_res res;
386ca64b086SPhilippe Mathieu-Daudé
387ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_startup_tpm_resume(is_resume, buffersize);
388ca64b086SPhilippe Mathieu-Daudé
389ca64b086SPhilippe Mathieu-Daudé if (buffersize != 0 &&
390ca64b086SPhilippe Mathieu-Daudé tpm_emulator_set_buffer_size(tb, buffersize, NULL) < 0) {
391ca64b086SPhilippe Mathieu-Daudé goto err_exit;
392ca64b086SPhilippe Mathieu-Daudé }
393ca64b086SPhilippe Mathieu-Daudé
394ca64b086SPhilippe Mathieu-Daudé if (is_resume) {
395ca64b086SPhilippe Mathieu-Daudé init.u.req.init_flags |= cpu_to_be32(PTM_INIT_FLAG_DELETE_VOLATILE);
396ca64b086SPhilippe Mathieu-Daudé }
397ca64b086SPhilippe Mathieu-Daudé
398ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_INIT, &init, sizeof(init),
399ca64b086SPhilippe Mathieu-Daudé sizeof(init)) < 0) {
400ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: could not send INIT: %s",
401ca64b086SPhilippe Mathieu-Daudé strerror(errno));
402ca64b086SPhilippe Mathieu-Daudé goto err_exit;
403ca64b086SPhilippe Mathieu-Daudé }
404ca64b086SPhilippe Mathieu-Daudé
405ca64b086SPhilippe Mathieu-Daudé res = be32_to_cpu(init.u.resp.tpm_result);
406ca64b086SPhilippe Mathieu-Daudé if (res) {
407ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: TPM result for CMD_INIT: 0x%x %s", res,
408ca64b086SPhilippe Mathieu-Daudé tpm_emulator_strerror(res));
409ca64b086SPhilippe Mathieu-Daudé goto err_exit;
410ca64b086SPhilippe Mathieu-Daudé }
411ca64b086SPhilippe Mathieu-Daudé return 0;
412ca64b086SPhilippe Mathieu-Daudé
413ca64b086SPhilippe Mathieu-Daudé err_exit:
414ca64b086SPhilippe Mathieu-Daudé return -1;
415ca64b086SPhilippe Mathieu-Daudé }
416ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_startup_tpm(TPMBackend * tb,size_t buffersize)417ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_startup_tpm(TPMBackend *tb, size_t buffersize)
418ca64b086SPhilippe Mathieu-Daudé {
419a0bcec03SRoss Lagerwall /* TPM startup will be done from post_load hook */
420a0bcec03SRoss Lagerwall if (runstate_check(RUN_STATE_INMIGRATE)) {
421a0bcec03SRoss Lagerwall if (buffersize != 0) {
422a0bcec03SRoss Lagerwall return tpm_emulator_set_buffer_size(tb, buffersize, NULL);
423a0bcec03SRoss Lagerwall }
424a0bcec03SRoss Lagerwall
425a0bcec03SRoss Lagerwall return 0;
426a0bcec03SRoss Lagerwall }
427a0bcec03SRoss Lagerwall
428ca64b086SPhilippe Mathieu-Daudé return tpm_emulator_startup_tpm_resume(tb, buffersize, false);
429ca64b086SPhilippe Mathieu-Daudé }
430ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_get_tpm_established_flag(TPMBackend * tb)431ca64b086SPhilippe Mathieu-Daudé static bool tpm_emulator_get_tpm_established_flag(TPMBackend *tb)
432ca64b086SPhilippe Mathieu-Daudé {
433ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
434ca64b086SPhilippe Mathieu-Daudé ptm_est est;
435ca64b086SPhilippe Mathieu-Daudé
436ca64b086SPhilippe Mathieu-Daudé if (tpm_emu->established_flag_cached) {
437ca64b086SPhilippe Mathieu-Daudé return tpm_emu->established_flag;
438ca64b086SPhilippe Mathieu-Daudé }
439ca64b086SPhilippe Mathieu-Daudé
440ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_GET_TPMESTABLISHED, &est,
441ca64b086SPhilippe Mathieu-Daudé 0, sizeof(est)) < 0) {
442ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Could not get the TPM established flag: %s",
443ca64b086SPhilippe Mathieu-Daudé strerror(errno));
444ca64b086SPhilippe Mathieu-Daudé return false;
445ca64b086SPhilippe Mathieu-Daudé }
446ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_get_tpm_established_flag(est.u.resp.bit);
447ca64b086SPhilippe Mathieu-Daudé
448ca64b086SPhilippe Mathieu-Daudé tpm_emu->established_flag_cached = 1;
449ca64b086SPhilippe Mathieu-Daudé tpm_emu->established_flag = (est.u.resp.bit != 0);
450ca64b086SPhilippe Mathieu-Daudé
451ca64b086SPhilippe Mathieu-Daudé return tpm_emu->established_flag;
452ca64b086SPhilippe Mathieu-Daudé }
453ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_reset_tpm_established_flag(TPMBackend * tb,uint8_t locty)454ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_reset_tpm_established_flag(TPMBackend *tb,
455ca64b086SPhilippe Mathieu-Daudé uint8_t locty)
456ca64b086SPhilippe Mathieu-Daudé {
457ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
458ca64b086SPhilippe Mathieu-Daudé ptm_reset_est reset_est;
459ca64b086SPhilippe Mathieu-Daudé ptm_res res;
460ca64b086SPhilippe Mathieu-Daudé
461ca64b086SPhilippe Mathieu-Daudé /* only a TPM 2.0 will support this */
462ca64b086SPhilippe Mathieu-Daudé if (tpm_emu->tpm_version != TPM_VERSION_2_0) {
463ca64b086SPhilippe Mathieu-Daudé return 0;
464ca64b086SPhilippe Mathieu-Daudé }
465ca64b086SPhilippe Mathieu-Daudé
466ca64b086SPhilippe Mathieu-Daudé reset_est.u.req.loc = tpm_emu->cur_locty_number;
467ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_RESET_TPMESTABLISHED,
468ca64b086SPhilippe Mathieu-Daudé &reset_est, sizeof(reset_est),
469ca64b086SPhilippe Mathieu-Daudé sizeof(reset_est)) < 0) {
470ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Could not reset the establishment bit: %s",
471ca64b086SPhilippe Mathieu-Daudé strerror(errno));
472ca64b086SPhilippe Mathieu-Daudé return -1;
473ca64b086SPhilippe Mathieu-Daudé }
474ca64b086SPhilippe Mathieu-Daudé
475ca64b086SPhilippe Mathieu-Daudé res = be32_to_cpu(reset_est.u.resp.tpm_result);
476ca64b086SPhilippe Mathieu-Daudé if (res) {
477ca64b086SPhilippe Mathieu-Daudé error_report(
478ca64b086SPhilippe Mathieu-Daudé "tpm-emulator: TPM result for rest established flag: 0x%x %s",
479ca64b086SPhilippe Mathieu-Daudé res, tpm_emulator_strerror(res));
480ca64b086SPhilippe Mathieu-Daudé return -1;
481ca64b086SPhilippe Mathieu-Daudé }
482ca64b086SPhilippe Mathieu-Daudé
483ca64b086SPhilippe Mathieu-Daudé tpm_emu->established_flag_cached = 0;
484ca64b086SPhilippe Mathieu-Daudé
485ca64b086SPhilippe Mathieu-Daudé return 0;
486ca64b086SPhilippe Mathieu-Daudé }
487ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_cancel_cmd(TPMBackend * tb)488ca64b086SPhilippe Mathieu-Daudé static void tpm_emulator_cancel_cmd(TPMBackend *tb)
489ca64b086SPhilippe Mathieu-Daudé {
490ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
491ca64b086SPhilippe Mathieu-Daudé ptm_res res;
492ca64b086SPhilippe Mathieu-Daudé
493ca64b086SPhilippe Mathieu-Daudé if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu, PTM_CAP_CANCEL_TPM_CMD)) {
494ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_cancel_cmd_not_supt();
495ca64b086SPhilippe Mathieu-Daudé return;
496ca64b086SPhilippe Mathieu-Daudé }
497ca64b086SPhilippe Mathieu-Daudé
498ca64b086SPhilippe Mathieu-Daudé /* FIXME: make the function non-blocking, or it may block a VCPU */
499ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_CANCEL_TPM_CMD, &res, 0,
500ca64b086SPhilippe Mathieu-Daudé sizeof(res)) < 0) {
501ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Could not cancel command: %s",
502ca64b086SPhilippe Mathieu-Daudé strerror(errno));
503ca64b086SPhilippe Mathieu-Daudé } else if (res != 0) {
504ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Failed to cancel TPM: 0x%x",
505ca64b086SPhilippe Mathieu-Daudé be32_to_cpu(res));
506ca64b086SPhilippe Mathieu-Daudé }
507ca64b086SPhilippe Mathieu-Daudé }
508ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_get_tpm_version(TPMBackend * tb)509ca64b086SPhilippe Mathieu-Daudé static TPMVersion tpm_emulator_get_tpm_version(TPMBackend *tb)
510ca64b086SPhilippe Mathieu-Daudé {
511ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
512ca64b086SPhilippe Mathieu-Daudé
513ca64b086SPhilippe Mathieu-Daudé return tpm_emu->tpm_version;
514ca64b086SPhilippe Mathieu-Daudé }
515ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_get_buffer_size(TPMBackend * tb)516ca64b086SPhilippe Mathieu-Daudé static size_t tpm_emulator_get_buffer_size(TPMBackend *tb)
517ca64b086SPhilippe Mathieu-Daudé {
518ca64b086SPhilippe Mathieu-Daudé size_t actual_size;
519ca64b086SPhilippe Mathieu-Daudé
520ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_set_buffer_size(tb, 0, &actual_size) < 0) {
521ca64b086SPhilippe Mathieu-Daudé return 4096;
522ca64b086SPhilippe Mathieu-Daudé }
523ca64b086SPhilippe Mathieu-Daudé
524ca64b086SPhilippe Mathieu-Daudé return actual_size;
525ca64b086SPhilippe Mathieu-Daudé }
526ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_block_migration(TPMEmulator * tpm_emu)527ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_block_migration(TPMEmulator *tpm_emu)
528ca64b086SPhilippe Mathieu-Daudé {
529ca64b086SPhilippe Mathieu-Daudé Error *err = NULL;
530ca64b086SPhilippe Mathieu-Daudé ptm_cap caps = PTM_CAP_GET_STATEBLOB | PTM_CAP_SET_STATEBLOB |
531ca64b086SPhilippe Mathieu-Daudé PTM_CAP_STOP;
532ca64b086SPhilippe Mathieu-Daudé
533ca64b086SPhilippe Mathieu-Daudé if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu, caps)) {
534ca64b086SPhilippe Mathieu-Daudé error_setg(&tpm_emu->migration_blocker,
535ca64b086SPhilippe Mathieu-Daudé "Migration disabled: TPM emulator does not support "
536ca64b086SPhilippe Mathieu-Daudé "migration");
537c8a7fc51SSteve Sistare if (migrate_add_blocker(&tpm_emu->migration_blocker, &err) < 0) {
538ca64b086SPhilippe Mathieu-Daudé error_report_err(err);
539ca64b086SPhilippe Mathieu-Daudé return -1;
540ca64b086SPhilippe Mathieu-Daudé }
541ca64b086SPhilippe Mathieu-Daudé }
542ca64b086SPhilippe Mathieu-Daudé
543ca64b086SPhilippe Mathieu-Daudé return 0;
544ca64b086SPhilippe Mathieu-Daudé }
545ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_prepare_data_fd(TPMEmulator * tpm_emu)546ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_prepare_data_fd(TPMEmulator *tpm_emu)
547ca64b086SPhilippe Mathieu-Daudé {
548ca64b086SPhilippe Mathieu-Daudé ptm_res res;
549ca64b086SPhilippe Mathieu-Daudé Error *err = NULL;
550ca64b086SPhilippe Mathieu-Daudé int fds[2] = { -1, -1 };
551ca64b086SPhilippe Mathieu-Daudé
5520038e9a2SGuoyi Tu if (qemu_socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
553ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Failed to create socketpair");
554ca64b086SPhilippe Mathieu-Daudé return -1;
555ca64b086SPhilippe Mathieu-Daudé }
556ca64b086SPhilippe Mathieu-Daudé
557ca64b086SPhilippe Mathieu-Daudé qemu_chr_fe_set_msgfds(&tpm_emu->ctrl_chr, fds + 1, 1);
558ca64b086SPhilippe Mathieu-Daudé
559ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_SET_DATAFD, &res, 0,
560ca64b086SPhilippe Mathieu-Daudé sizeof(res)) < 0 || res != 0) {
561ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Failed to send CMD_SET_DATAFD: %s",
562ca64b086SPhilippe Mathieu-Daudé strerror(errno));
563ca64b086SPhilippe Mathieu-Daudé goto err_exit;
564ca64b086SPhilippe Mathieu-Daudé }
565ca64b086SPhilippe Mathieu-Daudé
566ca64b086SPhilippe Mathieu-Daudé tpm_emu->data_ioc = QIO_CHANNEL(qio_channel_socket_new_fd(fds[0], &err));
567ca64b086SPhilippe Mathieu-Daudé if (err) {
568ca64b086SPhilippe Mathieu-Daudé error_prepend(&err, "tpm-emulator: Failed to create io channel: ");
569ca64b086SPhilippe Mathieu-Daudé error_report_err(err);
570ca64b086SPhilippe Mathieu-Daudé goto err_exit;
571ca64b086SPhilippe Mathieu-Daudé }
572ca64b086SPhilippe Mathieu-Daudé
57325657fc6SMarc-André Lureau close(fds[1]);
574ca64b086SPhilippe Mathieu-Daudé
575ca64b086SPhilippe Mathieu-Daudé return 0;
576ca64b086SPhilippe Mathieu-Daudé
577ca64b086SPhilippe Mathieu-Daudé err_exit:
57825657fc6SMarc-André Lureau close(fds[0]);
57925657fc6SMarc-André Lureau close(fds[1]);
580ca64b086SPhilippe Mathieu-Daudé return -1;
581ca64b086SPhilippe Mathieu-Daudé }
582ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_handle_device_opts(TPMEmulator * tpm_emu,QemuOpts * opts)583ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_handle_device_opts(TPMEmulator *tpm_emu, QemuOpts *opts)
584ca64b086SPhilippe Mathieu-Daudé {
585ca64b086SPhilippe Mathieu-Daudé const char *value;
58688f83074SStefan Berger Error *err = NULL;
58788f83074SStefan Berger Chardev *dev;
588ca64b086SPhilippe Mathieu-Daudé
589ca64b086SPhilippe Mathieu-Daudé value = qemu_opt_get(opts, "chardev");
59088f83074SStefan Berger if (!value) {
59188f83074SStefan Berger error_report("tpm-emulator: parameter 'chardev' is missing");
59288f83074SStefan Berger goto err;
59388f83074SStefan Berger }
594ca64b086SPhilippe Mathieu-Daudé
59588f83074SStefan Berger dev = qemu_chr_find(value);
596ca64b086SPhilippe Mathieu-Daudé if (!dev) {
59788f83074SStefan Berger error_report("tpm-emulator: tpm chardev '%s' not found", value);
598ca64b086SPhilippe Mathieu-Daudé goto err;
599ca64b086SPhilippe Mathieu-Daudé }
600ca64b086SPhilippe Mathieu-Daudé
601ca64b086SPhilippe Mathieu-Daudé if (!qemu_chr_fe_init(&tpm_emu->ctrl_chr, dev, &err)) {
602ca64b086SPhilippe Mathieu-Daudé error_prepend(&err, "tpm-emulator: No valid chardev found at '%s':",
603ca64b086SPhilippe Mathieu-Daudé value);
604ca64b086SPhilippe Mathieu-Daudé error_report_err(err);
605ca64b086SPhilippe Mathieu-Daudé goto err;
606ca64b086SPhilippe Mathieu-Daudé }
607ca64b086SPhilippe Mathieu-Daudé
608ca64b086SPhilippe Mathieu-Daudé tpm_emu->options->chardev = g_strdup(value);
609ca64b086SPhilippe Mathieu-Daudé
610ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_prepare_data_fd(tpm_emu) < 0) {
611ca64b086SPhilippe Mathieu-Daudé goto err;
612ca64b086SPhilippe Mathieu-Daudé }
613ca64b086SPhilippe Mathieu-Daudé
614ca64b086SPhilippe Mathieu-Daudé /* FIXME: tpm_util_test_tpmdev() accepts only on socket fd, as it also used
615ca64b086SPhilippe Mathieu-Daudé * by passthrough driver, which not yet using GIOChannel.
616ca64b086SPhilippe Mathieu-Daudé */
617ca64b086SPhilippe Mathieu-Daudé if (tpm_util_test_tpmdev(QIO_CHANNEL_SOCKET(tpm_emu->data_ioc)->fd,
618ca64b086SPhilippe Mathieu-Daudé &tpm_emu->tpm_version)) {
619ca64b086SPhilippe Mathieu-Daudé error_report("'%s' is not emulating TPM device. Error: %s",
620ca64b086SPhilippe Mathieu-Daudé tpm_emu->options->chardev, strerror(errno));
621ca64b086SPhilippe Mathieu-Daudé goto err;
622ca64b086SPhilippe Mathieu-Daudé }
623ca64b086SPhilippe Mathieu-Daudé
624ca64b086SPhilippe Mathieu-Daudé switch (tpm_emu->tpm_version) {
625ca64b086SPhilippe Mathieu-Daudé case TPM_VERSION_1_2:
626ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_handle_device_opts_tpm12();
627ca64b086SPhilippe Mathieu-Daudé break;
628ca64b086SPhilippe Mathieu-Daudé case TPM_VERSION_2_0:
629ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_handle_device_opts_tpm2();
630ca64b086SPhilippe Mathieu-Daudé break;
631ca64b086SPhilippe Mathieu-Daudé default:
632ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_handle_device_opts_unspec();
633ca64b086SPhilippe Mathieu-Daudé }
634ca64b086SPhilippe Mathieu-Daudé
635ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_probe_caps(tpm_emu) ||
636ca64b086SPhilippe Mathieu-Daudé tpm_emulator_check_caps(tpm_emu)) {
637ca64b086SPhilippe Mathieu-Daudé goto err;
638ca64b086SPhilippe Mathieu-Daudé }
639ca64b086SPhilippe Mathieu-Daudé
640ca64b086SPhilippe Mathieu-Daudé return tpm_emulator_block_migration(tpm_emu);
641ca64b086SPhilippe Mathieu-Daudé
642ca64b086SPhilippe Mathieu-Daudé err:
643ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_handle_device_opts_startup_error();
644ca64b086SPhilippe Mathieu-Daudé
645ca64b086SPhilippe Mathieu-Daudé return -1;
646ca64b086SPhilippe Mathieu-Daudé }
647ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_create(QemuOpts * opts)648ca64b086SPhilippe Mathieu-Daudé static TPMBackend *tpm_emulator_create(QemuOpts *opts)
649ca64b086SPhilippe Mathieu-Daudé {
650ca64b086SPhilippe Mathieu-Daudé TPMBackend *tb = TPM_BACKEND(object_new(TYPE_TPM_EMULATOR));
651ca64b086SPhilippe Mathieu-Daudé
652ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_handle_device_opts(TPM_EMULATOR(tb), opts)) {
653ca64b086SPhilippe Mathieu-Daudé object_unref(OBJECT(tb));
654ca64b086SPhilippe Mathieu-Daudé return NULL;
655ca64b086SPhilippe Mathieu-Daudé }
656ca64b086SPhilippe Mathieu-Daudé
657ca64b086SPhilippe Mathieu-Daudé return tb;
658ca64b086SPhilippe Mathieu-Daudé }
659ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_get_tpm_options(TPMBackend * tb)660ca64b086SPhilippe Mathieu-Daudé static TpmTypeOptions *tpm_emulator_get_tpm_options(TPMBackend *tb)
661ca64b086SPhilippe Mathieu-Daudé {
662ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
663ca64b086SPhilippe Mathieu-Daudé TpmTypeOptions *options = g_new0(TpmTypeOptions, 1);
664ca64b086SPhilippe Mathieu-Daudé
66539dc3e4aSMarkus Armbruster options->type = TPM_TYPE_EMULATOR;
666ca64b086SPhilippe Mathieu-Daudé options->u.emulator.data = QAPI_CLONE(TPMEmulatorOptions, tpm_emu->options);
667ca64b086SPhilippe Mathieu-Daudé
668ca64b086SPhilippe Mathieu-Daudé return options;
669ca64b086SPhilippe Mathieu-Daudé }
670ca64b086SPhilippe Mathieu-Daudé
671ca64b086SPhilippe Mathieu-Daudé static const QemuOptDesc tpm_emulator_cmdline_opts[] = {
672ca64b086SPhilippe Mathieu-Daudé TPM_STANDARD_CMDLINE_OPTS,
673ca64b086SPhilippe Mathieu-Daudé {
674ca64b086SPhilippe Mathieu-Daudé .name = "chardev",
675ca64b086SPhilippe Mathieu-Daudé .type = QEMU_OPT_STRING,
676ca64b086SPhilippe Mathieu-Daudé .help = "Character device to use for out-of-band control messages",
677ca64b086SPhilippe Mathieu-Daudé },
678ca64b086SPhilippe Mathieu-Daudé { /* end of list */ },
679ca64b086SPhilippe Mathieu-Daudé };
680ca64b086SPhilippe Mathieu-Daudé
681ca64b086SPhilippe Mathieu-Daudé /*
682ca64b086SPhilippe Mathieu-Daudé * Transfer a TPM state blob from the TPM into a provided buffer.
683ca64b086SPhilippe Mathieu-Daudé *
684ca64b086SPhilippe Mathieu-Daudé * @tpm_emu: TPMEmulator
685ca64b086SPhilippe Mathieu-Daudé * @type: the type of blob to transfer
686ca64b086SPhilippe Mathieu-Daudé * @tsb: the TPMSizeBuffer to fill with the blob
687ca64b086SPhilippe Mathieu-Daudé * @flags: the flags to return to the caller
688ca64b086SPhilippe Mathieu-Daudé */
tpm_emulator_get_state_blob(TPMEmulator * tpm_emu,uint8_t type,TPMSizedBuffer * tsb,uint32_t * flags)689ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_get_state_blob(TPMEmulator *tpm_emu,
690ca64b086SPhilippe Mathieu-Daudé uint8_t type,
691ca64b086SPhilippe Mathieu-Daudé TPMSizedBuffer *tsb,
692ca64b086SPhilippe Mathieu-Daudé uint32_t *flags)
693ca64b086SPhilippe Mathieu-Daudé {
694ca64b086SPhilippe Mathieu-Daudé ptm_getstate pgs;
695ca64b086SPhilippe Mathieu-Daudé ptm_res res;
696ca64b086SPhilippe Mathieu-Daudé ssize_t n;
697ca64b086SPhilippe Mathieu-Daudé uint32_t totlength, length;
698ca64b086SPhilippe Mathieu-Daudé
699ca64b086SPhilippe Mathieu-Daudé tpm_sized_buffer_reset(tsb);
700ca64b086SPhilippe Mathieu-Daudé
701ca64b086SPhilippe Mathieu-Daudé pgs.u.req.state_flags = cpu_to_be32(PTM_STATE_FLAG_DECRYPTED);
702ca64b086SPhilippe Mathieu-Daudé pgs.u.req.type = cpu_to_be32(type);
703ca64b086SPhilippe Mathieu-Daudé pgs.u.req.offset = 0;
704ca64b086SPhilippe Mathieu-Daudé
705ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_GET_STATEBLOB,
706ca64b086SPhilippe Mathieu-Daudé &pgs, sizeof(pgs.u.req),
707ca64b086SPhilippe Mathieu-Daudé offsetof(ptm_getstate, u.resp.data)) < 0) {
708ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: could not get state blob type %d : %s",
709ca64b086SPhilippe Mathieu-Daudé type, strerror(errno));
710ca64b086SPhilippe Mathieu-Daudé return -1;
711ca64b086SPhilippe Mathieu-Daudé }
712ca64b086SPhilippe Mathieu-Daudé
713ca64b086SPhilippe Mathieu-Daudé res = be32_to_cpu(pgs.u.resp.tpm_result);
714ca64b086SPhilippe Mathieu-Daudé if (res != 0 && (res & 0x800) == 0) {
715ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Getting the stateblob (type %d) failed "
716ca64b086SPhilippe Mathieu-Daudé "with a TPM error 0x%x %s", type, res,
717ca64b086SPhilippe Mathieu-Daudé tpm_emulator_strerror(res));
718ca64b086SPhilippe Mathieu-Daudé return -1;
719ca64b086SPhilippe Mathieu-Daudé }
720ca64b086SPhilippe Mathieu-Daudé
721ca64b086SPhilippe Mathieu-Daudé totlength = be32_to_cpu(pgs.u.resp.totlength);
722ca64b086SPhilippe Mathieu-Daudé length = be32_to_cpu(pgs.u.resp.length);
723ca64b086SPhilippe Mathieu-Daudé if (totlength != length) {
724ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Expecting to read %u bytes "
725ca64b086SPhilippe Mathieu-Daudé "but would get %u", totlength, length);
726ca64b086SPhilippe Mathieu-Daudé return -1;
727ca64b086SPhilippe Mathieu-Daudé }
728ca64b086SPhilippe Mathieu-Daudé
729ca64b086SPhilippe Mathieu-Daudé *flags = be32_to_cpu(pgs.u.resp.state_flags);
730ca64b086SPhilippe Mathieu-Daudé
731ca64b086SPhilippe Mathieu-Daudé if (totlength > 0) {
732ca64b086SPhilippe Mathieu-Daudé tsb->buffer = g_try_malloc(totlength);
733ca64b086SPhilippe Mathieu-Daudé if (!tsb->buffer) {
734ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Out of memory allocating %u bytes",
735ca64b086SPhilippe Mathieu-Daudé totlength);
736ca64b086SPhilippe Mathieu-Daudé return -1;
737ca64b086SPhilippe Mathieu-Daudé }
738ca64b086SPhilippe Mathieu-Daudé
739ca64b086SPhilippe Mathieu-Daudé n = qemu_chr_fe_read_all(&tpm_emu->ctrl_chr, tsb->buffer, totlength);
740ca64b086SPhilippe Mathieu-Daudé if (n != totlength) {
741ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Could not read stateblob (type %d); "
742ca64b086SPhilippe Mathieu-Daudé "expected %u bytes, got %zd",
743ca64b086SPhilippe Mathieu-Daudé type, totlength, n);
744ca64b086SPhilippe Mathieu-Daudé return -1;
745ca64b086SPhilippe Mathieu-Daudé }
746ca64b086SPhilippe Mathieu-Daudé }
747ca64b086SPhilippe Mathieu-Daudé tsb->size = totlength;
748ca64b086SPhilippe Mathieu-Daudé
749ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_get_state_blob(type, tsb->size, *flags);
750ca64b086SPhilippe Mathieu-Daudé
751ca64b086SPhilippe Mathieu-Daudé return 0;
752ca64b086SPhilippe Mathieu-Daudé }
753ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_get_state_blobs(TPMEmulator * tpm_emu)754ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_get_state_blobs(TPMEmulator *tpm_emu)
755ca64b086SPhilippe Mathieu-Daudé {
756ca64b086SPhilippe Mathieu-Daudé TPMBlobBuffers *state_blobs = &tpm_emu->state_blobs;
757ca64b086SPhilippe Mathieu-Daudé
758ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_get_state_blob(tpm_emu, PTM_BLOB_TYPE_PERMANENT,
759ca64b086SPhilippe Mathieu-Daudé &state_blobs->permanent,
760ca64b086SPhilippe Mathieu-Daudé &state_blobs->permanent_flags) < 0 ||
761ca64b086SPhilippe Mathieu-Daudé tpm_emulator_get_state_blob(tpm_emu, PTM_BLOB_TYPE_VOLATILE,
762ca64b086SPhilippe Mathieu-Daudé &state_blobs->volatil,
763ca64b086SPhilippe Mathieu-Daudé &state_blobs->volatil_flags) < 0 ||
764ca64b086SPhilippe Mathieu-Daudé tpm_emulator_get_state_blob(tpm_emu, PTM_BLOB_TYPE_SAVESTATE,
765ca64b086SPhilippe Mathieu-Daudé &state_blobs->savestate,
766ca64b086SPhilippe Mathieu-Daudé &state_blobs->savestate_flags) < 0) {
767ca64b086SPhilippe Mathieu-Daudé goto err_exit;
768ca64b086SPhilippe Mathieu-Daudé }
769ca64b086SPhilippe Mathieu-Daudé
770ca64b086SPhilippe Mathieu-Daudé return 0;
771ca64b086SPhilippe Mathieu-Daudé
772ca64b086SPhilippe Mathieu-Daudé err_exit:
773ca64b086SPhilippe Mathieu-Daudé tpm_sized_buffer_reset(&state_blobs->volatil);
774ca64b086SPhilippe Mathieu-Daudé tpm_sized_buffer_reset(&state_blobs->permanent);
775ca64b086SPhilippe Mathieu-Daudé tpm_sized_buffer_reset(&state_blobs->savestate);
776ca64b086SPhilippe Mathieu-Daudé
777ca64b086SPhilippe Mathieu-Daudé return -1;
778ca64b086SPhilippe Mathieu-Daudé }
779ca64b086SPhilippe Mathieu-Daudé
780ca64b086SPhilippe Mathieu-Daudé /*
781ca64b086SPhilippe Mathieu-Daudé * Transfer a TPM state blob to the TPM emulator.
782ca64b086SPhilippe Mathieu-Daudé *
783ca64b086SPhilippe Mathieu-Daudé * @tpm_emu: TPMEmulator
784ca64b086SPhilippe Mathieu-Daudé * @type: the type of TPM state blob to transfer
785ca64b086SPhilippe Mathieu-Daudé * @tsb: TPMSizedBuffer containing the TPM state blob
786ca64b086SPhilippe Mathieu-Daudé * @flags: Flags describing the (encryption) state of the TPM state blob
787ca64b086SPhilippe Mathieu-Daudé */
tpm_emulator_set_state_blob(TPMEmulator * tpm_emu,uint32_t type,TPMSizedBuffer * tsb,uint32_t flags)788ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_set_state_blob(TPMEmulator *tpm_emu,
789ca64b086SPhilippe Mathieu-Daudé uint32_t type,
790ca64b086SPhilippe Mathieu-Daudé TPMSizedBuffer *tsb,
791ca64b086SPhilippe Mathieu-Daudé uint32_t flags)
792ca64b086SPhilippe Mathieu-Daudé {
793ca64b086SPhilippe Mathieu-Daudé ssize_t n;
794ca64b086SPhilippe Mathieu-Daudé ptm_setstate pss;
795ca64b086SPhilippe Mathieu-Daudé ptm_res tpm_result;
796ca64b086SPhilippe Mathieu-Daudé
797ca64b086SPhilippe Mathieu-Daudé if (tsb->size == 0) {
798ca64b086SPhilippe Mathieu-Daudé return 0;
799ca64b086SPhilippe Mathieu-Daudé }
800ca64b086SPhilippe Mathieu-Daudé
801ca64b086SPhilippe Mathieu-Daudé pss = (ptm_setstate) {
802ca64b086SPhilippe Mathieu-Daudé .u.req.state_flags = cpu_to_be32(flags),
803ca64b086SPhilippe Mathieu-Daudé .u.req.type = cpu_to_be32(type),
804ca64b086SPhilippe Mathieu-Daudé .u.req.length = cpu_to_be32(tsb->size),
805ca64b086SPhilippe Mathieu-Daudé };
806ca64b086SPhilippe Mathieu-Daudé
807ca64b086SPhilippe Mathieu-Daudé /* write the header only */
808ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_SET_STATEBLOB, &pss,
809ca64b086SPhilippe Mathieu-Daudé offsetof(ptm_setstate, u.req.data), 0) < 0) {
810ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: could not set state blob type %d : %s",
811ca64b086SPhilippe Mathieu-Daudé type, strerror(errno));
812ca64b086SPhilippe Mathieu-Daudé return -1;
813ca64b086SPhilippe Mathieu-Daudé }
814ca64b086SPhilippe Mathieu-Daudé
815ca64b086SPhilippe Mathieu-Daudé /* now the body */
816ca64b086SPhilippe Mathieu-Daudé n = qemu_chr_fe_write_all(&tpm_emu->ctrl_chr, tsb->buffer, tsb->size);
817ca64b086SPhilippe Mathieu-Daudé if (n != tsb->size) {
818ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Writing the stateblob (type %d) "
819ca64b086SPhilippe Mathieu-Daudé "failed; could not write %u bytes, but only %zd",
820ca64b086SPhilippe Mathieu-Daudé type, tsb->size, n);
821ca64b086SPhilippe Mathieu-Daudé return -1;
822ca64b086SPhilippe Mathieu-Daudé }
823ca64b086SPhilippe Mathieu-Daudé
824ca64b086SPhilippe Mathieu-Daudé /* now get the result */
825ca64b086SPhilippe Mathieu-Daudé n = qemu_chr_fe_read_all(&tpm_emu->ctrl_chr,
826ca64b086SPhilippe Mathieu-Daudé (uint8_t *)&pss, sizeof(pss.u.resp));
827ca64b086SPhilippe Mathieu-Daudé if (n != sizeof(pss.u.resp)) {
828ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Reading response from writing stateblob "
829ca64b086SPhilippe Mathieu-Daudé "(type %d) failed; expected %zu bytes, got %zd", type,
830ca64b086SPhilippe Mathieu-Daudé sizeof(pss.u.resp), n);
831ca64b086SPhilippe Mathieu-Daudé return -1;
832ca64b086SPhilippe Mathieu-Daudé }
833ca64b086SPhilippe Mathieu-Daudé
834ca64b086SPhilippe Mathieu-Daudé tpm_result = be32_to_cpu(pss.u.resp.tpm_result);
835ca64b086SPhilippe Mathieu-Daudé if (tpm_result != 0) {
836ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Setting the stateblob (type %d) failed "
837ca64b086SPhilippe Mathieu-Daudé "with a TPM error 0x%x %s", type, tpm_result,
838ca64b086SPhilippe Mathieu-Daudé tpm_emulator_strerror(tpm_result));
839ca64b086SPhilippe Mathieu-Daudé return -1;
840ca64b086SPhilippe Mathieu-Daudé }
841ca64b086SPhilippe Mathieu-Daudé
842ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_set_state_blob(type, tsb->size, flags);
843ca64b086SPhilippe Mathieu-Daudé
844ca64b086SPhilippe Mathieu-Daudé return 0;
845ca64b086SPhilippe Mathieu-Daudé }
846ca64b086SPhilippe Mathieu-Daudé
847ca64b086SPhilippe Mathieu-Daudé /*
848ca64b086SPhilippe Mathieu-Daudé * Set all the TPM state blobs.
849ca64b086SPhilippe Mathieu-Daudé *
850ca64b086SPhilippe Mathieu-Daudé * Returns a negative errno code in case of error.
851ca64b086SPhilippe Mathieu-Daudé */
tpm_emulator_set_state_blobs(TPMBackend * tb)852ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_set_state_blobs(TPMBackend *tb)
853ca64b086SPhilippe Mathieu-Daudé {
854ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
855ca64b086SPhilippe Mathieu-Daudé TPMBlobBuffers *state_blobs = &tpm_emu->state_blobs;
856ca64b086SPhilippe Mathieu-Daudé
857ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_set_state_blobs();
858ca64b086SPhilippe Mathieu-Daudé
859ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_stop_tpm(tb) < 0) {
860ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_set_state_blobs_error("Could not stop TPM");
861ca64b086SPhilippe Mathieu-Daudé return -EIO;
862ca64b086SPhilippe Mathieu-Daudé }
863ca64b086SPhilippe Mathieu-Daudé
864ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_set_state_blob(tpm_emu, PTM_BLOB_TYPE_PERMANENT,
865ca64b086SPhilippe Mathieu-Daudé &state_blobs->permanent,
866ca64b086SPhilippe Mathieu-Daudé state_blobs->permanent_flags) < 0 ||
867ca64b086SPhilippe Mathieu-Daudé tpm_emulator_set_state_blob(tpm_emu, PTM_BLOB_TYPE_VOLATILE,
868ca64b086SPhilippe Mathieu-Daudé &state_blobs->volatil,
869ca64b086SPhilippe Mathieu-Daudé state_blobs->volatil_flags) < 0 ||
870ca64b086SPhilippe Mathieu-Daudé tpm_emulator_set_state_blob(tpm_emu, PTM_BLOB_TYPE_SAVESTATE,
871ca64b086SPhilippe Mathieu-Daudé &state_blobs->savestate,
872ca64b086SPhilippe Mathieu-Daudé state_blobs->savestate_flags) < 0) {
873ca64b086SPhilippe Mathieu-Daudé return -EIO;
874ca64b086SPhilippe Mathieu-Daudé }
875ca64b086SPhilippe Mathieu-Daudé
876ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_set_state_blobs_done();
877ca64b086SPhilippe Mathieu-Daudé
878ca64b086SPhilippe Mathieu-Daudé return 0;
879ca64b086SPhilippe Mathieu-Daudé }
880ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_pre_save(void * opaque)881ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_pre_save(void *opaque)
882ca64b086SPhilippe Mathieu-Daudé {
883ca64b086SPhilippe Mathieu-Daudé TPMBackend *tb = opaque;
884ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
88599bdcd2cSStefan Berger int ret;
886ca64b086SPhilippe Mathieu-Daudé
887ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_pre_save();
888ca64b086SPhilippe Mathieu-Daudé
889ca64b086SPhilippe Mathieu-Daudé tpm_backend_finish_sync(tb);
890ca64b086SPhilippe Mathieu-Daudé
891ca64b086SPhilippe Mathieu-Daudé /* get the state blobs from the TPM */
89299bdcd2cSStefan Berger ret = tpm_emulator_get_state_blobs(tpm_emu);
89399bdcd2cSStefan Berger
89499bdcd2cSStefan Berger tpm_emu->relock_storage = ret == 0;
89599bdcd2cSStefan Berger
89699bdcd2cSStefan Berger return ret;
89799bdcd2cSStefan Berger }
89899bdcd2cSStefan Berger
tpm_emulator_vm_state_change(void * opaque,bool running,RunState state)89999bdcd2cSStefan Berger static void tpm_emulator_vm_state_change(void *opaque, bool running,
90099bdcd2cSStefan Berger RunState state)
90199bdcd2cSStefan Berger {
90299bdcd2cSStefan Berger TPMBackend *tb = opaque;
90399bdcd2cSStefan Berger TPMEmulator *tpm_emu = TPM_EMULATOR(tb);
90499bdcd2cSStefan Berger
90599bdcd2cSStefan Berger trace_tpm_emulator_vm_state_change(running, state);
90699bdcd2cSStefan Berger
907*0f1db069SSteve Sistare if (!running || !tpm_emu->relock_storage) {
90899bdcd2cSStefan Berger return;
90999bdcd2cSStefan Berger }
91099bdcd2cSStefan Berger
91199bdcd2cSStefan Berger /* lock storage after migration fall-back */
91299bdcd2cSStefan Berger tpm_emulator_lock_storage(tpm_emu);
913ca64b086SPhilippe Mathieu-Daudé }
914ca64b086SPhilippe Mathieu-Daudé
915ca64b086SPhilippe Mathieu-Daudé /*
916ca64b086SPhilippe Mathieu-Daudé * Load the TPM state blobs into the TPM.
917ca64b086SPhilippe Mathieu-Daudé *
918ca64b086SPhilippe Mathieu-Daudé * Returns negative errno codes in case of error.
919ca64b086SPhilippe Mathieu-Daudé */
tpm_emulator_post_load(void * opaque,int version_id)920ca64b086SPhilippe Mathieu-Daudé static int tpm_emulator_post_load(void *opaque, int version_id)
921ca64b086SPhilippe Mathieu-Daudé {
922ca64b086SPhilippe Mathieu-Daudé TPMBackend *tb = opaque;
923ca64b086SPhilippe Mathieu-Daudé int ret;
924ca64b086SPhilippe Mathieu-Daudé
925ca64b086SPhilippe Mathieu-Daudé ret = tpm_emulator_set_state_blobs(tb);
926ca64b086SPhilippe Mathieu-Daudé if (ret < 0) {
927ca64b086SPhilippe Mathieu-Daudé return ret;
928ca64b086SPhilippe Mathieu-Daudé }
929ca64b086SPhilippe Mathieu-Daudé
930ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_startup_tpm_resume(tb, 0, true) < 0) {
931ca64b086SPhilippe Mathieu-Daudé return -EIO;
932ca64b086SPhilippe Mathieu-Daudé }
933ca64b086SPhilippe Mathieu-Daudé
934ca64b086SPhilippe Mathieu-Daudé return 0;
935ca64b086SPhilippe Mathieu-Daudé }
936ca64b086SPhilippe Mathieu-Daudé
937ca64b086SPhilippe Mathieu-Daudé static const VMStateDescription vmstate_tpm_emulator = {
938ca64b086SPhilippe Mathieu-Daudé .name = "tpm-emulator",
939ca64b086SPhilippe Mathieu-Daudé .version_id = 0,
940ca64b086SPhilippe Mathieu-Daudé .pre_save = tpm_emulator_pre_save,
941ca64b086SPhilippe Mathieu-Daudé .post_load = tpm_emulator_post_load,
942ca64b086SPhilippe Mathieu-Daudé .fields = (const VMStateField[]) {
943ca64b086SPhilippe Mathieu-Daudé VMSTATE_UINT32(state_blobs.permanent_flags, TPMEmulator),
944ca64b086SPhilippe Mathieu-Daudé VMSTATE_UINT32(state_blobs.permanent.size, TPMEmulator),
945ca64b086SPhilippe Mathieu-Daudé VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs.permanent.buffer,
946ca64b086SPhilippe Mathieu-Daudé TPMEmulator, 0, 0,
947ca64b086SPhilippe Mathieu-Daudé state_blobs.permanent.size),
948ca64b086SPhilippe Mathieu-Daudé
949ca64b086SPhilippe Mathieu-Daudé VMSTATE_UINT32(state_blobs.volatil_flags, TPMEmulator),
950ca64b086SPhilippe Mathieu-Daudé VMSTATE_UINT32(state_blobs.volatil.size, TPMEmulator),
951ca64b086SPhilippe Mathieu-Daudé VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs.volatil.buffer,
952ca64b086SPhilippe Mathieu-Daudé TPMEmulator, 0, 0,
953ca64b086SPhilippe Mathieu-Daudé state_blobs.volatil.size),
954ca64b086SPhilippe Mathieu-Daudé
955ca64b086SPhilippe Mathieu-Daudé VMSTATE_UINT32(state_blobs.savestate_flags, TPMEmulator),
956ca64b086SPhilippe Mathieu-Daudé VMSTATE_UINT32(state_blobs.savestate.size, TPMEmulator),
957ca64b086SPhilippe Mathieu-Daudé VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs.savestate.buffer,
958ca64b086SPhilippe Mathieu-Daudé TPMEmulator, 0, 0,
959ca64b086SPhilippe Mathieu-Daudé state_blobs.savestate.size),
960ca64b086SPhilippe Mathieu-Daudé
961ca64b086SPhilippe Mathieu-Daudé VMSTATE_END_OF_LIST()
962ca64b086SPhilippe Mathieu-Daudé }
963ca64b086SPhilippe Mathieu-Daudé };
964ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_inst_init(Object * obj)965ca64b086SPhilippe Mathieu-Daudé static void tpm_emulator_inst_init(Object *obj)
966ca64b086SPhilippe Mathieu-Daudé {
967ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(obj);
968ca64b086SPhilippe Mathieu-Daudé
969ca64b086SPhilippe Mathieu-Daudé trace_tpm_emulator_inst_init();
970ca64b086SPhilippe Mathieu-Daudé
971ca64b086SPhilippe Mathieu-Daudé tpm_emu->options = g_new0(TPMEmulatorOptions, 1);
972ca64b086SPhilippe Mathieu-Daudé tpm_emu->cur_locty_number = ~0;
973ca64b086SPhilippe Mathieu-Daudé qemu_mutex_init(&tpm_emu->mutex);
97499bdcd2cSStefan Berger tpm_emu->vmstate =
97599bdcd2cSStefan Berger qemu_add_vm_change_state_handler(tpm_emulator_vm_state_change,
97699bdcd2cSStefan Berger tpm_emu);
977ca64b086SPhilippe Mathieu-Daudé
97899b16e8eSJuan Quintela vmstate_register_any(NULL, &vmstate_tpm_emulator, obj);
979ca64b086SPhilippe Mathieu-Daudé }
980ca64b086SPhilippe Mathieu-Daudé
981ca64b086SPhilippe Mathieu-Daudé /*
982ca64b086SPhilippe Mathieu-Daudé * Gracefully shut down the external TPM
983ca64b086SPhilippe Mathieu-Daudé */
tpm_emulator_shutdown(TPMEmulator * tpm_emu)984ca64b086SPhilippe Mathieu-Daudé static void tpm_emulator_shutdown(TPMEmulator *tpm_emu)
985ca64b086SPhilippe Mathieu-Daudé {
986ca64b086SPhilippe Mathieu-Daudé ptm_res res;
987ca64b086SPhilippe Mathieu-Daudé
98888f83074SStefan Berger if (!tpm_emu->options->chardev) {
98988f83074SStefan Berger /* was never properly initialized */
99088f83074SStefan Berger return;
99188f83074SStefan Berger }
99288f83074SStefan Berger
993ca64b086SPhilippe Mathieu-Daudé if (tpm_emulator_ctrlcmd(tpm_emu, CMD_SHUTDOWN, &res, 0, sizeof(res)) < 0) {
994ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: Could not cleanly shutdown the TPM: %s",
995ca64b086SPhilippe Mathieu-Daudé strerror(errno));
996ca64b086SPhilippe Mathieu-Daudé } else if (res != 0) {
997ca64b086SPhilippe Mathieu-Daudé error_report("tpm-emulator: TPM result for shutdown: 0x%x %s",
998ca64b086SPhilippe Mathieu-Daudé be32_to_cpu(res), tpm_emulator_strerror(be32_to_cpu(res)));
999ca64b086SPhilippe Mathieu-Daudé }
1000ca64b086SPhilippe Mathieu-Daudé }
1001ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_inst_finalize(Object * obj)1002ca64b086SPhilippe Mathieu-Daudé static void tpm_emulator_inst_finalize(Object *obj)
1003ca64b086SPhilippe Mathieu-Daudé {
1004ca64b086SPhilippe Mathieu-Daudé TPMEmulator *tpm_emu = TPM_EMULATOR(obj);
1005ca64b086SPhilippe Mathieu-Daudé TPMBlobBuffers *state_blobs = &tpm_emu->state_blobs;
1006ca64b086SPhilippe Mathieu-Daudé
1007ca64b086SPhilippe Mathieu-Daudé tpm_emulator_shutdown(tpm_emu);
1008ca64b086SPhilippe Mathieu-Daudé
1009ca64b086SPhilippe Mathieu-Daudé object_unref(OBJECT(tpm_emu->data_ioc));
1010ca64b086SPhilippe Mathieu-Daudé
1011ca64b086SPhilippe Mathieu-Daudé qemu_chr_fe_deinit(&tpm_emu->ctrl_chr, false);
1012ca64b086SPhilippe Mathieu-Daudé
1013ca64b086SPhilippe Mathieu-Daudé qapi_free_TPMEmulatorOptions(tpm_emu->options);
1014ca64b086SPhilippe Mathieu-Daudé
1015c8a7fc51SSteve Sistare migrate_del_blocker(&tpm_emu->migration_blocker);
1016ca64b086SPhilippe Mathieu-Daudé
1017ca64b086SPhilippe Mathieu-Daudé tpm_sized_buffer_reset(&state_blobs->volatil);
1018ca64b086SPhilippe Mathieu-Daudé tpm_sized_buffer_reset(&state_blobs->permanent);
1019ca64b086SPhilippe Mathieu-Daudé tpm_sized_buffer_reset(&state_blobs->savestate);
1020ca64b086SPhilippe Mathieu-Daudé
1021ca64b086SPhilippe Mathieu-Daudé qemu_mutex_destroy(&tpm_emu->mutex);
102299bdcd2cSStefan Berger qemu_del_vm_change_state_handler(tpm_emu->vmstate);
1023ca64b086SPhilippe Mathieu-Daudé
1024ca64b086SPhilippe Mathieu-Daudé vmstate_unregister(NULL, &vmstate_tpm_emulator, obj);
1025ca64b086SPhilippe Mathieu-Daudé }
1026ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_class_init(ObjectClass * klass,void * data)1027ca64b086SPhilippe Mathieu-Daudé static void tpm_emulator_class_init(ObjectClass *klass, void *data)
1028ca64b086SPhilippe Mathieu-Daudé {
1029ca64b086SPhilippe Mathieu-Daudé TPMBackendClass *tbc = TPM_BACKEND_CLASS(klass);
1030ca64b086SPhilippe Mathieu-Daudé
1031ca64b086SPhilippe Mathieu-Daudé tbc->type = TPM_TYPE_EMULATOR;
1032ca64b086SPhilippe Mathieu-Daudé tbc->opts = tpm_emulator_cmdline_opts;
1033ca64b086SPhilippe Mathieu-Daudé tbc->desc = "TPM emulator backend driver";
1034ca64b086SPhilippe Mathieu-Daudé tbc->create = tpm_emulator_create;
1035ca64b086SPhilippe Mathieu-Daudé tbc->startup_tpm = tpm_emulator_startup_tpm;
1036ca64b086SPhilippe Mathieu-Daudé tbc->cancel_cmd = tpm_emulator_cancel_cmd;
1037ca64b086SPhilippe Mathieu-Daudé tbc->get_tpm_established_flag = tpm_emulator_get_tpm_established_flag;
1038ca64b086SPhilippe Mathieu-Daudé tbc->reset_tpm_established_flag = tpm_emulator_reset_tpm_established_flag;
1039ca64b086SPhilippe Mathieu-Daudé tbc->get_tpm_version = tpm_emulator_get_tpm_version;
1040ca64b086SPhilippe Mathieu-Daudé tbc->get_buffer_size = tpm_emulator_get_buffer_size;
1041ca64b086SPhilippe Mathieu-Daudé tbc->get_tpm_options = tpm_emulator_get_tpm_options;
1042ca64b086SPhilippe Mathieu-Daudé
1043ca64b086SPhilippe Mathieu-Daudé tbc->handle_request = tpm_emulator_handle_request;
1044ca64b086SPhilippe Mathieu-Daudé }
1045ca64b086SPhilippe Mathieu-Daudé
1046ca64b086SPhilippe Mathieu-Daudé static const TypeInfo tpm_emulator_info = {
1047ca64b086SPhilippe Mathieu-Daudé .name = TYPE_TPM_EMULATOR,
1048ca64b086SPhilippe Mathieu-Daudé .parent = TYPE_TPM_BACKEND,
1049ca64b086SPhilippe Mathieu-Daudé .instance_size = sizeof(TPMEmulator),
1050ca64b086SPhilippe Mathieu-Daudé .class_init = tpm_emulator_class_init,
1051ca64b086SPhilippe Mathieu-Daudé .instance_init = tpm_emulator_inst_init,
1052ca64b086SPhilippe Mathieu-Daudé .instance_finalize = tpm_emulator_inst_finalize,
1053ca64b086SPhilippe Mathieu-Daudé };
1054ca64b086SPhilippe Mathieu-Daudé
tpm_emulator_register(void)1055ca64b086SPhilippe Mathieu-Daudé static void tpm_emulator_register(void)
1056ca64b086SPhilippe Mathieu-Daudé {
1057ca64b086SPhilippe Mathieu-Daudé type_register_static(&tpm_emulator_info);
1058ca64b086SPhilippe Mathieu-Daudé }
1059ca64b086SPhilippe Mathieu-Daudé
1060ca64b086SPhilippe Mathieu-Daudé type_init(tpm_emulator_register)
1061