[qemu.git] / tests / virtio-9p-test.c

/*
 * QTest testcase for VirtIO 9P
 *
 * Copyright (c) 2014 SUSE LINUX Products GmbH
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include "qemu/osdep.h"
#include "libqtest.h"
#include "hw/9pfs/9p.h"
#include "hw/9pfs/9p-synth.h"
#include "libqos/virtio-9p.h"
#include "libqos/qgraph.h"

#define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000)
static QGuestAllocator *alloc;

static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    size_t tag_len = qvirtio_config_readw(v9p->vdev, 0);
    char *tag;
    int i;

    g_assert_cmpint(tag_len, ==, strlen(MOUNT_TAG));

    tag = g_malloc(tag_len);
    for (i = 0; i < tag_len; i++) {
        tag[i] = qvirtio_config_readb(v9p->vdev, i + 2);
    }
    g_assert_cmpmem(tag, tag_len, MOUNT_TAG, tag_len);
    g_free(tag);
}

#define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */

typedef struct {
    QVirtio9P *v9p;
    uint16_t tag;
    uint64_t t_msg;
    uint32_t t_size;
    uint64_t r_msg;
    /* No r_size, it is hardcoded to P9_MAX_SIZE */
    size_t t_off;
    size_t r_off;
    uint32_t free_head;
} P9Req;

static void v9fs_memwrite(P9Req *req, const void *addr, size_t len)
{
    memwrite(req->t_msg + req->t_off, addr, len);
    req->t_off += len;
}

static void v9fs_memskip(P9Req *req, size_t len)
{
    req->r_off += len;
}

static void v9fs_memread(P9Req *req, void *addr, size_t len)
{
    memread(req->r_msg + req->r_off, addr, len);
    req->r_off += len;
}

static void v9fs_uint16_write(P9Req *req, uint16_t val)
{
    uint16_t le_val = cpu_to_le16(val);

    v9fs_memwrite(req, &le_val, 2);
}

static void v9fs_uint16_read(P9Req *req, uint16_t *val)
{
    v9fs_memread(req, val, 2);
    le16_to_cpus(val);
}

static void v9fs_uint32_write(P9Req *req, uint32_t val)
{
    uint32_t le_val = cpu_to_le32(val);

    v9fs_memwrite(req, &le_val, 4);
}

static void v9fs_uint64_write(P9Req *req, uint64_t val)
{
    uint64_t le_val = cpu_to_le64(val);

    v9fs_memwrite(req, &le_val, 8);
}

static void v9fs_uint32_read(P9Req *req, uint32_t *val)
{
    v9fs_memread(req, val, 4);
    le32_to_cpus(val);
}

/* len[2] string[len] */
static uint16_t v9fs_string_size(const char *string)
{
    size_t len = strlen(string);

    g_assert_cmpint(len, <=, UINT16_MAX - 2);

    return 2 + len;
}

static void v9fs_string_write(P9Req *req, const char *string)
{
    int len = strlen(string);

    g_assert_cmpint(len, <=, UINT16_MAX);

    v9fs_uint16_write(req, (uint16_t) len);
    v9fs_memwrite(req, string, len);
}

static void v9fs_string_read(P9Req *req, uint16_t *len, char **string)
{
    uint16_t local_len;

    v9fs_uint16_read(req, &local_len);
    if (len) {
        *len = local_len;
    }
    if (string) {
        *string = g_malloc(local_len);
        v9fs_memread(req, *string, local_len);
    } else {
        v9fs_memskip(req, local_len);
    }
}

 typedef struct {
    uint32_t size;
    uint8_t id;
    uint16_t tag;
} QEMU_PACKED P9Hdr;

static P9Req *v9fs_req_init(QVirtio9P *v9p, uint32_t size, uint8_t id,
                            uint16_t tag)
{
    P9Req *req = g_new0(P9Req, 1);
    uint32_t total_size = 7; /* 9P header has well-known size of 7 bytes */
    P9Hdr hdr = {
        .id = id,
        .tag = cpu_to_le16(tag)
    };

    g_assert_cmpint(total_size, <=, UINT32_MAX - size);
    total_size += size;
    hdr.size = cpu_to_le32(total_size);

    g_assert_cmpint(total_size, <=, P9_MAX_SIZE);

    req->v9p = v9p;
    req->t_size = total_size;
    req->t_msg = guest_alloc(alloc, req->t_size);
    v9fs_memwrite(req, &hdr, 7);
    req->tag = tag;
    return req;
}

static void v9fs_req_send(P9Req *req)
{
    QVirtio9P *v9p = req->v9p;

    req->r_msg = guest_alloc(alloc, P9_MAX_SIZE);
    req->free_head = qvirtqueue_add(v9p->vq, req->t_msg, req->t_size, false,
                                    true);
    qvirtqueue_add(v9p->vq, req->r_msg, P9_MAX_SIZE, true, false);
    qvirtqueue_kick(v9p->vdev, v9p->vq, req->free_head);
    req->t_off = 0;
}

static const char *rmessage_name(uint8_t id)
{
    return
        id == P9_RLERROR ? "RLERROR" :
        id == P9_RVERSION ? "RVERSION" :
        id == P9_RATTACH ? "RATTACH" :
        id == P9_RWALK ? "RWALK" :
        id == P9_RLOPEN ? "RLOPEN" :
        id == P9_RWRITE ? "RWRITE" :
        id == P9_RFLUSH ? "RFLUSH" :
        "<unknown>";
}

static void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len)
{
    QVirtio9P *v9p = req->v9p;

    qvirtio_wait_used_elem(v9p->vdev, v9p->vq, req->free_head, len,
                           QVIRTIO_9P_TIMEOUT_US);
}

