1 /* 2 * QTest testcase for TPM TIS 3 * 4 * Copyright (c) 2018 Red Hat, Inc. 5 * Copyright (c) 2018 IBM Corporation 6 * 7 * Authors: 8 * Marc-André Lureau <marcandre.lureau@redhat.com> 9 * Stefan Berger <stefanb@linux.vnet.ibm.com> 10 * 11 * This work is licensed under the terms of the GNU GPL, version 2 or later. 12 * See the COPYING file in the top-level directory. 13 */ 14 15 #include "qemu/osdep.h" 16 #include <glib/gstdio.h> 17 18 #include "hw/acpi/tpm.h" 19 #include "io/channel-socket.h" 20 #include "libqtest-single.h" 21 #include "qemu/module.h" 22 #include "tpm-emu.h" 23 24 #define TIS_REG(LOCTY, REG) \ 25 (TPM_TIS_ADDR_BASE + ((LOCTY) << 12) + REG) 26 27 #define DEBUG_TIS_TEST 0 28 29 #define DPRINTF(fmt, ...) do { \ 30 if (DEBUG_TIS_TEST) { \ 31 printf(fmt, ## __VA_ARGS__); \ 32 } \ 33 } while (0) 34 35 #define DPRINTF_ACCESS \ 36 DPRINTF("%s: %d: locty=%d l=%d access=0x%02x pending_request_flag=0x%x\n", \ 37 __func__, __LINE__, locty, l, access, pending_request_flag) 38 39 #define DPRINTF_STS \ 40 DPRINTF("%s: %d: sts = 0x%08x\n", __func__, __LINE__, sts) 41 42 static const uint8_t TPM_CMD[12] = 43 "\x80\x01\x00\x00\x00\x0c\x00\x00\x01\x44\x00\x00"; 44 45 static void tpm_tis_test_check_localities(const void *data) 46 { 47 uint8_t locty; 48 uint8_t access; 49 uint32_t ifaceid; 50 uint32_t capability; 51 uint32_t didvid; 52 uint32_t rid; 53 54 for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES; locty++) { 55 access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS)); 56 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 57 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 58 59 capability = readl(TIS_REG(locty, TPM_TIS_REG_INTF_CAPABILITY)); 60 g_assert_cmpint(capability, ==, TPM_TIS_CAPABILITIES_SUPPORTED2_0); 61 62 ifaceid = readl(TIS_REG(locty, TPM_TIS_REG_INTERFACE_ID)); 63 g_assert_cmpint(ifaceid, ==, TPM_TIS_IFACE_ID_SUPPORTED_FLAGS2_0); 64 65 didvid = readl(TIS_REG(locty, TPM_TIS_REG_DID_VID)); 66 g_assert_cmpint(didvid, !=, 0); 67 g_assert_cmpint(didvid, !=, 0xffffffff); 68 69 rid = readl(TIS_REG(locty, TPM_TIS_REG_RID)); 70 g_assert_cmpint(rid, !=, 0); 71 g_assert_cmpint(rid, !=, 0xffffffff); 72 } 73 } 74 75 static void tpm_tis_test_check_access_reg(const void *data) 76 { 77 uint8_t locty; 78 uint8_t access; 79 80 /* do not test locality 4 (hw only) */ 81 for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES - 1; locty++) { 82 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 83 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 84 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 85 86 /* request use of locality */ 87 writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE); 88 89 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 90 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 91 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 92 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 93 94 /* release access */ 95 writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), 96 TPM_TIS_ACCESS_ACTIVE_LOCALITY); 97 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 98 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 99 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 100 } 101 } 102 103 /* 104 * Test case for seizing access by a higher number locality 105 */ 106 static void tpm_tis_test_check_access_reg_seize(const void *data) 107 { 108 int locty, l; 109 uint8_t access; 110 uint8_t pending_request_flag; 111 112 /* do not test locality 4 (hw only) */ 113 for (locty = 0; locty < TPM_TIS_NUM_LOCALITIES - 1; locty++) { 114 pending_request_flag = 0; 115 116 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 117 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 118 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 119 120 /* request use of locality */ 121 writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE); 122 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 123 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 124 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 125 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 126 127 /* lower localities cannot seize access */ 128 for (l = 0; l < locty; l++) { 129 /* lower locality is not active */ 130 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 131 DPRINTF_ACCESS; 132 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 133 pending_request_flag | 134 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 135 136 /* try to request use from 'l' */ 137 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE); 138 139 /* requesting use from 'l' was not possible; 140 we must see REQUEST_USE and possibly PENDING_REQUEST */ 141 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 142 DPRINTF_ACCESS; 143 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 144 TPM_TIS_ACCESS_REQUEST_USE | 145 pending_request_flag | 146 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 147 148 /* locality 'locty' must be unchanged; 149 we must see PENDING_REQUEST */ 150 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 151 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 152 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 153 TPM_TIS_ACCESS_PENDING_REQUEST | 154 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 155 156 /* try to seize from 'l' */ 157 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_SEIZE); 158 /* seize from 'l' was not possible */ 159 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 160 DPRINTF_ACCESS; 161 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 162 TPM_TIS_ACCESS_REQUEST_USE | 163 pending_request_flag | 164 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 165 166 /* locality 'locty' must be unchanged */ 167 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 168 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 169 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 170 TPM_TIS_ACCESS_PENDING_REQUEST | 171 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 172 173 /* on the next loop we will have a PENDING_REQUEST flag 174 set for locality 'l' */ 175 pending_request_flag = TPM_TIS_ACCESS_PENDING_REQUEST; 176 } 177 178 /* higher localities can 'seize' access but not 'request use'; 179 note: this will activate first l+1, then l+2 etc. */ 180 for (l = locty + 1; l < TPM_TIS_NUM_LOCALITIES - 1; l++) { 181 /* try to 'request use' from 'l' */ 182 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE); 183 184 /* requesting use from 'l' was not possible; we should see 185 REQUEST_USE and may see PENDING_REQUEST */ 186 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 187 DPRINTF_ACCESS; 188 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 189 TPM_TIS_ACCESS_REQUEST_USE | 190 pending_request_flag | 191 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 192 193 /* locality 'l-1' must be unchanged; we should always 194 see PENDING_REQUEST from 'l' requesting access */ 195 access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS)); 196 DPRINTF_ACCESS; 197 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 198 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 199 TPM_TIS_ACCESS_PENDING_REQUEST | 200 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 201 202 /* try to seize from 'l' */ 203 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_SEIZE); 204 205 /* seize from 'l' was possible */ 206 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 207 DPRINTF_ACCESS; 208 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 209 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 210 pending_request_flag | 211 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 212 213 /* l - 1 should show that it has BEEN_SEIZED */ 214 access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS)); 215 DPRINTF_ACCESS; 216 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 217 TPM_TIS_ACCESS_BEEN_SEIZED | 218 pending_request_flag | 219 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 220 221 /* clear the BEEN_SEIZED flag and make sure it's gone */ 222 writeb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS), 223 TPM_TIS_ACCESS_BEEN_SEIZED); 224 225 access = readb(TIS_REG(l - 1, TPM_TIS_REG_ACCESS)); 226 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 227 pending_request_flag | 228 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 229 } 230 231 /* PENDING_REQUEST will not be set if locty = 0 since all localities 232 were active; in case of locty = 1, locality 0 will be active 233 but no PENDING_REQUEST anywhere */ 234 if (locty <= 1) { 235 pending_request_flag = 0; 236 } 237 238 /* release access from l - 1; this activates locty - 1 */ 239 l--; 240 241 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 242 DPRINTF_ACCESS; 243 244 DPRINTF("%s: %d: relinquishing control on l = %d\n", 245 __func__, __LINE__, l); 246 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), 247 TPM_TIS_ACCESS_ACTIVE_LOCALITY); 248 249 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 250 DPRINTF_ACCESS; 251 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 252 pending_request_flag | 253 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 254 255 for (l = locty - 1; l >= 0; l--) { 256 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 257 DPRINTF_ACCESS; 258 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 259 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 260 pending_request_flag | 261 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 262 263 /* release this locality */ 264 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), 265 TPM_TIS_ACCESS_ACTIVE_LOCALITY); 266 267 if (l == 1) { 268 pending_request_flag = 0; 269 } 270 } 271 272 /* no locality may be active now */ 273 for (l = 0; l < TPM_TIS_NUM_LOCALITIES - 1; l++) { 274 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 275 DPRINTF_ACCESS; 276 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 277 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 278 } 279 } 280 } 281 282 /* 283 * Test case for getting access when higher number locality relinquishes access 284 */ 285 static void tpm_tis_test_check_access_reg_release(const void *data) 286 { 287 int locty, l; 288 uint8_t access; 289 uint8_t pending_request_flag; 290 291 /* do not test locality 4 (hw only) */ 292 for (locty = TPM_TIS_NUM_LOCALITIES - 2; locty >= 0; locty--) { 293 pending_request_flag = 0; 294 295 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 296 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 297 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 298 299 /* request use of locality */ 300 writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE); 301 access = readb(TIS_REG(locty, TPM_TIS_REG_ACCESS)); 302 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 303 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 304 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 305 306 /* request use of all other localities */ 307 for (l = 0; l < TPM_TIS_NUM_LOCALITIES - 1; l++) { 308 if (l == locty) { 309 continue; 310 } 311 /* request use of locality 'l' -- we MUST see REQUEST USE and 312 may see PENDING_REQUEST */ 313 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE); 314 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 315 DPRINTF_ACCESS; 316 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 317 TPM_TIS_ACCESS_REQUEST_USE | 318 pending_request_flag | 319 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 320 pending_request_flag = TPM_TIS_ACCESS_PENDING_REQUEST; 321 } 322 /* release locality 'locty' */ 323 writeb(TIS_REG(locty, TPM_TIS_REG_ACCESS), 324 TPM_TIS_ACCESS_ACTIVE_LOCALITY); 325 /* highest locality should now be active; release it and make sure the 326 next higest locality is active afterwards */ 327 for (l = TPM_TIS_NUM_LOCALITIES - 2; l >= 0; l--) { 328 if (l == locty) { 329 continue; 330 } 331 /* 'l' should be active now */ 332 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 333 DPRINTF_ACCESS; 334 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 335 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 336 pending_request_flag | 337 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 338 /* 'l' relinquishes access */ 339 writeb(TIS_REG(l, TPM_TIS_REG_ACCESS), 340 TPM_TIS_ACCESS_ACTIVE_LOCALITY); 341 access = readb(TIS_REG(l, TPM_TIS_REG_ACCESS)); 342 DPRINTF_ACCESS; 343 if (l == 1 || (locty <= 1 && l == 2)) { 344 pending_request_flag = 0; 345 } 346 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 347 pending_request_flag | 348 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 349 } 350 } 351 } 352 353 /* 354 * Test case for transmitting packets 355 */ 356 static void tpm_tis_test_check_transmit(const void *data) 357 { 358 const TestState *s = data; 359 uint8_t access; 360 uint32_t sts; 361 uint16_t bcount; 362 size_t i; 363 364 /* request use of locality 0 */ 365 writeb(TIS_REG(0, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_REQUEST_USE); 366 access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS)); 367 g_assert_cmpint(access, ==, TPM_TIS_ACCESS_TPM_REG_VALID_STS | 368 TPM_TIS_ACCESS_ACTIVE_LOCALITY | 369 TPM_TIS_ACCESS_TPM_ESTABLISHMENT); 370 371 sts = readl(TIS_REG(0, TPM_TIS_REG_STS)); 372 DPRINTF_STS; 373 374 g_assert_cmpint(sts & 0xff, ==, 0); 375 g_assert_cmpint(sts & TPM_TIS_STS_TPM_FAMILY_MASK, ==, 376 TPM_TIS_STS_TPM_FAMILY2_0); 377 378 bcount = (sts >> 8) & 0xffff; 379 g_assert_cmpint(bcount, >=, 128); 380 381 writel(TIS_REG(0, TPM_TIS_REG_STS), TPM_TIS_STS_COMMAND_READY); 382 sts = readl(TIS_REG(0, TPM_TIS_REG_STS)); 383 DPRINTF_STS; 384 g_assert_cmpint(sts & 0xff, ==, TPM_TIS_STS_COMMAND_READY); 385 386 /* transmit command */ 387 for (i = 0; i < sizeof(TPM_CMD); i++) { 388 writeb(TIS_REG(0, TPM_TIS_REG_DATA_FIFO), TPM_CMD[i]); 389 sts = readl(TIS_REG(0, TPM_TIS_REG_STS)); 390 DPRINTF_STS; 391 if (i < sizeof(TPM_CMD) - 1) { 392 g_assert_cmpint(sts & 0xff, ==, 393 TPM_TIS_STS_EXPECT | TPM_TIS_STS_VALID); 394 } else { 395 g_assert_cmpint(sts & 0xff, ==, TPM_TIS_STS_VALID); 396 } 397 g_assert_cmpint((sts >> 8) & 0xffff, ==, --bcount); 398 } 399 /* start processing */ 400 writeb(TIS_REG(0, TPM_TIS_REG_STS), TPM_TIS_STS_TPM_GO); 401 402 uint64_t end_time = g_get_monotonic_time() + 50 * G_TIME_SPAN_SECOND; 403 do { 404 sts = readl(TIS_REG(0, TPM_TIS_REG_STS)); 405 if ((sts & TPM_TIS_STS_DATA_AVAILABLE) != 0) { 406 break; 407 } 408 } while (g_get_monotonic_time() < end_time); 409 410 sts = readl(TIS_REG(0, TPM_TIS_REG_STS)); 411 DPRINTF_STS; 412 g_assert_cmpint(sts & 0xff, == , 413 TPM_TIS_STS_VALID | TPM_TIS_STS_DATA_AVAILABLE); 414 bcount = (sts >> 8) & 0xffff; 415 416 /* read response */ 417 uint8_t tpm_msg[sizeof(struct tpm_hdr)]; 418 g_assert_cmpint(sizeof(tpm_msg), ==, bcount); 419 420 for (i = 0; i < sizeof(tpm_msg); i++) { 421 tpm_msg[i] = readb(TIS_REG(0, TPM_TIS_REG_DATA_FIFO)); 422 sts = readl(TIS_REG(0, TPM_TIS_REG_STS)); 423 DPRINTF_STS; 424 if (sts & TPM_TIS_STS_DATA_AVAILABLE) { 425 g_assert_cmpint((sts >> 8) & 0xffff, ==, --bcount); 426 } 427 } 428 g_assert_cmpmem(tpm_msg, sizeof(tpm_msg), s->tpm_msg, sizeof(*s->tpm_msg)); 429 430 /* relinquish use of locality 0 */ 431 writeb(TIS_REG(0, TPM_TIS_REG_ACCESS), TPM_TIS_ACCESS_ACTIVE_LOCALITY); 432 access = readb(TIS_REG(0, TPM_TIS_REG_ACCESS)); 433 } 434 435 int main(int argc, char **argv) 436 { 437 int ret; 438 char *args, *tmp_path = g_dir_make_tmp("qemu-tpm-tis-test.XXXXXX", NULL); 439 GThread *thread; 440 TestState test; 441 442 module_call_init(MODULE_INIT_QOM); 443 g_test_init(&argc, &argv, NULL); 444 445 test.addr = g_new0(SocketAddress, 1); 446 test.addr->type = SOCKET_ADDRESS_TYPE_UNIX; 447 test.addr->u.q_unix.path = g_build_filename(tmp_path, "sock", NULL); 448 g_mutex_init(&test.data_mutex); 449 g_cond_init(&test.data_cond); 450 test.data_cond_signal = false; 451 452 thread = g_thread_new(NULL, tpm_emu_ctrl_thread, &test); 453 tpm_emu_test_wait_cond(&test); 454 455 args = g_strdup_printf( 456 "-chardev socket,id=chr,path=%s " 457 "-tpmdev emulator,id=dev,chardev=chr " 458 "-device tpm-tis,tpmdev=dev", 459 test.addr->u.q_unix.path); 460 qtest_start(args); 461 462 qtest_add_data_func("/tpm-tis/test_check_localities", &test, 463 tpm_tis_test_check_localities); 464 465 qtest_add_data_func("/tpm-tis/test_check_access_reg", &test, 466 tpm_tis_test_check_access_reg); 467 468 qtest_add_data_func("/tpm-tis/test_check_access_reg_seize", &test, 469 tpm_tis_test_check_access_reg_seize); 470 471 qtest_add_data_func("/tpm-tis/test_check_access_reg_release", &test, 472 tpm_tis_test_check_access_reg_release); 473 474 qtest_add_data_func("/tpm-tis/test_check_transmit", &test, 475 tpm_tis_test_check_transmit); 476 477 ret = g_test_run(); 478 479 qtest_end(); 480 481 g_thread_join(thread); 482 g_unlink(test.addr->u.q_unix.path); 483 qapi_free_SocketAddress(test.addr); 484 g_rmdir(tmp_path); 485 g_free(tmp_path); 486 g_free(args); 487 return ret; 488 } 489