tests/qtest/tpm-emu.c

   1 /*
   2  * Minimal TPM emulator for TPM test cases
   3  *
   4  * Copyright (c) 2018 Red Hat, Inc.
   5  *
   6  * Authors:
   7  *   Marc-André Lureau <marcandre.lureau@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include <glib/gstdio.h>
  15
  16 #include "hw/tpm/tpm_ioctl.h"
  17 #include "io/channel-socket.h"
  18 #include "qapi/error.h"
  19 #include "tpm-emu.h"
  20
  21 void tpm_emu_test_wait_cond(TestState *s)
  22 {
  23     gint64 end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
  24
  25     g_mutex_lock(&s->data_mutex);
  26
  27     if (!s->data_cond_signal &&
  28         !g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
  29         g_assert_not_reached();
  30     }
  31
  32     s->data_cond_signal = false;
  33
  34     g_mutex_unlock(&s->data_mutex);
  35 }
  36
  37 static void *tpm_emu_tpm_thread(void *data)
  38 {
  39     TestState *s = data;
  40     QIOChannel *ioc = s->tpm_ioc;
  41
  42     s->tpm_msg = g_new(struct tpm_hdr, 1);
  43     while (true) {
  44         int minhlen = sizeof(s->tpm_msg->tag) + sizeof(s->tpm_msg->len);
  45
  46         if (!qio_channel_read(ioc, (char *)s->tpm_msg, minhlen, &error_abort)) {
  47             break;
  48         }
  49         s->tpm_msg->tag = be16_to_cpu(s->tpm_msg->tag);
  50         s->tpm_msg->len = be32_to_cpu(s->tpm_msg->len);
  51         g_assert_cmpint(s->tpm_msg->len, >=, minhlen);
  52
  53         s->tpm_msg = g_realloc(s->tpm_msg, s->tpm_msg->len);
  54         qio_channel_read(ioc, (char *)&s->tpm_msg->code,
  55                          s->tpm_msg->len - minhlen, &error_abort);
  56         s->tpm_msg->code = be32_to_cpu(s->tpm_msg->code);
  57
  58         /* reply error */
  59         s->tpm_msg->tag = cpu_to_be16(TPM2_ST_NO_SESSIONS);
  60         s->tpm_msg->len = cpu_to_be32(sizeof(struct tpm_hdr));
  61         s->tpm_msg->code = cpu_to_be32(TPM_RC_FAILURE);
  62         qio_channel_write(ioc, (char *)s->tpm_msg, be32_to_cpu(s->tpm_msg->len),
  63                           &error_abort);
  64     }
  65
  66     g_free(s->tpm_msg);
  67     s->tpm_msg = NULL;
  68     object_unref(OBJECT(s->tpm_ioc));
  69     return NULL;
  70 }
  71
  72 void *tpm_emu_ctrl_thread(void *data)
  73 {
  74     TestState *s = data;
  75     QIOChannelSocket *lioc = qio_channel_socket_new();
  76     QIOChannel *ioc;
  77
  78     qio_channel_socket_listen_sync(lioc, s->addr, 1, &error_abort);
  79
  80     g_mutex_lock(&s->data_mutex);
  81     s->data_cond_signal = true;
  82     g_mutex_unlock(&s->data_mutex);
  83     g_cond_signal(&s->data_cond);
  84
  85     qio_channel_wait(QIO_CHANNEL(lioc), G_IO_IN);
  86     ioc = QIO_CHANNEL(qio_channel_socket_accept(lioc, &error_abort));
  87     g_assert(ioc);
  88
  89     {
  90         uint32_t cmd = 0;
  91         struct iovec iov = { .iov_base = &cmd, .iov_len = sizeof(cmd) };
  92         int *pfd = NULL;
  93         size_t nfd = 0;
  94
  95         qio_channel_readv_full(ioc, &iov, 1, &pfd, &nfd, &error_abort);
  96         cmd = be32_to_cpu(cmd);
  97         g_assert_cmpint(cmd, ==, CMD_SET_DATAFD);
  98         g_assert_cmpint(nfd, ==, 1);
  99         s->tpm_ioc = QIO_CHANNEL(qio_channel_socket_new_fd(*pfd, &error_abort));
 100         g_free(pfd);
 101
 102         cmd = 0;
 103         qio_channel_write(ioc, (char *)&cmd, sizeof(cmd), &error_abort);
 104
 105         s->emu_tpm_thread = g_thread_new(NULL, tpm_emu_tpm_thread, s);
 106     }
 107
 108     while (true) {
 109         uint32_t cmd;
 110         ssize_t ret;
 111
 112         ret = qio_channel_read(ioc, (char *)&cmd, sizeof(cmd), NULL);
 113         if (ret <= 0) {
 114             break;
 115         }
 116
 117         cmd = be32_to_cpu(cmd);
 118         switch (cmd) {
 119         case CMD_GET_CAPABILITY: {
 120             ptm_cap cap = cpu_to_be64(0x3fff);
 121             qio_channel_write(ioc, (char *)&cap, sizeof(cap), &error_abort);
 122             break;
 123         }
 124         case CMD_INIT: {
 125             ptm_init init;
 126             qio_channel_read(ioc, (char *)&init.u.req, sizeof(init.u.req),
 127                               &error_abort);
 128             init.u.resp.tpm_result = 0;
 129             qio_channel_write(ioc, (char *)&init.u.resp, sizeof(init.u.resp),
 130                               &error_abort);
 131             break;
 132         }
 133         case CMD_SHUTDOWN: {
 134             ptm_res res = 0;
 135             qio_channel_write(ioc, (char *)&res, sizeof(res), &error_abort);
 136             /* the tpm data thread is expected to finish now */
 137             g_thread_join(s->emu_tpm_thread);
 138             break;
 139         }
 140         case CMD_STOP: {
 141             ptm_res res = 0;
 142             qio_channel_write(ioc, (char *)&res, sizeof(res), &error_abort);
 143             break;
 144         }
 145         case CMD_SET_BUFFERSIZE: {
 146             ptm_setbuffersize sbs;
 147             qio_channel_read(ioc, (char *)&sbs.u.req, sizeof(sbs.u.req),
 148                              &error_abort);
 149             sbs.u.resp.buffersize = sbs.u.req.buffersize ?: cpu_to_be32(4096);
 150             sbs.u.resp.tpm_result = 0;
 151             sbs.u.resp.minsize = cpu_to_be32(128);
 152             sbs.u.resp.maxsize = cpu_to_be32(4096);
 153             qio_channel_write(ioc, (char *)&sbs.u.resp, sizeof(sbs.u.resp),
 154                               &error_abort);
 155             break;
 156         }
 157         case CMD_SET_LOCALITY: {
 158             ptm_loc loc;
 159             /* Note: this time it's not u.req / u.resp... */
 160             qio_channel_read(ioc, (char *)&loc, sizeof(loc), &error_abort);
 161             g_assert_cmpint(loc.u.req.loc, ==, 0);
 162             loc.u.resp.tpm_result = 0;
 163             qio_channel_write(ioc, (char *)&loc, sizeof(loc), &error_abort);
 164             break;
 165         }
 166         case CMD_GET_TPMESTABLISHED: {
 167             ptm_est est = {
 168                 .u.resp.bit = 0,
 169             };
 170             qio_channel_write(ioc, (char *)&est, sizeof(est), &error_abort);
 171             break;
 172         }
 173         default:
 174             g_debug("unimplemented %u", cmd);
 175             g_assert_not_reached();
 176         }
 177     }
 178
 179     object_unref(OBJECT(ioc));
 180     object_unref(OBJECT(lioc));
 181     return NULL;
 182 }