static void v9fs_req_recv(P9Req *req, uint8_t id)
{
    P9Hdr hdr;

    v9fs_memread(req, &hdr, 7);
    hdr.size = ldl_le_p(&hdr.size);
    hdr.tag = lduw_le_p(&hdr.tag);

    g_assert_cmpint(hdr.size, >=, 7);
    g_assert_cmpint(hdr.size, <=, P9_MAX_SIZE);
    g_assert_cmpint(hdr.tag, ==, req->tag);

    if (hdr.id != id) {
        g_printerr("Received response %d (%s) instead of %d (%s)\n",
                   hdr.id, rmessage_name(hdr.id), id, rmessage_name(id));

        if (hdr.id == P9_RLERROR) {
            uint32_t err;
            v9fs_uint32_read(req, &err);
            g_printerr("Rlerror has errno %d (%s)\n", err, strerror(err));
        }
    }
    g_assert_cmpint(hdr.id, ==, id);
}

static void v9fs_req_free(P9Req *req)
{
    guest_free(alloc, req->t_msg);
    guest_free(alloc, req->r_msg);
    g_free(req);
}

/* size[4] Rlerror tag[2] ecode[4] */
static void v9fs_rlerror(P9Req *req, uint32_t *err)
{
    v9fs_req_recv(req, P9_RLERROR);
    v9fs_uint32_read(req, err);
    v9fs_req_free(req);
}

/* size[4] Tversion tag[2] msize[4] version[s] */
static P9Req *v9fs_tversion(QVirtio9P *v9p, uint32_t msize, const char *version,
                            uint16_t tag)
{
    P9Req *req;
    uint32_t body_size = 4;
    uint16_t string_size = v9fs_string_size(version);

    g_assert_cmpint(body_size, <=, UINT32_MAX - string_size);
    body_size += string_size;
    req = v9fs_req_init(v9p, body_size, P9_TVERSION, tag);

    v9fs_uint32_write(req, msize);
    v9fs_string_write(req, version);
    v9fs_req_send(req);
    return req;
}

/* size[4] Rversion tag[2] msize[4] version[s] */
static void v9fs_rversion(P9Req *req, uint16_t *len, char **version)
{
    uint32_t msize;

    v9fs_req_recv(req, P9_RVERSION);
    v9fs_uint32_read(req, &msize);

    g_assert_cmpint(msize, ==, P9_MAX_SIZE);

    if (len || version) {
        v9fs_string_read(req, len, version);
    }

    v9fs_req_free(req);
}

/* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */
static P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname,
                           uint16_t tag)
{
    const char *uname = ""; /* ignored by QEMU */
    const char *aname = ""; /* ignored by QEMU */
    P9Req *req = v9fs_req_init(v9p, 4 + 4 + 2 + 2 + 4, P9_TATTACH, tag);

    v9fs_uint32_write(req, fid);
    v9fs_uint32_write(req, P9_NOFID);
    v9fs_string_write(req, uname);
    v9fs_string_write(req, aname);
    v9fs_uint32_write(req, n_uname);
    v9fs_req_send(req);
    return req;
}

typedef char v9fs_qid[13];

/* size[4] Rattach tag[2] qid[13] */
static void v9fs_rattach(P9Req *req, v9fs_qid *qid)
{
    v9fs_req_recv(req, P9_RATTACH);
    if (qid) {
        v9fs_memread(req, qid, 13);
    }
    v9fs_req_free(req);
}

/* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
static P9Req *v9fs_twalk(QVirtio9P *v9p, uint32_t fid, uint32_t newfid,
                         uint16_t nwname, char *const wnames[], uint16_t tag)
{
    P9Req *req;
    int i;
    uint32_t body_size = 4 + 4 + 2;

    for (i = 0; i < nwname; i++) {
        uint16_t wname_size = v9fs_string_size(wnames[i]);

        g_assert_cmpint(body_size, <=, UINT32_MAX - wname_size);
        body_size += wname_size;
    }
    req = v9fs_req_init(v9p,  body_size, P9_TWALK, tag);
    v9fs_uint32_write(req, fid);
    v9fs_uint32_write(req, newfid);
    v9fs_uint16_write(req, nwname);
    for (i = 0; i < nwname; i++) {
        v9fs_string_write(req, wnames[i]);
    }
    v9fs_req_send(req);
    return req;
}

/* size[4] Rwalk tag[2] nwqid[2] nwqid*(wqid[13]) */
static void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid)
{
    uint16_t local_nwqid;

    v9fs_req_recv(req, P9_RWALK);
    v9fs_uint16_read(req, &local_nwqid);
    if (nwqid) {
        *nwqid = local_nwqid;
    }
    if (wqid) {
        *wqid = g_malloc(local_nwqid * 13);
        v9fs_memread(req, *wqid, local_nwqid * 13);
    }
    v9fs_req_free(req);
}

/* size[4] Tlopen tag[2] fid[4] flags[4] */
static P9Req *v9fs_tlopen(QVirtio9P *v9p, uint32_t fid, uint32_t flags,
                          uint16_t tag)
{
    P9Req *req;

    req = v9fs_req_init(v9p,  4 + 4, P9_TLOPEN, tag);
    v9fs_uint32_write(req, fid);
    v9fs_uint32_write(req, flags);
    v9fs_req_send(req);
    return req;
}

/* size[4] Rlopen tag[2] qid[13] iounit[4] */
static void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *iounit)
{
    v9fs_req_recv(req, P9_RLOPEN);
    if (qid) {
        v9fs_memread(req, qid, 13);
    } else {
        v9fs_memskip(req, 13);
    }
    if (iounit) {
        v9fs_uint32_read(req, iounit);
    }
    v9fs_req_free(req);
}

/* size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count] */
static P9Req *v9fs_twrite(QVirtio9P *v9p, uint32_t fid, uint64_t offset,
                          uint32_t count, const void *data, uint16_t tag)
{
    P9Req *req;
    uint32_t body_size = 4 + 8 + 4;

    g_assert_cmpint(body_size, <=, UINT32_MAX - count);
    body_size += count;
    req = v9fs_req_init(v9p,  body_size, P9_TWRITE, tag);
    v9fs_uint32_write(req, fid);
    v9fs_uint64_write(req, offset);
    v9fs_uint32_write(req, count);
    v9fs_memwrite(req, data, count);
    v9fs_req_send(req);
    return req;
}

