From 066eb006b54308be60fc2a435a04cde8f4187502 Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:27 +0100 Subject: [PATCH 01/10] 9pfs: drop v9fs_register_transport() No good reasons to do this outside of v9fs_device_realize_common(). Signed-off-by: Greg Kurz Reviewed-by: Stefano Stabellini --- hw/9pfs/9p.c | 6 +++++- hw/9pfs/9p.h | 10 ++-------- hw/9pfs/virtio-9p-device.c | 8 ++------ hw/9pfs/xen-9p-backend.c | 3 +-- 4 files changed, 10 insertions(+), 17 deletions(-) diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c index 909a611394..364c7cb446 100644 --- a/hw/9pfs/9p.c +++ b/hw/9pfs/9p.c @@ -3485,7 +3485,8 @@ void pdu_submit(V9fsPDU *pdu, P9MsgHeader *hdr) } /* Returns 0 on success, 1 on failure. */ -int v9fs_device_realize_common(V9fsState *s, Error **errp) +int v9fs_device_realize_common(V9fsState *s, const V9fsTransport *t, + Error **errp) { int i, len; struct stat stat; @@ -3493,6 +3494,9 @@ int v9fs_device_realize_common(V9fsState *s, Error **errp) V9fsPath path; int rc = 1; + assert(!s->transport); + s->transport = t; + /* initialize pdu allocator */ QLIST_INIT(&s->free_list); QLIST_INIT(&s->active_list); diff --git a/hw/9pfs/9p.h b/hw/9pfs/9p.h index ffe658ab89..5ced427d86 100644 --- a/hw/9pfs/9p.h +++ b/hw/9pfs/9p.h @@ -346,7 +346,8 @@ void v9fs_path_sprintf(V9fsPath *path, const char *fmt, ...); void v9fs_path_copy(V9fsPath *lhs, V9fsPath *rhs); int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath, const char *name, V9fsPath *path); -int v9fs_device_realize_common(V9fsState *s, Error **errp); +int v9fs_device_realize_common(V9fsState *s, const V9fsTransport *t, + Error **errp); void v9fs_device_unrealize_common(V9fsState *s, Error **errp); V9fsPDU *pdu_alloc(V9fsState *s); @@ -366,11 +367,4 @@ struct V9fsTransport { void (*push_and_notify)(V9fsPDU *pdu); }; -static inline int v9fs_register_transport(V9fsState *s, const V9fsTransport *t) -{ - assert(!s->transport); - s->transport = t; - return 0; -} - #endif diff --git a/hw/9pfs/virtio-9p-device.c b/hw/9pfs/virtio-9p-device.c index 43f4e53f33..775e8ff766 100644 --- a/hw/9pfs/virtio-9p-device.c +++ b/hw/9pfs/virtio-9p-device.c @@ -198,17 +198,13 @@ static void virtio_9p_device_realize(DeviceState *dev, Error **errp) V9fsVirtioState *v = VIRTIO_9P(dev); V9fsState *s = &v->state; - if (v9fs_device_realize_common(s, errp)) { - goto out; + if (v9fs_device_realize_common(s, &virtio_9p_transport, errp)) { + return; } v->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P, v->config_size); v->vq = virtio_add_queue(vdev, MAX_REQ, handle_9p_output); - v9fs_register_transport(s, &virtio_9p_transport); - -out: - return; } static void virtio_9p_device_unrealize(DeviceState *dev, Error **errp) diff --git a/hw/9pfs/xen-9p-backend.c b/hw/9pfs/xen-9p-backend.c index df2a4100bf..14f0d6a50e 100644 --- a/hw/9pfs/xen-9p-backend.c +++ b/hw/9pfs/xen-9p-backend.c @@ -446,7 +446,6 @@ static int xen_9pfs_connect(struct XenDevice *xendev) xen_9pdev->id = s->fsconf.fsdev_id = g_strdup_printf("xen9p%d", xendev->dev); xen_9pdev->tag = s->fsconf.tag = xenstore_read_fe_str(xendev, "tag"); - v9fs_register_transport(s, &xen_9p_transport); fsdev = qemu_opts_create(qemu_find_opts("fsdev"), s->fsconf.tag, 1, NULL); @@ -455,7 +454,7 @@ static int xen_9pfs_connect(struct XenDevice *xendev) qemu_opt_set(fsdev, "security_model", xen_9pdev->security_model, NULL); qemu_opts_set_id(fsdev, s->fsconf.fsdev_id); qemu_fsdev_add(fsdev); - v9fs_device_realize_common(s, NULL); + v9fs_device_realize_common(s, &xen_9p_transport, NULL); return 0; From fc78d5ee7622342699d9d9626c8df712f1486e07 Mon Sep 17 00:00:00 2001 From: Keno Fischer Date: Thu, 1 Feb 2018 21:21:27 +0100 Subject: [PATCH 02/10] 9pfs: Correctly handle cancelled requests # Background I was investigating spurious non-deterministic EINTR returns from various 9p file system operations in a Linux guest served from the qemu 9p server. ## EINTR, ERESTARTSYS and the linux kernel When a signal arrives that the Linux kernel needs to deliver to user-space while a given thread is blocked (in the 9p case waiting for a reply to its request in 9p_client_rpc -> wait_event_interruptible), it asks whatever driver is currently running to abort its current operation (in the 9p case causing the submission of a TFLUSH message) and return to user space. In these situations, the error message reported is generally ERESTARTSYS. If the userspace processes specified SA_RESTART, this means that the system call will get restarted upon completion of the signal handler delivery (assuming the signal handler doesn't modify the process state in complicated ways not relevant here). If SA_RESTART is not specified, ERESTARTSYS gets translated to EINTR and user space is expected to handle the restart itself. ## The 9p TFLUSH command The 9p TFLUSH commands requests that the server abort an ongoing operation. The man page [1] specifies: ``` If it recognizes oldtag as the tag of a pending transaction, it should abort any pending response and discard that tag. [...] When the client sends a Tflush, it must wait to receive the corresponding Rflush before reusing oldtag for subsequent messages. If a response to the flushed request is received before the Rflush, the client must honor the response as if it had not been flushed, since the completed request may signify a state change in the server ``` In particular, this means that the server must not send a reply with the orignal tag in response to the cancellation request, because the client is obligated to interpret such a reply as a coincidental reply to the original request. # The bug When qemu receives a TFlush request, it sets the `cancelled` flag on the relevant pdu. This flag is periodically checked, e.g. in `v9fs_co_name_to_path`, and if set, the operation is aborted and the error is set to EINTR. However, the server then violates the spec, by returning to the client an Rerror response, rather than discarding the message entirely. As a result, the client is required to assume that said Rerror response is a result of the original request, not a result of the cancellation and thus passes the EINTR error back to user space. This is not the worst thing it could do, however as discussed above, the correct error code would have been ERESTARTSYS, such that user space programs with SA_RESTART set get correctly restarted upon completion of the signal handler. Instead, such programs get spurious EINTR results that they were not expecting to handle. It should be noted that there are plenty of user space programs that do not set SA_RESTART and do not correctly handle EINTR either. However, that is then a userspace bug. It should also be noted that this bug has been mitigated by a recent commit to the Linux kernel [2], which essentially prevents the kernel from sending Tflush requests unless the process is about to die (in which case the process likely doesn't care about the response). Nevertheless, for older kernels and to comply with the spec, I believe this change is beneficial. # Implementation The fix is fairly simple, just skipping notification of a reply if the pdu was previously cancelled. We do however, also notify the transport layer that we're doing this, so it can clean up any resources it may be holding. I also added a new trace event to distinguish operations that caused an error reply from those that were cancelled. One complication is that we only omit sending the message on EINTR errors in order to avoid confusing the rest of the code (which may assume that a client knows about a fid if it sucessfully passed it off to pud_complete without checking for cancellation status). This does mean that if the server acts upon the cancellation flag, it always needs to set err to EINTR. I believe this is true of the current code. [1] https://9fans.github.io/plan9port/man/man9/flush.html [2] https://github.com/torvalds/linux/commit/9523feac272ccad2ad8186ba4fcc891 Signed-off-by: Keno Fischer Reviewed-by: Greg Kurz [groug, send a zero-sized reply instead of detaching the buffer] Signed-off-by: Greg Kurz Acked-by: Michael S. Tsirkin Reviewed-by: Stefano Stabellini --- hw/9pfs/9p.c | 18 ++++++++++++++++++ hw/9pfs/trace-events | 1 + 2 files changed, 19 insertions(+) diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c index 364c7cb446..e88bb50f13 100644 --- a/hw/9pfs/9p.c +++ b/hw/9pfs/9p.c @@ -630,6 +630,24 @@ static void coroutine_fn pdu_complete(V9fsPDU *pdu, ssize_t len) V9fsState *s = pdu->s; int ret; + /* + * The 9p spec requires that successfully cancelled pdus receive no reply. + * Sending a reply would confuse clients because they would + * assume that any EINTR is the actual result of the operation, + * rather than a consequence of the cancellation. However, if + * the operation completed (succesfully or with an error other + * than caused be cancellation), we do send out that reply, both + * for efficiency and to avoid confusing the rest of the state machine + * that assumes passing a non-error here will mean a successful + * transmission of the reply. + */ + bool discard = pdu->cancelled && len == -EINTR; + if (discard) { + trace_v9fs_rcancel(pdu->tag, pdu->id); + pdu->size = 0; + goto out_notify; + } + if (len < 0) { int err = -len; len = 7; diff --git a/hw/9pfs/trace-events b/hw/9pfs/trace-events index 08a4abf22e..1aee350c42 100644 --- a/hw/9pfs/trace-events +++ b/hw/9pfs/trace-events @@ -1,6 +1,7 @@ # See docs/devel/tracing.txt for syntax documentation. # hw/9pfs/virtio-9p.c +v9fs_rcancel(uint16_t tag, uint8_t id) "tag %d id %d" v9fs_rerror(uint16_t tag, uint8_t id, int err) "tag %d id %d err %d" v9fs_version(uint16_t tag, uint8_t id, int32_t msize, char* version) "tag %d id %d msize %d version %s" v9fs_version_return(uint16_t tag, uint8_t id, int32_t msize, char* version) "tag %d id %d msize %d version %s" From 693b21d2c7e54474017a4b45d36faa767279d4d4 Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:27 +0100 Subject: [PATCH 03/10] tests: virtio-9p: move request tag to the test functions It doesn't really makes sense to hide the request tag from the test functions. It prevents to test the 9p server behavior when passed a wrong tag (ie, still in use or different from P9_NOTAG for a version request). Also the spec says that a tag is reusable as soon as the corresponding request was replied or flushed: no need to always increment tags like we do now. And finaly, an upcoming test of the flush command will need to manipulate tags explicitely. This simply changes all request functions to have a tag argument. Except for the version request which needs P9_NOTAG, all other tests can pass 0 since they wait for the reply before sending another request. Signed-off-by: Greg Kurz Reviewed-by: Stefan Hajnoczi --- tests/virtio-9p-test.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index 00f00f7246..5ada2839b9 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -27,7 +27,6 @@ typedef struct { QOSState *qs; QVirtQueue *vq; char *test_share; - uint16_t p9_req_tag; } QVirtIO9P; static QVirtIO9P *qvirtio_9p_start(const char *driver) @@ -294,10 +293,11 @@ static void v9fs_rlerror(P9Req *req, uint32_t *err) } /* size[4] Tversion tag[2] msize[4] version[s] */ -static P9Req *v9fs_tversion(QVirtIO9P *v9p, uint32_t msize, const char *version) +static P9Req *v9fs_tversion(QVirtIO9P *v9p, uint32_t msize, const char *version, + uint16_t tag) { P9Req *req = v9fs_req_init(v9p, 4 + v9fs_string_size(version), P9_TVERSION, - P9_NOTAG); + tag); v9fs_uint32_write(req, msize); v9fs_string_write(req, version); @@ -323,12 +323,12 @@ static void v9fs_rversion(P9Req *req, uint16_t *len, char **version) } /* 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) +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, - ++(v9p->p9_req_tag)); + 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); @@ -353,7 +353,7 @@ static void v9fs_rattach(P9Req *req, v9fs_qid *qid) /* 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 nwname, char *const wnames[], uint16_t tag) { P9Req *req; int i; @@ -362,7 +362,7 @@ static P9Req *v9fs_twalk(QVirtIO9P *v9p, uint32_t fid, uint32_t newfid, for (i = 0; i < nwname; i++) { size += v9fs_string_size(wnames[i]); } - req = v9fs_req_init(v9p, size, P9_TWALK, ++(v9p->p9_req_tag)); + req = v9fs_req_init(v9p, size, P9_TWALK, tag); v9fs_uint32_write(req, fid); v9fs_uint32_write(req, newfid); v9fs_uint16_write(req, nwname); @@ -397,7 +397,7 @@ static void fs_version(QVirtIO9P *v9p) char *server_version; P9Req *req; - req = v9fs_tversion(v9p, P9_MAX_SIZE, version); + req = v9fs_tversion(v9p, P9_MAX_SIZE, version, P9_NOTAG); v9fs_rversion(req, &server_len, &server_version); g_assert_cmpmem(server_version, server_len, version, strlen(version)); @@ -410,7 +410,7 @@ static void fs_attach(QVirtIO9P *v9p) P9Req *req; fs_version(v9p); - req = v9fs_tattach(v9p, 0, getuid()); + req = v9fs_tattach(v9p, 0, getuid(), 0); v9fs_rattach(req, NULL); } @@ -430,7 +430,7 @@ static void fs_walk(QVirtIO9P *v9p) } fs_attach(v9p); - req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames); + req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0); v9fs_rwalk(req, &nwqid, &wqid); g_assert_cmpint(nwqid, ==, P9_MAXWELEM); @@ -451,7 +451,7 @@ static void fs_walk_no_slash(QVirtIO9P *v9p) uint32_t err; fs_attach(v9p); - req = v9fs_twalk(v9p, 0, 1, 1, wnames); + req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); v9fs_rlerror(req, &err); g_assert_cmpint(err, ==, ENOENT); @@ -466,10 +466,10 @@ static void fs_walk_dotdot(QVirtIO9P *v9p) P9Req *req; fs_version(v9p); - req = v9fs_tattach(v9p, 0, getuid()); + req = v9fs_tattach(v9p, 0, getuid(), 0); v9fs_rattach(req, &root_qid); - req = v9fs_twalk(v9p, 0, 1, 1, wnames); + req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */ g_assert_cmpmem(&root_qid, 13, wqid[0], 13); From 60b1fa9de1513713807b49be8a9f25077d5ab2ed Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:27 +0100 Subject: [PATCH 04/10] tests: virtio-9p: wait for completion in the test code In order to test request cancellation, we will need to send multiple requests and wait for the associated replies. Since we poll the ISR to know if a request completed, we may have several replies to parse when we detect ISR was set to 1. This patch moves the waiting out of the reply parsing path, up into the functional tests. Signed-off-by: Greg Kurz Reviewed-by: Stefan Hajnoczi --- tests/virtio-9p-test.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index 5ada2839b9..cb086315a3 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -246,13 +246,17 @@ static const char *rmessage_name(uint8_t id) ""; } -static void v9fs_req_recv(P9Req *req, uint8_t id) +static void v9fs_req_wait_for_reply(P9Req *req) { QVirtIO9P *v9p = req->v9p; - P9Hdr hdr; qvirtio_wait_used_elem(v9p->dev, v9p->vq, req->free_head, 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); @@ -398,6 +402,7 @@ static void fs_version(QVirtIO9P *v9p) P9Req *req; req = v9fs_tversion(v9p, P9_MAX_SIZE, version, P9_NOTAG); + v9fs_req_wait_for_reply(req); v9fs_rversion(req, &server_len, &server_version); g_assert_cmpmem(server_version, server_len, version, strlen(version)); @@ -411,6 +416,7 @@ static void fs_attach(QVirtIO9P *v9p) fs_version(v9p); req = v9fs_tattach(v9p, 0, getuid(), 0); + v9fs_req_wait_for_reply(req); v9fs_rattach(req, NULL); } @@ -431,6 +437,7 @@ static void fs_walk(QVirtIO9P *v9p) fs_attach(v9p); req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0); + v9fs_req_wait_for_reply(req); v9fs_rwalk(req, &nwqid, &wqid); g_assert_cmpint(nwqid, ==, P9_MAXWELEM); @@ -452,6 +459,7 @@ static void fs_walk_no_slash(QVirtIO9P *v9p) fs_attach(v9p); req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + v9fs_req_wait_for_reply(req); v9fs_rlerror(req, &err); g_assert_cmpint(err, ==, ENOENT); @@ -467,9 +475,11 @@ static void fs_walk_dotdot(QVirtIO9P *v9p) fs_version(v9p); req = v9fs_tattach(v9p, 0, getuid(), 0); + v9fs_req_wait_for_reply(req); v9fs_rattach(req, &root_qid); req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + v9fs_req_wait_for_reply(req); v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */ g_assert_cmpmem(&root_qid, 13, wqid[0], 13); From 2893ddd5988a38196e3ca72853985814de831672 Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:27 +0100 Subject: [PATCH 05/10] tests: virtio-9p: use the synth backend The purpose of virtio-9p-test is to test the virtio-9p device, especially the 9p server state machine. We don't really care what fsdev backend we're using. Moreover, if we want to be able to test the flush request or a device reset with in-flights I/O, it is close to impossible to achieve with a physical backend because we cannot ask it reliably to put an I/O on hold at a specific point in time. Fortunately, we can do that with the synthetic backend, which allows to register callbacks on read/write accesses to a specific file. This will be used by a later patch to test the 9P flush request. The walk request test is converted to using the synth backend. Signed-off-by: Greg Kurz Reviewed-by: Stefan Hajnoczi --- hw/9pfs/9p-synth.c | 16 ++++++++++++++++ hw/9pfs/9p-synth.h | 4 ++++ tests/virtio-9p-test.c | 22 ++++++---------------- 3 files changed, 26 insertions(+), 16 deletions(-) diff --git a/hw/9pfs/9p-synth.c b/hw/9pfs/9p-synth.c index 8f255e91c0..dcbd320da1 100644 --- a/hw/9pfs/9p-synth.c +++ b/hw/9pfs/9p-synth.c @@ -19,6 +19,7 @@ #include "qemu/rcu.h" #include "qemu/rcu_queue.h" #include "qemu/cutils.h" +#include "sysemu/qtest.h" /* Root node for synth file system */ static V9fsSynthNode synth_root = { @@ -527,6 +528,21 @@ static int synth_init(FsContext *ctx, Error **errp) /* Mark the subsystem is ready for use */ synth_fs = 1; + + if (qtest_enabled()) { + V9fsSynthNode *node = NULL; + int i, ret; + + /* Directory hierarchy for WALK test */ + for (i = 0; i < P9_MAXWELEM; i++) { + char *name = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i); + + ret = qemu_v9fs_synth_mkdir(node, 0700, name, &node); + assert(!ret); + g_free(name); + } + } + return 0; } diff --git a/hw/9pfs/9p-synth.h b/hw/9pfs/9p-synth.h index 49c2fc7b27..876b4ef582 100644 --- a/hw/9pfs/9p-synth.h +++ b/hw/9pfs/9p-synth.h @@ -49,4 +49,8 @@ int qemu_v9fs_synth_add_file(V9fsSynthNode *parent, int mode, const char *name, v9fs_synth_read read, v9fs_synth_write write, void *arg); +/* qtest stuff */ + +#define QTEST_V9FS_SYNTH_WALK_FILE "WALK%d" + #endif diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index cb086315a3..6521981567 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -17,6 +17,7 @@ #include "standard-headers/linux/virtio_ids.h" #include "standard-headers/linux/virtio_pci.h" #include "hw/9pfs/9p.h" +#include "hw/9pfs/9p-synth.h" #define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000) @@ -26,23 +27,19 @@ typedef struct { QVirtioDevice *dev; QOSState *qs; QVirtQueue *vq; - char *test_share; } QVirtIO9P; static QVirtIO9P *qvirtio_9p_start(const char *driver) { const char *arch = qtest_get_arch(); - const char *cmd = "-fsdev local,id=fsdev0,security_model=none,path=%s " + const char *cmd = "-fsdev synth,id=fsdev0 " "-device %s,fsdev=fsdev0,mount_tag=%s"; QVirtIO9P *v9p = g_new0(QVirtIO9P, 1); - v9p->test_share = g_strdup("/tmp/qtest.XXXXXX"); - g_assert_nonnull(mkdtemp(v9p->test_share)); - if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) { - v9p->qs = qtest_pc_boot(cmd, v9p->test_share, driver, mount_tag); + v9p->qs = qtest_pc_boot(cmd, driver, mount_tag); } else if (strcmp(arch, "ppc64") == 0) { - v9p->qs = qtest_spapr_boot(cmd, v9p->test_share, driver, mount_tag); + v9p->qs = qtest_spapr_boot(cmd, driver, mount_tag); } else { g_printerr("virtio-9p tests are only available on x86 or ppc64\n"); exit(EXIT_FAILURE); @@ -54,8 +51,6 @@ static QVirtIO9P *qvirtio_9p_start(const char *driver) static void qvirtio_9p_stop(QVirtIO9P *v9p) { qtest_shutdown(v9p->qs); - rmdir(v9p->test_share); - g_free(v9p->test_share); g_free(v9p); } @@ -422,17 +417,14 @@ static void fs_attach(QVirtIO9P *v9p) static void fs_walk(QVirtIO9P *v9p) { - char *wnames[P9_MAXWELEM], *paths[P9_MAXWELEM]; - char *last_path = v9p->test_share; + 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("%s%d", __func__, i); - last_path = paths[i] = g_strdup_printf("%s/%s", last_path, wnames[i]); - g_assert(!mkdir(paths[i], 0700)); + wnames[i] = g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i); } fs_attach(v9p); @@ -443,8 +435,6 @@ static void fs_walk(QVirtIO9P *v9p) g_assert_cmpint(nwqid, ==, P9_MAXWELEM); for (i = 0; i < P9_MAXWELEM; i++) { - rmdir(paths[P9_MAXWELEM - i - 1]); - g_free(paths[P9_MAXWELEM - i - 1]); g_free(wnames[i]); } From 82469aaefea4f8e7a4469c3ec1f680bbf0341c98 Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:28 +0100 Subject: [PATCH 06/10] tests: virtio-9p: add LOPEN operation test Trivial test of a successful open. Signed-off-by: Greg Kurz Reviewed-by: Stefan Hajnoczi --- hw/9pfs/9p-synth.c | 5 +++++ hw/9pfs/9p-synth.h | 1 + tests/virtio-9p-test.c | 47 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 53 insertions(+) diff --git a/hw/9pfs/9p-synth.c b/hw/9pfs/9p-synth.c index dcbd320da1..f17b74f444 100644 --- a/hw/9pfs/9p-synth.c +++ b/hw/9pfs/9p-synth.c @@ -541,6 +541,11 @@ static int synth_init(FsContext *ctx, Error **errp) assert(!ret); g_free(name); } + + /* File for LOPEN test */ + ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_LOPEN_FILE, + NULL, NULL, ctx); + assert(!ret); } return 0; diff --git a/hw/9pfs/9p-synth.h b/hw/9pfs/9p-synth.h index 876b4ef582..2a8d6fd00d 100644 --- a/hw/9pfs/9p-synth.h +++ b/hw/9pfs/9p-synth.h @@ -52,5 +52,6 @@ int qemu_v9fs_synth_add_file(V9fsSynthNode *parent, int mode, /* qtest stuff */ #define QTEST_V9FS_SYNTH_WALK_FILE "WALK%d" +#define QTEST_V9FS_SYNTH_LOPEN_FILE "LOPEN" #endif diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index 6521981567..6ba782e24f 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -238,6 +238,7 @@ static const char *rmessage_name(uint8_t id) id == P9_RVERSION ? "RVERSION" : id == P9_RATTACH ? "RATTACH" : id == P9_RWALK ? "RWALK" : + id == P9_RLOPEN ? "RLOPEN" : ""; } @@ -389,6 +390,34 @@ static void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid) 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); +} + static void fs_version(QVirtIO9P *v9p) { const char *version = "9P2000.L"; @@ -478,6 +507,23 @@ static void fs_walk_dotdot(QVirtIO9P *v9p) g_free(wnames[0]); } +static void fs_lopen(QVirtIO9P *v9p) +{ + char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) }; + P9Req *req; + + fs_attach(v9p); + req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + v9fs_req_wait_for_reply(req); + v9fs_rwalk(req, NULL, NULL); + + req = v9fs_tlopen(v9p, 1, O_WRONLY, 0); + v9fs_req_wait_for_reply(req); + v9fs_rlopen(req, NULL, NULL); + + g_free(wnames[0]); +} + typedef void (*v9fs_test_fn)(QVirtIO9P *v9p); static void v9fs_run_pci_test(gconstpointer data) @@ -507,6 +553,7 @@ int main(int argc, char **argv) v9fs_qtest_pci_add("/virtio/9p/pci/fs/walk/no_slash", fs_walk_no_slash); v9fs_qtest_pci_add("/virtio/9p/pci/fs/walk/dotdot_from_root", fs_walk_dotdot); + v9fs_qtest_pci_add("/virtio/9p/pci/fs/lopen/basic", fs_lopen); return g_test_run(); } From 354b86f85f516fecb60185f9c2b8e5933177b300 Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:28 +0100 Subject: [PATCH 07/10] tests: virtio-9p: add WRITE operation test Trivial test of a successful write. Signed-off-by: Greg Kurz (groug, handle potential overflow when computing request size, add missing g_free(buf), backend handles one written byte at a time to validate the server doesn't do short-reads) Reviewed-by: Stefan Hajnoczi --- hw/9pfs/9p-synth.c | 11 ++++++++ hw/9pfs/9p-synth.h | 1 + tests/virtio-9p-test.c | 63 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 75 insertions(+) diff --git a/hw/9pfs/9p-synth.c b/hw/9pfs/9p-synth.c index f17b74f444..ade3460706 100644 --- a/hw/9pfs/9p-synth.c +++ b/hw/9pfs/9p-synth.c @@ -515,6 +515,12 @@ static int synth_unlinkat(FsContext *ctx, V9fsPath *dir, return -1; } +static ssize_t v9fs_synth_qtest_write(void *buf, int len, off_t offset, + void *arg) +{ + return 1; +} + static int synth_init(FsContext *ctx, Error **errp) { QLIST_INIT(&synth_root.child); @@ -546,6 +552,11 @@ static int synth_init(FsContext *ctx, Error **errp) ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_LOPEN_FILE, NULL, NULL, ctx); assert(!ret); + + /* File for WRITE test */ + ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_WRITE_FILE, + NULL, v9fs_synth_qtest_write, ctx); + assert(!ret); } return 0; diff --git a/hw/9pfs/9p-synth.h b/hw/9pfs/9p-synth.h index 2a8d6fd00d..a74032d7bd 100644 --- a/hw/9pfs/9p-synth.h +++ b/hw/9pfs/9p-synth.h @@ -53,5 +53,6 @@ int qemu_v9fs_synth_add_file(V9fsSynthNode *parent, int mode, #define QTEST_V9FS_SYNTH_WALK_FILE "WALK%d" #define QTEST_V9FS_SYNTH_LOPEN_FILE "LOPEN" +#define QTEST_V9FS_SYNTH_WRITE_FILE "WRITE" #endif diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index 6ba782e24f..12315aeb4e 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -150,6 +150,13 @@ static void v9fs_uint32_write(P9Req *req, uint32_t 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); @@ -239,6 +246,7 @@ static const char *rmessage_name(uint8_t id) id == P9_RATTACH ? "RATTACH" : id == P9_RWALK ? "RWALK" : id == P9_RLOPEN ? "RLOPEN" : + id == P9_RWRITE ? "RWRITE" : ""; } @@ -418,6 +426,34 @@ static void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *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); +} + static void fs_version(QVirtIO9P *v9p) { const char *version = "9P2000.L"; @@ -524,6 +560,32 @@ static void fs_lopen(QVirtIO9P *v9p) g_free(wnames[0]); } +static void fs_write(QVirtIO9P *v9p) +{ + 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); + req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + v9fs_req_wait_for_reply(req); + v9fs_rwalk(req, NULL, NULL); + + req = v9fs_tlopen(v9p, 1, O_WRONLY, 0); + v9fs_req_wait_for_reply(req); + v9fs_rlopen(req, NULL, NULL); + + req = v9fs_twrite(v9p, 1, 0, write_count, buf, 0); + v9fs_req_wait_for_reply(req); + v9fs_rwrite(req, &count); + g_assert_cmpint(count, ==, write_count); + + g_free(buf); + g_free(wnames[0]); +} + typedef void (*v9fs_test_fn)(QVirtIO9P *v9p); static void v9fs_run_pci_test(gconstpointer data) @@ -554,6 +616,7 @@ int main(int argc, char **argv) v9fs_qtest_pci_add("/virtio/9p/pci/fs/walk/dotdot_from_root", fs_walk_dotdot); v9fs_qtest_pci_add("/virtio/9p/pci/fs/lopen/basic", fs_lopen); + v9fs_qtest_pci_add("/virtio/9p/pci/fs/write/basic", fs_write); return g_test_run(); } From be3a6781605803b2c48a48135002869ed2c73cf1 Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:28 +0100 Subject: [PATCH 08/10] libqos/virtio: return length written into used descriptor When a 9p request is flushed (ie, cancelled) by the guest, the device is expected to simply mark the request as used, without sending a 9p reply (ie, without writing anything into the used buffer). To be able to test this, we need access to the length written by the device into the used descriptor. This patch adds a uint32_t * argument to qvirtqueue_get_buf() and qvirtio_wait_used_elem() for this purpose. All existing users are updated accordingly. Signed-off-by: Greg Kurz Reviewed-by: Stefan Hajnoczi --- tests/libqos/virtio.c | 25 +++++++++++++++++-------- tests/libqos/virtio.h | 3 ++- tests/virtio-9p-test.c | 2 +- tests/virtio-blk-test.c | 24 +++++++++++++----------- tests/virtio-net-test.c | 6 +++--- tests/virtio-scsi-test.c | 3 ++- 6 files changed, 38 insertions(+), 25 deletions(-) diff --git a/tests/libqos/virtio.c b/tests/libqos/virtio.c index 0879a621c8..0dad5c19ac 100644 --- a/tests/libqos/virtio.c +++ b/tests/libqos/virtio.c @@ -119,6 +119,8 @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d, /* * qvirtio_wait_used_elem: * @desc_idx: The next expected vq->desc[] index in the used ring + * @len: A pointer that is filled with the length written into the buffer, may + * be NULL * @timeout_us: How many microseconds to wait before failing * * This function waits for the next completed request on the used ring. @@ -126,6 +128,7 @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d, void qvirtio_wait_used_elem(QVirtioDevice *d, QVirtQueue *vq, uint32_t desc_idx, + uint32_t *len, gint64 timeout_us) { gint64 start_time = g_get_monotonic_time(); @@ -136,7 +139,7 @@ void qvirtio_wait_used_elem(QVirtioDevice *d, clock_step(100); if (d->bus->get_queue_isr_status(d, vq) && - qvirtqueue_get_buf(vq, &got_desc_idx)) { + qvirtqueue_get_buf(vq, &got_desc_idx, len)) { g_assert_cmpint(got_desc_idx, ==, desc_idx); return; } @@ -304,30 +307,36 @@ void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head) /* * qvirtqueue_get_buf: * @desc_idx: A pointer that is filled with the vq->desc[] index, may be NULL + * @len: A pointer that is filled with the length written into the buffer, may + * be NULL * * This function gets the next used element if there is one ready. * * Returns: true if an element was ready, false otherwise */ -bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx) +bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx, uint32_t *len) { uint16_t idx; + uint64_t elem_addr; idx = readw(vq->used + offsetof(struct vring_used, idx)); if (idx == vq->last_used_idx) { return false; } - if (desc_idx) { - uint64_t elem_addr; + elem_addr = vq->used + + offsetof(struct vring_used, ring) + + (vq->last_used_idx % vq->size) * + sizeof(struct vring_used_elem); - elem_addr = vq->used + - offsetof(struct vring_used, ring) + - (vq->last_used_idx % vq->size) * - sizeof(struct vring_used_elem); + if (desc_idx) { *desc_idx = readl(elem_addr + offsetof(struct vring_used_elem, id)); } + if (len) { + *len = readw(elem_addr + offsetof(struct vring_used_elem, len)); + } + vq->last_used_idx++; return true; } diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h index 0a04740adf..69b5b13840 100644 --- a/tests/libqos/virtio.h +++ b/tests/libqos/virtio.h @@ -124,6 +124,7 @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d, void qvirtio_wait_used_elem(QVirtioDevice *d, QVirtQueue *vq, uint32_t desc_idx, + uint32_t *len, gint64 timeout_us); void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us); QVirtQueue *qvirtqueue_setup(QVirtioDevice *d, @@ -140,7 +141,7 @@ uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write, bool next); uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect); void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head); -bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx); +bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx, uint32_t *len); void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx); diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index 12315aeb4e..0d0341491e 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -254,7 +254,7 @@ static void v9fs_req_wait_for_reply(P9Req *req) { QVirtIO9P *v9p = req->v9p; - qvirtio_wait_used_elem(v9p->dev, v9p->vq, req->free_head, + qvirtio_wait_used_elem(v9p->dev, v9p->vq, req->free_head, NULL, QVIRTIO_9P_TIMEOUT_US); } diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c index 45f368dcd9..2ac64e5e25 100644 --- a/tests/virtio-blk-test.c +++ b/tests/virtio-blk-test.c @@ -193,7 +193,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc, qvirtqueue_kick(dev, vq, free_head); - qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US); + qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); g_assert_cmpint(status, ==, 0); @@ -215,7 +215,7 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc, qvirtqueue_kick(dev, vq, free_head); - qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US); + qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); g_assert_cmpint(status, ==, 0); @@ -243,7 +243,8 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc, qvirtqueue_add(vq, req_addr + 528, 1, true, false); qvirtqueue_kick(dev, vq, free_head); - qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US); + qvirtio_wait_used_elem(dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); g_assert_cmpint(status, ==, 0); @@ -264,7 +265,8 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc, qvirtqueue_kick(dev, vq, free_head); - qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US); + qvirtio_wait_used_elem(dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); g_assert_cmpint(status, ==, 0); @@ -345,7 +347,7 @@ static void pci_indirect(void) free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect); qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head); - qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, + qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); g_assert_cmpint(status, ==, 0); @@ -370,7 +372,7 @@ static void pci_indirect(void) free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect); qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head); - qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, + qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); g_assert_cmpint(status, ==, 0); @@ -481,7 +483,7 @@ static void pci_msix(void) qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false); qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head); - qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, + qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); @@ -506,7 +508,7 @@ static void pci_msix(void) qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head); - qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, + qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); status = readb(req_addr + 528); @@ -580,7 +582,7 @@ static void pci_idx(void) qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false); qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head); - qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, + qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head, NULL, QVIRTIO_BLK_TIMEOUT_US); /* Write request */ @@ -627,9 +629,9 @@ static void pci_idx(void) qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head); /* We get just one notification for both requests */ - qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, write_head, + qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, write_head, NULL, QVIRTIO_BLK_TIMEOUT_US); - g_assert(qvirtqueue_get_buf(&vqpci->vq, &desc_idx)); + g_assert(qvirtqueue_get_buf(&vqpci->vq, &desc_idx, NULL)); g_assert_cmpint(desc_idx, ==, free_head); status = readb(req_addr + 528); diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c index 635b942c36..ea634dc05a 100644 --- a/tests/virtio-net-test.c +++ b/tests/virtio-net-test.c @@ -108,7 +108,7 @@ static void rx_test(QVirtioDevice *dev, ret = iov_send(socket, iov, 2, 0, sizeof(len) + sizeof(test)); g_assert_cmpint(ret, ==, sizeof(test) + sizeof(len)); - qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US); + qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_NET_TIMEOUT_US); memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test)); g_assert_cmpstr(buffer, ==, "TEST"); @@ -131,7 +131,7 @@ static void tx_test(QVirtioDevice *dev, free_head = qvirtqueue_add(vq, req_addr, 64, false, false); qvirtqueue_kick(dev, vq, free_head); - qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US); + qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_NET_TIMEOUT_US); guest_free(alloc, req_addr); ret = qemu_recv(socket, &len, sizeof(len), 0); @@ -182,7 +182,7 @@ static void rx_stop_cont_test(QVirtioDevice *dev, rsp = qmp("{ 'execute' : 'cont'}"); QDECREF(rsp); - qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US); + qvirtio_wait_used_elem(dev, vq, free_head, NULL, QVIRTIO_NET_TIMEOUT_US); memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test)); g_assert_cmpstr(buffer, ==, "TEST"); diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c index 2934305b2b..bcf408fbb6 100644 --- a/tests/virtio-scsi-test.c +++ b/tests/virtio-scsi-test.c @@ -121,7 +121,8 @@ static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb, } qvirtqueue_kick(vs->dev, vq, free_head); - qvirtio_wait_used_elem(vs->dev, vq, free_head, QVIRTIO_SCSI_TIMEOUT_US); + qvirtio_wait_used_elem(vs->dev, vq, free_head, NULL, + QVIRTIO_SCSI_TIMEOUT_US); response = readb(resp_addr + offsetof(struct virtio_scsi_cmd_resp, response)); From 357e2f7f4e4dc68f01d5b81f5cd669874314e14a Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:28 +0100 Subject: [PATCH 09/10] tests: virtio-9p: add FLUSH operation test The idea is to send a victim request that will possibly block in the server and to send a flush request to cancel the victim request. This patch adds two test to verifiy that: - the server does not reply to a victim request that was actually cancelled - the server replies to the flush request after replying to the victim request if it could not cancel it 9p request cancellation reference: http://man.cat-v.org/plan_9/5/flush Signed-off-by: Greg Kurz Reviewed-by: Stefan Hajnoczi (groug, change the test to only write a single byte to avoid any alignment or endianess consideration) --- hw/9pfs/9p-synth.c | 20 +++++++ hw/9pfs/9p-synth.h | 7 +++ hw/9pfs/9p.c | 1 + tests/virtio-9p-test.c | 117 ++++++++++++++++++++++++++++++++++++----- 4 files changed, 132 insertions(+), 13 deletions(-) diff --git a/hw/9pfs/9p-synth.c b/hw/9pfs/9p-synth.c index ade3460706..18082dffe8 100644 --- a/hw/9pfs/9p-synth.c +++ b/hw/9pfs/9p-synth.c @@ -521,6 +521,20 @@ static ssize_t v9fs_synth_qtest_write(void *buf, int len, off_t offset, return 1; } +static ssize_t v9fs_synth_qtest_flush_write(void *buf, int len, off_t offset, + void *arg) +{ + bool should_block = !!*(uint8_t *)buf; + + if (should_block) { + /* This will cause the server to call us again until we're cancelled */ + errno = EINTR; + return -1; + } + + return 1; +} + static int synth_init(FsContext *ctx, Error **errp) { QLIST_INIT(&synth_root.child); @@ -557,6 +571,12 @@ static int synth_init(FsContext *ctx, Error **errp) ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_WRITE_FILE, NULL, v9fs_synth_qtest_write, ctx); assert(!ret); + + /* File for FLUSH test */ + ret = qemu_v9fs_synth_add_file(NULL, 0, QTEST_V9FS_SYNTH_FLUSH_FILE, + NULL, v9fs_synth_qtest_flush_write, + ctx); + assert(!ret); } return 0; diff --git a/hw/9pfs/9p-synth.h b/hw/9pfs/9p-synth.h index a74032d7bd..af7a993a1e 100644 --- a/hw/9pfs/9p-synth.h +++ b/hw/9pfs/9p-synth.h @@ -55,4 +55,11 @@ int qemu_v9fs_synth_add_file(V9fsSynthNode *parent, int mode, #define QTEST_V9FS_SYNTH_LOPEN_FILE "LOPEN" #define QTEST_V9FS_SYNTH_WRITE_FILE "WRITE" +/* Any write to the "FLUSH" file is handled one byte at a time by the + * backend. If the byte is zero, the backend returns success (ie, 1), + * otherwise it forces the server to try again forever. Thus allowing + * the client to cancel the request. + */ +#define QTEST_V9FS_SYNTH_FLUSH_FILE "FLUSH" + #endif diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c index e88bb50f13..85a1ed8171 100644 --- a/hw/9pfs/9p.c +++ b/hw/9pfs/9p.c @@ -24,6 +24,7 @@ #include "coth.h" #include "trace.h" #include "migration/blocker.h" +#include "sysemu/qtest.h" int open_fd_hw; int total_open_fd; diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index 0d0341491e..0d3334a6ce 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -247,14 +247,15 @@ static const char *rmessage_name(uint8_t id) id == P9_RWALK ? "RWALK" : id == P9_RLOPEN ? "RLOPEN" : id == P9_RWRITE ? "RWRITE" : + id == P9_RFLUSH ? "RFLUSH" : ""; } -static void v9fs_req_wait_for_reply(P9Req *req) +static void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len) { QVirtIO9P *v9p = req->v9p; - qvirtio_wait_used_elem(v9p->dev, v9p->vq, req->free_head, NULL, + qvirtio_wait_used_elem(v9p->dev, v9p->vq, req->free_head, len, QVIRTIO_9P_TIMEOUT_US); } @@ -454,6 +455,24 @@ static void v9fs_rwrite(P9Req *req, uint32_t *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(QVirtIO9P *v9p) { const char *version = "9P2000.L"; @@ -462,7 +481,7 @@ static void fs_version(QVirtIO9P *v9p) P9Req *req; req = v9fs_tversion(v9p, P9_MAX_SIZE, version, P9_NOTAG); - v9fs_req_wait_for_reply(req); + v9fs_req_wait_for_reply(req, NULL); v9fs_rversion(req, &server_len, &server_version); g_assert_cmpmem(server_version, server_len, version, strlen(version)); @@ -476,7 +495,7 @@ static void fs_attach(QVirtIO9P *v9p) fs_version(v9p); req = v9fs_tattach(v9p, 0, getuid(), 0); - v9fs_req_wait_for_reply(req); + v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, NULL); } @@ -494,7 +513,7 @@ static void fs_walk(QVirtIO9P *v9p) fs_attach(v9p); req = v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0); - v9fs_req_wait_for_reply(req); + v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, &nwqid, &wqid); g_assert_cmpint(nwqid, ==, P9_MAXWELEM); @@ -514,7 +533,7 @@ static void fs_walk_no_slash(QVirtIO9P *v9p) fs_attach(v9p); req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); - v9fs_req_wait_for_reply(req); + v9fs_req_wait_for_reply(req, NULL); v9fs_rlerror(req, &err); g_assert_cmpint(err, ==, ENOENT); @@ -530,11 +549,11 @@ static void fs_walk_dotdot(QVirtIO9P *v9p) fs_version(v9p); req = v9fs_tattach(v9p, 0, getuid(), 0); - v9fs_req_wait_for_reply(req); + 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); + 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); @@ -550,11 +569,11 @@ static void fs_lopen(QVirtIO9P *v9p) fs_attach(v9p); req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); - v9fs_req_wait_for_reply(req); + 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); + v9fs_req_wait_for_reply(req, NULL); v9fs_rlopen(req, NULL, NULL); g_free(wnames[0]); @@ -570,15 +589,15 @@ static void fs_write(QVirtIO9P *v9p) fs_attach(v9p); req = v9fs_twalk(v9p, 0, 1, 1, wnames, 0); - v9fs_req_wait_for_reply(req); + 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); + 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); + v9fs_req_wait_for_reply(req, NULL); v9fs_rwrite(req, &count); g_assert_cmpint(count, ==, write_count); @@ -586,6 +605,76 @@ static void fs_write(QVirtIO9P *v9p) g_free(wnames[0]); } +static void fs_flush_success(QVirtIO9P *v9p) +{ + 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); + 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(QVirtIO9P *v9p) +{ + char *const wnames[] = { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; + P9Req *req, *flush_req; + uint32_t count; + uint8_t should_block; + + fs_attach(v9p); + 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]); +} + typedef void (*v9fs_test_fn)(QVirtIO9P *v9p); static void v9fs_run_pci_test(gconstpointer data) @@ -617,6 +706,8 @@ int main(int argc, char **argv) fs_walk_dotdot); v9fs_qtest_pci_add("/virtio/9p/pci/fs/lopen/basic", fs_lopen); v9fs_qtest_pci_add("/virtio/9p/pci/fs/write/basic", fs_write); + v9fs_qtest_pci_add("/virtio/9p/pci/fs/flush/success", fs_flush_success); + v9fs_qtest_pci_add("/virtio/9p/pci/fs/flush/ignored", fs_flush_ignored); return g_test_run(); } From 9ea776ee7d4061c043d0fbf89aa85f86ec0cf8a2 Mon Sep 17 00:00:00 2001 From: Greg Kurz Date: Thu, 1 Feb 2018 21:21:28 +0100 Subject: [PATCH 10/10] tests/virtio-9p: explicitly handle potential integer overflows Signed-off-by: Greg Kurz Reviewed-by: Eric Blake Reviewed-by: Stefan Hajnoczi --- tests/virtio-9p-test.c | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/tests/virtio-9p-test.c b/tests/virtio-9p-test.c index 0d3334a6ce..54edcb9955 100644 --- a/tests/virtio-9p-test.c +++ b/tests/virtio-9p-test.c @@ -168,7 +168,7 @@ static uint16_t v9fs_string_size(const char *string) { size_t len = strlen(string); - g_assert_cmpint(len, <=, UINT16_MAX); + g_assert_cmpint(len, <=, UINT16_MAX - 2); return 2 + len; } @@ -209,17 +209,20 @@ static P9Req *v9fs_req_init(QVirtIO9P *v9p, uint32_t size, uint8_t id, uint16_t tag) { P9Req *req = g_new0(P9Req, 1); - uint32_t t_size = 7 + size; /* 9P header has well-known size of 7 bytes */ + uint32_t total_size = 7; /* 9P header has well-known size of 7 bytes */ P9Hdr hdr = { - .size = cpu_to_le32(t_size), .id = id, .tag = cpu_to_le16(tag) }; - g_assert_cmpint(t_size, <=, P9_MAX_SIZE); + 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 = t_size; + req->t_size = total_size; req->t_msg = guest_alloc(v9p->qs->alloc, req->t_size); v9fs_memwrite(req, &hdr, 7); req->tag = tag; @@ -305,8 +308,13 @@ static void v9fs_rlerror(P9Req *req, uint32_t *err) static P9Req *v9fs_tversion(QVirtIO9P *v9p, uint32_t msize, const char *version, uint16_t tag) { - P9Req *req = v9fs_req_init(v9p, 4 + v9fs_string_size(version), P9_TVERSION, - 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); @@ -366,12 +374,15 @@ static P9Req *v9fs_twalk(QVirtIO9P *v9p, uint32_t fid, uint32_t newfid, { P9Req *req; int i; - uint32_t size = 4 + 4 + 2; + uint32_t body_size = 4 + 4 + 2; for (i = 0; i < nwname; i++) { - size += v9fs_string_size(wnames[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, size, P9_TWALK, tag); + 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);