4 * Copyright (c) 2017 Intel Corporation
5 * Author: Amarnath Valluri <amarnath.valluri@intel.com>
7 * Copyright (c) 2010 - 2013, 2018 IBM Corporation
9 * Stefan Berger <stefanb@us.ibm.com>
11 * Copyright (C) 2011 IAIK, Graz University of Technology
12 * Author: Andreas Niederl
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2 of the License, or (at your option) any later version.
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, see <http://www.gnu.org/licenses/>
29 #include "qemu/osdep.h"
30 #include "qemu/error-report.h"
31 #include "qemu/module.h"
32 #include "qemu/sockets.h"
33 #include "io/channel-socket.h"
34 #include "sysemu/tpm_backend.h"
37 #include "tpm_ioctl.h"
38 #include "migration/blocker.h"
39 #include "migration/vmstate.h"
40 #include "qapi/error.h"
41 #include "qapi/clone-visitor.h"
42 #include "qapi/qapi-visit-tpm.h"
43 #include "chardev/char-fe.h"
46 #define TYPE_TPM_EMULATOR "tpm-emulator"
47 #define TPM_EMULATOR(obj) \
48 OBJECT_CHECK(TPMEmulator, (obj), TYPE_TPM_EMULATOR)
50 #define TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(S, cap) (((S)->caps & (cap)) == (cap))
54 /* blobs from the TPM; part of VM state when migrating */
55 typedef struct TPMBlobBuffers
{
56 uint32_t permanent_flags
;
57 TPMSizedBuffer permanent
;
59 uint32_t volatil_flags
;
60 TPMSizedBuffer volatil
;
62 uint32_t savestate_flags
;
63 TPMSizedBuffer savestate
;
66 typedef struct TPMEmulator
{
69 TPMEmulatorOptions
*options
;
72 TPMVersion tpm_version
;
73 ptm_cap caps
; /* capabilities of the TPM */
74 uint8_t cur_locty_number
; /* last set locality */
75 Error
*migration_blocker
;
79 unsigned int established_flag
:1;
80 unsigned int established_flag_cached
:1;
82 TPMBlobBuffers state_blobs
;
90 static const struct tpm_error tpm_errors
[] = {
91 /* TPM 1.2 error codes */
92 { TPM_BAD_PARAMETER
, "a parameter is bad" },
93 { TPM_FAIL
, "operation failed" },
94 { TPM_KEYNOTFOUND
, "key could not be found" },
95 { TPM_BAD_PARAM_SIZE
, "bad parameter size"},
96 { TPM_ENCRYPT_ERROR
, "encryption error" },
97 { TPM_DECRYPT_ERROR
, "decryption error" },
98 { TPM_BAD_KEY_PROPERTY
, "bad key property" },
99 { TPM_BAD_MODE
, "bad (encryption) mode" },
100 { TPM_BAD_VERSION
, "bad version identifier" },
101 { TPM_BAD_LOCALITY
, "bad locality" },
102 /* TPM 2 error codes */
103 { TPM_RC_FAILURE
, "operation failed" },
104 { TPM_RC_LOCALITY
, "bad locality" },
105 { TPM_RC_INSUFFICIENT
, "insufficient amount of data" },
108 static const char *tpm_emulator_strerror(uint32_t tpm_result
)
112 for (i
= 0; i
< ARRAY_SIZE(tpm_errors
); i
++) {
113 if (tpm_errors
[i
].tpm_result
== tpm_result
) {
114 return tpm_errors
[i
].string
;
120 static int tpm_emulator_ctrlcmd(TPMEmulator
*tpm
, unsigned long cmd
, void *msg
,
121 size_t msg_len_in
, size_t msg_len_out
)
123 CharBackend
*dev
= &tpm
->ctrl_chr
;
124 uint32_t cmd_no
= cpu_to_be32(cmd
);
125 ssize_t n
= sizeof(uint32_t) + msg_len_in
;
129 qemu_mutex_lock(&tpm
->mutex
);
132 memcpy(buf
, &cmd_no
, sizeof(cmd_no
));
133 memcpy(buf
+ sizeof(cmd_no
), msg
, msg_len_in
);
135 n
= qemu_chr_fe_write_all(dev
, buf
, n
);
140 if (msg_len_out
!= 0) {
141 n
= qemu_chr_fe_read_all(dev
, msg
, msg_len_out
);
150 qemu_mutex_unlock(&tpm
->mutex
);
154 static int tpm_emulator_unix_tx_bufs(TPMEmulator
*tpm_emu
,
155 const uint8_t *in
, uint32_t in_len
,
156 uint8_t *out
, uint32_t out_len
,
161 bool is_selftest
= false;
164 *selftest_done
= false;
165 is_selftest
= tpm_util_is_selftest(in
, in_len
);
168 ret
= qio_channel_write_all(tpm_emu
->data_ioc
, (char *)in
, in_len
, err
);
173 ret
= qio_channel_read_all(tpm_emu
->data_ioc
, (char *)out
,
174 sizeof(struct tpm_resp_hdr
), err
);
179 ret
= qio_channel_read_all(tpm_emu
->data_ioc
,
180 (char *)out
+ sizeof(struct tpm_resp_hdr
),
181 tpm_cmd_get_size(out
) - sizeof(struct tpm_resp_hdr
), err
);
187 *selftest_done
= tpm_cmd_get_errcode(out
) == 0;
193 static int tpm_emulator_set_locality(TPMEmulator
*tpm_emu
, uint8_t locty_number
,
198 if (tpm_emu
->cur_locty_number
== locty_number
) {
202 trace_tpm_emulator_set_locality(locty_number
);
204 memset(&loc
, 0, sizeof(loc
));
205 loc
.u
.req
.loc
= locty_number
;
206 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SET_LOCALITY
, &loc
,
207 sizeof(loc
), sizeof(loc
)) < 0) {
208 error_setg(errp
, "tpm-emulator: could not set locality : %s",
213 loc
.u
.resp
.tpm_result
= be32_to_cpu(loc
.u
.resp
.tpm_result
);
214 if (loc
.u
.resp
.tpm_result
!= 0) {
215 error_setg(errp
, "tpm-emulator: TPM result for set locality : 0x%x",
216 loc
.u
.resp
.tpm_result
);
220 tpm_emu
->cur_locty_number
= locty_number
;
225 static void tpm_emulator_handle_request(TPMBackend
*tb
, TPMBackendCmd
*cmd
,
228 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
230 trace_tpm_emulator_handle_request();
232 if (tpm_emulator_set_locality(tpm_emu
, cmd
->locty
, errp
) < 0 ||
233 tpm_emulator_unix_tx_bufs(tpm_emu
, cmd
->in
, cmd
->in_len
,
234 cmd
->out
, cmd
->out_len
,
235 &cmd
->selftest_done
, errp
) < 0) {
236 tpm_util_write_fatal_error_response(cmd
->out
, cmd
->out_len
);
240 static int tpm_emulator_probe_caps(TPMEmulator
*tpm_emu
)
242 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_GET_CAPABILITY
,
243 &tpm_emu
->caps
, 0, sizeof(tpm_emu
->caps
)) < 0) {
244 error_report("tpm-emulator: probing failed : %s", strerror(errno
));
248 tpm_emu
->caps
= be64_to_cpu(tpm_emu
->caps
);
250 trace_tpm_emulator_probe_caps(tpm_emu
->caps
);
255 static int tpm_emulator_check_caps(TPMEmulator
*tpm_emu
)
258 const char *tpm
= NULL
;
260 /* check for min. required capabilities */
261 switch (tpm_emu
->tpm_version
) {
262 case TPM_VERSION_1_2
:
263 caps
= PTM_CAP_INIT
| PTM_CAP_SHUTDOWN
| PTM_CAP_GET_TPMESTABLISHED
|
264 PTM_CAP_SET_LOCALITY
| PTM_CAP_SET_DATAFD
| PTM_CAP_STOP
|
265 PTM_CAP_SET_BUFFERSIZE
;
268 case TPM_VERSION_2_0
:
269 caps
= PTM_CAP_INIT
| PTM_CAP_SHUTDOWN
| PTM_CAP_GET_TPMESTABLISHED
|
270 PTM_CAP_SET_LOCALITY
| PTM_CAP_RESET_TPMESTABLISHED
|
271 PTM_CAP_SET_DATAFD
| PTM_CAP_STOP
| PTM_CAP_SET_BUFFERSIZE
;
274 case TPM_VERSION_UNSPEC
:
275 error_report("tpm-emulator: TPM version has not been set");
279 if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu
, caps
)) {
280 error_report("tpm-emulator: TPM does not implement minimum set of "
281 "required capabilities for TPM %s (0x%x)", tpm
, (int)caps
);
288 static int tpm_emulator_stop_tpm(TPMBackend
*tb
)
290 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
293 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_STOP
, &res
, 0, sizeof(res
)) < 0) {
294 error_report("tpm-emulator: Could not stop TPM: %s",
299 res
= be32_to_cpu(res
);
301 error_report("tpm-emulator: TPM result for CMD_STOP: 0x%x %s", res
,
302 tpm_emulator_strerror(res
));
309 static int tpm_emulator_set_buffer_size(TPMBackend
*tb
,
313 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
314 ptm_setbuffersize psbs
;
316 if (tpm_emulator_stop_tpm(tb
) < 0) {
320 psbs
.u
.req
.buffersize
= cpu_to_be32(wanted_size
);
322 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SET_BUFFERSIZE
, &psbs
,
323 sizeof(psbs
.u
.req
), sizeof(psbs
.u
.resp
)) < 0) {
324 error_report("tpm-emulator: Could not set buffer size: %s",
329 psbs
.u
.resp
.tpm_result
= be32_to_cpu(psbs
.u
.resp
.tpm_result
);
330 if (psbs
.u
.resp
.tpm_result
!= 0) {
331 error_report("tpm-emulator: TPM result for set buffer size : 0x%x %s",
332 psbs
.u
.resp
.tpm_result
,
333 tpm_emulator_strerror(psbs
.u
.resp
.tpm_result
));
338 *actual_size
= be32_to_cpu(psbs
.u
.resp
.buffersize
);
341 trace_tpm_emulator_set_buffer_size(
342 be32_to_cpu(psbs
.u
.resp
.buffersize
),
343 be32_to_cpu(psbs
.u
.resp
.minsize
),
344 be32_to_cpu(psbs
.u
.resp
.maxsize
));
349 static int tpm_emulator_startup_tpm_resume(TPMBackend
*tb
, size_t buffersize
,
352 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
354 .u
.req
.init_flags
= 0,
358 trace_tpm_emulator_startup_tpm_resume(is_resume
, buffersize
);
360 if (buffersize
!= 0 &&
361 tpm_emulator_set_buffer_size(tb
, buffersize
, NULL
) < 0) {
366 init
.u
.req
.init_flags
|= cpu_to_be32(PTM_INIT_FLAG_DELETE_VOLATILE
);
369 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_INIT
, &init
, sizeof(init
),
371 error_report("tpm-emulator: could not send INIT: %s",
376 res
= be32_to_cpu(init
.u
.resp
.tpm_result
);
378 error_report("tpm-emulator: TPM result for CMD_INIT: 0x%x %s", res
,
379 tpm_emulator_strerror(res
));
388 static int tpm_emulator_startup_tpm(TPMBackend
*tb
, size_t buffersize
)
390 return tpm_emulator_startup_tpm_resume(tb
, buffersize
, false);
393 static bool tpm_emulator_get_tpm_established_flag(TPMBackend
*tb
)
395 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
398 if (tpm_emu
->established_flag_cached
) {
399 return tpm_emu
->established_flag
;
402 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_GET_TPMESTABLISHED
, &est
,
403 0, sizeof(est
)) < 0) {
404 error_report("tpm-emulator: Could not get the TPM established flag: %s",
408 trace_tpm_emulator_get_tpm_established_flag(est
.u
.resp
.bit
);
410 tpm_emu
->established_flag_cached
= 1;
411 tpm_emu
->established_flag
= (est
.u
.resp
.bit
!= 0);
413 return tpm_emu
->established_flag
;
416 static int tpm_emulator_reset_tpm_established_flag(TPMBackend
*tb
,
419 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
420 ptm_reset_est reset_est
;
423 /* only a TPM 2.0 will support this */
424 if (tpm_emu
->tpm_version
!= TPM_VERSION_2_0
) {
428 reset_est
.u
.req
.loc
= tpm_emu
->cur_locty_number
;
429 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_RESET_TPMESTABLISHED
,
430 &reset_est
, sizeof(reset_est
),
431 sizeof(reset_est
)) < 0) {
432 error_report("tpm-emulator: Could not reset the establishment bit: %s",
437 res
= be32_to_cpu(reset_est
.u
.resp
.tpm_result
);
440 "tpm-emulator: TPM result for rest established flag: 0x%x %s",
441 res
, tpm_emulator_strerror(res
));
445 tpm_emu
->established_flag_cached
= 0;
450 static void tpm_emulator_cancel_cmd(TPMBackend
*tb
)
452 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
455 if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu
, PTM_CAP_CANCEL_TPM_CMD
)) {
456 trace_tpm_emulator_cancel_cmd_not_supt();
460 /* FIXME: make the function non-blocking, or it may block a VCPU */
461 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_CANCEL_TPM_CMD
, &res
, 0,
463 error_report("tpm-emulator: Could not cancel command: %s",
465 } else if (res
!= 0) {
466 error_report("tpm-emulator: Failed to cancel TPM: 0x%x",
471 static TPMVersion
tpm_emulator_get_tpm_version(TPMBackend
*tb
)
473 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
475 return tpm_emu
->tpm_version
;
478 static size_t tpm_emulator_get_buffer_size(TPMBackend
*tb
)
482 if (tpm_emulator_set_buffer_size(tb
, 0, &actual_size
) < 0) {
489 static int tpm_emulator_block_migration(TPMEmulator
*tpm_emu
)
492 ptm_cap caps
= PTM_CAP_GET_STATEBLOB
| PTM_CAP_SET_STATEBLOB
|
495 if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu
, caps
)) {
496 error_setg(&tpm_emu
->migration_blocker
,
497 "Migration disabled: TPM emulator does not support "
499 migrate_add_blocker(tpm_emu
->migration_blocker
, &err
);
501 error_report_err(err
);
502 error_free(tpm_emu
->migration_blocker
);
503 tpm_emu
->migration_blocker
= NULL
;
512 static int tpm_emulator_prepare_data_fd(TPMEmulator
*tpm_emu
)
516 int fds
[2] = { -1, -1 };
518 if (socketpair(AF_UNIX
, SOCK_STREAM
, 0, fds
) < 0) {
519 error_report("tpm-emulator: Failed to create socketpair");
523 qemu_chr_fe_set_msgfds(&tpm_emu
->ctrl_chr
, fds
+ 1, 1);
525 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SET_DATAFD
, &res
, 0,
526 sizeof(res
)) < 0 || res
!= 0) {
527 error_report("tpm-emulator: Failed to send CMD_SET_DATAFD: %s",
532 tpm_emu
->data_ioc
= QIO_CHANNEL(qio_channel_socket_new_fd(fds
[0], &err
));
534 error_prepend(&err
, "tpm-emulator: Failed to create io channel: ");
535 error_report_err(err
);
549 static int tpm_emulator_handle_device_opts(TPMEmulator
*tpm_emu
, QemuOpts
*opts
)
553 value
= qemu_opt_get(opts
, "chardev");
556 Chardev
*dev
= qemu_chr_find(value
);
559 error_report("tpm-emulator: tpm chardev '%s' not found.", value
);
563 if (!qemu_chr_fe_init(&tpm_emu
->ctrl_chr
, dev
, &err
)) {
564 error_prepend(&err
, "tpm-emulator: No valid chardev found at '%s':",
566 error_report_err(err
);
570 tpm_emu
->options
->chardev
= g_strdup(value
);
573 if (tpm_emulator_prepare_data_fd(tpm_emu
) < 0) {
577 /* FIXME: tpm_util_test_tpmdev() accepts only on socket fd, as it also used
578 * by passthrough driver, which not yet using GIOChannel.
580 if (tpm_util_test_tpmdev(QIO_CHANNEL_SOCKET(tpm_emu
->data_ioc
)->fd
,
581 &tpm_emu
->tpm_version
)) {
582 error_report("'%s' is not emulating TPM device. Error: %s",
583 tpm_emu
->options
->chardev
, strerror(errno
));
587 switch (tpm_emu
->tpm_version
) {
588 case TPM_VERSION_1_2
:
589 trace_tpm_emulator_handle_device_opts_tpm12();
591 case TPM_VERSION_2_0
:
592 trace_tpm_emulator_handle_device_opts_tpm2();
595 trace_tpm_emulator_handle_device_opts_unspec();
598 if (tpm_emulator_probe_caps(tpm_emu
) ||
599 tpm_emulator_check_caps(tpm_emu
)) {
603 return tpm_emulator_block_migration(tpm_emu
);
606 trace_tpm_emulator_handle_device_opts_startup_error();
611 static TPMBackend
*tpm_emulator_create(QemuOpts
*opts
)
613 TPMBackend
*tb
= TPM_BACKEND(object_new(TYPE_TPM_EMULATOR
));
615 if (tpm_emulator_handle_device_opts(TPM_EMULATOR(tb
), opts
)) {
616 object_unref(OBJECT(tb
));
623 static TpmTypeOptions
*tpm_emulator_get_tpm_options(TPMBackend
*tb
)
625 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
626 TpmTypeOptions
*options
= g_new0(TpmTypeOptions
, 1);
628 options
->type
= TPM_TYPE_OPTIONS_KIND_EMULATOR
;
629 options
->u
.emulator
.data
= QAPI_CLONE(TPMEmulatorOptions
, tpm_emu
->options
);
634 static const QemuOptDesc tpm_emulator_cmdline_opts
[] = {
635 TPM_STANDARD_CMDLINE_OPTS
,
638 .type
= QEMU_OPT_STRING
,
639 .help
= "Character device to use for out-of-band control messages",
641 { /* end of list */ },
645 * Transfer a TPM state blob from the TPM into a provided buffer.
647 * @tpm_emu: TPMEmulator
648 * @type: the type of blob to transfer
649 * @tsb: the TPMSizeBuffer to fill with the blob
650 * @flags: the flags to return to the caller
652 static int tpm_emulator_get_state_blob(TPMEmulator
*tpm_emu
,
660 uint32_t totlength
, length
;
662 tpm_sized_buffer_reset(tsb
);
664 pgs
.u
.req
.state_flags
= cpu_to_be32(PTM_STATE_FLAG_DECRYPTED
);
665 pgs
.u
.req
.type
= cpu_to_be32(type
);
666 pgs
.u
.req
.offset
= 0;
668 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_GET_STATEBLOB
,
669 &pgs
, sizeof(pgs
.u
.req
),
670 offsetof(ptm_getstate
, u
.resp
.data
)) < 0) {
671 error_report("tpm-emulator: could not get state blob type %d : %s",
672 type
, strerror(errno
));
676 res
= be32_to_cpu(pgs
.u
.resp
.tpm_result
);
677 if (res
!= 0 && (res
& 0x800) == 0) {
678 error_report("tpm-emulator: Getting the stateblob (type %d) failed "
679 "with a TPM error 0x%x %s", type
, res
,
680 tpm_emulator_strerror(res
));
684 totlength
= be32_to_cpu(pgs
.u
.resp
.totlength
);
685 length
= be32_to_cpu(pgs
.u
.resp
.length
);
686 if (totlength
!= length
) {
687 error_report("tpm-emulator: Expecting to read %u bytes "
688 "but would get %u", totlength
, length
);
692 *flags
= be32_to_cpu(pgs
.u
.resp
.state_flags
);
695 tsb
->buffer
= g_try_malloc(totlength
);
697 error_report("tpm-emulator: Out of memory allocating %u bytes",
702 n
= qemu_chr_fe_read_all(&tpm_emu
->ctrl_chr
, tsb
->buffer
, totlength
);
703 if (n
!= totlength
) {
704 error_report("tpm-emulator: Could not read stateblob (type %d); "
705 "expected %u bytes, got %zd",
710 tsb
->size
= totlength
;
712 trace_tpm_emulator_get_state_blob(type
, tsb
->size
, *flags
);
717 static int tpm_emulator_get_state_blobs(TPMEmulator
*tpm_emu
)
719 TPMBlobBuffers
*state_blobs
= &tpm_emu
->state_blobs
;
721 if (tpm_emulator_get_state_blob(tpm_emu
, PTM_BLOB_TYPE_PERMANENT
,
722 &state_blobs
->permanent
,
723 &state_blobs
->permanent_flags
) < 0 ||
724 tpm_emulator_get_state_blob(tpm_emu
, PTM_BLOB_TYPE_VOLATILE
,
725 &state_blobs
->volatil
,
726 &state_blobs
->volatil_flags
) < 0 ||
727 tpm_emulator_get_state_blob(tpm_emu
, PTM_BLOB_TYPE_SAVESTATE
,
728 &state_blobs
->savestate
,
729 &state_blobs
->savestate_flags
) < 0) {
736 tpm_sized_buffer_reset(&state_blobs
->volatil
);
737 tpm_sized_buffer_reset(&state_blobs
->permanent
);
738 tpm_sized_buffer_reset(&state_blobs
->savestate
);
744 * Transfer a TPM state blob to the TPM emulator.
746 * @tpm_emu: TPMEmulator
747 * @type: the type of TPM state blob to transfer
748 * @tsb: TPMSizedBuffer containing the TPM state blob
749 * @flags: Flags describing the (encryption) state of the TPM state blob
751 static int tpm_emulator_set_state_blob(TPMEmulator
*tpm_emu
,
760 if (tsb
->size
== 0) {
764 pss
= (ptm_setstate
) {
765 .u
.req
.state_flags
= cpu_to_be32(flags
),
766 .u
.req
.type
= cpu_to_be32(type
),
767 .u
.req
.length
= cpu_to_be32(tsb
->size
),
770 /* write the header only */
771 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SET_STATEBLOB
, &pss
,
772 offsetof(ptm_setstate
, u
.req
.data
), 0) < 0) {
773 error_report("tpm-emulator: could not set state blob type %d : %s",
774 type
, strerror(errno
));
779 n
= qemu_chr_fe_write_all(&tpm_emu
->ctrl_chr
, tsb
->buffer
, tsb
->size
);
780 if (n
!= tsb
->size
) {
781 error_report("tpm-emulator: Writing the stateblob (type %d) "
782 "failed; could not write %u bytes, but only %zd",
787 /* now get the result */
788 n
= qemu_chr_fe_read_all(&tpm_emu
->ctrl_chr
,
789 (uint8_t *)&pss
, sizeof(pss
.u
.resp
));
790 if (n
!= sizeof(pss
.u
.resp
)) {
791 error_report("tpm-emulator: Reading response from writing stateblob "
792 "(type %d) failed; expected %zu bytes, got %zd", type
,
793 sizeof(pss
.u
.resp
), n
);
797 tpm_result
= be32_to_cpu(pss
.u
.resp
.tpm_result
);
798 if (tpm_result
!= 0) {
799 error_report("tpm-emulator: Setting the stateblob (type %d) failed "
800 "with a TPM error 0x%x %s", type
, tpm_result
,
801 tpm_emulator_strerror(tpm_result
));
805 trace_tpm_emulator_set_state_blob(type
, tsb
->size
, flags
);
811 * Set all the TPM state blobs.
813 * Returns a negative errno code in case of error.
815 static int tpm_emulator_set_state_blobs(TPMBackend
*tb
)
817 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
818 TPMBlobBuffers
*state_blobs
= &tpm_emu
->state_blobs
;
820 trace_tpm_emulator_set_state_blobs();
822 if (tpm_emulator_stop_tpm(tb
) < 0) {
823 trace_tpm_emulator_set_state_blobs_error("Could not stop TPM");
827 if (tpm_emulator_set_state_blob(tpm_emu
, PTM_BLOB_TYPE_PERMANENT
,
828 &state_blobs
->permanent
,
829 state_blobs
->permanent_flags
) < 0 ||
830 tpm_emulator_set_state_blob(tpm_emu
, PTM_BLOB_TYPE_VOLATILE
,
831 &state_blobs
->volatil
,
832 state_blobs
->volatil_flags
) < 0 ||
833 tpm_emulator_set_state_blob(tpm_emu
, PTM_BLOB_TYPE_SAVESTATE
,
834 &state_blobs
->savestate
,
835 state_blobs
->savestate_flags
) < 0) {
839 trace_tpm_emulator_set_state_blobs_done();
844 static int tpm_emulator_pre_save(void *opaque
)
846 TPMBackend
*tb
= opaque
;
847 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
849 trace_tpm_emulator_pre_save();
851 tpm_backend_finish_sync(tb
);
853 /* get the state blobs from the TPM */
854 return tpm_emulator_get_state_blobs(tpm_emu
);
858 * Load the TPM state blobs into the TPM.
860 * Returns negative errno codes in case of error.
862 static int tpm_emulator_post_load(void *opaque
, int version_id
)
864 TPMBackend
*tb
= opaque
;
867 ret
= tpm_emulator_set_state_blobs(tb
);
872 if (tpm_emulator_startup_tpm_resume(tb
, 0, true) < 0) {
879 static const VMStateDescription vmstate_tpm_emulator
= {
880 .name
= "tpm-emulator",
882 .pre_save
= tpm_emulator_pre_save
,
883 .post_load
= tpm_emulator_post_load
,
884 .fields
= (VMStateField
[]) {
885 VMSTATE_UINT32(state_blobs
.permanent_flags
, TPMEmulator
),
886 VMSTATE_UINT32(state_blobs
.permanent
.size
, TPMEmulator
),
887 VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs
.permanent
.buffer
,
889 state_blobs
.permanent
.size
),
891 VMSTATE_UINT32(state_blobs
.volatil_flags
, TPMEmulator
),
892 VMSTATE_UINT32(state_blobs
.volatil
.size
, TPMEmulator
),
893 VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs
.volatil
.buffer
,
895 state_blobs
.volatil
.size
),
897 VMSTATE_UINT32(state_blobs
.savestate_flags
, TPMEmulator
),
898 VMSTATE_UINT32(state_blobs
.savestate
.size
, TPMEmulator
),
899 VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs
.savestate
.buffer
,
901 state_blobs
.savestate
.size
),
903 VMSTATE_END_OF_LIST()
907 static void tpm_emulator_inst_init(Object
*obj
)
909 TPMEmulator
*tpm_emu
= TPM_EMULATOR(obj
);
911 trace_tpm_emulator_inst_init();
913 tpm_emu
->options
= g_new0(TPMEmulatorOptions
, 1);
914 tpm_emu
->cur_locty_number
= ~0;
915 qemu_mutex_init(&tpm_emu
->mutex
);
917 vmstate_register(NULL
, -1, &vmstate_tpm_emulator
, obj
);
921 * Gracefully shut down the external TPM
923 static void tpm_emulator_shutdown(TPMEmulator
*tpm_emu
)
927 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SHUTDOWN
, &res
, 0, sizeof(res
)) < 0) {
928 error_report("tpm-emulator: Could not cleanly shutdown the TPM: %s",
930 } else if (res
!= 0) {
931 error_report("tpm-emulator: TPM result for shutdown: 0x%x %s",
932 be32_to_cpu(res
), tpm_emulator_strerror(be32_to_cpu(res
)));
936 static void tpm_emulator_inst_finalize(Object
*obj
)
938 TPMEmulator
*tpm_emu
= TPM_EMULATOR(obj
);
939 TPMBlobBuffers
*state_blobs
= &tpm_emu
->state_blobs
;
941 tpm_emulator_shutdown(tpm_emu
);
943 object_unref(OBJECT(tpm_emu
->data_ioc
));
945 qemu_chr_fe_deinit(&tpm_emu
->ctrl_chr
, false);
947 qapi_free_TPMEmulatorOptions(tpm_emu
->options
);
949 if (tpm_emu
->migration_blocker
) {
950 migrate_del_blocker(tpm_emu
->migration_blocker
);
951 error_free(tpm_emu
->migration_blocker
);
954 tpm_sized_buffer_reset(&state_blobs
->volatil
);
955 tpm_sized_buffer_reset(&state_blobs
->permanent
);
956 tpm_sized_buffer_reset(&state_blobs
->savestate
);
958 qemu_mutex_destroy(&tpm_emu
->mutex
);
960 vmstate_unregister(NULL
, &vmstate_tpm_emulator
, obj
);
963 static void tpm_emulator_class_init(ObjectClass
*klass
, void *data
)
965 TPMBackendClass
*tbc
= TPM_BACKEND_CLASS(klass
);
967 tbc
->type
= TPM_TYPE_EMULATOR
;
968 tbc
->opts
= tpm_emulator_cmdline_opts
;
969 tbc
->desc
= "TPM emulator backend driver";
970 tbc
->create
= tpm_emulator_create
;
971 tbc
->startup_tpm
= tpm_emulator_startup_tpm
;
972 tbc
->cancel_cmd
= tpm_emulator_cancel_cmd
;
973 tbc
->get_tpm_established_flag
= tpm_emulator_get_tpm_established_flag
;
974 tbc
->reset_tpm_established_flag
= tpm_emulator_reset_tpm_established_flag
;
975 tbc
->get_tpm_version
= tpm_emulator_get_tpm_version
;
976 tbc
->get_buffer_size
= tpm_emulator_get_buffer_size
;
977 tbc
->get_tpm_options
= tpm_emulator_get_tpm_options
;
979 tbc
->handle_request
= tpm_emulator_handle_request
;
982 static const TypeInfo tpm_emulator_info
= {
983 .name
= TYPE_TPM_EMULATOR
,
984 .parent
= TYPE_TPM_BACKEND
,
985 .instance_size
= sizeof(TPMEmulator
),
986 .class_init
= tpm_emulator_class_init
,
987 .instance_init
= tpm_emulator_inst_init
,
988 .instance_finalize
= tpm_emulator_inst_finalize
,
991 static void tpm_emulator_register(void)
993 type_register_static(&tpm_emulator_info
);
996 type_init(tpm_emulator_register
)