/* size[4] Rwrite tag[2] count[4] */
static void v9fs_rwrite(P9Req *req, uint32_t *count)
{
    v9fs_req_recv(req, P9_RWRITE);
    if (count) {
        v9fs_uint32_read(req, count);
    }
    v9fs_req_free(req);
}

/* size[4] Tflush tag[2] oldtag[2] */
static P9Req *v9fs_tflush(QVirtio9P *v9p, uint16_t oldtag, uint16_t tag)
{
    P9Req *req;

    req = v9fs_req_init(v9p,  2, P9_TFLUSH, tag);
    v9fs_uint32_write(req, oldtag);
    v9fs_req_send(req);
    return req;
}

/* size[4] Rflush tag[2] */
static void v9fs_rflush(P9Req *req)
{
    v9fs_req_recv(req, P9_RFLUSH);
    v9fs_req_free(req);
}

static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    const char *version = "9P2000.L";
    uint16_t server_len;
    char *server_version;
    P9Req *req;

    req = v9fs_tversion(v9p, P9_MAX_SIZE, version, P9_NOTAG);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rversion(req, &server_len, &server_version);

    g_assert_cmpmem(server_version, server_len, version, strlen(version));

    g_free(server_version);
}

static void fs_attach(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    P9Req *req;

    fs_version(v9p, NULL, t_alloc);
    req = v9fs_tattach(v9p, 0, getuid(), 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rattach(req, NULL);
}

static void fs_walk(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    char *wnames[P9_MAXWELEM];
    uint16_t nwqid;
    v9fs_qid *wqid;
    int i;
    P9Req *req;

    for (i = 0; i < P9_MAXWELEM; i++) {
        wnames[i] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i);
    }

    fs_attach(v9p, NULL, t_alloc);
    req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwalk(req, &nwqid, &wqid);

    g_assert_cmpint(nwqid, ==, P9_MAXWELEM);

    for (i = 0; i < P9_MAXWELEM; i++) {
        g_free(wnames[i]);
    }

    g_free(wqid);
}

static void fs_walk_no_slash(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    char *const wnames[] = { g_strdup(" /") };
    P9Req *req;
    uint32_t err;

    fs_attach(v9p, NULL, t_alloc);
    req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rlerror(req, &err);

    g_assert_cmpint(err, ==, ENOENT);

    g_free(wnames[0]);
}

static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    char *const wnames[] = { g_strdup("..") };
    v9fs_qid root_qid, *wqid;
    P9Req *req;

    fs_version(v9p, NULL, t_alloc);
    req = v9fs_tattach(v9p, 0, getuid(), 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rattach(req, &root_qid);

    req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */

    g_assert_cmpmem(&root_qid, 13, wqid[0], 13);

    g_free(wqid);
    g_free(wnames[0]);
}

static void fs_lopen(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) };
    P9Req *req;

    fs_attach(v9p, NULL, t_alloc);
    req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwalk(req, NULL, NULL);

    req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rlopen(req, NULL, NULL);

    g_free(wnames[0]);
}

static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    static const uint32_t write_count = P9_MAX_SIZE / 2;
    char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) };
    char *buf = g_malloc0(write_count);
    uint32_t count;
    P9Req *req;

    fs_attach(v9p, NULL, t_alloc);
    req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwalk(req, NULL, NULL);

    req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rlopen(req, NULL, NULL);

    req = v9fs_twrite(v9p, 1, 0, write_count, buf, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwrite(req, &count);
    g_assert_cmpint(count, ==, write_count);

    g_free(buf);
    g_free(wnames[0]);
}

static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
    P9Req *req, *flush_req;
    uint32_t reply_len;
    uint8_t should_block;

    fs_attach(v9p, NULL, t_alloc);
    req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwalk(req, NULL, NULL);

    req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rlopen(req, NULL, NULL);

    /* This will cause the 9p server to try to write data to the backend,
     * until the write request gets cancelled.
     */
    should_block = 1;
    req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);

    flush_req = v9fs_tflush(v9p, req->tag, 1);

    /* The write request is supposed to be flushed: the server should just
     * mark the write request as used and reply to the flush request.
     */
    v9fs_req_wait_for_reply(req, &reply_len);
    g_assert_cmpint(reply_len, ==, 0);
    v9fs_req_free(req);
    v9fs_rflush(flush_req);

    g_free(wnames[0]);
}

static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)
{
    QVirtio9P *v9p = obj;
    alloc = t_alloc;
    char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
    P9Req *req, *flush_req;
    uint32_t count;
    uint8_t should_block;

    fs_attach(v9p, NULL, t_alloc);
    req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwalk(req, NULL, NULL);

    req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rlopen(req, NULL, NULL);

    /* This will cause the write request to complete right away, before it
     * could be actually cancelled.
     */
    should_block = 0;
    req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);

    flush_req = v9fs_tflush(v9p, req->tag, 1);

    /* The write request is supposed to complete. The server should
     * reply to the write request and the flush request.
     */
    v9fs_req_wait_for_reply(req, NULL);
    v9fs_rwrite(req, &count);
    g_assert_cmpint(count, ==, sizeof(should_block));
    v9fs_rflush(flush_req);

    g_free(wnames[0]);
}

