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.1 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 "qemu/lockable.h"
34 #include "io/channel-socket.h"
35 #include "sysemu/runstate.h"
36 #include "sysemu/tpm_backend.h"
37 #include "sysemu/tpm_util.h"
39 #include "tpm_ioctl.h"
40 #include "migration/blocker.h"
41 #include "migration/vmstate.h"
42 #include "qapi/error.h"
43 #include "qapi/clone-visitor.h"
44 #include "qapi/qapi-visit-tpm.h"
45 #include "chardev/char-fe.h"
47 #include "qom/object.h"
49 #define TYPE_TPM_EMULATOR "tpm-emulator"
50 OBJECT_DECLARE_SIMPLE_TYPE(TPMEmulator
, TPM_EMULATOR
)
52 #define TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(S, cap) (((S)->caps & (cap)) == (cap))
56 /* blobs from the TPM; part of VM state when migrating */
57 typedef struct TPMBlobBuffers
{
58 uint32_t permanent_flags
;
59 TPMSizedBuffer permanent
;
61 uint32_t volatil_flags
;
62 TPMSizedBuffer volatil
;
64 uint32_t savestate_flags
;
65 TPMSizedBuffer savestate
;
71 TPMEmulatorOptions
*options
;
74 TPMVersion tpm_version
;
75 ptm_cap caps
; /* capabilities of the TPM */
76 uint8_t cur_locty_number
; /* last set locality */
77 Error
*migration_blocker
;
81 unsigned int established_flag
:1;
82 unsigned int established_flag_cached
:1;
84 TPMBlobBuffers state_blobs
;
87 VMChangeStateEntry
*vmstate
;
95 static const struct tpm_error tpm_errors
[] = {
96 /* TPM 1.2 error codes */
97 { TPM_BAD_PARAMETER
, "a parameter is bad" },
98 { TPM_FAIL
, "operation failed" },
99 { TPM_KEYNOTFOUND
, "key could not be found" },
100 { TPM_BAD_PARAM_SIZE
, "bad parameter size"},
101 { TPM_ENCRYPT_ERROR
, "encryption error" },
102 { TPM_DECRYPT_ERROR
, "decryption error" },
103 { TPM_BAD_KEY_PROPERTY
, "bad key property" },
104 { TPM_BAD_MODE
, "bad (encryption) mode" },
105 { TPM_BAD_VERSION
, "bad version identifier" },
106 { TPM_BAD_LOCALITY
, "bad locality" },
107 /* TPM 2 error codes */
108 { TPM_RC_FAILURE
, "operation failed" },
109 { TPM_RC_LOCALITY
, "bad locality" },
110 { TPM_RC_INSUFFICIENT
, "insufficient amount of data" },
113 static const char *tpm_emulator_strerror(uint32_t tpm_result
)
117 for (i
= 0; i
< ARRAY_SIZE(tpm_errors
); i
++) {
118 if (tpm_errors
[i
].tpm_result
== tpm_result
) {
119 return tpm_errors
[i
].string
;
125 static int tpm_emulator_ctrlcmd(TPMEmulator
*tpm
, unsigned long cmd
, void *msg
,
126 size_t msg_len_in
, size_t msg_len_out
)
128 CharBackend
*dev
= &tpm
->ctrl_chr
;
129 uint32_t cmd_no
= cpu_to_be32(cmd
);
130 ssize_t n
= sizeof(uint32_t) + msg_len_in
;
133 WITH_QEMU_LOCK_GUARD(&tpm
->mutex
) {
135 memcpy(buf
, &cmd_no
, sizeof(cmd_no
));
136 memcpy(buf
+ sizeof(cmd_no
), msg
, msg_len_in
);
138 n
= qemu_chr_fe_write_all(dev
, buf
, n
);
143 if (msg_len_out
!= 0) {
144 n
= qemu_chr_fe_read_all(dev
, msg
, msg_len_out
);
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
, errp
);
173 ret
= qio_channel_read_all(tpm_emu
->data_ioc
, (char *)out
,
174 sizeof(struct tpm_resp_hdr
), errp
);
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
), errp
);
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_lock_storage(TPMEmulator
*tpm_emu
)
313 if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu
, PTM_CAP_LOCK_STORAGE
)) {
314 trace_tpm_emulator_lock_storage_cmd_not_supt();
318 /* give failing side 300 * 10ms time to release lock */
319 pls
.u
.req
.retries
= cpu_to_be32(300);
320 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_LOCK_STORAGE
, &pls
,
321 sizeof(pls
.u
.req
), sizeof(pls
.u
.resp
)) < 0) {
322 error_report("tpm-emulator: Could not lock storage within 3 seconds: "
323 "%s", strerror(errno
));
327 pls
.u
.resp
.tpm_result
= be32_to_cpu(pls
.u
.resp
.tpm_result
);
328 if (pls
.u
.resp
.tpm_result
!= 0) {
329 error_report("tpm-emulator: TPM result for CMD_LOCK_STORAGE: 0x%x %s",
330 pls
.u
.resp
.tpm_result
,
331 tpm_emulator_strerror(pls
.u
.resp
.tpm_result
));
338 static int tpm_emulator_set_buffer_size(TPMBackend
*tb
,
342 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
343 ptm_setbuffersize psbs
;
345 if (tpm_emulator_stop_tpm(tb
) < 0) {
349 psbs
.u
.req
.buffersize
= cpu_to_be32(wanted_size
);
351 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SET_BUFFERSIZE
, &psbs
,
352 sizeof(psbs
.u
.req
), sizeof(psbs
.u
.resp
)) < 0) {
353 error_report("tpm-emulator: Could not set buffer size: %s",
358 psbs
.u
.resp
.tpm_result
= be32_to_cpu(psbs
.u
.resp
.tpm_result
);
359 if (psbs
.u
.resp
.tpm_result
!= 0) {
360 error_report("tpm-emulator: TPM result for set buffer size : 0x%x %s",
361 psbs
.u
.resp
.tpm_result
,
362 tpm_emulator_strerror(psbs
.u
.resp
.tpm_result
));
367 *actual_size
= be32_to_cpu(psbs
.u
.resp
.buffersize
);
370 trace_tpm_emulator_set_buffer_size(
371 be32_to_cpu(psbs
.u
.resp
.buffersize
),
372 be32_to_cpu(psbs
.u
.resp
.minsize
),
373 be32_to_cpu(psbs
.u
.resp
.maxsize
));
378 static int tpm_emulator_startup_tpm_resume(TPMBackend
*tb
, size_t buffersize
,
381 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
383 .u
.req
.init_flags
= 0,
387 trace_tpm_emulator_startup_tpm_resume(is_resume
, buffersize
);
389 if (buffersize
!= 0 &&
390 tpm_emulator_set_buffer_size(tb
, buffersize
, NULL
) < 0) {
395 init
.u
.req
.init_flags
|= cpu_to_be32(PTM_INIT_FLAG_DELETE_VOLATILE
);
398 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_INIT
, &init
, sizeof(init
),
400 error_report("tpm-emulator: could not send INIT: %s",
405 res
= be32_to_cpu(init
.u
.resp
.tpm_result
);
407 error_report("tpm-emulator: TPM result for CMD_INIT: 0x%x %s", res
,
408 tpm_emulator_strerror(res
));
417 static int tpm_emulator_startup_tpm(TPMBackend
*tb
, size_t buffersize
)
419 /* TPM startup will be done from post_load hook */
420 if (runstate_check(RUN_STATE_INMIGRATE
)) {
421 if (buffersize
!= 0) {
422 return tpm_emulator_set_buffer_size(tb
, buffersize
, NULL
);
428 return tpm_emulator_startup_tpm_resume(tb
, buffersize
, false);
431 static bool tpm_emulator_get_tpm_established_flag(TPMBackend
*tb
)
433 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
436 if (tpm_emu
->established_flag_cached
) {
437 return tpm_emu
->established_flag
;
440 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_GET_TPMESTABLISHED
, &est
,
441 0, sizeof(est
)) < 0) {
442 error_report("tpm-emulator: Could not get the TPM established flag: %s",
446 trace_tpm_emulator_get_tpm_established_flag(est
.u
.resp
.bit
);
448 tpm_emu
->established_flag_cached
= 1;
449 tpm_emu
->established_flag
= (est
.u
.resp
.bit
!= 0);
451 return tpm_emu
->established_flag
;
454 static int tpm_emulator_reset_tpm_established_flag(TPMBackend
*tb
,
457 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
458 ptm_reset_est reset_est
;
461 /* only a TPM 2.0 will support this */
462 if (tpm_emu
->tpm_version
!= TPM_VERSION_2_0
) {
466 reset_est
.u
.req
.loc
= tpm_emu
->cur_locty_number
;
467 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_RESET_TPMESTABLISHED
,
468 &reset_est
, sizeof(reset_est
),
469 sizeof(reset_est
)) < 0) {
470 error_report("tpm-emulator: Could not reset the establishment bit: %s",
475 res
= be32_to_cpu(reset_est
.u
.resp
.tpm_result
);
478 "tpm-emulator: TPM result for rest established flag: 0x%x %s",
479 res
, tpm_emulator_strerror(res
));
483 tpm_emu
->established_flag_cached
= 0;
488 static void tpm_emulator_cancel_cmd(TPMBackend
*tb
)
490 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
493 if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu
, PTM_CAP_CANCEL_TPM_CMD
)) {
494 trace_tpm_emulator_cancel_cmd_not_supt();
498 /* FIXME: make the function non-blocking, or it may block a VCPU */
499 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_CANCEL_TPM_CMD
, &res
, 0,
501 error_report("tpm-emulator: Could not cancel command: %s",
503 } else if (res
!= 0) {
504 error_report("tpm-emulator: Failed to cancel TPM: 0x%x",
509 static TPMVersion
tpm_emulator_get_tpm_version(TPMBackend
*tb
)
511 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
513 return tpm_emu
->tpm_version
;
516 static size_t tpm_emulator_get_buffer_size(TPMBackend
*tb
)
520 if (tpm_emulator_set_buffer_size(tb
, 0, &actual_size
) < 0) {
527 static int tpm_emulator_block_migration(TPMEmulator
*tpm_emu
)
530 ptm_cap caps
= PTM_CAP_GET_STATEBLOB
| PTM_CAP_SET_STATEBLOB
|
533 if (!TPM_EMULATOR_IMPLEMENTS_ALL_CAPS(tpm_emu
, caps
)) {
534 error_setg(&tpm_emu
->migration_blocker
,
535 "Migration disabled: TPM emulator does not support "
537 if (migrate_add_blocker(tpm_emu
->migration_blocker
, &err
) < 0) {
538 error_report_err(err
);
539 error_free(tpm_emu
->migration_blocker
);
540 tpm_emu
->migration_blocker
= NULL
;
549 static int tpm_emulator_prepare_data_fd(TPMEmulator
*tpm_emu
)
553 int fds
[2] = { -1, -1 };
555 if (qemu_socketpair(AF_UNIX
, SOCK_STREAM
, 0, fds
) < 0) {
556 error_report("tpm-emulator: Failed to create socketpair");
560 qemu_chr_fe_set_msgfds(&tpm_emu
->ctrl_chr
, fds
+ 1, 1);
562 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SET_DATAFD
, &res
, 0,
563 sizeof(res
)) < 0 || res
!= 0) {
564 error_report("tpm-emulator: Failed to send CMD_SET_DATAFD: %s",
569 tpm_emu
->data_ioc
= QIO_CHANNEL(qio_channel_socket_new_fd(fds
[0], &err
));
571 error_prepend(&err
, "tpm-emulator: Failed to create io channel: ");
572 error_report_err(err
);
586 static int tpm_emulator_handle_device_opts(TPMEmulator
*tpm_emu
, QemuOpts
*opts
)
592 value
= qemu_opt_get(opts
, "chardev");
594 error_report("tpm-emulator: parameter 'chardev' is missing");
598 dev
= qemu_chr_find(value
);
600 error_report("tpm-emulator: tpm chardev '%s' not found", value
);
604 if (!qemu_chr_fe_init(&tpm_emu
->ctrl_chr
, dev
, &err
)) {
605 error_prepend(&err
, "tpm-emulator: No valid chardev found at '%s':",
607 error_report_err(err
);
611 tpm_emu
->options
->chardev
= g_strdup(value
);
613 if (tpm_emulator_prepare_data_fd(tpm_emu
) < 0) {
617 /* FIXME: tpm_util_test_tpmdev() accepts only on socket fd, as it also used
618 * by passthrough driver, which not yet using GIOChannel.
620 if (tpm_util_test_tpmdev(QIO_CHANNEL_SOCKET(tpm_emu
->data_ioc
)->fd
,
621 &tpm_emu
->tpm_version
)) {
622 error_report("'%s' is not emulating TPM device. Error: %s",
623 tpm_emu
->options
->chardev
, strerror(errno
));
627 switch (tpm_emu
->tpm_version
) {
628 case TPM_VERSION_1_2
:
629 trace_tpm_emulator_handle_device_opts_tpm12();
631 case TPM_VERSION_2_0
:
632 trace_tpm_emulator_handle_device_opts_tpm2();
635 trace_tpm_emulator_handle_device_opts_unspec();
638 if (tpm_emulator_probe_caps(tpm_emu
) ||
639 tpm_emulator_check_caps(tpm_emu
)) {
643 return tpm_emulator_block_migration(tpm_emu
);
646 trace_tpm_emulator_handle_device_opts_startup_error();
651 static TPMBackend
*tpm_emulator_create(QemuOpts
*opts
)
653 TPMBackend
*tb
= TPM_BACKEND(object_new(TYPE_TPM_EMULATOR
));
655 if (tpm_emulator_handle_device_opts(TPM_EMULATOR(tb
), opts
)) {
656 object_unref(OBJECT(tb
));
663 static TpmTypeOptions
*tpm_emulator_get_tpm_options(TPMBackend
*tb
)
665 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
666 TpmTypeOptions
*options
= g_new0(TpmTypeOptions
, 1);
668 options
->type
= TPM_TYPE_EMULATOR
;
669 options
->u
.emulator
.data
= QAPI_CLONE(TPMEmulatorOptions
, tpm_emu
->options
);
674 static const QemuOptDesc tpm_emulator_cmdline_opts
[] = {
675 TPM_STANDARD_CMDLINE_OPTS
,
678 .type
= QEMU_OPT_STRING
,
679 .help
= "Character device to use for out-of-band control messages",
681 { /* end of list */ },
685 * Transfer a TPM state blob from the TPM into a provided buffer.
687 * @tpm_emu: TPMEmulator
688 * @type: the type of blob to transfer
689 * @tsb: the TPMSizeBuffer to fill with the blob
690 * @flags: the flags to return to the caller
692 static int tpm_emulator_get_state_blob(TPMEmulator
*tpm_emu
,
700 uint32_t totlength
, length
;
702 tpm_sized_buffer_reset(tsb
);
704 pgs
.u
.req
.state_flags
= cpu_to_be32(PTM_STATE_FLAG_DECRYPTED
);
705 pgs
.u
.req
.type
= cpu_to_be32(type
);
706 pgs
.u
.req
.offset
= 0;
708 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_GET_STATEBLOB
,
709 &pgs
, sizeof(pgs
.u
.req
),
710 offsetof(ptm_getstate
, u
.resp
.data
)) < 0) {
711 error_report("tpm-emulator: could not get state blob type %d : %s",
712 type
, strerror(errno
));
716 res
= be32_to_cpu(pgs
.u
.resp
.tpm_result
);
717 if (res
!= 0 && (res
& 0x800) == 0) {
718 error_report("tpm-emulator: Getting the stateblob (type %d) failed "
719 "with a TPM error 0x%x %s", type
, res
,
720 tpm_emulator_strerror(res
));
724 totlength
= be32_to_cpu(pgs
.u
.resp
.totlength
);
725 length
= be32_to_cpu(pgs
.u
.resp
.length
);
726 if (totlength
!= length
) {
727 error_report("tpm-emulator: Expecting to read %u bytes "
728 "but would get %u", totlength
, length
);
732 *flags
= be32_to_cpu(pgs
.u
.resp
.state_flags
);
735 tsb
->buffer
= g_try_malloc(totlength
);
737 error_report("tpm-emulator: Out of memory allocating %u bytes",
742 n
= qemu_chr_fe_read_all(&tpm_emu
->ctrl_chr
, tsb
->buffer
, totlength
);
743 if (n
!= totlength
) {
744 error_report("tpm-emulator: Could not read stateblob (type %d); "
745 "expected %u bytes, got %zd",
750 tsb
->size
= totlength
;
752 trace_tpm_emulator_get_state_blob(type
, tsb
->size
, *flags
);
757 static int tpm_emulator_get_state_blobs(TPMEmulator
*tpm_emu
)
759 TPMBlobBuffers
*state_blobs
= &tpm_emu
->state_blobs
;
761 if (tpm_emulator_get_state_blob(tpm_emu
, PTM_BLOB_TYPE_PERMANENT
,
762 &state_blobs
->permanent
,
763 &state_blobs
->permanent_flags
) < 0 ||
764 tpm_emulator_get_state_blob(tpm_emu
, PTM_BLOB_TYPE_VOLATILE
,
765 &state_blobs
->volatil
,
766 &state_blobs
->volatil_flags
) < 0 ||
767 tpm_emulator_get_state_blob(tpm_emu
, PTM_BLOB_TYPE_SAVESTATE
,
768 &state_blobs
->savestate
,
769 &state_blobs
->savestate_flags
) < 0) {
776 tpm_sized_buffer_reset(&state_blobs
->volatil
);
777 tpm_sized_buffer_reset(&state_blobs
->permanent
);
778 tpm_sized_buffer_reset(&state_blobs
->savestate
);
784 * Transfer a TPM state blob to the TPM emulator.
786 * @tpm_emu: TPMEmulator
787 * @type: the type of TPM state blob to transfer
788 * @tsb: TPMSizedBuffer containing the TPM state blob
789 * @flags: Flags describing the (encryption) state of the TPM state blob
791 static int tpm_emulator_set_state_blob(TPMEmulator
*tpm_emu
,
800 if (tsb
->size
== 0) {
804 pss
= (ptm_setstate
) {
805 .u
.req
.state_flags
= cpu_to_be32(flags
),
806 .u
.req
.type
= cpu_to_be32(type
),
807 .u
.req
.length
= cpu_to_be32(tsb
->size
),
810 /* write the header only */
811 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SET_STATEBLOB
, &pss
,
812 offsetof(ptm_setstate
, u
.req
.data
), 0) < 0) {
813 error_report("tpm-emulator: could not set state blob type %d : %s",
814 type
, strerror(errno
));
819 n
= qemu_chr_fe_write_all(&tpm_emu
->ctrl_chr
, tsb
->buffer
, tsb
->size
);
820 if (n
!= tsb
->size
) {
821 error_report("tpm-emulator: Writing the stateblob (type %d) "
822 "failed; could not write %u bytes, but only %zd",
827 /* now get the result */
828 n
= qemu_chr_fe_read_all(&tpm_emu
->ctrl_chr
,
829 (uint8_t *)&pss
, sizeof(pss
.u
.resp
));
830 if (n
!= sizeof(pss
.u
.resp
)) {
831 error_report("tpm-emulator: Reading response from writing stateblob "
832 "(type %d) failed; expected %zu bytes, got %zd", type
,
833 sizeof(pss
.u
.resp
), n
);
837 tpm_result
= be32_to_cpu(pss
.u
.resp
.tpm_result
);
838 if (tpm_result
!= 0) {
839 error_report("tpm-emulator: Setting the stateblob (type %d) failed "
840 "with a TPM error 0x%x %s", type
, tpm_result
,
841 tpm_emulator_strerror(tpm_result
));
845 trace_tpm_emulator_set_state_blob(type
, tsb
->size
, flags
);
851 * Set all the TPM state blobs.
853 * Returns a negative errno code in case of error.
855 static int tpm_emulator_set_state_blobs(TPMBackend
*tb
)
857 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
858 TPMBlobBuffers
*state_blobs
= &tpm_emu
->state_blobs
;
860 trace_tpm_emulator_set_state_blobs();
862 if (tpm_emulator_stop_tpm(tb
) < 0) {
863 trace_tpm_emulator_set_state_blobs_error("Could not stop TPM");
867 if (tpm_emulator_set_state_blob(tpm_emu
, PTM_BLOB_TYPE_PERMANENT
,
868 &state_blobs
->permanent
,
869 state_blobs
->permanent_flags
) < 0 ||
870 tpm_emulator_set_state_blob(tpm_emu
, PTM_BLOB_TYPE_VOLATILE
,
871 &state_blobs
->volatil
,
872 state_blobs
->volatil_flags
) < 0 ||
873 tpm_emulator_set_state_blob(tpm_emu
, PTM_BLOB_TYPE_SAVESTATE
,
874 &state_blobs
->savestate
,
875 state_blobs
->savestate_flags
) < 0) {
879 trace_tpm_emulator_set_state_blobs_done();
884 static int tpm_emulator_pre_save(void *opaque
)
886 TPMBackend
*tb
= opaque
;
887 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
890 trace_tpm_emulator_pre_save();
892 tpm_backend_finish_sync(tb
);
894 /* get the state blobs from the TPM */
895 ret
= tpm_emulator_get_state_blobs(tpm_emu
);
897 tpm_emu
->relock_storage
= ret
== 0;
902 static void tpm_emulator_vm_state_change(void *opaque
, bool running
,
905 TPMBackend
*tb
= opaque
;
906 TPMEmulator
*tpm_emu
= TPM_EMULATOR(tb
);
908 trace_tpm_emulator_vm_state_change(running
, state
);
910 if (!running
|| state
!= RUN_STATE_RUNNING
|| !tpm_emu
->relock_storage
) {
914 /* lock storage after migration fall-back */
915 tpm_emulator_lock_storage(tpm_emu
);
919 * Load the TPM state blobs into the TPM.
921 * Returns negative errno codes in case of error.
923 static int tpm_emulator_post_load(void *opaque
, int version_id
)
925 TPMBackend
*tb
= opaque
;
928 ret
= tpm_emulator_set_state_blobs(tb
);
933 if (tpm_emulator_startup_tpm_resume(tb
, 0, true) < 0) {
940 static const VMStateDescription vmstate_tpm_emulator
= {
941 .name
= "tpm-emulator",
943 .pre_save
= tpm_emulator_pre_save
,
944 .post_load
= tpm_emulator_post_load
,
945 .fields
= (VMStateField
[]) {
946 VMSTATE_UINT32(state_blobs
.permanent_flags
, TPMEmulator
),
947 VMSTATE_UINT32(state_blobs
.permanent
.size
, TPMEmulator
),
948 VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs
.permanent
.buffer
,
950 state_blobs
.permanent
.size
),
952 VMSTATE_UINT32(state_blobs
.volatil_flags
, TPMEmulator
),
953 VMSTATE_UINT32(state_blobs
.volatil
.size
, TPMEmulator
),
954 VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs
.volatil
.buffer
,
956 state_blobs
.volatil
.size
),
958 VMSTATE_UINT32(state_blobs
.savestate_flags
, TPMEmulator
),
959 VMSTATE_UINT32(state_blobs
.savestate
.size
, TPMEmulator
),
960 VMSTATE_VBUFFER_ALLOC_UINT32(state_blobs
.savestate
.buffer
,
962 state_blobs
.savestate
.size
),
964 VMSTATE_END_OF_LIST()
968 static void tpm_emulator_inst_init(Object
*obj
)
970 TPMEmulator
*tpm_emu
= TPM_EMULATOR(obj
);
972 trace_tpm_emulator_inst_init();
974 tpm_emu
->options
= g_new0(TPMEmulatorOptions
, 1);
975 tpm_emu
->cur_locty_number
= ~0;
976 qemu_mutex_init(&tpm_emu
->mutex
);
978 qemu_add_vm_change_state_handler(tpm_emulator_vm_state_change
,
981 vmstate_register(NULL
, VMSTATE_INSTANCE_ID_ANY
,
982 &vmstate_tpm_emulator
, obj
);
986 * Gracefully shut down the external TPM
988 static void tpm_emulator_shutdown(TPMEmulator
*tpm_emu
)
992 if (!tpm_emu
->options
->chardev
) {
993 /* was never properly initialized */
997 if (tpm_emulator_ctrlcmd(tpm_emu
, CMD_SHUTDOWN
, &res
, 0, sizeof(res
)) < 0) {
998 error_report("tpm-emulator: Could not cleanly shutdown the TPM: %s",
1000 } else if (res
!= 0) {
1001 error_report("tpm-emulator: TPM result for shutdown: 0x%x %s",
1002 be32_to_cpu(res
), tpm_emulator_strerror(be32_to_cpu(res
)));
1006 static void tpm_emulator_inst_finalize(Object
*obj
)
1008 TPMEmulator
*tpm_emu
= TPM_EMULATOR(obj
);
1009 TPMBlobBuffers
*state_blobs
= &tpm_emu
->state_blobs
;
1011 tpm_emulator_shutdown(tpm_emu
);
1013 object_unref(OBJECT(tpm_emu
->data_ioc
));
1015 qemu_chr_fe_deinit(&tpm_emu
->ctrl_chr
, false);
1017 qapi_free_TPMEmulatorOptions(tpm_emu
->options
);
1019 if (tpm_emu
->migration_blocker
) {
1020 migrate_del_blocker(tpm_emu
->migration_blocker
);
1021 error_free(tpm_emu
->migration_blocker
);
1024 tpm_sized_buffer_reset(&state_blobs
->volatil
);
1025 tpm_sized_buffer_reset(&state_blobs
->permanent
);
1026 tpm_sized_buffer_reset(&state_blobs
->savestate
);
1028 qemu_mutex_destroy(&tpm_emu
->mutex
);
1029 qemu_del_vm_change_state_handler(tpm_emu
->vmstate
);
1031 vmstate_unregister(NULL
, &vmstate_tpm_emulator
, obj
);
1034 static void tpm_emulator_class_init(ObjectClass
*klass
, void *data
)
1036 TPMBackendClass
*tbc
= TPM_BACKEND_CLASS(klass
);
1038 tbc
->type
= TPM_TYPE_EMULATOR
;
1039 tbc
->opts
= tpm_emulator_cmdline_opts
;
1040 tbc
->desc
= "TPM emulator backend driver";
1041 tbc
->create
= tpm_emulator_create
;
1042 tbc
->startup_tpm
= tpm_emulator_startup_tpm
;
1043 tbc
->cancel_cmd
= tpm_emulator_cancel_cmd
;
1044 tbc
->get_tpm_established_flag
= tpm_emulator_get_tpm_established_flag
;
1045 tbc
->reset_tpm_established_flag
= tpm_emulator_reset_tpm_established_flag
;
1046 tbc
->get_tpm_version
= tpm_emulator_get_tpm_version
;
1047 tbc
->get_buffer_size
= tpm_emulator_get_buffer_size
;
1048 tbc
->get_tpm_options
= tpm_emulator_get_tpm_options
;
1050 tbc
->handle_request
= tpm_emulator_handle_request
;
1053 static const TypeInfo tpm_emulator_info
= {
1054 .name
= TYPE_TPM_EMULATOR
,
1055 .parent
= TYPE_TPM_BACKEND
,
1056 .instance_size
= sizeof(TPMEmulator
),
1057 .class_init
= tpm_emulator_class_init
,
1058 .instance_init
= tpm_emulator_inst_init
,
1059 .instance_finalize
= tpm_emulator_inst_finalize
,
1062 static void tpm_emulator_register(void)
1064 type_register_static(&tpm_emulator_info
);
1067 type_init(tpm_emulator_register
)