tests/qtest/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-single.h"
  12 #include "qemu/module.h"
  13 #include "hw/9pfs/9p.h"
  14 #include "hw/9pfs/9p-synth.h"
  15 #include "libqos/virtio-9p.h"
  16 #include "libqos/qgraph.h"
  17
  18 #define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000)
  19 static QGuestAllocator *alloc;
  20
  21 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc)
  22 {
  23     QVirtio9P *v9p = obj;
  24     alloc = t_alloc;
  25     size_t tag_len = qvirtio_config_readw(v9p->vdev, 0);
  26     char *tag;
  27     int i;
  28
  29     g_assert_cmpint(tag_len, ==, strlen(MOUNT_TAG));
  30
  31     tag = g_malloc(tag_len);
  32     for (i = 0; i < tag_len; i++) {
  33         tag[i] = qvirtio_config_readb(v9p->vdev, i + 2);
  34     }
  35     g_assert_cmpmem(tag, tag_len, MOUNT_TAG, tag_len);
  36     g_free(tag);
  37 }
  38
  39 #define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */
  40
  41 typedef struct {
  42     QTestState *qts;
  43     QVirtio9P *v9p;
  44     uint16_t tag;
  45     uint64_t t_msg;
  46     uint32_t t_size;
  47     uint64_t r_msg;
  48     /* No r_size, it is hardcoded to P9_MAX_SIZE */
  49     size_t t_off;
  50     size_t r_off;
  51     uint32_t free_head;
  52 } P9Req;
  53
  54 static void v9fs_memwrite(P9Req *req, const void *addr, size_t len)
  55 {
  56     qtest_memwrite(req->qts, req->t_msg + req->t_off, addr, len);
  57     req->t_off += len;
  58 }
  59
  60 static void v9fs_memskip(P9Req *req, size_t len)
  61 {
  62     req->r_off += len;
  63 }
  64
  65 static void v9fs_memread(P9Req *req, void *addr, size_t len)
  66 {
  67     qtest_memread(req->qts, req->r_msg + req->r_off, addr, len);
  68     req->r_off += len;
  69 }
  70
  71 static void v9fs_uint8_read(P9Req *req, uint8_t *val)
  72 {
  73     v9fs_memread(req, val, 1);
  74 }
  75
  76 static void v9fs_uint16_write(P9Req *req, uint16_t val)
  77 {
  78     uint16_t le_val = cpu_to_le16(val);
  79
  80     v9fs_memwrite(req, &le_val, 2);
  81 }
  82
  83 static void v9fs_uint16_read(P9Req *req, uint16_t *val)
  84 {
  85     v9fs_memread(req, val, 2);
  86     le16_to_cpus(val);
  87 }
  88
  89 static void v9fs_uint32_write(P9Req *req, uint32_t val)
  90 {
  91     uint32_t le_val = cpu_to_le32(val);
  92
  93     v9fs_memwrite(req, &le_val, 4);
  94 }
  95
  96 static void v9fs_uint64_write(P9Req *req, uint64_t val)
  97 {
  98     uint64_t le_val = cpu_to_le64(val);
  99
 100     v9fs_memwrite(req, &le_val, 8);
 101 }
 102
 103 static void v9fs_uint32_read(P9Req *req, uint32_t *val)
 104 {
 105     v9fs_memread(req, val, 4);
 106     le32_to_cpus(val);
 107 }
 108
 109 static void v9fs_uint64_read(P9Req *req, uint64_t *val)
 110 {
 111     v9fs_memread(req, val, 8);
 112     le64_to_cpus(val);
 113 }
 114
 115 /* len[2] string[len] */
 116 static uint16_t v9fs_string_size(const char *string)
 117 {
 118     size_t len = strlen(string);
 119
 120     g_assert_cmpint(len, <=, UINT16_MAX - 2);
 121
 122     return 2 + len;
 123 }
 124
 125 static void v9fs_string_write(P9Req *req, const char *string)
 126 {
 127     int len = strlen(string);
 128
 129     g_assert_cmpint(len, <=, UINT16_MAX);
 130
 131     v9fs_uint16_write(req, (uint16_t) len);
 132     v9fs_memwrite(req, string, len);
 133 }
 134
 135 static void v9fs_string_read(P9Req *req, uint16_t *len, char **string)
 136 {
 137     uint16_t local_len;
 138
 139     v9fs_uint16_read(req, &local_len);
 140     if (len) {
 141         *len = local_len;
 142     }
 143     if (string) {
 144         *string = g_malloc(local_len + 1);
 145         v9fs_memread(req, *string, local_len);
 146         (*string)[local_len] = 0;
 147     } else {
 148         v9fs_memskip(req, local_len);
 149     }
 150 }
 151
 152  typedef struct {
 153     uint32_t size;
 154     uint8_t id;
 155     uint16_t tag;
 156 } QEMU_PACKED P9Hdr;
 157
 158 static P9Req *v9fs_req_init(QVirtio9P *v9p, uint32_t size, uint8_t id,
 159                             uint16_t tag)
 160 {
 161     P9Req *req = g_new0(P9Req, 1);
 162     uint32_t total_size = 7; /* 9P header has well-known size of 7 bytes */
 163     P9Hdr hdr = {
 164         .id = id,
 165         .tag = cpu_to_le16(tag)
 166     };
 167
 168     g_assert_cmpint(total_size, <=, UINT32_MAX - size);
 169     total_size += size;
 170     hdr.size = cpu_to_le32(total_size);
 171
 172     g_assert_cmpint(total_size, <=, P9_MAX_SIZE);
 173
 174     req->qts = global_qtest;
 175     req->v9p = v9p;
 176     req->t_size = total_size;
 177     req->t_msg = guest_alloc(alloc, req->t_size);
 178     v9fs_memwrite(req, &hdr, 7);
 179     req->tag = tag;
 180     return req;
 181 }
 182
 183 static void v9fs_req_send(P9Req *req)
 184 {
 185     QVirtio9P *v9p = req->v9p;
 186
 187     req->r_msg = guest_alloc(alloc, P9_MAX_SIZE);
 188     req->free_head = qvirtqueue_add(req->qts, v9p->vq, req->t_msg, req->t_size,
 189                                     false, true);
 190     qvirtqueue_add(req->qts, v9p->vq, req->r_msg, P9_MAX_SIZE, true, false);
 191     qvirtqueue_kick(req->qts, v9p->vdev, v9p->vq, req->free_head);
 192     req->t_off = 0;
 193 }
 194
 195 static const char *rmessage_name(uint8_t id)
 196 {
 197     return
 198         id == P9_RLERROR ? "RLERROR" :
 199         id == P9_RVERSION ? "RVERSION" :
 200         id == P9_RATTACH ? "RATTACH" :
 201         id == P9_RWALK ? "RWALK" :
 202         id == P9_RLOPEN ? "RLOPEN" :
 203         id == P9_RWRITE ? "RWRITE" :
 204         id == P9_RFLUSH ? "RFLUSH" :
 205         id == P9_RREADDIR ? "READDIR" :
 206         "<unknown>";
 207 }
 208
 209 static void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len)
 210 {
 211     QVirtio9P *v9p = req->v9p;
 212
 213     qvirtio_wait_used_elem(req->qts, v9p->vdev, v9p->vq, req->free_head, len,
 214                            QVIRTIO_9P_TIMEOUT_US);
 215 }
 216
 217 static void v9fs_req_recv(P9Req *req, uint8_t id)
 218 {
 219     P9Hdr hdr;
 220
 221     v9fs_memread(req, &hdr, 7);
 222     hdr.size = ldl_le_p(&hdr.size);
 223     hdr.tag = lduw_le_p(&hdr.tag);
 224
 225     g_assert_cmpint(hdr.size, >=, 7);
 226     g_assert_cmpint(hdr.size, <=, P9_MAX_SIZE);
 227     g_assert_cmpint(hdr.tag, ==, req->tag);
 228
 229     if (hdr.id != id) {
 230         g_printerr("Received response %d (%s) instead of %d (%s)\n",
 231                    hdr.id, rmessage_name(hdr.id), id, rmessage_name(id));
 232
 233         if (hdr.id == P9_RLERROR) {
 234             uint32_t err;
 235             v9fs_uint32_read(req, &err);
 236             g_printerr("Rlerror has errno %d (%s)\n", err, strerror(err));
 237         }
 238     }
 239     g_assert_cmpint(hdr.id, ==, id);
 240 }
 241
 242 static void v9fs_req_free(P9Req *req)
 243 {
 244     guest_free(alloc, req->t_msg);
 245     guest_free(alloc, req->r_msg);
 246     g_free(req);
 247 }
 248
 249 /* size[4] Rlerror tag[2] ecode[4] */
 250 static void v9fs_rlerror(P9Req *req, uint32_t *err)
 251 {
 252     v9fs_req_recv(req, P9_RLERROR);
 253     v9fs_uint32_read(req, err);
 254     v9fs_req_free(req);
 255 }
 256
 257 /* size[4] Tversion tag[2] msize[4] version[s] */
 258 static P9Req *v9fs_tversion(QVirtio9P *v9p, uint32_t msize, const char *version,
 259                             uint16_t tag)
 260 {
 261     P9Req *req;
 262     uint32_t body_size = 4;
 263     uint16_t string_size = v9fs_string_size(version);
 264
 265     g_assert_cmpint(body_size, <=, UINT32_MAX - string_size);
 266     body_size += string_size;
 267     req = v9fs_req_init(v9p, body_size, P9_TVERSION, tag);
 268
 269     v9fs_uint32_write(req, msize);
 270     v9fs_string_write(req, version);
 271     v9fs_req_send(req);
 272     return req;
 273 }
 274
 275 /* size[4] Rversion tag[2] msize[4] version[s] */
 276 static void v9fs_rversion(P9Req *req, uint16_t *len, char **version)
 277 {
 278     uint32_t msize;
 279
 280     v9fs_req_recv(req, P9_RVERSION);
 281     v9fs_uint32_read(req, &msize);
 282
 283     g_assert_cmpint(msize, ==, P9_MAX_SIZE);
 284
 285     if (len || version) {
 286         v9fs_string_read(req, len, version);
 287     }
 288
 289     v9fs_req_free(req);
 290 }
 291
 292 /* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */
 293 static P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname,
 294                            uint16_t tag)
 295 {
 296     const char *uname = ""; /* ignored by QEMU */
 297     const char *aname = ""; /* ignored by QEMU */
 298     P9Req *req = v9fs_req_init(v9p, 4 + 4 + 2 + 2 + 4, P9_TATTACH, tag);
 299
 300     v9fs_uint32_write(req, fid);
 301     v9fs_uint32_write(req, P9_NOFID);
 302     v9fs_string_write(req, uname);
 303     v9fs_string_write(req, aname);
 304     v9fs_uint32_write(req, n_uname);
 305     v9fs_req_send(req);
 306     return req;
 307 }
 308
 309 typedef char v9fs_qid[13];
 310
 311 /* size[4] Rattach tag[2] qid[13] */
 312 static void v9fs_rattach(P9Req *req, v9fs_qid *qid)
 313 {
 314     v9fs_req_recv(req, P9_RATTACH);
 315     if (qid) {
 316         v9fs_memread(req, qid, 13);
 317     }
 318     v9fs_req_free(req);
 319 }
 320
 321 /* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
 322 static P9Req *v9fs_twalk(QVirtio9P *v9p, uint32_t fid, uint32_t newfid,
 323                          uint16_t nwname, char *const wnames[], uint16_t tag)
 324 {
 325     P9Req *req;
 326     int i;
 327     uint32_t body_size = 4 + 4 + 2;
 328
 329     for (i = 0; i < nwname; i++) {
 330         uint16_t wname_size = v9fs_string_size(wnames[i]);
 331
 332         g_assert_cmpint(body_size, <=, UINT32_MAX - wname_size);
 333         body_size += wname_size;
 334     }
 335     req = v9fs_req_init(v9p,  body_size, P9_TWALK, tag);
 336     v9fs_uint32_write(req, fid);
 337     v9fs_uint32_write(req, newfid);
 338     v9fs_uint16_write(req, nwname);
 339     for (i = 0; i < nwname; i++) {
 340         v9fs_string_write(req, wnames[i]);
 341     }
 342     v9fs_req_send(req);
 343     return req;
 344 }
 345
 346 /* size[4] Rwalk tag[2] nwqid[2] nwqid*(wqid[13]) */
 347 static void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid)
 348 {
 349     uint16_t local_nwqid;
 350
 351     v9fs_req_recv(req, P9_RWALK);
 352     v9fs_uint16_read(req, &local_nwqid);
 353     if (nwqid) {
 354         *nwqid = local_nwqid;
 355     }
 356     if (wqid) {
 357         *wqid = g_malloc(local_nwqid * 13);
 358         v9fs_memread(req, *wqid, local_nwqid * 13);
 359     }
 360     v9fs_req_free(req);
 361 }
 362
 363 /* size[4] Treaddir tag[2] fid[4] offset[8] count[4] */
 364 static P9Req *v9fs_treaddir(QVirtio9P *v9p, uint32_t fid, uint64_t offset,
 365                             uint32_t count, uint16_t tag)
 366 {
 367     P9Req *req;
 368
 369     req = v9fs_req_init(v9p, 4 + 8 + 4, P9_TREADDIR, tag);
 370     v9fs_uint32_write(req, fid);
 371     v9fs_uint64_write(req, offset);
 372     v9fs_uint32_write(req, count);
 373     v9fs_req_send(req);
 374     return req;
 375 }
 376
 377 struct V9fsDirent {
 378     v9fs_qid qid;
 379     uint64_t offset;
 380     uint8_t type;
 381     char *name;
 382     struct V9fsDirent *next;
 383 };
 384
 385 /* size[4] Rreaddir tag[2] count[4] data[count] */
 386 static void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_t *nentries,
 387                           struct V9fsDirent **entries)
 388 {
 389     uint32_t local_count;
 390     struct V9fsDirent *e = NULL;
 391     uint16_t slen;
 392     uint32_t n = 0;
 393
 394     v9fs_req_recv(req, P9_RREADDIR);
 395     v9fs_uint32_read(req, &local_count);
 396
 397     if (count) {
 398         *count = local_count;
 399     }
 400
 401     for (int32_t togo = (int32_t)local_count;
 402          togo >= 13 + 8 + 1 + 2;
 403          togo -= 13 + 8 + 1 + 2 + slen, ++n)
 404     {
 405         if (!e) {
 406             e = g_malloc(sizeof(struct V9fsDirent));
 407             if (entries) {
 408                 *entries = e;
 409             }
 410         } else {
 411             e = e->next = g_malloc(sizeof(struct V9fsDirent));
 412         }
 413         e->next = NULL;
 414         /* qid[13] offset[8] type[1] name[s] */
 415         v9fs_memread(req, &e->qid, 13);
 416         v9fs_uint64_read(req, &e->offset);
 417         v9fs_uint8_read(req, &e->type);
 418         v9fs_string_read(req, &slen, &e->name);
 419     }
 420
 421     if (nentries) {
 422         *nentries = n;
 423     }
 424
 425     v9fs_req_free(req);
 426 }
 427
 428 static void v9fs_free_dirents(struct V9fsDirent *e)
 429 {
 430     struct V9fsDirent *next = NULL;
 431
 432     for (; e; e = next) {
 433         next = e->next;
 434         g_free(e->name);
 435         g_free(e);
 436     }
 437 }
 438
 439 /* size[4] Tlopen tag[2] fid[4] flags[4] */
 440 static P9Req *v9fs_tlopen(QVirtio9P *v9p, uint32_t fid, uint32_t flags,
 441                           uint16_t tag)
 442 {
 443     P9Req *req;
 444
 445     req = v9fs_req_init(v9p,  4 + 4, P9_TLOPEN, tag);
 446     v9fs_uint32_write(req, fid);
 447     v9fs_uint32_write(req, flags);
 448     v9fs_req_send(req);
 449     return req;
 450 }
 451
 452 /* size[4] Rlopen tag[2] qid[13] iounit[4] */
 453 static void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *iounit)
 454 {
 455     v9fs_req_recv(req, P9_RLOPEN);
 456     if (qid) {
 457         v9fs_memread(req, qid, 13);
 458     } else {
 459         v9fs_memskip(req, 13);
 460     }
 461     if (iounit) {
 462         v9fs_uint32_read(req, iounit);
 463     }
 464     v9fs_req_free(req);
 465 }
 466
 467 /* size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count] */
 468 static P9Req *v9fs_twrite(QVirtio9P *v9p, uint32_t fid, uint64_t offset,
 469                           uint32_t count, const void *data, uint16_t tag)
 470 {
 471     P9Req *req;
 472     uint32_t body_size = 4 + 8 + 4;
 473
 474     g_assert_cmpint(body_size, <=, UINT32_MAX - count);
 475     body_size += count;
 476     req = v9fs_req_init(v9p,  body_size, P9_TWRITE, tag);
 477     v9fs_uint32_write(req, fid);
 478     v9fs_uint64_write(req, offset);
 479     v9fs_uint32_write(req, count);
 480     v9fs_memwrite(req, data, count);
 481     v9fs_req_send(req);
 482     return req;
 483 }
 484
 485 /* size[4] Rwrite tag[2] count[4] */
 486 static void v9fs_rwrite(P9Req *req, uint32_t *count)
 487 {
 488     v9fs_req_recv(req, P9_RWRITE);
 489     if (count) {
 490         v9fs_uint32_read(req, count);
 491     }
 492     v9fs_req_free(req);
 493 }
 494
 495 /* size[4] Tflush tag[2] oldtag[2] */
 496 static P9Req *v9fs_tflush(QVirtio9P *v9p, uint16_t oldtag, uint16_t tag)
 497 {
 498     P9Req *req;
 499
 500     req = v9fs_req_init(v9p,  2, P9_TFLUSH, tag);
 501     v9fs_uint32_write(req, oldtag);
 502     v9fs_req_send(req);
 503     return req;
 504 }
 505
 506 /* size[4] Rflush tag[2] */
 507 static void v9fs_rflush(P9Req *req)
 508 {
 509     v9fs_req_recv(req, P9_RFLUSH);
 510     v9fs_req_free(req);
 511 }
 512
 513 static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc)
 514 {
 515     QVirtio9P *v9p = obj;
 516     alloc = t_alloc;
 517     const char *version = "9P2000.L";
 518     uint16_t server_len;
 519     char *server_version;
 520     P9Req *req;
 521
 522     req = v9fs_tversion(v9p, P9_MAX_SIZE, version, P9_NOTAG);
 523     v9fs_req_wait_for_reply(req, NULL);
 524     v9fs_rversion(req, &server_len, &server_version);
 525
 526     g_assert_cmpmem(server_version, server_len, version, strlen(version));
 527
 528     g_free(server_version);
 529 }
 530
 531 static void fs_attach(void *obj, void *data, QGuestAllocator *t_alloc)
 532 {
 533     QVirtio9P *v9p = obj;
 534     alloc = t_alloc;
 535     P9Req *req;
 536
 537     fs_version(v9p, NULL, t_alloc);
 538     req = v9fs_tattach(v9p, 0, getuid(), 0);
 539     v9fs_req_wait_for_reply(req, NULL);
 540     v9fs_rattach(req, NULL);
 541 }
 542
 543 static void fs_walk(void *obj, void *data, QGuestAllocator *t_alloc)
 544 {
 545     QVirtio9P *v9p = obj;
 546     alloc = t_alloc;
 547     char *wnames[P9_MAXWELEM];
 548     uint16_t nwqid;
 549     v9fs_qid *wqid;
 550     int i;
 551     P9Req *req;
 552
 553     for (i = 0; i < P9_MAXWELEM; i++) {
 554         wnames[i] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i);
 555     }
 556
 557     fs_attach(v9p, NULL, t_alloc);
 558     req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0);
 559     v9fs_req_wait_for_reply(req, NULL);
 560     v9fs_rwalk(req, &nwqid, &wqid);
 561
 562     g_assert_cmpint(nwqid, ==, P9_MAXWELEM);
 563
 564     for (i = 0; i < P9_MAXWELEM; i++) {
 565         g_free(wnames[i]);
 566     }
 567
 568     g_free(wqid);
 569 }
 570
 571 static bool fs_dirents_contain_name(struct V9fsDirent *e, const char* name)
 572 {
 573     for (; e; e = e->next) {
 574         if (!strcmp(e->name, name)) {
 575             return true;
 576         }
 577     }
 578     return false;
 579 }
 580
 581 static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc)
 582 {
 583     QVirtio9P *v9p = obj;
 584     alloc = t_alloc;
 585     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) };
 586     uint16_t nqid;
 587     v9fs_qid qid;
 588     uint32_t count, nentries;
 589     struct V9fsDirent *entries = NULL;
 590     P9Req *req;
 591
 592     fs_attach(v9p, NULL, t_alloc);
 593     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 594     v9fs_req_wait_for_reply(req, NULL);
 595     v9fs_rwalk(req, &nqid, NULL);
 596     g_assert_cmpint(nqid, ==, 1);
 597
 598     req = v9fs_tlopen(v9p, 1, O_DIRECTORY, 0);
 599     v9fs_req_wait_for_reply(req, NULL);
 600     v9fs_rlopen(req, &qid, NULL);
 601
 602     /*
 603      * submit count = msize - 11, because 11 is the header size of Rreaddir
 604      */
 605     req = v9fs_treaddir(v9p, 1, 0, P9_MAX_SIZE - 11, 0);
 606     v9fs_req_wait_for_reply(req, NULL);
 607     v9fs_rreaddir(req, &count, &nentries, &entries);
 608
 609     /*
 610      * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all
 611      * dir entries with only one readdir request.
 612      */
 613     g_assert_cmpint(
 614         nentries, ==,
 615         QTEST_V9FS_SYNTH_READDIR_NFILES + 2 /* "." and ".." */
 616     );
 617
 618     /*
 619      * Check all file names exist in returned entries, ignore their order
 620      * though.
 621      */
 622     g_assert_cmpint(fs_dirents_contain_name(entries, "."), ==, true);
 623     g_assert_cmpint(fs_dirents_contain_name(entries, ".."), ==, true);
 624     for (int i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) {
 625         char *name = g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE, i);
 626         g_assert_cmpint(fs_dirents_contain_name(entries, name), ==, true);
 627         g_free(name);
 628     }
 629
 630     v9fs_free_dirents(entries);
 631     g_free(wnames[0]);
 632 }
 633
 634 static void fs_walk_no_slash(void *obj, void *data, QGuestAllocator *t_alloc)
 635 {
 636     QVirtio9P *v9p = obj;
 637     alloc = t_alloc;
 638     char *const wnames[] = { g_strdup(" /") };
 639     P9Req *req;
 640     uint32_t err;
 641
 642     fs_attach(v9p, NULL, t_alloc);
 643     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 644     v9fs_req_wait_for_reply(req, NULL);
 645     v9fs_rlerror(req, &err);
 646
 647     g_assert_cmpint(err, ==, ENOENT);
 648
 649     g_free(wnames[0]);
 650 }
 651
 652 static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc)
 653 {
 654     QVirtio9P *v9p = obj;
 655     alloc = t_alloc;
 656     char *const wnames[] = { g_strdup("..") };
 657     v9fs_qid root_qid, *wqid;
 658     P9Req *req;
 659
 660     fs_version(v9p, NULL, t_alloc);
 661     req = v9fs_tattach(v9p, 0, getuid(), 0);
 662     v9fs_req_wait_for_reply(req, NULL);
 663     v9fs_rattach(req, &root_qid);
 664
 665     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 666     v9fs_req_wait_for_reply(req, NULL);
 667     v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */
 668
 669     g_assert_cmpmem(&root_qid, 13, wqid[0], 13);
 670
 671     g_free(wqid);
 672     g_free(wnames[0]);
 673 }
 674
 675 static void fs_lopen(void *obj, void *data, QGuestAllocator *t_alloc)
 676 {
 677     QVirtio9P *v9p = obj;
 678     alloc = t_alloc;
 679     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) };
 680     P9Req *req;
 681
 682     fs_attach(v9p, NULL, t_alloc);
 683     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 684     v9fs_req_wait_for_reply(req, NULL);
 685     v9fs_rwalk(req, NULL, NULL);
 686
 687     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 688     v9fs_req_wait_for_reply(req, NULL);
 689     v9fs_rlopen(req, NULL, NULL);
 690
 691     g_free(wnames[0]);
 692 }
 693
 694 static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc)
 695 {
 696     QVirtio9P *v9p = obj;
 697     alloc = t_alloc;
 698     static const uint32_t write_count = P9_MAX_SIZE / 2;
 699     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) };
 700     char *buf = g_malloc0(write_count);
 701     uint32_t count;
 702     P9Req *req;
 703
 704     fs_attach(v9p, NULL, t_alloc);
 705     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 706     v9fs_req_wait_for_reply(req, NULL);
 707     v9fs_rwalk(req, NULL, NULL);
 708
 709     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 710     v9fs_req_wait_for_reply(req, NULL);
 711     v9fs_rlopen(req, NULL, NULL);
 712
 713     req = v9fs_twrite(v9p, 1, 0, write_count, buf, 0);
 714     v9fs_req_wait_for_reply(req, NULL);
 715     v9fs_rwrite(req, &count);
 716     g_assert_cmpint(count, ==, write_count);
 717
 718     g_free(buf);
 719     g_free(wnames[0]);
 720 }
 721
 722 static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc)
 723 {
 724     QVirtio9P *v9p = obj;
 725     alloc = t_alloc;
 726     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
 727     P9Req *req, *flush_req;
 728     uint32_t reply_len;
 729     uint8_t should_block;
 730
 731     fs_attach(v9p, NULL, t_alloc);
 732     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 733     v9fs_req_wait_for_reply(req, NULL);
 734     v9fs_rwalk(req, NULL, NULL);
 735
 736     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 737     v9fs_req_wait_for_reply(req, NULL);
 738     v9fs_rlopen(req, NULL, NULL);
 739
 740     /* This will cause the 9p server to try to write data to the backend,
 741      * until the write request gets cancelled.
 742      */
 743     should_block = 1;
 744     req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);
 745
 746     flush_req = v9fs_tflush(v9p, req->tag, 1);
 747
 748     /* The write request is supposed to be flushed: the server should just
 749      * mark the write request as used and reply to the flush request.
 750      */
 751     v9fs_req_wait_for_reply(req, &reply_len);
 752     g_assert_cmpint(reply_len, ==, 0);
 753     v9fs_req_free(req);
 754     v9fs_rflush(flush_req);
 755
 756     g_free(wnames[0]);
 757 }
 758
 759 static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)
 760 {
 761     QVirtio9P *v9p = obj;
 762     alloc = t_alloc;
 763     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
 764     P9Req *req, *flush_req;
 765     uint32_t count;
 766     uint8_t should_block;
 767
 768     fs_attach(v9p, NULL, t_alloc);
 769     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 770     v9fs_req_wait_for_reply(req, NULL);
 771     v9fs_rwalk(req, NULL, NULL);
 772
 773     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 774     v9fs_req_wait_for_reply(req, NULL);
 775     v9fs_rlopen(req, NULL, NULL);
 776
 777     /* This will cause the write request to complete right away, before it
 778      * could be actually cancelled.
 779      */
 780     should_block = 0;
 781     req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);
 782
 783     flush_req = v9fs_tflush(v9p, req->tag, 1);
 784
 785     /* The write request is supposed to complete. The server should
 786      * reply to the write request and the flush request.
 787      */
 788     v9fs_req_wait_for_reply(req, NULL);
 789     v9fs_rwrite(req, &count);
 790     g_assert_cmpint(count, ==, sizeof(should_block));
 791     v9fs_rflush(flush_req);
 792
 793     g_free(wnames[0]);
 794 }
 795
 796 static void register_virtio_9p_test(void)
 797 {
 798     qos_add_test("config", "virtio-9p", pci_config, NULL);
 799     qos_add_test("fs/version/basic", "virtio-9p", fs_version, NULL);
 800     qos_add_test("fs/attach/basic", "virtio-9p", fs_attach, NULL);
 801     qos_add_test("fs/walk/basic", "virtio-9p", fs_walk, NULL);
 802     qos_add_test("fs/walk/no_slash", "virtio-9p", fs_walk_no_slash,
 803                  NULL);
 804     qos_add_test("fs/walk/dotdot_from_root", "virtio-9p",
 805                  fs_walk_dotdot, NULL);
 806     qos_add_test("fs/lopen/basic", "virtio-9p", fs_lopen, NULL);
 807     qos_add_test("fs/write/basic", "virtio-9p", fs_write, NULL);
 808     qos_add_test("fs/flush/success", "virtio-9p", fs_flush_success,
 809                  NULL);
 810     qos_add_test("fs/flush/ignored", "virtio-9p", fs_flush_ignored,
 811                  NULL);
 812     qos_add_test("fs/readdir/basic", "virtio-9p", fs_readdir, NULL);
 813 }
 814
 815 libqos_init(register_virtio_9p_test);