static void register_virtio_9p_test(void)
{
    qos_add_test("config", "virtio-9p", pci_config, NULL);
    qos_add_test("fs/version/basic", "virtio-9p", fs_version, NULL);
    qos_add_test("fs/attach/basic", "virtio-9p", fs_attach, NULL);
    qos_add_test("fs/walk/basic", "virtio-9p", fs_walk, NULL);
    qos_add_test("fs/walk/no_slash", "virtio-9p", fs_walk_no_slash,
                 NULL);
    qos_add_test("fs/walk/dotdot_from_root", "virtio-9p",
                 fs_walk_dotdot, NULL);
    qos_add_test("fs/lopen/basic", "virtio-9p", fs_lopen, NULL);
    qos_add_test("fs/write/basic", "virtio-9p", fs_write, NULL);
    qos_add_test("fs/flush/success", "virtio-9p", fs_flush_success,
                 NULL);
    qos_add_test("fs/flush/ignored", "virtio-9p", fs_flush_ignored,
                 NULL);
}

libqos_init(register_virtio_9p_test);
Commit	Line	Data
2d888c09 AF	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
fbc04127	10	#include "qemu/osdep.h"
2d888c09	11	#include "libqtest.h"
6cc9906b	12	#include "hw/9pfs/9p.h"
2893ddd5	13	#include "hw/9pfs/9p-synth.h"
dfbe8b43 EGE	14	#include "libqos/virtio-9p.h"
dfbe8b43 EGE	15	#include "libqos/qgraph.h"
2d888c09	16
65b70fc7	17	#define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000)
dfbe8b43	18	static QGuestAllocator *alloc;
65b70fc7	19
dfbe8b43	20	static void pci_config(void obj, void data, QGuestAllocator *t_alloc)
557a4cc0	21	{
dfbe8b43 EGE	22	QVirtio9P *v9p = obj;
	23	alloc = t_alloc;
	24	size_t tag_len = qvirtio_config_readw(v9p->vdev, 0);
557a4cc0 GK	25	char *tag;
557a4cc0 GK	26	int i;
557a4cc0	27
dfbe8b43	28	g_assert_cmpint(tag_len, ==, strlen(MOUNT_TAG));
557a4cc0 GK	29
	30	tag = g_malloc(tag_len);
	31	for (i = 0; i < tag_len; i++) {
dfbe8b43	32	tag[i] = qvirtio_config_readb(v9p->vdev, i + 2);
557a4cc0	33	}
dfbe8b43	34	g_assert_cmpmem(tag, tag_len, MOUNT_TAG, tag_len);
557a4cc0	35	g_free(tag);
1211d81b GK	36	}
1211d81b GK	37
6cc9906b GK	38	#define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */
	39
	40	typedef struct {
dfbe8b43	41	QVirtio9P *v9p;
6cc9906b GK	42	uint16_t tag;
	43	uint64_t t_msg;
	44	uint32_t t_size;
	45	uint64_t r_msg;
	46	/* No r_size, it is hardcoded to P9_MAX_SIZE */
	47	size_t t_off;
	48	size_t r_off;
65b70fc7	49	uint32_t free_head;
6cc9906b GK	50	} P9Req;
	51
	52	static void v9fs_memwrite(P9Req req, const void addr, size_t len)
	53	{
	54	memwrite(req->t_msg + req->t_off, addr, len);
	55	req->t_off += len;
	56	}
	57
	58	static void v9fs_memskip(P9Req *req, size_t len)
	59	{
	60	req->r_off += len;
	61	}
	62
6cc9906b GK	63	static void v9fs_memread(P9Req req, void addr, size_t len)
	64	{
	65	memread(req->r_msg + req->r_off, addr, len);
	66	req->r_off += len;
	67	}
	68
	69	static void v9fs_uint16_write(P9Req *req, uint16_t val)
	70	{
	71	uint16_t le_val = cpu_to_le16(val);
	72
	73	v9fs_memwrite(req, &le_val, 2);
	74	}
	75
	76	static void v9fs_uint16_read(P9Req req, uint16_t val)
	77	{
	78	v9fs_memread(req, val, 2);
	79	le16_to_cpus(val);
	80	}
	81
	82	static void v9fs_uint32_write(P9Req *req, uint32_t val)
	83	{
	84	uint32_t le_val = cpu_to_le32(val);
	85
	86	v9fs_memwrite(req, &le_val, 4);
	87	}
	88
354b86f8 GK	89	static void v9fs_uint64_write(P9Req *req, uint64_t val)
	90	{
	91	uint64_t le_val = cpu_to_le64(val);
	92
	93	v9fs_memwrite(req, &le_val, 8);
	94	}
	95
6cc9906b GK	96	static void v9fs_uint32_read(P9Req req, uint32_t val)
	97	{
	98	v9fs_memread(req, val, 4);
	99	le32_to_cpus(val);
	100	}
	101
	102	/* len[2] string[len] */
	103	static uint16_t v9fs_string_size(const char *string)
	104	{
	105	size_t len = strlen(string);
	106
9ea776ee	107	g_assert_cmpint(len, <=, UINT16_MAX - 2);
6cc9906b GK	108
	109	return 2 + len;
	110	}
	111
	112	static void v9fs_string_write(P9Req req, const char string)
	113	{
	114	int len = strlen(string);
	115
	116	g_assert_cmpint(len, <=, UINT16_MAX);
	117
	118	v9fs_uint16_write(req, (uint16_t) len);
	119	v9fs_memwrite(req, string, len);
	120	}
	121
	122	static void v9fs_string_read(P9Req req, uint16_t len, char **string)
	123	{
	124	uint16_t local_len;
	125
	126	v9fs_uint16_read(req, &local_len);
	127	if (len) {
	128	*len = local_len;
	129	}
	130	if (string) {
	131	*string = g_malloc(local_len);
	132	v9fs_memread(req, *string, local_len);
	133	} else {
	134	v9fs_memskip(req, local_len);
	135	}
	136	}
	137
	138	typedef struct {
	139	uint32_t size;
	140	uint8_t id;
	141	uint16_t tag;
	142	} QEMU_PACKED P9Hdr;
	143
