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 /* basic readdir test where reply fits into a single response message */
 582 static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc)
 583 {
 584     QVirtio9P *v9p = obj;
 585     alloc = t_alloc;
 586     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) };
 587     uint16_t nqid;
 588     v9fs_qid qid;
 589     uint32_t count, nentries;
 590     struct V9fsDirent *entries = NULL;
 591     P9Req *req;
 592
 593     fs_attach(v9p, NULL, t_alloc);
 594     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 595     v9fs_req_wait_for_reply(req, NULL);
 596     v9fs_rwalk(req, &nqid, NULL);
 597     g_assert_cmpint(nqid, ==, 1);
 598
 599     req = v9fs_tlopen(v9p, 1, O_DIRECTORY, 0);
 600     v9fs_req_wait_for_reply(req, NULL);
 601     v9fs_rlopen(req, &qid, NULL);
 602
 603     /*
 604      * submit count = msize - 11, because 11 is the header size of Rreaddir
 605      */
 606     req = v9fs_treaddir(v9p, 1, 0, P9_MAX_SIZE - 11, 0);
 607     v9fs_req_wait_for_reply(req, NULL);
 608     v9fs_rreaddir(req, &count, &nentries, &entries);
 609
 610     /*
 611      * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all
 612      * dir entries with only one readdir request.
 613      */
 614     g_assert_cmpint(
 615         nentries, ==,
 616         QTEST_V9FS_SYNTH_READDIR_NFILES + 2 /* "." and ".." */
 617     );
 618
 619     /*
 620      * Check all file names exist in returned entries, ignore their order
 621      * though.
 622      */
 623     g_assert_cmpint(fs_dirents_contain_name(entries, "."), ==, true);
 624     g_assert_cmpint(fs_dirents_contain_name(entries, ".."), ==, true);
 625     for (int i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) {
 626         char *name = g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE, i);
 627         g_assert_cmpint(fs_dirents_contain_name(entries, name), ==, true);
 628         g_free(name);
 629     }
 630
 631     v9fs_free_dirents(entries);
 632     g_free(wnames[0]);
 633 }
 634
 635 /* readdir test where overall request is split over several messages */
 636 static void fs_readdir_split(void *obj, void *data, QGuestAllocator *t_alloc,
 637                              uint32_t count)
 638 {
 639     QVirtio9P *v9p = obj;
 640     alloc = t_alloc;
 641     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) };
 642     uint16_t nqid;
 643     v9fs_qid qid;
 644     uint32_t nentries, npartialentries;
 645     struct V9fsDirent *entries, *tail, *partialentries;
 646     P9Req *req;
 647     int fid;
 648     uint64_t offset;
 649
 650     fs_attach(v9p, NULL, t_alloc);
 651
 652     fid = 1;
 653     offset = 0;
 654     entries = NULL;
 655     nentries = 0;
 656     tail = NULL;
 657
 658     req = v9fs_twalk(v9p, 0, fid, 1, wnames, 0);
 659     v9fs_req_wait_for_reply(req, NULL);
 660     v9fs_rwalk(req, &nqid, NULL);
 661     g_assert_cmpint(nqid, ==, 1);
 662
 663     req = v9fs_tlopen(v9p, fid, O_DIRECTORY, 0);
 664     v9fs_req_wait_for_reply(req, NULL);
 665     v9fs_rlopen(req, &qid, NULL);
 666
 667     /*
 668      * send as many Treaddir requests as required to get all directory
 669      * entries
 670      */
 671     while (true) {
 672         npartialentries = 0;
 673         partialentries = NULL;
 674
 675         req = v9fs_treaddir(v9p, fid, offset, count, 0);
 676         v9fs_req_wait_for_reply(req, NULL);
 677         v9fs_rreaddir(req, &count, &npartialentries, &partialentries);
 678         if (npartialentries > 0 && partialentries) {
 679             if (!entries) {
 680                 entries = partialentries;
 681                 nentries = npartialentries;
 682                 tail = partialentries;
 683             } else {
 684                 tail->next = partialentries;
 685                 nentries += npartialentries;
 686             }
 687             while (tail->next) {
 688                 tail = tail->next;
 689             }
 690             offset = tail->offset;
 691         } else {
 692             break;
 693         }
 694     }
 695
 696     g_assert_cmpint(
 697         nentries, ==,
 698         QTEST_V9FS_SYNTH_READDIR_NFILES + 2 /* "." and ".." */
 699     );
 700
 701     /*
 702      * Check all file names exist in returned entries, ignore their order
 703      * though.
 704      */
 705     g_assert_cmpint(fs_dirents_contain_name(entries, "."), ==, true);
 706     g_assert_cmpint(fs_dirents_contain_name(entries, ".."), ==, true);
 707     for (int i = 0; i < QTEST_V9FS_SYNTH_READDIR_NFILES; ++i) {
 708         char *name = g_strdup_printf(QTEST_V9FS_SYNTH_READDIR_FILE, i);
 709         g_assert_cmpint(fs_dirents_contain_name(entries, name), ==, true);
 710         g_free(name);
 711     }
 712
 713     v9fs_free_dirents(entries);
 714
 715     g_free(wnames[0]);
 716 }
 717
 718 static void fs_walk_no_slash(void *obj, void *data, QGuestAllocator *t_alloc)
 719 {
 720     QVirtio9P *v9p = obj;
 721     alloc = t_alloc;
 722     char *const wnames[] = { g_strdup(" /") };
 723     P9Req *req;
 724     uint32_t err;
 725
 726     fs_attach(v9p, NULL, t_alloc);
 727     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 728     v9fs_req_wait_for_reply(req, NULL);
 729     v9fs_rlerror(req, &err);
 730
 731     g_assert_cmpint(err, ==, ENOENT);
 732
 733     g_free(wnames[0]);
 734 }
 735
 736 static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc)
 737 {
 738     QVirtio9P *v9p = obj;
 739     alloc = t_alloc;
 740     char *const wnames[] = { g_strdup("..") };
 741     v9fs_qid root_qid, *wqid;
 742     P9Req *req;
 743
 744     fs_version(v9p, NULL, t_alloc);
 745     req = v9fs_tattach(v9p, 0, getuid(), 0);
 746     v9fs_req_wait_for_reply(req, NULL);
 747     v9fs_rattach(req, &root_qid);
 748
 749     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 750     v9fs_req_wait_for_reply(req, NULL);
 751     v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */
 752
 753     g_assert_cmpmem(&root_qid, 13, wqid[0], 13);
 754
 755     g_free(wqid);
 756     g_free(wnames[0]);
 757 }
 758
 759 static void fs_lopen(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_LOPEN_FILE) };
 764     P9Req *req;
 765
 766     fs_attach(v9p, NULL, t_alloc);
 767     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 768     v9fs_req_wait_for_reply(req, NULL);
 769     v9fs_rwalk(req, NULL, NULL);
 770
 771     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 772     v9fs_req_wait_for_reply(req, NULL);
 773     v9fs_rlopen(req, NULL, NULL);
 774
 775     g_free(wnames[0]);
 776 }
 777
 778 static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc)
 779 {
 780     QVirtio9P *v9p = obj;
 781     alloc = t_alloc;
 782     static const uint32_t write_count = P9_MAX_SIZE / 2;
 783     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) };
 784     char *buf = g_malloc0(write_count);
 785     uint32_t count;
 786     P9Req *req;
 787
 788     fs_attach(v9p, NULL, t_alloc);
 789     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 790     v9fs_req_wait_for_reply(req, NULL);
 791     v9fs_rwalk(req, NULL, NULL);
 792
 793     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 794     v9fs_req_wait_for_reply(req, NULL);
 795     v9fs_rlopen(req, NULL, NULL);
 796
 797     req = v9fs_twrite(v9p, 1, 0, write_count, buf, 0);
 798     v9fs_req_wait_for_reply(req, NULL);
 799     v9fs_rwrite(req, &count);
 800     g_assert_cmpint(count, ==, write_count);
 801
 802     g_free(buf);
 803     g_free(wnames[0]);
 804 }
 805
 806 static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc)
 807 {
 808     QVirtio9P *v9p = obj;
 809     alloc = t_alloc;
 810     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
 811     P9Req *req, *flush_req;
 812     uint32_t reply_len;
 813     uint8_t should_block;
 814
 815     fs_attach(v9p, NULL, t_alloc);
 816     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 817     v9fs_req_wait_for_reply(req, NULL);
 818     v9fs_rwalk(req, NULL, NULL);
 819
 820     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 821     v9fs_req_wait_for_reply(req, NULL);
 822     v9fs_rlopen(req, NULL, NULL);
 823
 824     /* This will cause the 9p server to try to write data to the backend,
 825      * until the write request gets cancelled.
 826      */
 827     should_block = 1;
 828     req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);
 829
 830     flush_req = v9fs_tflush(v9p, req->tag, 1);
 831
 832     /* The write request is supposed to be flushed: the server should just
 833      * mark the write request as used and reply to the flush request.
 834      */
 835     v9fs_req_wait_for_reply(req, &reply_len);
 836     g_assert_cmpint(reply_len, ==, 0);
 837     v9fs_req_free(req);
 838     v9fs_rflush(flush_req);
 839
 840     g_free(wnames[0]);
 841 }
 842
 843 static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)
 844 {
 845     QVirtio9P *v9p = obj;
 846     alloc = t_alloc;
 847     char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
 848     P9Req *req, *flush_req;
 849     uint32_t count;
 850     uint8_t should_block;
 851
 852     fs_attach(v9p, NULL, t_alloc);
 853     req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
 854     v9fs_req_wait_for_reply(req, NULL);
 855     v9fs_rwalk(req, NULL, NULL);
 856
 857     req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
 858     v9fs_req_wait_for_reply(req, NULL);
 859     v9fs_rlopen(req, NULL, NULL);
 860
 861     /* This will cause the write request to complete right away, before it
 862      * could be actually cancelled.
 863      */
 864     should_block = 0;
 865     req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);
 866
 867     flush_req = v9fs_tflush(v9p, req->tag, 1);
 868
 869     /* The write request is supposed to complete. The server should
 870      * reply to the write request and the flush request.
 871      */
 872     v9fs_req_wait_for_reply(req, NULL);
 873     v9fs_rwrite(req, &count);
 874     g_assert_cmpint(count, ==, sizeof(should_block));
 875     v9fs_rflush(flush_req);
 876
 877     g_free(wnames[0]);
 878 }
 879
 880 static void fs_readdir_split_128(void *obj, void *data,
 881                                  QGuestAllocator *t_alloc)
 882 {
 883     fs_readdir_split(obj, data, t_alloc, 128);
 884 }
 885
 886 static void fs_readdir_split_256(void *obj, void *data,
 887                                  QGuestAllocator *t_alloc)
 888 {
 889     fs_readdir_split(obj, data, t_alloc, 256);
 890 }
 891
 892 static void fs_readdir_split_512(void *obj, void *data,
 893                                  QGuestAllocator *t_alloc)
 894 {
 895     fs_readdir_split(obj, data, t_alloc, 512);
 896 }
 897
 898 static void register_virtio_9p_test(void)
 899 {
 900     qos_add_test("config", "virtio-9p", pci_config, NULL);
 901     qos_add_test("fs/version/basic", "virtio-9p", fs_version, NULL);
 902     qos_add_test("fs/attach/basic", "virtio-9p", fs_attach, NULL);
 903     qos_add_test("fs/walk/basic", "virtio-9p", fs_walk, NULL);
 904     qos_add_test("fs/walk/no_slash", "virtio-9p", fs_walk_no_slash,
 905                  NULL);
 906     qos_add_test("fs/walk/dotdot_from_root", "virtio-9p",
 907                  fs_walk_dotdot, NULL);
 908     qos_add_test("fs/lopen/basic", "virtio-9p", fs_lopen, NULL);
 909     qos_add_test("fs/write/basic", "virtio-9p", fs_write, NULL);
 910     qos_add_test("fs/flush/success", "virtio-9p", fs_flush_success,
 911                  NULL);
 912     qos_add_test("fs/flush/ignored", "virtio-9p", fs_flush_ignored,
 913                  NULL);
 914     qos_add_test("fs/readdir/basic", "virtio-9p", fs_readdir, NULL);
 915     qos_add_test("fs/readdir/split_512", "virtio-9p",
 916                  fs_readdir_split_512, NULL);
 917     qos_add_test("fs/readdir/split_256", "virtio-9p",
 918                  fs_readdir_split_256, NULL);
 919     qos_add_test("fs/readdir/split_128", "virtio-9p",
 920                  fs_readdir_split_128, NULL);
 921 }
 922
 923 libqos_init(register_virtio_9p_test);