]>
Commit | Line | Data |
---|---|---|
4549a8b7 SB |
1 | /* |
2 | * passthrough TPM driver | |
3 | * | |
4 | * Copyright (c) 2010 - 2013 IBM Corporation | |
5 | * Authors: | |
6 | * Stefan Berger <stefanb@us.ibm.com> | |
7 | * | |
8 | * Copyright (C) 2011 IAIK, Graz University of Technology | |
9 | * Author: Andreas Niederl | |
10 | * | |
11 | * This library is free software; you can redistribute it and/or | |
12 | * modify it under the terms of the GNU Lesser General Public | |
13 | * License as published by the Free Software Foundation; either | |
14 | * version 2 of the License, or (at your option) any later version. | |
15 | * | |
16 | * This library is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
19 | * Lesser General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU Lesser General Public | |
22 | * License along with this library; if not, see <http://www.gnu.org/licenses/> | |
23 | */ | |
24 | ||
0430891c | 25 | #include "qemu/osdep.h" |
a8d25326 | 26 | #include "qemu-common.h" |
d49b6836 | 27 | #include "qemu/error-report.h" |
0b8fa32f | 28 | #include "qemu/module.h" |
4549a8b7 | 29 | #include "qemu/sockets.h" |
dccfcd0e | 30 | #include "sysemu/tpm_backend.h" |
0f7d2148 | 31 | #include "sysemu/tpm_util.h" |
4549a8b7 | 32 | #include "tpm_int.h" |
f59864ba | 33 | #include "qapi/clone-visitor.h" |
9af23989 | 34 | #include "qapi/qapi-visit-tpm.h" |
49d302fe | 35 | #include "trace.h" |
db1015e9 | 36 | #include "qom/object.h" |
4549a8b7 | 37 | |
8f0605cc | 38 | #define TYPE_TPM_PASSTHROUGH "tpm-passthrough" |
8063396b | 39 | OBJECT_DECLARE_SIMPLE_TYPE(TPMPassthruState, TPM_PASSTHROUGH) |
4549a8b7 | 40 | |
8f0605cc | 41 | /* data structures */ |
4549a8b7 | 42 | struct TPMPassthruState { |
8f0605cc SB |
43 | TPMBackend parent; |
44 | ||
f59864ba AV |
45 | TPMPassthroughOptions *options; |
46 | const char *tpm_dev; | |
4549a8b7 | 47 | int tpm_fd; |
92dcc234 SB |
48 | bool tpm_executing; |
49 | bool tpm_op_canceled; | |
50 | int cancel_fd; | |
56a3c24f SB |
51 | |
52 | TPMVersion tpm_version; | |
abc5cda0 | 53 | size_t tpm_buffersize; |
4549a8b7 SB |
54 | }; |
55 | ||
8f0605cc | 56 | |
4549a8b7 SB |
57 | #define TPM_PASSTHROUGH_DEFAULT_DEVICE "/dev/tpm0" |
58 | ||
92dcc234 SB |
59 | /* functions */ |
60 | ||
61 | static void tpm_passthrough_cancel_cmd(TPMBackend *tb); | |
62 | ||
4549a8b7 SB |
63 | static int tpm_passthrough_unix_read(int fd, uint8_t *buf, uint32_t len) |
64 | { | |
46f296cd DB |
65 | int ret; |
66 | reread: | |
67 | ret = read(fd, buf, len); | |
68 | if (ret < 0) { | |
69 | if (errno != EINTR && errno != EAGAIN) { | |
70 | return -1; | |
71 | } | |
72 | goto reread; | |
73 | } | |
74 | return ret; | |
4549a8b7 | 75 | } |
6a8a2354 MAL |
76 | |
77 | static void tpm_passthrough_unix_tx_bufs(TPMPassthruState *tpm_pt, | |
78 | const uint8_t *in, uint32_t in_len, | |
79 | uint8_t *out, uint32_t out_len, | |
80 | bool *selftest_done, Error **errp) | |
4549a8b7 | 81 | { |
4a3d8098 | 82 | ssize_t ret; |
fd859081 | 83 | bool is_selftest; |
4549a8b7 | 84 | |
21cb1e63 | 85 | /* FIXME: protect shared variables or use other sync mechanism */ |
92dcc234 SB |
86 | tpm_pt->tpm_op_canceled = false; |
87 | tpm_pt->tpm_executing = true; | |
fd859081 SB |
88 | *selftest_done = false; |
89 | ||
4a3d8098 | 90 | is_selftest = tpm_util_is_selftest(in, in_len); |
92dcc234 | 91 | |
54aa36d5 | 92 | ret = qemu_write_full(tpm_pt->tpm_fd, in, in_len); |
4549a8b7 | 93 | if (ret != in_len) { |
5f333d79 | 94 | if (!tpm_pt->tpm_op_canceled || errno != ECANCELED) { |
6a8a2354 MAL |
95 | error_setg_errno(errp, errno, "tpm_passthrough: error while " |
96 | "transmitting data to TPM"); | |
92dcc234 | 97 | } |
4549a8b7 SB |
98 | goto err_exit; |
99 | } | |
100 | ||
92dcc234 SB |
101 | tpm_pt->tpm_executing = false; |
102 | ||
103 | ret = tpm_passthrough_unix_read(tpm_pt->tpm_fd, out, out_len); | |
4549a8b7 | 104 | if (ret < 0) { |
5f333d79 | 105 | if (!tpm_pt->tpm_op_canceled || errno != ECANCELED) { |
6a8a2354 MAL |
106 | error_setg_errno(errp, errno, "tpm_passthrough: error while " |
107 | "reading data from TPM"); | |
92dcc234 | 108 | } |
4549a8b7 | 109 | } else if (ret < sizeof(struct tpm_resp_hdr) || |
cc1b6c55 | 110 | tpm_cmd_get_size(out) != ret) { |
4549a8b7 | 111 | ret = -1; |
6a8a2354 MAL |
112 | error_setg_errno(errp, errno, "tpm_passthrough: received invalid " |
113 | "response packet from TPM"); | |
4549a8b7 SB |
114 | } |
115 | ||
fd859081 | 116 | if (is_selftest && (ret >= sizeof(struct tpm_resp_hdr))) { |
cc1b6c55 | 117 | *selftest_done = tpm_cmd_get_errcode(out) == 0; |
fd859081 SB |
118 | } |
119 | ||
4549a8b7 SB |
120 | err_exit: |
121 | if (ret < 0) { | |
4a3d8098 | 122 | tpm_util_write_fatal_error_response(out, out_len); |
4549a8b7 SB |
123 | } |
124 | ||
92dcc234 | 125 | tpm_pt->tpm_executing = false; |
4549a8b7 SB |
126 | } |
127 | ||
6a8a2354 MAL |
128 | static void tpm_passthrough_handle_request(TPMBackend *tb, TPMBackendCmd *cmd, |
129 | Error **errp) | |
4549a8b7 | 130 | { |
b19a5eea | 131 | TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb); |
4549a8b7 | 132 | |
49d302fe | 133 | trace_tpm_passthrough_handle_request(cmd); |
905e78ba | 134 | |
0e43b7e6 | 135 | tpm_passthrough_unix_tx_bufs(tpm_pt, cmd->in, cmd->in_len, |
6a8a2354 MAL |
136 | cmd->out, cmd->out_len, &cmd->selftest_done, |
137 | errp); | |
4549a8b7 SB |
138 | } |
139 | ||
4549a8b7 SB |
140 | static void tpm_passthrough_reset(TPMBackend *tb) |
141 | { | |
49d302fe | 142 | trace_tpm_passthrough_reset(); |
4549a8b7 | 143 | |
92dcc234 | 144 | tpm_passthrough_cancel_cmd(tb); |
4549a8b7 SB |
145 | } |
146 | ||
147 | static bool tpm_passthrough_get_tpm_established_flag(TPMBackend *tb) | |
148 | { | |
149 | return false; | |
150 | } | |
151 | ||
116694c3 SB |
152 | static int tpm_passthrough_reset_tpm_established_flag(TPMBackend *tb, |
153 | uint8_t locty) | |
154 | { | |
155 | /* only a TPM 2.0 will support this */ | |
156 | return 0; | |
157 | } | |
158 | ||
4549a8b7 SB |
159 | static void tpm_passthrough_cancel_cmd(TPMBackend *tb) |
160 | { | |
8f0605cc | 161 | TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb); |
92dcc234 SB |
162 | int n; |
163 | ||
164 | /* | |
165 | * As of Linux 3.7 the tpm_tis driver does not properly cancel | |
166 | * commands on all TPM manufacturers' TPMs. | |
167 | * Only cancel if we're busy so we don't cancel someone else's | |
168 | * command, e.g., a command executed on the host. | |
169 | */ | |
170 | if (tpm_pt->tpm_executing) { | |
171 | if (tpm_pt->cancel_fd >= 0) { | |
21cb1e63 | 172 | tpm_pt->tpm_op_canceled = true; |
92dcc234 SB |
173 | n = write(tpm_pt->cancel_fd, "-", 1); |
174 | if (n != 1) { | |
27215a22 | 175 | error_report("Canceling TPM command failed: %s", |
92dcc234 | 176 | strerror(errno)); |
92dcc234 SB |
177 | } |
178 | } else { | |
179 | error_report("Cannot cancel TPM command due to missing " | |
180 | "TPM sysfs cancel entry"); | |
181 | } | |
182 | } | |
4549a8b7 SB |
183 | } |
184 | ||
116694c3 SB |
185 | static TPMVersion tpm_passthrough_get_tpm_version(TPMBackend *tb) |
186 | { | |
56a3c24f | 187 | TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb); |
4549a8b7 | 188 | |
56a3c24f | 189 | return tpm_pt->tpm_version; |
4549a8b7 SB |
190 | } |
191 | ||
b21e6aaf SB |
192 | static size_t tpm_passthrough_get_buffer_size(TPMBackend *tb) |
193 | { | |
abc5cda0 SB |
194 | TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb); |
195 | int ret; | |
196 | ||
197 | ret = tpm_util_get_buffer_size(tpm_pt->tpm_fd, tpm_pt->tpm_version, | |
198 | &tpm_pt->tpm_buffersize); | |
199 | if (ret < 0) { | |
200 | tpm_pt->tpm_buffersize = 4096; | |
201 | } | |
202 | return tpm_pt->tpm_buffersize; | |
b21e6aaf SB |
203 | } |
204 | ||
92dcc234 SB |
205 | /* |
206 | * Unless path or file descriptor set has been provided by user, | |
207 | * determine the sysfs cancel file following kernel documentation | |
208 | * in Documentation/ABI/stable/sysfs-class-tpm. | |
05b71fb2 MAL |
209 | * From /dev/tpm0 create /sys/class/tpm/tpm0/device/cancel |
210 | * before 4.0: /sys/class/misc/tpm0/device/cancel | |
92dcc234 | 211 | */ |
f59864ba | 212 | static int tpm_passthrough_open_sysfs_cancel(TPMPassthruState *tpm_pt) |
92dcc234 SB |
213 | { |
214 | int fd = -1; | |
8e36d6ca | 215 | char *dev; |
92dcc234 | 216 | char path[PATH_MAX]; |
92dcc234 | 217 | |
f59864ba | 218 | if (tpm_pt->options->cancel_path) { |
448058aa | 219 | fd = qemu_open_old(tpm_pt->options->cancel_path, O_WRONLY); |
92dcc234 | 220 | if (fd < 0) { |
05b71fb2 | 221 | error_report("tpm_passthrough: Could not open TPM cancel path: %s", |
92dcc234 SB |
222 | strerror(errno)); |
223 | } | |
224 | return fd; | |
225 | } | |
226 | ||
8e36d6ca | 227 | dev = strrchr(tpm_pt->tpm_dev, '/'); |
05b71fb2 MAL |
228 | if (!dev) { |
229 | error_report("tpm_passthrough: Bad TPM device path %s", | |
230 | tpm_pt->tpm_dev); | |
231 | return -1; | |
232 | } | |
233 | ||
234 | dev++; | |
235 | if (snprintf(path, sizeof(path), "/sys/class/tpm/%s/device/cancel", | |
236 | dev) < sizeof(path)) { | |
448058aa | 237 | fd = qemu_open_old(path, O_WRONLY); |
05b71fb2 MAL |
238 | if (fd < 0) { |
239 | if (snprintf(path, sizeof(path), "/sys/class/misc/%s/device/cancel", | |
240 | dev) < sizeof(path)) { | |
448058aa | 241 | fd = qemu_open_old(path, O_WRONLY); |
8e36d6ca | 242 | } |
92dcc234 | 243 | } |
05b71fb2 MAL |
244 | } |
245 | ||
246 | if (fd < 0) { | |
247 | error_report("tpm_passthrough: Could not guess TPM cancel path"); | |
8e36d6ca | 248 | } else { |
05b71fb2 | 249 | tpm_pt->options->cancel_path = g_strdup(path); |
92dcc234 SB |
250 | } |
251 | ||
252 | return fd; | |
253 | } | |
254 | ||
803de211 MAL |
255 | static int |
256 | tpm_passthrough_handle_device_opts(TPMPassthruState *tpm_pt, QemuOpts *opts) | |
4549a8b7 SB |
257 | { |
258 | const char *value; | |
259 | ||
92dcc234 | 260 | value = qemu_opt_get(opts, "cancel-path"); |
f59864ba AV |
261 | if (value) { |
262 | tpm_pt->options->cancel_path = g_strdup(value); | |
263 | tpm_pt->options->has_cancel_path = true; | |
264 | } | |
92dcc234 | 265 | |
4549a8b7 | 266 | value = qemu_opt_get(opts, "path"); |
f59864ba AV |
267 | if (value) { |
268 | tpm_pt->options->has_path = true; | |
269 | tpm_pt->options->path = g_strdup(value); | |
4549a8b7 SB |
270 | } |
271 | ||
f59864ba | 272 | tpm_pt->tpm_dev = value ? value : TPM_PASSTHROUGH_DEFAULT_DEVICE; |
448058aa | 273 | tpm_pt->tpm_fd = qemu_open_old(tpm_pt->tpm_dev, O_RDWR); |
8f0605cc | 274 | if (tpm_pt->tpm_fd < 0) { |
27215a22 | 275 | error_report("Cannot access TPM device using '%s': %s", |
8f0605cc | 276 | tpm_pt->tpm_dev, strerror(errno)); |
bef2ed3f | 277 | return -1; |
4549a8b7 SB |
278 | } |
279 | ||
56a3c24f | 280 | if (tpm_util_test_tpmdev(tpm_pt->tpm_fd, &tpm_pt->tpm_version)) { |
27215a22 | 281 | error_report("'%s' is not a TPM device.", |
8f0605cc | 282 | tpm_pt->tpm_dev); |
bef2ed3f | 283 | return -1; |
4549a8b7 SB |
284 | } |
285 | ||
bef2ed3f MAL |
286 | tpm_pt->cancel_fd = tpm_passthrough_open_sysfs_cancel(tpm_pt); |
287 | if (tpm_pt->cancel_fd < 0) { | |
288 | return -1; | |
289 | } | |
4549a8b7 | 290 | |
bef2ed3f | 291 | return 0; |
4549a8b7 SB |
292 | } |
293 | ||
9f7c0ef2 | 294 | static TPMBackend *tpm_passthrough_create(QemuOpts *opts) |
4549a8b7 | 295 | { |
8f0605cc | 296 | Object *obj = object_new(TYPE_TPM_PASSTHROUGH); |
4549a8b7 | 297 | |
bef2ed3f MAL |
298 | if (tpm_passthrough_handle_device_opts(TPM_PASSTHROUGH(obj), opts)) { |
299 | object_unref(obj); | |
300 | return NULL; | |
92dcc234 SB |
301 | } |
302 | ||
9f7c0ef2 | 303 | return TPM_BACKEND(obj); |
4549a8b7 SB |
304 | } |
305 | ||
683c4b77 SB |
306 | static int tpm_passthrough_startup_tpm(TPMBackend *tb, size_t buffersize) |
307 | { | |
308 | TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb); | |
309 | ||
310 | if (buffersize && buffersize < tpm_pt->tpm_buffersize) { | |
311 | error_report("Requested buffer size of %zu is smaller than host TPM's " | |
312 | "fixed buffer size of %zu", | |
313 | buffersize, tpm_pt->tpm_buffersize); | |
314 | return -1; | |
315 | } | |
316 | ||
317 | return 0; | |
318 | } | |
319 | ||
f59864ba AV |
320 | static TpmTypeOptions *tpm_passthrough_get_tpm_options(TPMBackend *tb) |
321 | { | |
322 | TpmTypeOptions *options = g_new0(TpmTypeOptions, 1); | |
323 | ||
324 | options->type = TPM_TYPE_OPTIONS_KIND_PASSTHROUGH; | |
325 | options->u.passthrough.data = QAPI_CLONE(TPMPassthroughOptions, | |
326 | TPM_PASSTHROUGH(tb)->options); | |
327 | ||
328 | return options; | |
329 | } | |
330 | ||
bb716238 SB |
331 | static const QemuOptDesc tpm_passthrough_cmdline_opts[] = { |
332 | TPM_STANDARD_CMDLINE_OPTS, | |
333 | { | |
334 | .name = "cancel-path", | |
335 | .type = QEMU_OPT_STRING, | |
336 | .help = "Sysfs file entry for canceling TPM commands", | |
337 | }, | |
338 | { | |
339 | .name = "path", | |
340 | .type = QEMU_OPT_STRING, | |
341 | .help = "Path to TPM device on the host", | |
342 | }, | |
343 | { /* end of list */ }, | |
344 | }; | |
345 | ||
8f0605cc SB |
346 | static void tpm_passthrough_inst_init(Object *obj) |
347 | { | |
f35fe5cb AV |
348 | TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(obj); |
349 | ||
f59864ba | 350 | tpm_pt->options = g_new0(TPMPassthroughOptions, 1); |
f35fe5cb AV |
351 | tpm_pt->tpm_fd = -1; |
352 | tpm_pt->cancel_fd = -1; | |
8f0605cc SB |
353 | } |
354 | ||
355 | static void tpm_passthrough_inst_finalize(Object *obj) | |
356 | { | |
f35fe5cb AV |
357 | TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(obj); |
358 | ||
359 | tpm_passthrough_cancel_cmd(TPM_BACKEND(obj)); | |
360 | ||
8df4d848 MAL |
361 | if (tpm_pt->tpm_fd >= 0) { |
362 | qemu_close(tpm_pt->tpm_fd); | |
363 | } | |
364 | if (tpm_pt->cancel_fd >= 0) { | |
365 | qemu_close(tpm_pt->cancel_fd); | |
366 | } | |
f59864ba | 367 | qapi_free_TPMPassthroughOptions(tpm_pt->options); |
8f0605cc SB |
368 | } |
369 | ||
370 | static void tpm_passthrough_class_init(ObjectClass *klass, void *data) | |
371 | { | |
372 | TPMBackendClass *tbc = TPM_BACKEND_CLASS(klass); | |
373 | ||
d31076ba MAL |
374 | tbc->type = TPM_TYPE_PASSTHROUGH; |
375 | tbc->opts = tpm_passthrough_cmdline_opts; | |
376 | tbc->desc = "Passthrough TPM backend driver"; | |
377 | tbc->create = tpm_passthrough_create; | |
683c4b77 | 378 | tbc->startup_tpm = tpm_passthrough_startup_tpm; |
d31076ba MAL |
379 | tbc->reset = tpm_passthrough_reset; |
380 | tbc->cancel_cmd = tpm_passthrough_cancel_cmd; | |
381 | tbc->get_tpm_established_flag = tpm_passthrough_get_tpm_established_flag; | |
382 | tbc->reset_tpm_established_flag = | |
383 | tpm_passthrough_reset_tpm_established_flag; | |
384 | tbc->get_tpm_version = tpm_passthrough_get_tpm_version; | |
b21e6aaf | 385 | tbc->get_buffer_size = tpm_passthrough_get_buffer_size; |
d31076ba | 386 | tbc->get_tpm_options = tpm_passthrough_get_tpm_options; |
b19a5eea | 387 | tbc->handle_request = tpm_passthrough_handle_request; |
8f0605cc SB |
388 | } |
389 | ||
390 | static const TypeInfo tpm_passthrough_info = { | |
391 | .name = TYPE_TPM_PASSTHROUGH, | |
392 | .parent = TYPE_TPM_BACKEND, | |
393 | .instance_size = sizeof(TPMPassthruState), | |
394 | .class_init = tpm_passthrough_class_init, | |
395 | .instance_init = tpm_passthrough_inst_init, | |
396 | .instance_finalize = tpm_passthrough_inst_finalize, | |
397 | }; | |
398 | ||
4549a8b7 SB |
399 | static void tpm_passthrough_register(void) |
400 | { | |
8f0605cc | 401 | type_register_static(&tpm_passthrough_info); |
4549a8b7 SB |
402 | } |
403 | ||
404 | type_init(tpm_passthrough_register) |