dfbe8b43	144	static P9Req v9fs_req_init(QVirtio9P v9p, uint32_t size, uint8_t id,
6cc9906b GK	145	uint16_t tag)
	146	{
	147	P9Req *req = g_new0(P9Req, 1);
9ea776ee	148	uint32_t total_size = 7; /* 9P header has well-known size of 7 bytes */
6cc9906b	149	P9Hdr hdr = {
6cc9906b GK	150	.id = id,
	151	.tag = cpu_to_le16(tag)
	152	};
	153
9ea776ee GK	154	g_assert_cmpint(total_size, <=, UINT32_MAX - size);
	155	total_size += size;
	156	hdr.size = cpu_to_le32(total_size);
	157
	158	g_assert_cmpint(total_size, <=, P9_MAX_SIZE);
6cc9906b GK	159
6cc9906b GK	160	req->v9p = v9p;
9ea776ee	161	req->t_size = total_size;
dfbe8b43	162	req->t_msg = guest_alloc(alloc, req->t_size);
6cc9906b GK	163	v9fs_memwrite(req, &hdr, 7);
	164	req->tag = tag;
	165	return req;
	166	}
	167
	168	static void v9fs_req_send(P9Req *req)
	169	{
dfbe8b43	170	QVirtio9P *v9p = req->v9p;
6cc9906b	171
dfbe8b43	172	req->r_msg = guest_alloc(alloc, P9_MAX_SIZE);
65b70fc7 GK	173	req->free_head = qvirtqueue_add(v9p->vq, req->t_msg, req->t_size, false,
65b70fc7 GK	174	true);
6cc9906b	175	qvirtqueue_add(v9p->vq, req->r_msg, P9_MAX_SIZE, true, false);
dfbe8b43	176	qvirtqueue_kick(v9p->vdev, v9p->vq, req->free_head);
6cc9906b GK	177	req->t_off = 0;
	178	}
	179
6e37f458 GK	180	static const char *rmessage_name(uint8_t id)
	181	{
	182	return
	183	id == P9_RLERROR ? "RLERROR" :
	184	id == P9_RVERSION ? "RVERSION" :
	185	id == P9_RATTACH ? "RATTACH" :
	186	id == P9_RWALK ? "RWALK" :
82469aae	187	id == P9_RLOPEN ? "RLOPEN" :
354b86f8	188	id == P9_RWRITE ? "RWRITE" :
357e2f7f	189	id == P9_RFLUSH ? "RFLUSH" :
6e37f458 GK	190	"<unknown>";
	191	}
	192
357e2f7f	193	static void v9fs_req_wait_for_reply(P9Req req, uint32_t len)
6cc9906b	194	{
dfbe8b43	195	QVirtio9P *v9p = req->v9p;
6cc9906b	196
dfbe8b43	197	qvirtio_wait_used_elem(v9p->vdev, v9p->vq, req->free_head, len,
65b70fc7	198	QVIRTIO_9P_TIMEOUT_US);
60b1fa9d GK	199	}
	200
	201	static void v9fs_req_recv(P9Req *req, uint8_t id)
	202	{
	203	P9Hdr hdr;
6cc9906b	204
65b70fc7 GK	205	v9fs_memread(req, &hdr, 7);
	206	hdr.size = ldl_le_p(&hdr.size);
	207	hdr.tag = lduw_le_p(&hdr.tag);
6cc9906b GK	208
	209	g_assert_cmpint(hdr.size, >=, 7);
	210	g_assert_cmpint(hdr.size, <=, P9_MAX_SIZE);
	211	g_assert_cmpint(hdr.tag, ==, req->tag);
	212
6e37f458 GK	213	if (hdr.id != id) {
	214	g_printerr("Received response %d (%s) instead of %d (%s)\n",
	215	hdr.id, rmessage_name(hdr.id), id, rmessage_name(id));
	216
	217	if (hdr.id == P9_RLERROR) {
	218	uint32_t err;
	219	v9fs_uint32_read(req, &err);
	220	g_printerr("Rlerror has errno %d (%s)\n", err, strerror(err));
	221	}
6cc9906b GK	222	}
	223	g_assert_cmpint(hdr.id, ==, id);
	224	}
	225
	226	static void v9fs_req_free(P9Req *req)
	227	{
dfbe8b43 EGE	228	guest_free(alloc, req->t_msg);
dfbe8b43 EGE	229	guest_free(alloc, req->r_msg);
6cc9906b GK	230	g_free(req);
	231	}
	232
ba0d1037 GK	233	/* size[4] Rlerror tag[2] ecode[4] */
	234	static void v9fs_rlerror(P9Req req, uint32_t err)
	235	{
	236	v9fs_req_recv(req, P9_RLERROR);
	237	v9fs_uint32_read(req, err);
	238	v9fs_req_free(req);
	239	}
	240
6cc9906b	241	/* size[4] Tversion tag[2] msize[4] version[s] */
dfbe8b43	242	static P9Req v9fs_tversion(QVirtio9P v9p, uint32_t msize, const char *version,
693b21d2	243	uint16_t tag)
6cc9906b	244	{
9ea776ee GK	245	P9Req *req;
	246	uint32_t body_size = 4;
	247	uint16_t string_size = v9fs_string_size(version);
	248
	249	g_assert_cmpint(body_size, <=, UINT32_MAX - string_size);
	250	body_size += string_size;
	251	req = v9fs_req_init(v9p, body_size, P9_TVERSION, tag);
6cc9906b GK	252
	253	v9fs_uint32_write(req, msize);
	254	v9fs_string_write(req, version);
	255	v9fs_req_send(req);
	256	return req;
	257	}
	258
	259	/* size[4] Rversion tag[2] msize[4] version[s] */
	260	static void v9fs_rversion(P9Req req, uint16_t len, char **version)
	261	{
	262	uint32_t msize;
	263
	264	v9fs_req_recv(req, P9_RVERSION);
	265	v9fs_uint32_read(req, &msize);
	266
	267	g_assert_cmpint(msize, ==, P9_MAX_SIZE);
	268
	269	if (len \|\| version) {
	270	v9fs_string_read(req, len, version);
	271	}
	272
	273	v9fs_req_free(req);
	274	}
	275
