tests/tpm-tis-test.c

   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 }