tests/virtio-9p-test.c

   1 /*
   2  * QTest testcase for VirtIO 9P
   3  *
   4  * Copyright (c) 2014 SUSE LINUX Products GmbH
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "libqtest.h"
  12 #include "qemu-common.h"
  13 #include "libqos/libqos-pc.h"
  14 #include "libqos/libqos-spapr.h"
  15 #include "libqos/virtio.h"
  16 #include "libqos/virtio-pci.h"
  17 #include "standard-headers/linux/virtio_ids.h"
  18 #include "standard-headers/linux/virtio_pci.h"
  19 #include "hw/9pfs/9p.h"
  20
  21 static const char mount_tag[] = "qtest";
  22
  23 typedef struct {
  24     QVirtioDevice *dev;
  25     QOSState *qs;
  26     QVirtQueue *vq;
  27     char *test_share;
  28 } QVirtIO9P;
  29
  30 static QVirtIO9P *qvirtio_9p_start(const char *driver)
  31 {
  32     const char *arch = qtest_get_arch();
  33     const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s "
  34                       "-device %s,fsdev=fsdev0,mount_tag=%s";
  35     QVirtIO9P *v9p = g_new0(QVirtIO9P, 1);
  36
  37     v9p->test_share = g_strdup("/tmp/qtest.XXXXXX");
  38     g_assert_nonnull(mkdtemp(v9p->test_share));
  39
  40     if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
  41         v9p->qs = qtest_pc_boot(cmd, v9p->test_share, driver, mount_tag);
  42     } else if (strcmp(arch, "ppc64") == 0) {
  43         v9p->qs = qtest_spapr_boot(cmd, v9p->test_share, driver, mount_tag);
  44     } else {
  45         g_printerr("virtio-9p tests are only available on x86 or ppc64\n");
  46         exit(EXIT_FAILURE);
  47     }
  48
  49     return v9p;
  50 }
  51
  52 static void qvirtio_9p_stop(QVirtIO9P *v9p)
  53 {
  54     qtest_shutdown(v9p->qs);
  55     rmdir(v9p->test_share);
  56     g_free(v9p->test_share);
  57     g_free(v9p);
  58 }
  59
  60 static QVirtIO9P *qvirtio_9p_pci_start(void)
  61 {
  62     QVirtIO9P *v9p = qvirtio_9p_start("virtio-9p-pci");
  63     QVirtioPCIDevice *dev = qvirtio_pci_device_find(v9p->qs->pcibus,
  64                                                     VIRTIO_ID_9P);
  65     g_assert_nonnull(dev);
  66     g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P);
  67     v9p->dev = (QVirtioDevice *) dev;
  68
  69     qvirtio_pci_device_enable(dev);
  70     qvirtio_reset(v9p->dev);
  71     qvirtio_set_acknowledge(v9p->dev);
  72     qvirtio_set_driver(v9p->dev);
  73
  74     v9p->vq = qvirtqueue_setup(v9p->dev, v9p->qs->alloc, 0);
  75     return v9p;
  76 }
  77
  78 static void qvirtio_9p_pci_stop(QVirtIO9P *v9p)
  79 {
  80     qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc);
  81     qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
  82     g_free(v9p->dev);
  83     qvirtio_9p_stop(v9p);
  84 }
  85
  86 static void pci_config(QVirtIO9P *v9p)
  87 {
  88     size_t tag_len = qvirtio_config_readw(v9p->dev, 0);
  89     char *tag;
  90     int i;
  91
  92     g_assert_cmpint(tag_len, ==, strlen(mount_tag));
  93
  94     tag = g_malloc(tag_len);
  95     for (i = 0; i < tag_len; i++) {
  96         tag[i] = qvirtio_config_readb(v9p->dev, i + 2);
  97     }
  98     g_assert_cmpmem(tag, tag_len, mount_tag, tag_len);
  99     g_free(tag);
 100 }
 101
 102 #define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */
 103
 104 typedef struct {
 105     QVirtIO9P *v9p;
 106     uint16_t tag;
 107     uint64_t t_msg;
 108     uint32_t t_size;
 109     uint64_t r_msg;
 110     /* No r_size, it is hardcoded to P9_MAX_SIZE */
 111     size_t t_off;
 112     size_t r_off;
 113 } P9Req;
 114
 115 static void v9fs_memwrite(P9Req *req, const void *addr, size_t len)
 116 {
 117     memwrite(req->t_msg + req->t_off, addr, len);
 118     req->t_off += len;
 119 }
 120
 121 static void v9fs_memskip(P9Req *req, size_t len)
 122 {
 123     req->r_off += len;
 124 }
 125
 126 static void v9fs_memrewind(P9Req *req, size_t len)
 127 {
 128     req->r_off -= len;
 129 }
 130
 131 static void v9fs_memread(P9Req *req, void *addr, size_t len)
 132 {
 133     memread(req->r_msg + req->r_off, addr, len);
 134     req->r_off += len;
 135 }
 136
 137 static void v9fs_uint16_write(P9Req *req, uint16_t val)
 138 {
 139     uint16_t le_val = cpu_to_le16(val);
 140
 141     v9fs_memwrite(req, &le_val, 2);
 142 }
 143
 144 static void v9fs_uint16_read(P9Req *req, uint16_t *val)
 145 {
 146     v9fs_memread(req, val, 2);
 147     le16_to_cpus(val);
 148 }
 149
 150 static void v9fs_uint32_write(P9Req *req, uint32_t val)
 151 {
 152     uint32_t le_val = cpu_to_le32(val);
 153
 154     v9fs_memwrite(req, &le_val, 4);
 155 }
 156
 157 static void v9fs_uint32_read(P9Req *req, uint32_t *val)
 158 {
 159     v9fs_memread(req, val, 4);
 160     le32_to_cpus(val);
 161 }
 162
 163 /* len[2] string[len] */
 164 static uint16_t v9fs_string_size(const char *string)
 165 {
 166     size_t len = strlen(string);
 167
 168     g_assert_cmpint(len, <=, UINT16_MAX);
 169
 170     return 2 + len;
 171 }
 172
 173 static void v9fs_string_write(P9Req *req, const char *string)
 174 {
 175     int len = strlen(string);
 176
 177     g_assert_cmpint(len, <=, UINT16_MAX);
 178
 179     v9fs_uint16_write(req, (uint16_t) len);
 180     v9fs_memwrite(req, string, len);
 181 }
 182
 183 static void v9fs_string_read(P9Req *req, uint16_t *len, char **string)
 184 {
 185     uint16_t local_len;
 186
 187     v9fs_uint16_read(req, &local_len);
 188     if (len) {
 189         *len = local_len;
 190     }
 191     if (string) {
 192         *string = g_malloc(local_len);
 193         v9fs_memread(req, *string, local_len);
 194     } else {
 195         v9fs_memskip(req, local_len);
 196     }
 197 }
 198
 199  typedef struct {
 200     uint32_t size;
 201     uint8_t id;
 202     uint16_t tag;
 203 } QEMU_PACKED P9Hdr;
 204
 205 static P9Req *v9fs_req_init(QVirtIO9P *v9p, uint32_t size, uint8_t id,
 206                             uint16_t tag)
 207 {
 208     P9Req *req = g_new0(P9Req, 1);
 209     uint32_t t_size = 7 + size; /* 9P header has well-known size of 7 bytes */
 210     P9Hdr hdr = {
 211         .size = cpu_to_le32(t_size),
 212         .id = id,
 213         .tag = cpu_to_le16(tag)
 214     };
 215
 216     g_assert_cmpint(t_size, <=, P9_MAX_SIZE);
 217
 218     req->v9p = v9p;
 219     req->t_size = t_size;
 220     req->t_msg = guest_alloc(v9p->qs->alloc, req->t_size);
 221     v9fs_memwrite(req, &hdr, 7);
 222     req->tag = tag;
 223     return req;
 224 }
 225
 226 static void v9fs_req_send(P9Req *req)
 227 {
 228     QVirtIO9P *v9p = req->v9p;
 229     uint32_t free_head;
 230
 231     req->r_msg = guest_alloc(v9p->qs->alloc, P9_MAX_SIZE);
 232     free_head = qvirtqueue_add(v9p->vq, req->t_msg, req->t_size, false, true);
 233     qvirtqueue_add(v9p->vq, req->r_msg, P9_MAX_SIZE, true, false);
 234     qvirtqueue_kick(v9p->dev, v9p->vq, free_head);
 235     req->t_off = 0;
 236 }
 237
 238 static void v9fs_req_recv(P9Req *req, uint8_t id)
 239 {
 240     QVirtIO9P *v9p = req->v9p;
 241     P9Hdr hdr;
 242     int i;
 243
 244     for (i = 0; i < 10; i++) {
 245         qvirtio_wait_queue_isr(v9p->dev, v9p->vq, 1000 * 1000);
 246
 247         v9fs_memread(req, &hdr, 7);
 248         le32_to_cpus(&hdr.size);
 249         le16_to_cpus(&hdr.tag);
 250         if (hdr.size >= 7) {
 251             break;
 252         }
 253         v9fs_memrewind(req, 7);
 254     }
 255
 256     g_assert_cmpint(hdr.size, >=, 7);
 257     g_assert_cmpint(hdr.size, <=, P9_MAX_SIZE);
 258     g_assert_cmpint(hdr.tag, ==, req->tag);
 259
 260     if (hdr.id != id && hdr.id == P9_RLERROR) {
 261         uint32_t err;
 262         v9fs_uint32_read(req, &err);
 263         g_printerr("Received Rlerror (%d) instead of Response %d\n", err, id);
 264         g_assert_not_reached();
 265     }
 266     g_assert_cmpint(hdr.id, ==, id);
 267 }
 268
 269 static void v9fs_req_free(P9Req *req)
 270 {
 271     QVirtIO9P *v9p = req->v9p;
 272
 273     guest_free(v9p->qs->alloc, req->t_msg);
 274     guest_free(v9p->qs->alloc, req->r_msg);
 275     g_free(req);
 276 }
 277
 278 /* size[4] Tversion tag[2] msize[4] version[s] */
 279 static P9Req *v9fs_tversion(QVirtIO9P *v9p, uint32_t msize, const char *version)
 280 {
 281     P9Req *req = v9fs_req_init(v9p, 4 + v9fs_string_size(version), P9_TVERSION,
 282                                P9_NOTAG);
 283
 284     v9fs_uint32_write(req, msize);
 285     v9fs_string_write(req, version);
 286     v9fs_req_send(req);
 287     return req;
 288 }
 289
 290 /* size[4] Rversion tag[2] msize[4] version[s] */
 291 static void v9fs_rversion(P9Req *req, uint16_t *len, char **version)
 292 {
 293     uint32_t msize;
 294
 295     v9fs_req_recv(req, P9_RVERSION);
 296     v9fs_uint32_read(req, &msize);
 297
 298     g_assert_cmpint(msize, ==, P9_MAX_SIZE);
 299
 300     if (len || version) {
 301         v9fs_string_read(req, len, version);
 302     }
 303
 304     v9fs_req_free(req);
 305 }
 306
 307 static void fs_version(QVirtIO9P *v9p)
 308 {
 309     const char *version = "9P2000.L";
 310     uint16_t server_len;
 311     char *server_version;
 312     P9Req *req;
 313
 314     req = v9fs_tversion(v9p, P9_MAX_SIZE, version);
 315     v9fs_rversion(req, &server_len, &server_version);
 316
 317     g_assert_cmpmem(server_version, server_len, version, strlen(version));
 318
 319     g_free(server_version);
 320 }
 321
 322 typedef void (*v9fs_test_fn)(QVirtIO9P *v9p);
 323
 324 static void v9fs_run_pci_test(gconstpointer data)
 325 {
 326     v9fs_test_fn fn = data;
 327     QVirtIO9P *v9p = qvirtio_9p_pci_start();
 328
 329     if (fn) {
 330         fn(v9p);
 331     }
 332     qvirtio_9p_pci_stop(v9p);
 333 }
 334
 335 static void v9fs_qtest_pci_add(const char *path, v9fs_test_fn fn)
 336 {
 337     qtest_add_data_func(path, fn, v9fs_run_pci_test);
 338 }
 339
 340 int main(int argc, char **argv)
 341 {
 342     g_test_init(&argc, &argv, NULL);
 343     v9fs_qtest_pci_add("/virtio/9p/pci/nop", NULL);
 344     v9fs_qtest_pci_add("/virtio/9p/pci/config", pci_config);
 345     v9fs_qtest_pci_add("/virtio/9p/pci/fs/version/basic", fs_version);
 346
 347     return g_test_run();
 348 }