5c3df1f0	276	/* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */
dfbe8b43	277	static P9Req v9fs_tattach(QVirtio9P v9p, uint32_t fid, uint32_t n_uname,
693b21d2	278	uint16_t tag)
5c3df1f0 GK	279	{
	280	const char uname = ""; / ignored by QEMU */
	281	const char aname = ""; / ignored by QEMU */
693b21d2	282	P9Req *req = v9fs_req_init(v9p, 4 + 4 + 2 + 2 + 4, P9_TATTACH, tag);
5c3df1f0 GK	283
	284	v9fs_uint32_write(req, fid);
	285	v9fs_uint32_write(req, P9_NOFID);
	286	v9fs_string_write(req, uname);
	287	v9fs_string_write(req, aname);
	288	v9fs_uint32_write(req, n_uname);
	289	v9fs_req_send(req);
	290	return req;
	291	}
	292
	293	typedef char v9fs_qid[13];
	294
	295	/* size[4] Rattach tag[2] qid[13] */
	296	static void v9fs_rattach(P9Req req, v9fs_qid qid)
	297	{
	298	v9fs_req_recv(req, P9_RATTACH);
	299	if (qid) {
	300	v9fs_memread(req, qid, 13);
	301	}
	302	v9fs_req_free(req);
	303	}
	304
04b88c84	305	/* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname(wname[s]) /
dfbe8b43	306	static P9Req v9fs_twalk(QVirtio9P v9p, uint32_t fid, uint32_t newfid,
693b21d2	307	uint16_t nwname, char *const wnames[], uint16_t tag)
04b88c84 GK	308	{
	309	P9Req *req;
	310	int i;
9ea776ee	311	uint32_t body_size = 4 + 4 + 2;
04b88c84 GK	312
04b88c84 GK	313	for (i = 0; i < nwname; i++) {
9ea776ee GK	314	uint16_t wname_size = v9fs_string_size(wnames[i]);
	315
	316	g_assert_cmpint(body_size, <=, UINT32_MAX - wname_size);
	317	body_size += wname_size;
04b88c84	318	}
9ea776ee	319	req = v9fs_req_init(v9p, body_size, P9_TWALK, tag);
04b88c84 GK	320	v9fs_uint32_write(req, fid);
	321	v9fs_uint32_write(req, newfid);
	322	v9fs_uint16_write(req, nwname);
	323	for (i = 0; i < nwname; i++) {
	324	v9fs_string_write(req, wnames[i]);
	325	}
	326	v9fs_req_send(req);
	327	return req;
	328	}
	329
	330	/* size[4] Rwalk tag[2] nwqid[2] nwqid(wqid[13]) /
	331	static void v9fs_rwalk(P9Req req, uint16_t nwqid, v9fs_qid **wqid)
	332	{
	333	uint16_t local_nwqid;
	334
	335	v9fs_req_recv(req, P9_RWALK);
	336	v9fs_uint16_read(req, &local_nwqid);
	337	if (nwqid) {
	338	*nwqid = local_nwqid;
	339	}
	340	if (wqid) {
	341	wqid = g_malloc(local_nwqid 13);
	342	v9fs_memread(req, wqid, local_nwqid 13);
	343	}
	344	v9fs_req_free(req);
	345	}
	346
82469aae	347	/* size[4] Tlopen tag[2] fid[4] flags[4] */
dfbe8b43	348	static P9Req v9fs_tlopen(QVirtio9P v9p, uint32_t fid, uint32_t flags,
82469aae GK	349	uint16_t tag)
	350	{
	351	P9Req *req;
	352
	353	req = v9fs_req_init(v9p, 4 + 4, P9_TLOPEN, tag);
	354	v9fs_uint32_write(req, fid);
	355	v9fs_uint32_write(req, flags);
	356	v9fs_req_send(req);
	357	return req;
	358	}
	359
	360	/* size[4] Rlopen tag[2] qid[13] iounit[4] */
	361	static void v9fs_rlopen(P9Req req, v9fs_qid qid, uint32_t *iounit)
	362	{
	363	v9fs_req_recv(req, P9_RLOPEN);
	364	if (qid) {
	365	v9fs_memread(req, qid, 13);
	366	} else {
	367	v9fs_memskip(req, 13);
	368	}
	369	if (iounit) {
	370	v9fs_uint32_read(req, iounit);
	371	}
	372	v9fs_req_free(req);
	373	}
	374
354b86f8	375	/* size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count] */
dfbe8b43	376	static P9Req v9fs_twrite(QVirtio9P v9p, uint32_t fid, uint64_t offset,
354b86f8 GK	377	uint32_t count, const void *data, uint16_t tag)
	378	{
	379	P9Req *req;
	380	uint32_t body_size = 4 + 8 + 4;
	381
	382	g_assert_cmpint(body_size, <=, UINT32_MAX - count);
	383	body_size += count;
	384	req = v9fs_req_init(v9p, body_size, P9_TWRITE, tag);
	385	v9fs_uint32_write(req, fid);
	386	v9fs_uint64_write(req, offset);
	387	v9fs_uint32_write(req, count);
	388	v9fs_memwrite(req, data, count);
	389	v9fs_req_send(req);
	390	return req;
	391	}
	392
	393	/* size[4] Rwrite tag[2] count[4] */
	394	static void v9fs_rwrite(P9Req req, uint32_t count)
	395	{
	396	v9fs_req_recv(req, P9_RWRITE);
	397	if (count) {
	398	v9fs_uint32_read(req, count);
	399	}
	400	v9fs_req_free(req);
	401	}
	402
357e2f7f	403	/* size[4] Tflush tag[2] oldtag[2] */
dfbe8b43	404	static P9Req v9fs_tflush(QVirtio9P v9p, uint16_t oldtag, uint16_t tag)
357e2f7f GK	405	{
	406	P9Req *req;
	407
	408	req = v9fs_req_init(v9p, 2, P9_TFLUSH, tag);
	409	v9fs_uint32_write(req, oldtag);
	410	v9fs_req_send(req);
	411	return req;
	412	}
	413
	414	/* size[4] Rflush tag[2] */
	415	static void v9fs_rflush(P9Req *req)
	416	{
	417	v9fs_req_recv(req, P9_RFLUSH);
	418	v9fs_req_free(req);
	419	}
	420
dfbe8b43	421	static void fs_version(void obj, void data, QGuestAllocator *t_alloc)
6cc9906b	422	{
dfbe8b43 EGE	423	QVirtio9P *v9p = obj;
dfbe8b43 EGE	424	alloc = t_alloc;
6cc9906b GK	425	const char *version = "9P2000.L";
	426	uint16_t server_len;
	427	char *server_version;
	428	P9Req *req;
	429
693b21d2	430	req = v9fs_tversion(v9p, P9_MAX_SIZE, version, P9_NOTAG);
357e2f7f	431	v9fs_req_wait_for_reply(req, NULL);
6cc9906b GK	432	v9fs_rversion(req, &server_len, &server_version);
	433
	434	g_assert_cmpmem(server_version, server_len, version, strlen(version));
	435
	436	g_free(server_version);
	437	}
	438
dfbe8b43	439	static void fs_attach(void obj, void data, QGuestAllocator *t_alloc)
5c3df1f0	440	{
dfbe8b43 EGE	441	QVirtio9P *v9p = obj;
dfbe8b43 EGE	442	alloc = t_alloc;
5c3df1f0 GK	443	P9Req *req;
5c3df1f0 GK	444
dfbe8b43	445	fs_version(v9p, NULL, t_alloc);
693b21d2	446	req = v9fs_tattach(v9p, 0, getuid(), 0);
357e2f7f	447	v9fs_req_wait_for_reply(req, NULL);
5c3df1f0 GK	448	v9fs_rattach(req, NULL);
	449	}
	450
dfbe8b43	451	static void fs_walk(void obj, void data, QGuestAllocator *t_alloc)
04b88c84	452	{
dfbe8b43 EGE	453	QVirtio9P *v9p = obj;
dfbe8b43 EGE	454	alloc = t_alloc;
2893ddd5	455	char *wnames[P9_MAXWELEM];
04b88c84 GK	456	uint16_t nwqid;
	457	v9fs_qid *wqid;
	458	int i;
	459	P9Req *req;
	460
	461	for (i = 0; i < P9_MAXWELEM; i++) {
2893ddd5	462	wnames[i] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i);
04b88c84 GK	463	}
04b88c84 GK	464
dfbe8b43	465	fs_attach(v9p, NULL, t_alloc);
693b21d2	466	req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0);
357e2f7f	467	v9fs_req_wait_for_reply(req, NULL);
04b88c84 GK	468	v9fs_rwalk(req, &nwqid, &wqid);
	469
	470	g_assert_cmpint(nwqid, ==, P9_MAXWELEM);
	471
	472	for (i = 0; i < P9_MAXWELEM; i++) {
04b88c84 GK	473	g_free(wnames[i]);
	474	}
	475
	476	g_free(wqid);
	477	}
	478
dfbe8b43	479	static void fs_walk_no_slash(void obj, void data, QGuestAllocator *t_alloc)
ba0d1037	480	{
dfbe8b43 EGE	481	QVirtio9P *v9p = obj;
dfbe8b43 EGE	482	alloc = t_alloc;
ba0d1037 GK	483	char *const wnames[] = { g_strdup(" /") };
	484	P9Req *req;
	485	uint32_t err;
	486
dfbe8b43	487	fs_attach(v9p, NULL, t_alloc);
693b21d2	488	req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
357e2f7f	489	v9fs_req_wait_for_reply(req, NULL);
ba0d1037 GK	490	v9fs_rlerror(req, &err);
	491
	492	g_assert_cmpint(err, ==, ENOENT);
	493
	494	g_free(wnames[0]);
	495	}
	496
dfbe8b43	497	static void fs_walk_dotdot(void obj, void data, QGuestAllocator *t_alloc)
a37c0702	498	{
dfbe8b43 EGE	499	QVirtio9P *v9p = obj;
dfbe8b43 EGE	500	alloc = t_alloc;
a37c0702 GK	501	char *const wnames[] = { g_strdup("..") };
	502	v9fs_qid root_qid, *wqid;
	503	P9Req *req;
	504
dfbe8b43	505	fs_version(v9p, NULL, t_alloc);
693b21d2	506	req = v9fs_tattach(v9p, 0, getuid(), 0);
357e2f7f	507	v9fs_req_wait_for_reply(req, NULL);
a37c0702 GK	508	v9fs_rattach(req, &root_qid);
a37c0702 GK	509
693b21d2	510	req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
357e2f7f	511	v9fs_req_wait_for_reply(req, NULL);
a37c0702 GK	512	v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */
	513
	514	g_assert_cmpmem(&root_qid, 13, wqid[0], 13);
	515
	516	g_free(wqid);
	517	g_free(wnames[0]);
	518	}
	519
dfbe8b43	520	static void fs_lopen(void obj, void data, QGuestAllocator *t_alloc)
82469aae	521	{
dfbe8b43 EGE	522	QVirtio9P *v9p = obj;
dfbe8b43 EGE	523	alloc = t_alloc;
82469aae GK	524	char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) };
	525	P9Req *req;
	526
dfbe8b43	527	fs_attach(v9p, NULL, t_alloc);
82469aae	528	req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
357e2f7f	529	v9fs_req_wait_for_reply(req, NULL);
82469aae GK	530	v9fs_rwalk(req, NULL, NULL);
	531
	532	req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
357e2f7f	533	v9fs_req_wait_for_reply(req, NULL);
82469aae GK	534	v9fs_rlopen(req, NULL, NULL);
	535
	536	g_free(wnames[0]);
	537	}
	538
dfbe8b43	539	static void fs_write(void obj, void data, QGuestAllocator *t_alloc)
354b86f8	540	{
dfbe8b43 EGE	541	QVirtio9P *v9p = obj;
dfbe8b43 EGE	542	alloc = t_alloc;
354b86f8 GK	543	static const uint32_t write_count = P9_MAX_SIZE / 2;
	544	char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) };
	545	char *buf = g_malloc0(write_count);
	546	uint32_t count;
	547	P9Req *req;
	548
dfbe8b43	549	fs_attach(v9p, NULL, t_alloc);
354b86f8	550	req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
357e2f7f	551	v9fs_req_wait_for_reply(req, NULL);
354b86f8 GK	552	v9fs_rwalk(req, NULL, NULL);
	553
	554	req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
357e2f7f	555	v9fs_req_wait_for_reply(req, NULL);
354b86f8 GK	556	v9fs_rlopen(req, NULL, NULL);
	557
	558	req = v9fs_twrite(v9p, 1, 0, write_count, buf, 0);
357e2f7f	559	v9fs_req_wait_for_reply(req, NULL);
354b86f8 GK	560	v9fs_rwrite(req, &count);
	561	g_assert_cmpint(count, ==, write_count);
	562
	563	g_free(buf);
	564	g_free(wnames[0]);
	565	}
	566
dfbe8b43	567	static void fs_flush_success(void obj, void data, QGuestAllocator *t_alloc)
357e2f7f	568	{
dfbe8b43 EGE	569	QVirtio9P *v9p = obj;
dfbe8b43 EGE	570	alloc = t_alloc;
357e2f7f GK	571	char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
	572	P9Req req, flush_req;
	573	uint32_t reply_len;
	574	uint8_t should_block;
	575
dfbe8b43	576	fs_attach(v9p, NULL, t_alloc);
357e2f7f GK	577	req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
	578	v9fs_req_wait_for_reply(req, NULL);
	579	v9fs_rwalk(req, NULL, NULL);
	580
	581	req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
	582	v9fs_req_wait_for_reply(req, NULL);
	583	v9fs_rlopen(req, NULL, NULL);
	584
	585	/* This will cause the 9p server to try to write data to the backend,
	586	* until the write request gets cancelled.
	587	*/
	588	should_block = 1;
	589	req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);
	590
	591	flush_req = v9fs_tflush(v9p, req->tag, 1);
	592
	593	/* The write request is supposed to be flushed: the server should just
	594	* mark the write request as used and reply to the flush request.
	595	*/
	596	v9fs_req_wait_for_reply(req, &reply_len);
	597	g_assert_cmpint(reply_len, ==, 0);
	598	v9fs_req_free(req);
	599	v9fs_rflush(flush_req);
	600
	601	g_free(wnames[0]);
	602	}
	603
dfbe8b43	604	static void fs_flush_ignored(void obj, void data, QGuestAllocator *t_alloc)
357e2f7f	605	{
dfbe8b43 EGE	606	QVirtio9P *v9p = obj;
dfbe8b43 EGE	607	alloc = t_alloc;
357e2f7f GK	608	char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) };
	609	P9Req req, flush_req;
	610	uint32_t count;
	611	uint8_t should_block;
	612
dfbe8b43	613	fs_attach(v9p, NULL, t_alloc);
357e2f7f GK	614	req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0);
	615	v9fs_req_wait_for_reply(req, NULL);
	616	v9fs_rwalk(req, NULL, NULL);
	617
	618	req = v9fs_tlopen(v9p, 1, O_WRONLY, 0);
	619	v9fs_req_wait_for_reply(req, NULL);
	620	v9fs_rlopen(req, NULL, NULL);
	621
	622	/* This will cause the write request to complete right away, before it
	623	* could be actually cancelled.
	624	*/
	625	should_block = 0;
	626	req = v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0);
	627
	628	flush_req = v9fs_tflush(v9p, req->tag, 1);
	629
	630	/* The write request is supposed to complete. The server should
	631	* reply to the write request and the flush request.
	632	*/
	633	v9fs_req_wait_for_reply(req, NULL);
	634	v9fs_rwrite(req, &count);
	635	g_assert_cmpint(count, ==, sizeof(should_block));
	636	v9fs_rflush(flush_req);
	637
	638	g_free(wnames[0]);
	639	}
	640
dfbe8b43	641	static void register_virtio_9p_test(void)
1211d81b	642	{
dfbe8b43 EGE	643	qos_add_test("config", "virtio-9p", pci_config, NULL);
	644	qos_add_test("fs/version/basic", "virtio-9p", fs_version, NULL);
	645	qos_add_test("fs/attach/basic", "virtio-9p", fs_attach, NULL);
	646	qos_add_test("fs/walk/basic", "virtio-9p", fs_walk, NULL);
	647	qos_add_test("fs/walk/no_slash", "virtio-9p", fs_walk_no_slash,
	648	NULL);
	649	qos_add_test("fs/walk/dotdot_from_root", "virtio-9p",
	650	fs_walk_dotdot, NULL);
	651	qos_add_test("fs/lopen/basic", "virtio-9p", fs_lopen, NULL);
	652	qos_add_test("fs/write/basic", "virtio-9p", fs_write, NULL);
	653	qos_add_test("fs/flush/success", "virtio-9p", fs_flush_success,
	654	NULL);
	655	qos_add_test("fs/flush/ignored", "virtio-9p", fs_flush_ignored,
	656	NULL);
557a4cc0 GK	657	}
557a4cc0 GK	658
dfbe8b43	659	libqos_init(register_virtio_9p_test);