From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611845; cv=none; d=zohomail.com; s=zohoarc; b=JE99RMYyd5mNY5bz3T2TVWBUsirqVPXEisJviccQj+OWdAx6GCoTDL59Fdt/QFuALnVq1uUTqlbcjqi+Lifz64kz5z1J1ovfex2Zgv/3rWmDHTqGIoEty++jwQiOja24zKN5z9g4ia4o6walC2biXZsHu4Dyx4yO1fl9vllSo/I= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611845; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=OOUuvHQ3ZvZyswiEWMATddvQ5xkB4LreZjcDVjUK7VY=; b=KpZ0YYFFYN7v943Hf6Na1WcVK/wFMe0HGi+IPtWFwGRlHppOaRNnxbP6PNZbAFO9lDnyfLtw3rsDqgS429pbiKtZZ7fiVQtl5nUZBvdrFnk3lk+Suxpnh0AUI2uMR+V6volmeMvzlNyuhfTxixdUWvN5vu1unWBW0Ko+TrfqpiQ= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611845057581.1262246493667; Mon, 24 Oct 2022 04:44:05 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvLF-0007yU-TS; Mon, 24 Oct 2022 07:10:01 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvLE-0007yC-NJ for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:00 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvLD-0006YY-Cg for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:00 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=OOUuvHQ3ZvZyswiEWMATddvQ5xkB4LreZjcDVjUK7VY=; b=GpGSn /H/KE6l1LELX785RJ/WiyVR3EV2bRUDRo4ikiHPsBgm9mZ4SZoBlfbK7HHYFQLP5H94vBqGC5p7/y osolgqcUvL3BQUDTF/zS88m0yFM6V7+DmX1WlbnFQPd9jaX0Ign/oxxKFIQl4/SmpF5F2lnZkiyQw MV3XJtj/Ugy+1nUFlW/iw5WOXELGbBjcXnOd2Ybk6DzvHQ/EhrhYgCRgzsGQBWdk80pk9PMDDvcsj 4+8u1SRz/fMC5IFN8jjg9l8i+yUYril+qVYjc9q3TVS0jGNRTqezc6MwEisFAsrICGnu9N8dMzp6P wJB9ZqMUkOw0FbEFnNRVwJvqIpAxQ==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 01/23] fsdev/virtfs-proxy-helper: Use g_mkdir() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz , Bin Meng Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=f723f626627fda681327075105701695d7c630e5@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611847817100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Bin Meng Use g_mkdir() to create a directory on all platforms. Signed-off-by: Bin Meng Reviewed-by: Christian Schoenebeck Message-Id: <20220927110632.1973965-27-bmeng.cn@gmail.com> Signed-off-by: Christian Schoenebeck --- fsdev/virtfs-proxy-helper.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/fsdev/virtfs-proxy-helper.c b/fsdev/virtfs-proxy-helper.c index 2dde27922f..5cafcd7703 100644 --- a/fsdev/virtfs-proxy-helper.c +++ b/fsdev/virtfs-proxy-helper.c @@ -10,6 +10,7 @@ */ =20 #include "qemu/osdep.h" +#include #include #include #include @@ -639,7 +640,7 @@ static int do_create_others(int type, struct iovec *iov= ec) if (retval < 0) { goto err_out; } - retval =3D mkdir(path.data, mode); + retval =3D g_mkdir(path.data, mode); break; case T_SYMLINK: retval =3D proxy_unmarshal(iovec, offset, "ss", &oldpath, &path); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610150; cv=none; d=zohomail.com; s=zohoarc; b=jKtiQipSKaJN/0DxnuDgvuWd0wbxhaYit71m3zqKtpr1vcwW0yowO4aRdIytmJI+KielnHx0aWoajsNdbLU11TYa+3vZhob5woZuLMV43JRD+zyxyfZ6jM9EZGCPoCWbXV8ztcsRcXy0TTv3ozft0K1bsqj2Hr6gtUlsKfeshQo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610150; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=69mhZstyQKMY6rIhNKKW5XZoszFDtzPdGOpygUqiWck=; b=YLXI8EziNLpVsPgOZLvtDvr2ebMKFis6JgLTPEK5q98iOcjD3XNhTPmUBZHULMmTAXzB6vmBmXaSGXI5iyaT4WqLJpd0oSLnjRrb4VMXKMjWAk0wyE3AeOtflpHfnAfy9+SkzRABXkVNS1se1zOsOXU1racQ54F628vLXqMQOZI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610150196454.6976264954892; Mon, 24 Oct 2022 04:15:50 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvLY-0008Cp-PL; Mon, 24 Oct 2022 07:10:20 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <684f912034395a4958600a3ccca972db5d31be94@lizzy.crudebyte.com>) id 1omvLX-0008BE-Al for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:19 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <684f912034395a4958600a3ccca972db5d31be94@lizzy.crudebyte.com>) id 1omvLM-0006iZ-AT for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:19 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=69mhZstyQKMY6rIhNKKW5XZoszFDtzPdGOpygUqiWck=; b=aE+3Y EAZR+6PraWIRPEAAkJDhWWwAQ5rJk3RmFDY+GI6C8vuxUfsicgESaJrkuZeL14OnQMhxIrWhGh18r fOlckppiJb6z+gNCyEE/vSdAZWldvjUlt2JN9kYbjZjguD3kLztEyb2Wb94kaUURSTA15A/ZGTxii ENnOuCBhhR4OsL0Bpiqjwjh4cQ7n3mxrtWOTwlivLaAhocnE4W6fcQDRnbrUcMumnUEBl1Uanxn8n Mx9bvfnj40oXwGSgw31Cyad9nvNlj05VTmlSfTpzkXwBRgWhlqLFNd2b7j2zqMaJW/gri1qWQS0BV AisGMyj6OissgSwA/5RS/NOwEcGOw==; Message-Id: <684f912034395a4958600a3ccca972db5d31be94.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 02/23] tests/9p: split virtio-9p-test.c into tests and 9p client part To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=684f912034395a4958600a3ccca972db5d31be94@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610151429100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" This patch is pure refactoring, it does not change behaviour. virtio-9p-test.c grew to 1657 lines. Let's split this file up between actual 9p test cases vs. 9p test client, to make it easier to concentrate on the actual 9p tests. Move the 9p test client code to a new unit virtio-9p-client.c, which are basically all functions and types prefixed with v9fs_* already. Note that some client wrapper functions (do_*) are preserved in virtio-9p-test.c, simply because these wrapper functions are going to be wiped with subsequent patches anyway. As the global QGuestAllocator variable is moved to virtio-9p-client.c, add a new function v9fs_set_allocator() to be used by virtio-9p-test.c instead of fiddling with a global variable across units and libraries. Signed-off-by: Christian Schoenebeck Reviewed-by: Greg Kurz Message-Id: --- tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/virtio-9p-client.c | 684 +++++++++++++++++++++++ tests/qtest/libqos/virtio-9p-client.h | 138 +++++ tests/qtest/virtio-9p-test.c | 770 +------------------------- 4 files changed, 849 insertions(+), 744 deletions(-) create mode 100644 tests/qtest/libqos/virtio-9p-client.c create mode 100644 tests/qtest/libqos/virtio-9p-client.h diff --git a/tests/qtest/libqos/meson.build b/tests/qtest/libqos/meson.build index a5b6d5197a..113c80b4e4 100644 --- a/tests/qtest/libqos/meson.build +++ b/tests/qtest/libqos/meson.build @@ -34,6 +34,7 @@ libqos_srcs =3D files( 'tpci200.c', 'virtio.c', 'virtio-9p.c', + 'virtio-9p-client.c', 'virtio-balloon.c', 'virtio-blk.c', 'vhost-user-blk.c', diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c new file mode 100644 index 0000000000..f5c35fd722 --- /dev/null +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -0,0 +1,684 @@ +/* + * 9P network client for VirtIO 9P test cases (based on QTest) + * + * Copyright (c) 2014 SUSE LINUX Products GmbH + * + * This work is licensed under the terms of the GNU GPL, version 2 or late= r. + * See the COPYING file in the top-level directory. + */ + +/* + * Not so fast! You might want to read the 9p developer docs first: + * https://wiki.qemu.org/Documentation/9p + */ + +#include "qemu/osdep.h" +#include "virtio-9p-client.h" + +#define QVIRTIO_9P_TIMEOUT_US (10 * 1000 * 1000) +static QGuestAllocator *alloc; + +void v9fs_set_allocator(QGuestAllocator *t_alloc) +{ + alloc =3D t_alloc; +} + +void v9fs_memwrite(P9Req *req, const void *addr, size_t len) +{ + qtest_memwrite(req->qts, req->t_msg + req->t_off, addr, len); + req->t_off +=3D len; +} + +void v9fs_memskip(P9Req *req, size_t len) +{ + req->r_off +=3D len; +} + +void v9fs_memread(P9Req *req, void *addr, size_t len) +{ + qtest_memread(req->qts, req->r_msg + req->r_off, addr, len); + req->r_off +=3D len; +} + +void v9fs_uint8_read(P9Req *req, uint8_t *val) +{ + v9fs_memread(req, val, 1); +} + +void v9fs_uint16_write(P9Req *req, uint16_t val) +{ + uint16_t le_val =3D cpu_to_le16(val); + + v9fs_memwrite(req, &le_val, 2); +} + +void v9fs_uint16_read(P9Req *req, uint16_t *val) +{ + v9fs_memread(req, val, 2); + le16_to_cpus(val); +} + +void v9fs_uint32_write(P9Req *req, uint32_t val) +{ + uint32_t le_val =3D cpu_to_le32(val); + + v9fs_memwrite(req, &le_val, 4); +} + +void v9fs_uint64_write(P9Req *req, uint64_t val) +{ + uint64_t le_val =3D cpu_to_le64(val); + + v9fs_memwrite(req, &le_val, 8); +} + +void v9fs_uint32_read(P9Req *req, uint32_t *val) +{ + v9fs_memread(req, val, 4); + le32_to_cpus(val); +} + +void v9fs_uint64_read(P9Req *req, uint64_t *val) +{ + v9fs_memread(req, val, 8); + le64_to_cpus(val); +} + +/* len[2] string[len] */ +uint16_t v9fs_string_size(const char *string) +{ + size_t len =3D strlen(string); + + g_assert_cmpint(len, <=3D, UINT16_MAX - 2); + + return 2 + len; +} + +void v9fs_string_write(P9Req *req, const char *string) +{ + int len =3D strlen(string); + + g_assert_cmpint(len, <=3D, UINT16_MAX); + + v9fs_uint16_write(req, (uint16_t) len); + v9fs_memwrite(req, string, len); +} + +void v9fs_string_read(P9Req *req, uint16_t *len, char **string) +{ + uint16_t local_len; + + v9fs_uint16_read(req, &local_len); + if (len) { + *len =3D local_len; + } + if (string) { + *string =3D g_malloc(local_len + 1); + v9fs_memread(req, *string, local_len); + (*string)[local_len] =3D 0; + } else { + v9fs_memskip(req, local_len); + } +} + +typedef struct { + uint32_t size; + uint8_t id; + uint16_t tag; +} QEMU_PACKED P9Hdr; + +P9Req *v9fs_req_init(QVirtio9P *v9p, uint32_t size, uint8_t id, + uint16_t tag) +{ + P9Req *req =3D g_new0(P9Req, 1); + uint32_t total_size =3D 7; /* 9P header has well-known size of 7 bytes= */ + P9Hdr hdr =3D { + .id =3D id, + .tag =3D cpu_to_le16(tag) + }; + + g_assert_cmpint(total_size, <=3D, UINT32_MAX - size); + total_size +=3D size; + hdr.size =3D cpu_to_le32(total_size); + + g_assert_cmpint(total_size, <=3D, P9_MAX_SIZE); + + req->qts =3D global_qtest; + req->v9p =3D v9p; + req->t_size =3D total_size; + req->t_msg =3D guest_alloc(alloc, req->t_size); + v9fs_memwrite(req, &hdr, 7); + req->tag =3D tag; + return req; +} + +void v9fs_req_send(P9Req *req) +{ + QVirtio9P *v9p =3D req->v9p; + + req->r_msg =3D guest_alloc(alloc, P9_MAX_SIZE); + req->free_head =3D qvirtqueue_add(req->qts, v9p->vq, req->t_msg, req->= t_size, + false, true); + qvirtqueue_add(req->qts, v9p->vq, req->r_msg, P9_MAX_SIZE, true, false= ); + qvirtqueue_kick(req->qts, v9p->vdev, v9p->vq, req->free_head); + req->t_off =3D 0; +} + +static const char *rmessage_name(uint8_t id) +{ + return + id =3D=3D P9_RLERROR ? "RLERROR" : + id =3D=3D P9_RVERSION ? "RVERSION" : + id =3D=3D P9_RATTACH ? "RATTACH" : + id =3D=3D P9_RWALK ? "RWALK" : + id =3D=3D P9_RLOPEN ? "RLOPEN" : + id =3D=3D P9_RWRITE ? "RWRITE" : + id =3D=3D P9_RMKDIR ? "RMKDIR" : + id =3D=3D P9_RLCREATE ? "RLCREATE" : + id =3D=3D P9_RSYMLINK ? "RSYMLINK" : + id =3D=3D P9_RLINK ? "RLINK" : + id =3D=3D P9_RUNLINKAT ? "RUNLINKAT" : + id =3D=3D P9_RFLUSH ? "RFLUSH" : + id =3D=3D P9_RREADDIR ? "READDIR" : + ""; +} + +void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len) +{ + QVirtio9P *v9p =3D req->v9p; + + qvirtio_wait_used_elem(req->qts, v9p->vdev, v9p->vq, req->free_head, l= en, + QVIRTIO_9P_TIMEOUT_US); +} + +void v9fs_req_recv(P9Req *req, uint8_t id) +{ + P9Hdr hdr; + + v9fs_memread(req, &hdr, 7); + hdr.size =3D ldl_le_p(&hdr.size); + hdr.tag =3D lduw_le_p(&hdr.tag); + + g_assert_cmpint(hdr.size, >=3D, 7); + g_assert_cmpint(hdr.size, <=3D, P9_MAX_SIZE); + g_assert_cmpint(hdr.tag, =3D=3D, req->tag); + + if (hdr.id !=3D 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 =3D=3D 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, =3D=3D, id); +} + +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] */ +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] */ +P9Req *v9fs_tversion(QVirtio9P *v9p, uint32_t msize, const char *version, + uint16_t tag) +{ + P9Req *req; + uint32_t body_size =3D 4; + uint16_t string_size =3D v9fs_string_size(version); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); + body_size +=3D string_size; + req =3D 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] */ +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, =3D=3D, 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] */ +P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname, + uint16_t tag) +{ + const char *uname =3D ""; /* ignored by QEMU */ + const char *aname =3D ""; /* ignored by QEMU */ + P9Req *req =3D 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; +} + +/* size[4] Rattach tag[2] qid[13] */ +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]) */ +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 =3D 4 + 4 + 2; + + for (i =3D 0; i < nwname; i++) { + uint16_t wname_size =3D v9fs_string_size(wnames[i]); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - wname_size); + body_size +=3D wname_size; + } + req =3D 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 =3D 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]) */ +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 =3D local_nwqid; + } + if (wqid) { + *wqid =3D g_malloc(local_nwqid * 13); + v9fs_memread(req, *wqid, local_nwqid * 13); + } + v9fs_req_free(req); +} + +/* size[4] Tgetattr tag[2] fid[4] request_mask[8] */ +P9Req *v9fs_tgetattr(QVirtio9P *v9p, uint32_t fid, uint64_t request_mask, + uint16_t tag) +{ + P9Req *req; + + req =3D v9fs_req_init(v9p, 4 + 8, P9_TGETATTR, tag); + v9fs_uint32_write(req, fid); + v9fs_uint64_write(req, request_mask); + v9fs_req_send(req); + return req; +} + +/* + * size[4] Rgetattr tag[2] valid[8] qid[13] mode[4] uid[4] gid[4] nlink[8] + * rdev[8] size[8] blksize[8] blocks[8] + * atime_sec[8] atime_nsec[8] mtime_sec[8] mtime_nsec[8] + * ctime_sec[8] ctime_nsec[8] btime_sec[8] btime_nsec[8] + * gen[8] data_version[8] + */ +void v9fs_rgetattr(P9Req *req, v9fs_attr *attr) +{ + v9fs_req_recv(req, P9_RGETATTR); + + v9fs_uint64_read(req, &attr->valid); + v9fs_memread(req, &attr->qid, 13); + v9fs_uint32_read(req, &attr->mode); + v9fs_uint32_read(req, &attr->uid); + v9fs_uint32_read(req, &attr->gid); + v9fs_uint64_read(req, &attr->nlink); + v9fs_uint64_read(req, &attr->rdev); + v9fs_uint64_read(req, &attr->size); + v9fs_uint64_read(req, &attr->blksize); + v9fs_uint64_read(req, &attr->blocks); + v9fs_uint64_read(req, &attr->atime_sec); + v9fs_uint64_read(req, &attr->atime_nsec); + v9fs_uint64_read(req, &attr->mtime_sec); + v9fs_uint64_read(req, &attr->mtime_nsec); + v9fs_uint64_read(req, &attr->ctime_sec); + v9fs_uint64_read(req, &attr->ctime_nsec); + v9fs_uint64_read(req, &attr->btime_sec); + v9fs_uint64_read(req, &attr->btime_nsec); + v9fs_uint64_read(req, &attr->gen); + v9fs_uint64_read(req, &attr->data_version); + + v9fs_req_free(req); +} + +/* size[4] Treaddir tag[2] fid[4] offset[8] count[4] */ +P9Req *v9fs_treaddir(QVirtio9P *v9p, uint32_t fid, uint64_t offset, + uint32_t count, uint16_t tag) +{ + P9Req *req; + + req =3D v9fs_req_init(v9p, 4 + 8 + 4, P9_TREADDIR, tag); + v9fs_uint32_write(req, fid); + v9fs_uint64_write(req, offset); + v9fs_uint32_write(req, count); + v9fs_req_send(req); + return req; +} + +/* size[4] Rreaddir tag[2] count[4] data[count] */ +void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_t *nentries, + struct V9fsDirent **entries) +{ + uint32_t local_count; + struct V9fsDirent *e =3D NULL; + uint16_t slen; + uint32_t n =3D 0; + + v9fs_req_recv(req, P9_RREADDIR); + v9fs_uint32_read(req, &local_count); + + if (count) { + *count =3D local_count; + } + + for (int32_t togo =3D (int32_t)local_count; + togo >=3D 13 + 8 + 1 + 2; + togo -=3D 13 + 8 + 1 + 2 + slen, ++n) + { + if (!e) { + e =3D g_new(struct V9fsDirent, 1); + if (entries) { + *entries =3D e; + } + } else { + e =3D e->next =3D g_new(struct V9fsDirent, 1); + } + e->next =3D NULL; + /* qid[13] offset[8] type[1] name[s] */ + v9fs_memread(req, &e->qid, 13); + v9fs_uint64_read(req, &e->offset); + v9fs_uint8_read(req, &e->type); + v9fs_string_read(req, &slen, &e->name); + } + + if (nentries) { + *nentries =3D n; + } + + v9fs_req_free(req); +} + +void v9fs_free_dirents(struct V9fsDirent *e) +{ + struct V9fsDirent *next =3D NULL; + + for (; e; e =3D next) { + next =3D e->next; + g_free(e->name); + g_free(e); + } +} + +/* size[4] Tlopen tag[2] fid[4] flags[4] */ +P9Req *v9fs_tlopen(QVirtio9P *v9p, uint32_t fid, uint32_t flags, + uint16_t tag) +{ + P9Req *req; + + req =3D 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] */ +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] */ +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 =3D 4 + 8 + 4; + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - count); + body_size +=3D count; + req =3D 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] */ +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] */ +P9Req *v9fs_tflush(QVirtio9P *v9p, uint16_t oldtag, uint16_t tag) +{ + P9Req *req; + + req =3D v9fs_req_init(v9p, 2, P9_TFLUSH, tag); + v9fs_uint32_write(req, oldtag); + v9fs_req_send(req); + return req; +} + +/* size[4] Rflush tag[2] */ +void v9fs_rflush(P9Req *req) +{ + v9fs_req_recv(req, P9_RFLUSH); + v9fs_req_free(req); +} + +/* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */ +P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name, + uint32_t mode, uint32_t gid, uint16_t tag) +{ + P9Req *req; + + uint32_t body_size =3D 4 + 4 + 4; + uint16_t string_size =3D v9fs_string_size(name); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); + body_size +=3D string_size; + + req =3D v9fs_req_init(v9p, body_size, P9_TMKDIR, tag); + v9fs_uint32_write(req, dfid); + v9fs_string_write(req, name); + v9fs_uint32_write(req, mode); + v9fs_uint32_write(req, gid); + v9fs_req_send(req); + return req; +} + +/* size[4] Rmkdir tag[2] qid[13] */ +void v9fs_rmkdir(P9Req *req, v9fs_qid *qid) +{ + v9fs_req_recv(req, P9_RMKDIR); + if (qid) { + v9fs_memread(req, qid, 13); + } else { + v9fs_memskip(req, 13); + } + v9fs_req_free(req); +} + +/* size[4] Tlcreate tag[2] fid[4] name[s] flags[4] mode[4] gid[4] */ +P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, + uint32_t flags, uint32_t mode, uint32_t gid, + uint16_t tag) +{ + P9Req *req; + + uint32_t body_size =3D 4 + 4 + 4 + 4; + uint16_t string_size =3D v9fs_string_size(name); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); + body_size +=3D string_size; + + req =3D v9fs_req_init(v9p, body_size, P9_TLCREATE, tag); + v9fs_uint32_write(req, fid); + v9fs_string_write(req, name); + v9fs_uint32_write(req, flags); + v9fs_uint32_write(req, mode); + v9fs_uint32_write(req, gid); + v9fs_req_send(req); + return req; +} + +/* size[4] Rlcreate tag[2] qid[13] iounit[4] */ +void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_t *iounit) +{ + v9fs_req_recv(req, P9_RLCREATE); + 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] Tsymlink tag[2] fid[4] name[s] symtgt[s] gid[4] */ +P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, const char *name, + const char *symtgt, uint32_t gid, uint16_t tag) +{ + P9Req *req; + + uint32_t body_size =3D 4 + 4; + uint16_t string_size =3D v9fs_string_size(name) + v9fs_string_size(sym= tgt); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); + body_size +=3D string_size; + + req =3D v9fs_req_init(v9p, body_size, P9_TSYMLINK, tag); + v9fs_uint32_write(req, fid); + v9fs_string_write(req, name); + v9fs_string_write(req, symtgt); + v9fs_uint32_write(req, gid); + v9fs_req_send(req); + return req; +} + +/* size[4] Rsymlink tag[2] qid[13] */ +void v9fs_rsymlink(P9Req *req, v9fs_qid *qid) +{ + v9fs_req_recv(req, P9_RSYMLINK); + if (qid) { + v9fs_memread(req, qid, 13); + } else { + v9fs_memskip(req, 13); + } + v9fs_req_free(req); +} + +/* size[4] Tlink tag[2] dfid[4] fid[4] name[s] */ +P9Req *v9fs_tlink(QVirtio9P *v9p, uint32_t dfid, uint32_t fid, + const char *name, uint16_t tag) +{ + P9Req *req; + + uint32_t body_size =3D 4 + 4; + uint16_t string_size =3D v9fs_string_size(name); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); + body_size +=3D string_size; + + req =3D v9fs_req_init(v9p, body_size, P9_TLINK, tag); + v9fs_uint32_write(req, dfid); + v9fs_uint32_write(req, fid); + v9fs_string_write(req, name); + v9fs_req_send(req); + return req; +} + +/* size[4] Rlink tag[2] */ +void v9fs_rlink(P9Req *req) +{ + v9fs_req_recv(req, P9_RLINK); + v9fs_req_free(req); +} + +/* size[4] Tunlinkat tag[2] dirfd[4] name[s] flags[4] */ +P9Req *v9fs_tunlinkat(QVirtio9P *v9p, uint32_t dirfd, const char *name, + uint32_t flags, uint16_t tag) +{ + P9Req *req; + + uint32_t body_size =3D 4 + 4; + uint16_t string_size =3D v9fs_string_size(name); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); + body_size +=3D string_size; + + req =3D v9fs_req_init(v9p, body_size, P9_TUNLINKAT, tag); + v9fs_uint32_write(req, dirfd); + v9fs_string_write(req, name); + v9fs_uint32_write(req, flags); + v9fs_req_send(req); + return req; +} + +/* size[4] Runlinkat tag[2] */ +void v9fs_runlinkat(P9Req *req) +{ + v9fs_req_recv(req, P9_RUNLINKAT); + v9fs_req_free(req); +} diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h new file mode 100644 index 0000000000..c502d12a66 --- /dev/null +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -0,0 +1,138 @@ +/* + * 9P network client for VirtIO 9P test cases (based on QTest) + * + * Copyright (c) 2014 SUSE LINUX Products GmbH + * + * This work is licensed under the terms of the GNU GPL, version 2 or late= r. + * See the COPYING file in the top-level directory. + */ + +/* + * Not so fast! You might want to read the 9p developer docs first: + * https://wiki.qemu.org/Documentation/9p + */ + +#ifndef TESTS_LIBQOS_VIRTIO_9P_CLIENT_H +#define TESTS_LIBQOS_VIRTIO_9P_CLIENT_H + +#include "hw/9pfs/9p.h" +#include "hw/9pfs/9p-synth.h" +#include "virtio-9p.h" +#include "qgraph.h" +#include "tests/qtest/libqtest-single.h" + +#define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */ + +typedef struct { + QTestState *qts; + 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; + +/* type[1] version[4] path[8] */ +typedef char v9fs_qid[13]; + +typedef struct v9fs_attr { + uint64_t valid; + v9fs_qid qid; + uint32_t mode; + uint32_t uid; + uint32_t gid; + uint64_t nlink; + uint64_t rdev; + uint64_t size; + uint64_t blksize; + uint64_t blocks; + uint64_t atime_sec; + uint64_t atime_nsec; + uint64_t mtime_sec; + uint64_t mtime_nsec; + uint64_t ctime_sec; + uint64_t ctime_nsec; + uint64_t btime_sec; + uint64_t btime_nsec; + uint64_t gen; + uint64_t data_version; +} v9fs_attr; + +#define P9_GETATTR_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS = */ + +struct V9fsDirent { + v9fs_qid qid; + uint64_t offset; + uint8_t type; + char *name; + struct V9fsDirent *next; +}; + +void v9fs_set_allocator(QGuestAllocator *t_alloc); +void v9fs_memwrite(P9Req *req, const void *addr, size_t len); +void v9fs_memskip(P9Req *req, size_t len); +void v9fs_memread(P9Req *req, void *addr, size_t len); +void v9fs_uint8_read(P9Req *req, uint8_t *val); +void v9fs_uint16_write(P9Req *req, uint16_t val); +void v9fs_uint16_read(P9Req *req, uint16_t *val); +void v9fs_uint32_write(P9Req *req, uint32_t val); +void v9fs_uint64_write(P9Req *req, uint64_t val); +void v9fs_uint32_read(P9Req *req, uint32_t *val); +void v9fs_uint64_read(P9Req *req, uint64_t *val); +uint16_t v9fs_string_size(const char *string); +void v9fs_string_write(P9Req *req, const char *string); +void v9fs_string_read(P9Req *req, uint16_t *len, char **string); +P9Req *v9fs_req_init(QVirtio9P *v9p, uint32_t size, uint8_t id, + uint16_t tag); +void v9fs_req_send(P9Req *req); +void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len); +void v9fs_req_recv(P9Req *req, uint8_t id); +void v9fs_req_free(P9Req *req); +void v9fs_rlerror(P9Req *req, uint32_t *err); +P9Req *v9fs_tversion(QVirtio9P *v9p, uint32_t msize, const char *version, + uint16_t tag); +void v9fs_rversion(P9Req *req, uint16_t *len, char **version); +P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname, + uint16_t tag); +void v9fs_rattach(P9Req *req, v9fs_qid *qid); +P9Req *v9fs_twalk(QVirtio9P *v9p, uint32_t fid, uint32_t newfid, + uint16_t nwname, char *const wnames[], uint16_t tag); +void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid); +P9Req *v9fs_tgetattr(QVirtio9P *v9p, uint32_t fid, uint64_t request_mask, + uint16_t tag); +void v9fs_rgetattr(P9Req *req, v9fs_attr *attr); +P9Req *v9fs_treaddir(QVirtio9P *v9p, uint32_t fid, uint64_t offset, + uint32_t count, uint16_t tag); +void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_t *nentries, + struct V9fsDirent **entries); +void v9fs_free_dirents(struct V9fsDirent *e); +P9Req *v9fs_tlopen(QVirtio9P *v9p, uint32_t fid, uint32_t flags, + uint16_t tag); +void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *iounit); +P9Req *v9fs_twrite(QVirtio9P *v9p, uint32_t fid, uint64_t offset, + uint32_t count, const void *data, uint16_t tag); +void v9fs_rwrite(P9Req *req, uint32_t *count); +P9Req *v9fs_tflush(QVirtio9P *v9p, uint16_t oldtag, uint16_t tag); +void v9fs_rflush(P9Req *req); +P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name, + uint32_t mode, uint32_t gid, uint16_t tag); +void v9fs_rmkdir(P9Req *req, v9fs_qid *qid); +P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, + uint32_t flags, uint32_t mode, uint32_t gid, + uint16_t tag); +void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_t *iounit); +P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, const char *name, + const char *symtgt, uint32_t gid, uint16_t tag); +void v9fs_rsymlink(P9Req *req, v9fs_qid *qid); +P9Req *v9fs_tlink(QVirtio9P *v9p, uint32_t dfid, uint32_t fid, + const char *name, uint16_t tag); +void v9fs_rlink(P9Req *req); +P9Req *v9fs_tunlinkat(QVirtio9P *v9p, uint32_t dirfd, const char *name, + uint32_t flags, uint16_t tag); +void v9fs_runlinkat(P9Req *req); + +#endif diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 25305a4cf7..498c32e21b 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -13,15 +13,8 @@ */ =20 #include "qemu/osdep.h" -#include "libqtest-single.h" #include "qemu/module.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; +#include "libqos/virtio-9p-client.h" =20 /* * Used to auto generate new fids. Start with arbitrary high value to avoid @@ -82,7 +75,7 @@ static void split_free(char ***out) static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); size_t tag_len =3D qvirtio_config_readw(v9p->vdev, 0); g_autofree char *tag =3D NULL; int i; @@ -96,565 +89,12 @@ static void pci_config(void *obj, void *data, QGuestAl= locator *t_alloc) g_assert_cmpmem(tag, tag_len, MOUNT_TAG, tag_len); } =20 -#define P9_MAX_SIZE 4096 /* Max size of a T-message or R-message */ - -typedef struct { - QTestState *qts; - 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) -{ - qtest_memwrite(req->qts, req->t_msg + req->t_off, addr, len); - req->t_off +=3D len; -} - -static void v9fs_memskip(P9Req *req, size_t len) -{ - req->r_off +=3D len; -} - -static void v9fs_memread(P9Req *req, void *addr, size_t len) -{ - qtest_memread(req->qts, req->r_msg + req->r_off, addr, len); - req->r_off +=3D len; -} - -static void v9fs_uint8_read(P9Req *req, uint8_t *val) -{ - v9fs_memread(req, val, 1); -} - -static void v9fs_uint16_write(P9Req *req, uint16_t val) -{ - uint16_t le_val =3D 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 =3D cpu_to_le32(val); - - v9fs_memwrite(req, &le_val, 4); -} - -static void v9fs_uint64_write(P9Req *req, uint64_t val) -{ - uint64_t le_val =3D 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); -} - -static void v9fs_uint64_read(P9Req *req, uint64_t *val) -{ - v9fs_memread(req, val, 8); - le64_to_cpus(val); -} - -/* len[2] string[len] */ -static uint16_t v9fs_string_size(const char *string) -{ - size_t len =3D strlen(string); - - g_assert_cmpint(len, <=3D, UINT16_MAX - 2); - - return 2 + len; -} - -static void v9fs_string_write(P9Req *req, const char *string) -{ - int len =3D strlen(string); - - g_assert_cmpint(len, <=3D, 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 =3D local_len; - } - if (string) { - *string =3D g_malloc(local_len + 1); - v9fs_memread(req, *string, local_len); - (*string)[local_len] =3D 0; - } 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 =3D g_new0(P9Req, 1); - uint32_t total_size =3D 7; /* 9P header has well-known size of 7 bytes= */ - P9Hdr hdr =3D { - .id =3D id, - .tag =3D cpu_to_le16(tag) - }; - - g_assert_cmpint(total_size, <=3D, UINT32_MAX - size); - total_size +=3D size; - hdr.size =3D cpu_to_le32(total_size); - - g_assert_cmpint(total_size, <=3D, P9_MAX_SIZE); - - req->qts =3D global_qtest; - req->v9p =3D v9p; - req->t_size =3D total_size; - req->t_msg =3D guest_alloc(alloc, req->t_size); - v9fs_memwrite(req, &hdr, 7); - req->tag =3D tag; - return req; -} - -static void v9fs_req_send(P9Req *req) -{ - QVirtio9P *v9p =3D req->v9p; - - req->r_msg =3D guest_alloc(alloc, P9_MAX_SIZE); - req->free_head =3D qvirtqueue_add(req->qts, v9p->vq, req->t_msg, req->= t_size, - false, true); - qvirtqueue_add(req->qts, v9p->vq, req->r_msg, P9_MAX_SIZE, true, false= ); - qvirtqueue_kick(req->qts, v9p->vdev, v9p->vq, req->free_head); - req->t_off =3D 0; -} - -static const char *rmessage_name(uint8_t id) -{ - return - id =3D=3D P9_RLERROR ? "RLERROR" : - id =3D=3D P9_RVERSION ? "RVERSION" : - id =3D=3D P9_RATTACH ? "RATTACH" : - id =3D=3D P9_RWALK ? "RWALK" : - id =3D=3D P9_RLOPEN ? "RLOPEN" : - id =3D=3D P9_RWRITE ? "RWRITE" : - id =3D=3D P9_RMKDIR ? "RMKDIR" : - id =3D=3D P9_RLCREATE ? "RLCREATE" : - id =3D=3D P9_RSYMLINK ? "RSYMLINK" : - id =3D=3D P9_RLINK ? "RLINK" : - id =3D=3D P9_RUNLINKAT ? "RUNLINKAT" : - id =3D=3D P9_RFLUSH ? "RFLUSH" : - id =3D=3D P9_RREADDIR ? "READDIR" : - ""; -} - -static void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len) -{ - QVirtio9P *v9p =3D req->v9p; - - qvirtio_wait_used_elem(req->qts, v9p->vdev, v9p->vq, req->free_head, l= en, - QVIRTIO_9P_TIMEOUT_US); -} - -static void v9fs_req_recv(P9Req *req, uint8_t id) -{ - P9Hdr hdr; - - v9fs_memread(req, &hdr, 7); - hdr.size =3D ldl_le_p(&hdr.size); - hdr.tag =3D lduw_le_p(&hdr.tag); - - g_assert_cmpint(hdr.size, >=3D, 7); - g_assert_cmpint(hdr.size, <=3D, P9_MAX_SIZE); - g_assert_cmpint(hdr.tag, =3D=3D, req->tag); - - if (hdr.id !=3D 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 =3D=3D 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, =3D=3D, 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 *ve= rsion, - uint16_t tag) -{ - P9Req *req; - uint32_t body_size =3D 4; - uint16_t string_size =3D v9fs_string_size(version); - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); - body_size +=3D string_size; - req =3D 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, =3D=3D, 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 =3D ""; /* ignored by QEMU */ - const char *aname =3D ""; /* ignored by QEMU */ - P9Req *req =3D 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; -} - -/* type[1] version[4] path[8] */ -typedef char v9fs_qid[13]; - static inline bool is_same_qid(v9fs_qid a, v9fs_qid b) { /* don't compare QID version for checking for file ID equalness */ return a[0] =3D=3D b[0] && memcmp(&a[5], &b[5], 8) =3D=3D 0; } =20 -/* 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 t= ag) -{ - P9Req *req; - int i; - uint32_t body_size =3D 4 + 4 + 2; - - for (i =3D 0; i < nwname; i++) { - uint16_t wname_size =3D v9fs_string_size(wnames[i]); - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - wname_size); - body_size +=3D wname_size; - } - req =3D 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 =3D 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 =3D local_nwqid; - } - if (wqid) { - *wqid =3D g_malloc(local_nwqid * 13); - v9fs_memread(req, *wqid, local_nwqid * 13); - } - v9fs_req_free(req); -} - -/* size[4] Tgetattr tag[2] fid[4] request_mask[8] */ -static P9Req *v9fs_tgetattr(QVirtio9P *v9p, uint32_t fid, uint64_t request= _mask, - uint16_t tag) -{ - P9Req *req; - - req =3D v9fs_req_init(v9p, 4 + 8, P9_TGETATTR, tag); - v9fs_uint32_write(req, fid); - v9fs_uint64_write(req, request_mask); - v9fs_req_send(req); - return req; -} - -typedef struct v9fs_attr { - uint64_t valid; - v9fs_qid qid; - uint32_t mode; - uint32_t uid; - uint32_t gid; - uint64_t nlink; - uint64_t rdev; - uint64_t size; - uint64_t blksize; - uint64_t blocks; - uint64_t atime_sec; - uint64_t atime_nsec; - uint64_t mtime_sec; - uint64_t mtime_nsec; - uint64_t ctime_sec; - uint64_t ctime_nsec; - uint64_t btime_sec; - uint64_t btime_nsec; - uint64_t gen; - uint64_t data_version; -} v9fs_attr; - -#define P9_GETATTR_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS = */ - -/* - * size[4] Rgetattr tag[2] valid[8] qid[13] mode[4] uid[4] gid[4] nlink[8] - * rdev[8] size[8] blksize[8] blocks[8] - * atime_sec[8] atime_nsec[8] mtime_sec[8] mtime_nsec[8] - * ctime_sec[8] ctime_nsec[8] btime_sec[8] btime_nsec[8] - * gen[8] data_version[8] - */ -static void v9fs_rgetattr(P9Req *req, v9fs_attr *attr) -{ - v9fs_req_recv(req, P9_RGETATTR); - - v9fs_uint64_read(req, &attr->valid); - v9fs_memread(req, &attr->qid, 13); - v9fs_uint32_read(req, &attr->mode); - v9fs_uint32_read(req, &attr->uid); - v9fs_uint32_read(req, &attr->gid); - v9fs_uint64_read(req, &attr->nlink); - v9fs_uint64_read(req, &attr->rdev); - v9fs_uint64_read(req, &attr->size); - v9fs_uint64_read(req, &attr->blksize); - v9fs_uint64_read(req, &attr->blocks); - v9fs_uint64_read(req, &attr->atime_sec); - v9fs_uint64_read(req, &attr->atime_nsec); - v9fs_uint64_read(req, &attr->mtime_sec); - v9fs_uint64_read(req, &attr->mtime_nsec); - v9fs_uint64_read(req, &attr->ctime_sec); - v9fs_uint64_read(req, &attr->ctime_nsec); - v9fs_uint64_read(req, &attr->btime_sec); - v9fs_uint64_read(req, &attr->btime_nsec); - v9fs_uint64_read(req, &attr->gen); - v9fs_uint64_read(req, &attr->data_version); - - v9fs_req_free(req); -} - -/* size[4] Treaddir tag[2] fid[4] offset[8] count[4] */ -static P9Req *v9fs_treaddir(QVirtio9P *v9p, uint32_t fid, uint64_t offset, - uint32_t count, uint16_t tag) -{ - P9Req *req; - - req =3D v9fs_req_init(v9p, 4 + 8 + 4, P9_TREADDIR, tag); - v9fs_uint32_write(req, fid); - v9fs_uint64_write(req, offset); - v9fs_uint32_write(req, count); - v9fs_req_send(req); - return req; -} - -struct V9fsDirent { - v9fs_qid qid; - uint64_t offset; - uint8_t type; - char *name; - struct V9fsDirent *next; -}; - -/* size[4] Rreaddir tag[2] count[4] data[count] */ -static void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_t *nentries, - struct V9fsDirent **entries) -{ - uint32_t local_count; - struct V9fsDirent *e =3D NULL; - uint16_t slen; - uint32_t n =3D 0; - - v9fs_req_recv(req, P9_RREADDIR); - v9fs_uint32_read(req, &local_count); - - if (count) { - *count =3D local_count; - } - - for (int32_t togo =3D (int32_t)local_count; - togo >=3D 13 + 8 + 1 + 2; - togo -=3D 13 + 8 + 1 + 2 + slen, ++n) - { - if (!e) { - e =3D g_new(struct V9fsDirent, 1); - if (entries) { - *entries =3D e; - } - } else { - e =3D e->next =3D g_new(struct V9fsDirent, 1); - } - e->next =3D NULL; - /* qid[13] offset[8] type[1] name[s] */ - v9fs_memread(req, &e->qid, 13); - v9fs_uint64_read(req, &e->offset); - v9fs_uint8_read(req, &e->type); - v9fs_string_read(req, &slen, &e->name); - } - - if (nentries) { - *nentries =3D n; - } - - v9fs_req_free(req); -} - -static void v9fs_free_dirents(struct V9fsDirent *e) -{ - struct V9fsDirent *next =3D NULL; - - for (; e; e =3D next) { - next =3D e->next; - g_free(e->name); - g_free(e); - } -} - -/* 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 =3D 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 =3D 4 + 8 + 4; - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - count); - body_size +=3D count; - req =3D 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 =3D 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 do_version(QVirtio9P *v9p) { const char *version =3D "9P2000.L"; @@ -717,7 +157,7 @@ static void do_walk_expect_error(QVirtio9P *v9p, const = char *path, uint32_t err) =20 static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc) { - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); do_version(obj); } =20 @@ -738,14 +178,14 @@ static void do_attach(QVirtio9P *v9p) =20 static void fs_attach(void *obj, void *data, QGuestAllocator *t_alloc) { - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); do_attach(obj); } =20 static void fs_walk(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); char *wnames[P9_MAXWELEM]; uint16_t nwqid; g_autofree v9fs_qid *wqid =3D NULL; @@ -778,169 +218,11 @@ static bool fs_dirents_contain_name(struct V9fsDiren= t *e, const char* name) return false; } =20 -/* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */ -static P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name, - uint32_t mode, uint32_t gid, uint16_t tag) -{ - P9Req *req; - - uint32_t body_size =3D 4 + 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); - body_size +=3D string_size; - - req =3D v9fs_req_init(v9p, body_size, P9_TMKDIR, tag); - v9fs_uint32_write(req, dfid); - v9fs_string_write(req, name); - v9fs_uint32_write(req, mode); - v9fs_uint32_write(req, gid); - v9fs_req_send(req); - return req; -} - -/* size[4] Rmkdir tag[2] qid[13] */ -static void v9fs_rmkdir(P9Req *req, v9fs_qid *qid) -{ - v9fs_req_recv(req, P9_RMKDIR); - if (qid) { - v9fs_memread(req, qid, 13); - } else { - v9fs_memskip(req, 13); - } - v9fs_req_free(req); -} - -/* size[4] Tlcreate tag[2] fid[4] name[s] flags[4] mode[4] gid[4] */ -static P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, - uint32_t flags, uint32_t mode, uint32_t gid, - uint16_t tag) -{ - P9Req *req; - - uint32_t body_size =3D 4 + 4 + 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); - body_size +=3D string_size; - - req =3D v9fs_req_init(v9p, body_size, P9_TLCREATE, tag); - v9fs_uint32_write(req, fid); - v9fs_string_write(req, name); - v9fs_uint32_write(req, flags); - v9fs_uint32_write(req, mode); - v9fs_uint32_write(req, gid); - v9fs_req_send(req); - return req; -} - -/* size[4] Rlcreate tag[2] qid[13] iounit[4] */ -static void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_t *iounit) -{ - v9fs_req_recv(req, P9_RLCREATE); - 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] Tsymlink tag[2] fid[4] name[s] symtgt[s] gid[4] */ -static P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, const char *name, - const char *symtgt, uint32_t gid, uint16_t tag) -{ - P9Req *req; - - uint32_t body_size =3D 4 + 4; - uint16_t string_size =3D v9fs_string_size(name) + v9fs_string_size(sym= tgt); - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); - body_size +=3D string_size; - - req =3D v9fs_req_init(v9p, body_size, P9_TSYMLINK, tag); - v9fs_uint32_write(req, fid); - v9fs_string_write(req, name); - v9fs_string_write(req, symtgt); - v9fs_uint32_write(req, gid); - v9fs_req_send(req); - return req; -} - -/* size[4] Rsymlink tag[2] qid[13] */ -static void v9fs_rsymlink(P9Req *req, v9fs_qid *qid) -{ - v9fs_req_recv(req, P9_RSYMLINK); - if (qid) { - v9fs_memread(req, qid, 13); - } else { - v9fs_memskip(req, 13); - } - v9fs_req_free(req); -} - -/* size[4] Tlink tag[2] dfid[4] fid[4] name[s] */ -static P9Req *v9fs_tlink(QVirtio9P *v9p, uint32_t dfid, uint32_t fid, - const char *name, uint16_t tag) -{ - P9Req *req; - - uint32_t body_size =3D 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); - body_size +=3D string_size; - - req =3D v9fs_req_init(v9p, body_size, P9_TLINK, tag); - v9fs_uint32_write(req, dfid); - v9fs_uint32_write(req, fid); - v9fs_string_write(req, name); - v9fs_req_send(req); - return req; -} - -/* size[4] Rlink tag[2] */ -static void v9fs_rlink(P9Req *req) -{ - v9fs_req_recv(req, P9_RLINK); - v9fs_req_free(req); -} - -/* size[4] Tunlinkat tag[2] dirfd[4] name[s] flags[4] */ -static P9Req *v9fs_tunlinkat(QVirtio9P *v9p, uint32_t dirfd, const char *n= ame, - uint32_t flags, uint16_t tag) -{ - P9Req *req; - - uint32_t body_size =3D 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); - - g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); - body_size +=3D string_size; - - req =3D v9fs_req_init(v9p, body_size, P9_TUNLINKAT, tag); - v9fs_uint32_write(req, dirfd); - v9fs_string_write(req, name); - v9fs_uint32_write(req, flags); - v9fs_req_send(req); - return req; -} - -/* size[4] Runlinkat tag[2] */ -static void v9fs_runlinkat(P9Req *req) -{ - v9fs_req_recv(req, P9_RUNLINKAT); - v9fs_req_free(req); -} - /* basic readdir test where reply fits into a single response message */ static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) }; uint16_t nqid; v9fs_qid qid; @@ -1073,7 +355,7 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t = count) static void fs_walk_no_slash(void *obj, void *data, QGuestAllocator *t_all= oc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); char *const wnames[] =3D { g_strdup(" /") }; P9Req *req; uint32_t err; @@ -1091,7 +373,7 @@ static void fs_walk_no_slash(void *obj, void *data, QG= uestAllocator *t_alloc) static void fs_walk_nonexistent(void *obj, void *data, QGuestAllocator *t_= alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); =20 do_attach(v9p); /* @@ -1105,7 +387,7 @@ static void fs_walk_2nd_nonexistent(void *obj, void *d= ata, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); v9fs_qid root_qid; uint16_t nwqid; uint32_t fid, err; @@ -1137,7 +419,7 @@ static void fs_walk_2nd_nonexistent(void *obj, void *d= ata, static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); v9fs_qid root_qid; g_autofree v9fs_qid *wqid =3D NULL; P9Req *req; @@ -1165,7 +447,7 @@ static void fs_walk_none(void *obj, void *data, QGuest= Allocator *t_alloc) static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); char *const wnames[] =3D { g_strdup("..") }; v9fs_qid root_qid; g_autofree v9fs_qid *wqid =3D NULL; @@ -1188,7 +470,7 @@ static void fs_walk_dotdot(void *obj, void *data, QGue= stAllocator *t_alloc) static void fs_lopen(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) }; P9Req *req; =20 @@ -1207,7 +489,7 @@ static void fs_lopen(void *obj, void *data, QGuestAllo= cator *t_alloc) static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); static const uint32_t write_count =3D P9_MAX_SIZE / 2; char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) }; g_autofree char *buf =3D g_malloc0(write_count); @@ -1234,7 +516,7 @@ static void fs_write(void *obj, void *data, QGuestAllo= cator *t_alloc) static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_all= oc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; P9Req *req, *flush_req; uint32_t reply_len; @@ -1271,7 +553,7 @@ static void fs_flush_success(void *obj, void *data, QG= uestAllocator *t_alloc) static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_all= oc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; P9Req *req, *flush_req; uint32_t count; @@ -1383,21 +665,21 @@ static void do_unlinkat(QVirtio9P *v9p, const char *= atpath, const char *rpath, static void fs_readdir_split_128(void *obj, void *data, QGuestAllocator *t_alloc) { - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); do_readdir_split(obj, 128); } =20 static void fs_readdir_split_256(void *obj, void *data, QGuestAllocator *t_alloc) { - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); do_readdir_split(obj, 256); } =20 static void fs_readdir_split_512(void *obj, void *data, QGuestAllocator *t_alloc) { - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); do_readdir_split(obj, 512); } =20 @@ -1407,7 +689,7 @@ static void fs_readdir_split_512(void *obj, void *data, static void fs_create_dir(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st; g_autofree char *root_path =3D virtio_9p_test_path(""); g_autofree char *new_dir =3D virtio_9p_test_path("01"); @@ -1426,7 +708,7 @@ static void fs_create_dir(void *obj, void *data, QGues= tAllocator *t_alloc) static void fs_unlinkat_dir(void *obj, void *data, QGuestAllocator *t_allo= c) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st; g_autofree char *root_path =3D virtio_9p_test_path(""); g_autofree char *new_dir =3D virtio_9p_test_path("02"); @@ -1449,7 +731,7 @@ static void fs_unlinkat_dir(void *obj, void *data, QGu= estAllocator *t_alloc) static void fs_create_file(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st; g_autofree char *new_file =3D virtio_9p_test_path("03/1st_file"); =20 @@ -1466,7 +748,7 @@ static void fs_create_file(void *obj, void *data, QGue= stAllocator *t_alloc) static void fs_unlinkat_file(void *obj, void *data, QGuestAllocator *t_all= oc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st; g_autofree char *new_file =3D virtio_9p_test_path("04/doa_file"); =20 @@ -1487,7 +769,7 @@ static void fs_unlinkat_file(void *obj, void *data, QG= uestAllocator *t_alloc) static void fs_symlink_file(void *obj, void *data, QGuestAllocator *t_allo= c) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st; g_autofree char *real_file =3D virtio_9p_test_path("05/real_file"); g_autofree char *symlink_file =3D virtio_9p_test_path("05/symlink_file= "); @@ -1508,7 +790,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st; g_autofree char *real_file =3D virtio_9p_test_path("06/real_file"); g_autofree char *symlink_file =3D virtio_9p_test_path("06/symlink_file= "); @@ -1530,7 +812,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, static void fs_hardlink_file(void *obj, void *data, QGuestAllocator *t_all= oc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st_real, st_link; g_autofree char *real_file =3D virtio_9p_test_path("07/real_file"); g_autofree char *hardlink_file =3D virtio_9p_test_path("07/hardlink_fi= le"); @@ -1555,7 +837,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, QGuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; - alloc =3D t_alloc; + v9fs_set_allocator(t_alloc); struct stat st_real, st_link; g_autofree char *real_file =3D virtio_9p_test_path("08/real_file"); g_autofree char *hardlink_file =3D virtio_9p_test_path("08/hardlink_fi= le"); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666609976; cv=none; d=zohomail.com; s=zohoarc; b=SHSDWhX+8EJ/CDhC6sN8+3nP3hd+buwchFgMh9tsbEar3e1TxVlhMN8kxBI60a0AMRkGx27iDnsQA4g6LlvirO5VXAU6jATmqoAxroCxV8pi+h1bhi6fkixJcVGNpEVpm/3jio5b2s14X8MA/yQKOsw7t1vDPfloRGjJ8vFwcI4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666609976; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=+M93Zo1AqKb/eHYu/3EHa3Qa4RhX9K9J8RcibMu0eBs=; b=F7NaNhWT4bdRv5M1bngysLfIjmC2R4Pz5IhWAPweqglcvdx+JDoNuh5EVLXWOtAmjFKV7E8fOnfLdIT+aUSJdU4ENsJR3Ns6/uU8HKJyVCsG9i2VYqsJ7qZYFSDC7EWiQQLi5lIe7Ki1J9/vLHupWw3ih7aG8gnG6aupuoIfF0E= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666609976534775.9017697395426; Mon, 24 Oct 2022 04:12:56 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvLY-0008CC-7V; Mon, 24 Oct 2022 07:10:20 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvLX-0008B5-0a for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:19 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvLS-0006lL-UO for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:18 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Content-Transfer-Encoding:Content-Type: MIME-Version:Subject:Date:From:References:In-Reply-To:Message-Id:Content-ID: Content-Description; bh=+M93Zo1AqKb/eHYu/3EHa3Qa4RhX9K9J8RcibMu0eBs=; b=jXrnu XGtUzCKuF1RDQ6KcMGKYEAPwbGWDmCOt5K5wwH2WKuiiB6kybicUBh7aaluqMjU4BzgcxD2u9hnfV kZ3ICV1+tamRVXLmmCnzzRDjyvEdaxxZ8jwqpWbZbn8EwFoj7Wn4xoBlTmr8rz3xz1bMHYvNLqO7A /U/4TrwwH5iaTdNSsAkzS9A43hWOi9bjBBFkp2mDKa5yUDZeeki9+OI606GC7p/2gv39BJhI4p3rs dcOxu13V5tnPeZY6D8R6dw2fK8pD11s9JEBFBg3RNEujIlNNuZY5WQ039Yn5vLi28uG3NQEyoPjq5 ME6auFsQDVyNhEm03Is2wfJ13dI/Q==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 03/23] 9pfs: use GHashTable for fid table MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz , Linus Heckemann Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=f5265c8f917ea8c71a30e549b7e3017c1038db63@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666609978719100001 From: Linus Heckemann The previous implementation would iterate over the fid table for lookup operations, resulting in an operation with O(n) complexity on the number of open files and poor cache locality -- for every open, stat, read, write, etc operation. This change uses a hashtable for this instead, significantly improving the performance of the 9p filesystem. The runtime of NixOS's simple installer test, which copies ~122k files totalling ~1.8GiB from 9p, decreased by a factor of about 10. Signed-off-by: Linus Heckemann Reviewed-by: Philippe Mathieu-Daud=C3=A9 Reviewed-by: Greg Kurz [CS: - Retain BUG_ON(f->clunked) in get_fid(). - Add TODO comment in clunk_fid(). ] Message-Id: <20221004104121.713689-1-git@sphalerite.org> [CS: - Drop unnecessary goto and out: label. ] Signed-off-by: Christian Schoenebeck --- hw/9pfs/9p.c | 196 +++++++++++++++++++++++++++++---------------------- hw/9pfs/9p.h | 2 +- 2 files changed, 113 insertions(+), 85 deletions(-) diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c index aebadeaa03..9bf13133e5 100644 --- a/hw/9pfs/9p.c +++ b/hw/9pfs/9p.c @@ -256,7 +256,8 @@ static size_t v9fs_string_size(V9fsString *str) } =20 /* - * returns 0 if fid got re-opened, 1 if not, < 0 on error */ + * returns 0 if fid got re-opened, 1 if not, < 0 on error + */ static int coroutine_fn v9fs_reopen_fid(V9fsPDU *pdu, V9fsFidState *f) { int err =3D 1; @@ -282,33 +283,32 @@ static V9fsFidState *coroutine_fn get_fid(V9fsPDU *pd= u, int32_t fid) V9fsFidState *f; V9fsState *s =3D pdu->s; =20 - QSIMPLEQ_FOREACH(f, &s->fid_list, next) { + f =3D g_hash_table_lookup(s->fids, GINT_TO_POINTER(fid)); + if (f) { BUG_ON(f->clunked); - if (f->fid =3D=3D fid) { - /* - * Update the fid ref upfront so that - * we don't get reclaimed when we yield - * in open later. - */ - f->ref++; - /* - * check whether we need to reopen the - * file. We might have closed the fd - * while trying to free up some file - * descriptors. - */ - err =3D v9fs_reopen_fid(pdu, f); - if (err < 0) { - f->ref--; - return NULL; - } - /* - * Mark the fid as referenced so that the LRU - * reclaim won't close the file descriptor - */ - f->flags |=3D FID_REFERENCED; - return f; + /* + * Update the fid ref upfront so that + * we don't get reclaimed when we yield + * in open later. + */ + f->ref++; + /* + * check whether we need to reopen the + * file. We might have closed the fd + * while trying to free up some file + * descriptors. + */ + err =3D v9fs_reopen_fid(pdu, f); + if (err < 0) { + f->ref--; + return NULL; } + /* + * Mark the fid as referenced so that the LRU + * reclaim won't close the file descriptor + */ + f->flags |=3D FID_REFERENCED; + return f; } return NULL; } @@ -317,12 +317,11 @@ static V9fsFidState *alloc_fid(V9fsState *s, int32_t = fid) { V9fsFidState *f; =20 - QSIMPLEQ_FOREACH(f, &s->fid_list, next) { + f =3D g_hash_table_lookup(s->fids, GINT_TO_POINTER(fid)); + if (f) { /* If fid is already there return NULL */ BUG_ON(f->clunked); - if (f->fid =3D=3D fid) { - return NULL; - } + return NULL; } f =3D g_new0(V9fsFidState, 1); f->fid =3D fid; @@ -333,7 +332,7 @@ static V9fsFidState *alloc_fid(V9fsState *s, int32_t fi= d) * reclaim won't close the file descriptor */ f->flags |=3D FID_REFERENCED; - QSIMPLEQ_INSERT_TAIL(&s->fid_list, f, next); + g_hash_table_insert(s->fids, GINT_TO_POINTER(fid), f); =20 v9fs_readdir_init(s->proto_version, &f->fs.dir); v9fs_readdir_init(s->proto_version, &f->fs_reclaim.dir); @@ -424,12 +423,12 @@ static V9fsFidState *clunk_fid(V9fsState *s, int32_t = fid) { V9fsFidState *fidp; =20 - QSIMPLEQ_FOREACH(fidp, &s->fid_list, next) { - if (fidp->fid =3D=3D fid) { - QSIMPLEQ_REMOVE(&s->fid_list, fidp, V9fsFidState, next); - fidp->clunked =3D true; - return fidp; - } + /* TODO: Use g_hash_table_steal_extended() instead? */ + fidp =3D g_hash_table_lookup(s->fids, GINT_TO_POINTER(fid)); + if (fidp) { + g_hash_table_remove(s->fids, GINT_TO_POINTER(fid)); + fidp->clunked =3D true; + return fidp; } return NULL; } @@ -439,10 +438,15 @@ void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu) int reclaim_count =3D 0; V9fsState *s =3D pdu->s; V9fsFidState *f; + GHashTableIter iter; + gpointer fid; + + g_hash_table_iter_init(&iter, s->fids); + QSLIST_HEAD(, V9fsFidState) reclaim_list =3D QSLIST_HEAD_INITIALIZER(reclaim_list); =20 - QSIMPLEQ_FOREACH(f, &s->fid_list, next) { + while (g_hash_table_iter_next(&iter, &fid, (gpointer *) &f)) { /* * Unlink fids cannot be reclaimed. Check * for them and skip them. Also skip fids @@ -514,72 +518,85 @@ void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu) } } =20 +/* + * This is used when a path is removed from the directory tree. Any + * fids that still reference it must not be closed from then on, since + * they cannot be reopened. + */ static int coroutine_fn v9fs_mark_fids_unreclaim(V9fsPDU *pdu, V9fsPath *p= ath) { - int err; + int err =3D 0; V9fsState *s =3D pdu->s; - V9fsFidState *fidp, *fidp_next; + V9fsFidState *fidp; + gpointer fid; + GHashTableIter iter; + /* + * The most common case is probably that we have exactly one + * fid for the given path, so preallocate exactly one. + */ + g_autoptr(GArray) to_reopen =3D g_array_sized_new(FALSE, FALSE, + sizeof(V9fsFidState *), 1); + gint i; =20 - fidp =3D QSIMPLEQ_FIRST(&s->fid_list); - if (!fidp) { - return 0; - } + g_hash_table_iter_init(&iter, s->fids); =20 /* - * v9fs_reopen_fid() can yield : a reference on the fid must be held - * to ensure its pointer remains valid and we can safely pass it to - * QSIMPLEQ_NEXT(). The corresponding put_fid() can also yield so - * we must keep a reference on the next fid as well. So the logic here - * is to get a reference on a fid and only put it back during the next - * iteration after we could get a reference on the next fid. Start with - * the first one. + * We iterate over the fid table looking for the entries we need + * to reopen, and store them in to_reopen. This is because + * v9fs_reopen_fid() and put_fid() yield. This allows the fid table + * to be modified in the meantime, invalidating our iterator. */ - for (fidp->ref++; fidp; fidp =3D fidp_next) { + while (g_hash_table_iter_next(&iter, &fid, (gpointer *) &fidp)) { if (fidp->path.size =3D=3D path->size && !memcmp(fidp->path.data, path->data, path->size)) { - /* Mark the fid non reclaimable. */ - fidp->flags |=3D FID_NON_RECLAIMABLE; - - /* reopen the file/dir if already closed */ - err =3D v9fs_reopen_fid(pdu, fidp); - if (err < 0) { - put_fid(pdu, fidp); - return err; - } - } - - fidp_next =3D QSIMPLEQ_NEXT(fidp, next); - - if (fidp_next) { /* - * Ensure the next fid survives a potential clunk request duri= ng - * put_fid() below and v9fs_reopen_fid() in the next iteration. + * Ensure the fid survives a potential clunk request during + * v9fs_reopen_fid or put_fid. */ - fidp_next->ref++; + fidp->ref++; + fidp->flags |=3D FID_NON_RECLAIMABLE; + g_array_append_val(to_reopen, fidp); } - - /* We're done with this fid */ - put_fid(pdu, fidp); } =20 - return 0; + for (i =3D 0; i < to_reopen->len; i++) { + fidp =3D g_array_index(to_reopen, V9fsFidState*, i); + /* reopen the file/dir if already closed */ + err =3D v9fs_reopen_fid(pdu, fidp); + if (err < 0) { + break; + } + } + + for (i =3D 0; i < to_reopen->len; i++) { + put_fid(pdu, g_array_index(to_reopen, V9fsFidState*, i)); + } + return err; } =20 static void coroutine_fn virtfs_reset(V9fsPDU *pdu) { V9fsState *s =3D pdu->s; V9fsFidState *fidp; + GList *freeing; + /* + * Get a list of all the values (fid states) in the table, which + * we then... + */ + g_autoptr(GList) fids =3D g_hash_table_get_values(s->fids); =20 - /* Free all fids */ - while (!QSIMPLEQ_EMPTY(&s->fid_list)) { - /* Get fid */ - fidp =3D QSIMPLEQ_FIRST(&s->fid_list); + /* ... remove from the table, taking over ownership. */ + g_hash_table_steal_all(s->fids); + + /* + * This allows us to release our references to them asynchronously wit= hout + * iterating over the hash table and risking iterator invalidation + * through concurrent modifications. + */ + for (freeing =3D fids; freeing; freeing =3D freeing->next) { + fidp =3D freeing->data; fidp->ref++; - - /* Clunk fid */ - QSIMPLEQ_REMOVE(&s->fid_list, fidp, V9fsFidState, next); fidp->clunked =3D true; - put_fid(pdu, fidp); } } @@ -3205,6 +3222,8 @@ static int coroutine_fn v9fs_complete_rename(V9fsPDU = *pdu, V9fsFidState *fidp, V9fsFidState *tfidp; V9fsState *s =3D pdu->s; V9fsFidState *dirfidp =3D NULL; + GHashTableIter iter; + gpointer fid; =20 v9fs_path_init(&new_path); if (newdirfid !=3D -1) { @@ -3238,11 +3257,13 @@ static int coroutine_fn v9fs_complete_rename(V9fsPD= U *pdu, V9fsFidState *fidp, if (err < 0) { goto out; } + /* * Fixup fid's pointing to the old name to * start pointing to the new name */ - QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) { + g_hash_table_iter_init(&iter, s->fids); + while (g_hash_table_iter_next(&iter, &fid, (gpointer *) &tfidp)) { if (v9fs_path_is_ancestor(&fidp->path, &tfidp->path)) { /* replace the name */ v9fs_fix_path(&tfidp->path, &new_path, strlen(fidp->path.data)= ); @@ -3320,6 +3341,8 @@ static int coroutine_fn v9fs_fix_fid_paths(V9fsPDU *p= du, V9fsPath *olddir, V9fsPath oldpath, newpath; V9fsState *s =3D pdu->s; int err; + GHashTableIter iter; + gpointer fid; =20 v9fs_path_init(&oldpath); v9fs_path_init(&newpath); @@ -3336,7 +3359,8 @@ static int coroutine_fn v9fs_fix_fid_paths(V9fsPDU *p= du, V9fsPath *olddir, * Fixup fid's pointing to the old name to * start pointing to the new name */ - QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) { + g_hash_table_iter_init(&iter, s->fids); + while (g_hash_table_iter_next(&iter, &fid, (gpointer *) &tfidp)) { if (v9fs_path_is_ancestor(&oldpath, &tfidp->path)) { /* replace the name */ v9fs_fix_path(&tfidp->path, &newpath, strlen(oldpath.data)); @@ -4226,7 +4250,7 @@ int v9fs_device_realize_common(V9fsState *s, const V9= fsTransport *t, s->ctx.fmode =3D fse->fmode; s->ctx.dmode =3D fse->dmode; =20 - QSIMPLEQ_INIT(&s->fid_list); + s->fids =3D g_hash_table_new(NULL, NULL); qemu_co_rwlock_init(&s->rename_lock); =20 if (s->ops->init(&s->ctx, errp) < 0) { @@ -4286,6 +4310,10 @@ void v9fs_device_unrealize_common(V9fsState *s) if (s->ctx.fst) { fsdev_throttle_cleanup(s->ctx.fst); } + if (s->fids) { + g_hash_table_destroy(s->fids); + s->fids =3D NULL; + } g_free(s->tag); qp_table_destroy(&s->qpd_table); qp_table_destroy(&s->qpp_table); diff --git a/hw/9pfs/9p.h b/hw/9pfs/9p.h index a523ac34a9..2fce4140d1 100644 --- a/hw/9pfs/9p.h +++ b/hw/9pfs/9p.h @@ -339,7 +339,7 @@ typedef struct { struct V9fsState { QLIST_HEAD(, V9fsPDU) free_list; QLIST_HEAD(, V9fsPDU) active_list; - QSIMPLEQ_HEAD(, V9fsFidState) fid_list; + GHashTable *fids; FileOperations *ops; FsContext ctx; char *tag; --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610484; cv=none; d=zohomail.com; s=zohoarc; b=oFqtgePmJXHUH0+WZbMWpgBe415EVRI2kMC/G1qftDhV3Wes/GEdV0ajexBIM0xJp8fRPPXS51ZfVoNC72lGaSK+CwiFZ3wa6xKa3vneyuvEDM3RXAEDlrAXOLnE8wkt73e6AAqFxgM3V3yDegdXM8xNKtBBWhl6nM75cOwJuDI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610484; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=n18fGllOdDIcvIlhhVxf6gj4QGYPWtXdFj9ab/FmlMY=; b=RZVuBMYtkqibt1VGRkKjKuMZZ1JKbRNfRWfqAdyGSSScBib9ojz1Dr8lTBoQsmY1SPNORXKyfp7QnGVFiZKc7HjEXlfSg+Ll5Xudw4zFNUIiprpLfpeqAiQ9nUGO/JVjhQsl9oQEJhQDIZsA8KMEyjYjZh4cj3p0RWMdjlgWaVA= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610484069248.08870966515065; Mon, 24 Oct 2022 04:21:24 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvLi-0008QD-7R; Mon, 24 Oct 2022 07:10:30 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <569f3b63ad5f65d0f86724766fedfffffe0feda3@lizzy.crudebyte.com>) id 1omvLf-0008Kg-TA for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:27 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <569f3b63ad5f65d0f86724766fedfffffe0feda3@lizzy.crudebyte.com>) id 1omvLb-0006mC-VN for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:26 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=n18fGllOdDIcvIlhhVxf6gj4QGYPWtXdFj9ab/FmlMY=; b=mYbty eIF4uNGRP1D47gpmjebrfCqFMvNaasSXs8GgbbXbS1BTjVmhA4RHhVzEMTYVufNAidTz/aISC96+1 U8HzFyUjBVbk0+egyG8QDnvr5gaymDLj3j7UGC4oI+kCb7r3XFV4XJfvDpBUq57jyIwcqBMP/q+Sg 3FONzbji5WtzEwURh1YYcsO6vLvc1g0p+Cw4ThRCCz3NwOiTP9TQDOMTr3f8F4P3lbIZUW2D2tOB1 /4DXJoJ5Ut2dNRb+juMBHDJ+A1QYJwomSPmYRgSCQ8EyiTNyRwFhdeNV6RGp442rTj4xtLWx1i3dm pMkT4Et6oDGsc679UEaY/ZCE2nllw==; Message-Id: <569f3b63ad5f65d0f86724766fedfffffe0feda3.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 04/23] tests/9p: merge *walk*() functions To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=569f3b63ad5f65d0f86724766fedfffffe0feda3@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610485472100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Introduce declarative function calls. There are currently 4 different functions for sending a 9p 'Twalk' request: v9fs_twalk(), do_walk(), do_walk_rqids() and do_walk_expect_error(). They are all doing the same thing, just in a slightly different way and with slightly different function arguments. Merge those 4 functions into a single function by using a struct for function call arguments and use designated initializers when calling this function to turn usage into a declarative approach, which is better readable and easier to maintain. Also move private functions genfid(), split() and split_free() from virtio-9p-test.c to virtio-9p-client.c. Based-on: Signed-off-by: Christian Schoenebeck Message-Id: <607969dbfbc63c1be008df9131133711b046e979.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 114 ++++++++++++++-- tests/qtest/libqos/virtio-9p-client.h | 37 ++++- tests/qtest/virtio-9p-test.c | 187 +++++++++----------------- 3 files changed, 198 insertions(+), 140 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index f5c35fd722..a95bbad9c8 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -23,6 +23,65 @@ void v9fs_set_allocator(QGuestAllocator *t_alloc) alloc =3D t_alloc; } =20 +/* + * Used to auto generate new fids. Start with arbitrary high value to avoid + * collision with hard coded fids in basic test code. + */ +static uint32_t fid_generator =3D 1000; + +static uint32_t genfid(void) +{ + return fid_generator++; +} + +/** + * Splits the @a in string by @a delim into individual (non empty) strings + * and outputs them to @a out. The output array @a out is NULL terminated. + * + * Output array @a out must be freed by calling split_free(). + * + * @returns number of individual elements in output array @a out (without = the + * final NULL terminating element) + */ +static int split(const char *in, const char *delim, char ***out) +{ + int n =3D 0, i =3D 0; + char *tmp, *p; + + tmp =3D g_strdup(in); + for (p =3D strtok(tmp, delim); p !=3D NULL; p =3D strtok(NULL, delim))= { + if (strlen(p) > 0) { + ++n; + } + } + g_free(tmp); + + *out =3D g_new0(char *, n + 1); /* last element NULL delimiter */ + + tmp =3D g_strdup(in); + for (p =3D strtok(tmp, delim); p !=3D NULL; p =3D strtok(NULL, delim))= { + if (strlen(p) > 0) { + (*out)[i++] =3D g_strdup(p); + } + } + g_free(tmp); + + return n; +} + +static void split_free(char ***out) +{ + int i; + if (!*out) { + return; + } + for (i =3D 0; (*out)[i]; ++i) { + g_free((*out)[i]); + } + g_free(*out); + *out =3D NULL; +} + void v9fs_memwrite(P9Req *req, const void *addr, size_t len) { qtest_memwrite(req->qts, req->t_msg + req->t_off, addr, len); @@ -294,28 +353,61 @@ void v9fs_rattach(P9Req *req, v9fs_qid *qid) } =20 /* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) */ -P9Req *v9fs_twalk(QVirtio9P *v9p, uint32_t fid, uint32_t newfid, - uint16_t nwname, char *const wnames[], uint16_t tag) +TWalkRes v9fs_twalk(TWalkOpt opt) { P9Req *req; int i; uint32_t body_size =3D 4 + 4 + 2; + uint32_t err; + char **wnames =3D NULL; =20 - for (i =3D 0; i < nwname; i++) { - uint16_t wname_size =3D v9fs_string_size(wnames[i]); + g_assert(opt.client); + /* expecting either high- or low-level path, both not both */ + g_assert(!opt.path || !(opt.nwname || opt.wnames)); + /* expecting either Rwalk or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !(opt.rwalk.nwqid || opt.rwalk.wqid)); + + if (!opt.newfid) { + opt.newfid =3D genfid(); + } + + if (opt.path) { + opt.nwname =3D split(opt.path, "/", &wnames); + opt.wnames =3D wnames; + } + + for (i =3D 0; i < opt.nwname; i++) { + uint16_t wname_size =3D v9fs_string_size(opt.wnames[i]); =20 g_assert_cmpint(body_size, <=3D, UINT32_MAX - wname_size); body_size +=3D wname_size; } - req =3D 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 =3D 0; i < nwname; i++) { - v9fs_string_write(req, wnames[i]); + req =3D v9fs_req_init(opt.client, body_size, P9_TWALK, opt.tag); + v9fs_uint32_write(req, opt.fid); + v9fs_uint32_write(req, opt.newfid); + v9fs_uint16_write(req, opt.nwname); + for (i =3D 0; i < opt.nwname; i++) { + v9fs_string_write(req, opt.wnames[i]); } v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rwalk(req, opt.rwalk.nwqid, opt.rwalk.wqid); + } + req =3D NULL; /* request was freed */ + } + + split_free(&wnames); + + return (TWalkRes) { + .newfid =3D opt.newfid, + .req =3D req, + }; } =20 /* size[4] Rwalk tag[2] nwqid[2] nwqid*(wqid[13]) */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index c502d12a66..8c6abbb173 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -72,6 +72,40 @@ struct V9fsDirent { struct V9fsDirent *next; }; =20 +/* options for 'Twalk' 9p request */ +typedef struct TWalkOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* file ID of directory from where walk should start (optional) */ + uint32_t fid; + /* file ID for target directory being walked to (optional) */ + uint32_t newfid; + /* low level variant of path to walk to (optional) */ + uint16_t nwname; + char **wnames; + /* high level variant of path to walk to (optional) */ + const char *path; + /* data being received from 9p server as 'Rwalk' response (optional) */ + struct { + uint16_t *nwqid; + v9fs_qid **wqid; + } rwalk; + /* only send Twalk request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TWalkOpt; + +/* result of 'Twalk' 9p request */ +typedef struct TWalkRes { + /* file ID of target directory been walked to */ + uint32_t newfid; + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TWalkRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -99,8 +133,7 @@ void v9fs_rversion(P9Req *req, uint16_t *len, char **ver= sion); P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname, uint16_t tag); void v9fs_rattach(P9Req *req, v9fs_qid *qid); -P9Req *v9fs_twalk(QVirtio9P *v9p, uint32_t fid, uint32_t newfid, - uint16_t nwname, char *const wnames[], uint16_t tag); +TWalkRes v9fs_twalk(TWalkOpt opt); void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid); P9Req *v9fs_tgetattr(QVirtio9P *v9p, uint32_t fid, uint64_t request_mask, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 498c32e21b..cf5d6146ad 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -16,61 +16,7 @@ #include "qemu/module.h" #include "libqos/virtio-9p-client.h" =20 -/* - * Used to auto generate new fids. Start with arbitrary high value to avoid - * collision with hard coded fids in basic test code. - */ -static uint32_t fid_generator =3D 1000; - -static uint32_t genfid(void) -{ - return fid_generator++; -} - -/** - * Splits the @a in string by @a delim into individual (non empty) strings - * and outputs them to @a out. The output array @a out is NULL terminated. - * - * Output array @a out must be freed by calling split_free(). - * - * @returns number of individual elements in output array @a out (without = the - * final NULL terminating element) - */ -static int split(const char *in, const char *delim, char ***out) -{ - int n =3D 0, i =3D 0; - char *tmp, *p; - - tmp =3D g_strdup(in); - for (p =3D strtok(tmp, delim); p !=3D NULL; p =3D strtok(NULL, delim))= { - if (strlen(p) > 0) { - ++n; - } - } - g_free(tmp); - - *out =3D g_new0(char *, n + 1); /* last element NULL delimiter */ - - tmp =3D g_strdup(in); - for (p =3D strtok(tmp, delim); p !=3D NULL; p =3D strtok(NULL, delim))= { - if (strlen(p) > 0) { - (*out)[i++] =3D g_strdup(p); - } - } - g_free(tmp); - - return n; -} - -static void split_free(char ***out) -{ - int i; - for (i =3D 0; (*out)[i]; ++i) { - g_free((*out)[i]); - } - g_free(*out); - *out =3D NULL; -} +#define twalk(...) v9fs_twalk((TWalkOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -109,52 +55,6 @@ static void do_version(QVirtio9P *v9p) g_assert_cmpmem(server_version, server_len, version, strlen(version)); } =20 -/* - * utility function: walk to requested dir and return fid for that dir and - * the QIDs of server response - */ -static uint32_t do_walk_rqids(QVirtio9P *v9p, const char *path, uint16_t *= nwqid, - v9fs_qid **wqid) -{ - char **wnames; - P9Req *req; - const uint32_t fid =3D genfid(); - - int nwnames =3D split(path, "/", &wnames); - - req =3D v9fs_twalk(v9p, 0, fid, nwnames, wnames, 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, nwqid, wqid); - - split_free(&wnames); - return fid; -} - -/* utility function: walk to requested dir and return fid for that dir */ -static uint32_t do_walk(QVirtio9P *v9p, const char *path) -{ - return do_walk_rqids(v9p, path, NULL, NULL); -} - -/* utility function: walk to requested dir and expect passed error respons= e */ -static void do_walk_expect_error(QVirtio9P *v9p, const char *path, uint32_= t err) -{ - char **wnames; - P9Req *req; - uint32_t _err; - const uint32_t fid =3D genfid(); - - int nwnames =3D split(path, "/", &wnames); - - req =3D v9fs_twalk(v9p, 0, fid, nwnames, wnames, 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlerror(req, &_err); - - g_assert_cmpint(_err, =3D=3D, err); - - split_free(&wnames); -} - static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc) { v9fs_set_allocator(t_alloc); @@ -197,7 +97,10 @@ static void fs_walk(void *obj, void *data, QGuestAlloca= tor *t_alloc) } =20 do_attach(v9p); - req =3D v9fs_twalk(v9p, 0, 1, P9_MAXWELEM, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, + .nwname =3D P9_MAXWELEM, .wnames =3D wnames, .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, &nwqid, &wqid); =20 @@ -223,7 +126,7 @@ static void fs_readdir(void *obj, void *data, QGuestAll= ocator *t_alloc) { QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); - char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) }; + char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) }; uint16_t nqid; v9fs_qid qid; uint32_t count, nentries; @@ -231,7 +134,10 @@ static void fs_readdir(void *obj, void *data, QGuestAl= locator *t_alloc) P9Req *req; =20 do_attach(v9p); - req =3D v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, + .nwname =3D 1, .wnames =3D wnames, .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, &nqid, NULL); g_assert_cmpint(nqid, =3D=3D, 1); @@ -275,7 +181,7 @@ static void fs_readdir(void *obj, void *data, QGuestAll= ocator *t_alloc) /* readdir test where overall request is split over several messages */ static void do_readdir_split(QVirtio9P *v9p, uint32_t count) { - char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) }; + char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_READDIR_DIR) }; uint16_t nqid; v9fs_qid qid; uint32_t nentries, npartialentries; @@ -292,7 +198,10 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t = count) nentries =3D 0; tail =3D NULL; =20 - req =3D v9fs_twalk(v9p, 0, fid, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D fid, + .nwname =3D 1, .wnames =3D wnames, .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, &nqid, NULL); g_assert_cmpint(nqid, =3D=3D, 1); @@ -356,12 +265,15 @@ static void fs_walk_no_slash(void *obj, void *data, Q= GuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); - char *const wnames[] =3D { g_strdup(" /") }; + char *wnames[] =3D { g_strdup(" /") }; P9Req *req; uint32_t err; =20 do_attach(v9p); - req =3D v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlerror(req, &err); =20 @@ -380,7 +292,7 @@ static void fs_walk_nonexistent(void *obj, void *data, = QGuestAllocator *t_alloc) * The 9p2000 protocol spec says: "If the first element cannot be walk= ed * for any reason, Rerror is returned." */ - do_walk_expect_error(v9p, "non-existent", ENOENT); + twalk({ .client =3D v9p, .path =3D "non-existent", .expectErr =3D ENOE= NT }); } =20 static void fs_walk_2nd_nonexistent(void *obj, void *data, @@ -398,7 +310,10 @@ static void fs_walk_2nd_nonexistent(void *obj, void *d= ata, ); =20 do_attach_rqid(v9p, &root_qid); - fid =3D do_walk_rqids(v9p, path, &nwqid, &wqid); + fid =3D twalk({ + .client =3D v9p, .path =3D path, + .rwalk.nwqid =3D &nwqid, .rwalk.wqid =3D &wqid + }).newfid; /* * The 9p2000 protocol spec says: "nwqid is therefore either nwname or= the * index of the first elementwise walk that failed." @@ -430,7 +345,10 @@ static void fs_walk_none(void *obj, void *data, QGuest= Allocator *t_alloc) v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); =20 - req =3D v9fs_twalk(v9p, 0, 1, 0, NULL, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 0, .wnames= =3D NULL, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, NULL, &wqid); =20 @@ -448,7 +366,7 @@ static void fs_walk_dotdot(void *obj, void *data, QGues= tAllocator *t_alloc) { QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); - char *const wnames[] =3D { g_strdup("..") }; + char *wnames[] =3D { g_strdup("..") }; v9fs_qid root_qid; g_autofree v9fs_qid *wqid =3D NULL; P9Req *req; @@ -458,7 +376,10 @@ static void fs_walk_dotdot(void *obj, void *data, QGue= stAllocator *t_alloc) v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); =20 - req =3D v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */ =20 @@ -471,11 +392,14 @@ static void fs_lopen(void *obj, void *data, QGuestAll= ocator *t_alloc) { QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); - char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) }; + char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) }; P9Req *req; =20 do_attach(v9p); - req =3D v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, NULL, NULL); =20 @@ -491,13 +415,16 @@ static void fs_write(void *obj, void *data, QGuestAll= ocator *t_alloc) QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); static const uint32_t write_count =3D P9_MAX_SIZE / 2; - char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) }; + char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) }; g_autofree char *buf =3D g_malloc0(write_count); uint32_t count; P9Req *req; =20 do_attach(v9p); - req =3D v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, NULL, NULL); =20 @@ -517,13 +444,16 @@ static void fs_flush_success(void *obj, void *data, Q= GuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); - char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; + char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; P9Req *req, *flush_req; uint32_t reply_len; uint8_t should_block; =20 do_attach(v9p); - req =3D v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, NULL, NULL); =20 @@ -554,13 +484,16 @@ static void fs_flush_ignored(void *obj, void *data, Q= GuestAllocator *t_alloc) { QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); - char *const wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; + char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_FLUSH_FILE) }; P9Req *req, *flush_req; uint32_t count; uint8_t should_block; =20 do_attach(v9p); - req =3D v9fs_twalk(v9p, 0, 1, 1, wnames, 0); + req =3D twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwalk(req, NULL, NULL); =20 @@ -593,7 +526,7 @@ static void do_mkdir(QVirtio9P *v9p, const char *path, = const char *cname) uint32_t fid; P9Req *req; =20 - fid =3D do_walk(v9p, path); + fid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; =20 req =3D v9fs_tmkdir(v9p, fid, name, 0750, 0, 0); v9fs_req_wait_for_reply(req, NULL); @@ -608,7 +541,7 @@ static uint32_t do_lcreate(QVirtio9P *v9p, const char *= path, uint32_t fid; P9Req *req; =20 - fid =3D do_walk(v9p, path); + fid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; =20 req =3D v9fs_tlcreate(v9p, fid, name, 0, 0750, 0, 0); v9fs_req_wait_for_reply(req, NULL); @@ -626,7 +559,7 @@ static void do_symlink(QVirtio9P *v9p, const char *path= , const char *clink, uint32_t fid; P9Req *req; =20 - fid =3D do_walk(v9p, path); + fid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; =20 req =3D v9fs_tsymlink(v9p, fid, name, dst, 0, 0); v9fs_req_wait_for_reply(req, NULL); @@ -640,8 +573,8 @@ static void do_hardlink(QVirtio9P *v9p, const char *pat= h, const char *clink, uint32_t dfid, fid; P9Req *req; =20 - dfid =3D do_walk(v9p, path); - fid =3D do_walk(v9p, to); + dfid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; + fid =3D twalk({ .client =3D v9p, .path =3D to }).newfid; =20 req =3D v9fs_tlink(v9p, dfid, fid, clink, 0); v9fs_req_wait_for_reply(req, NULL); @@ -655,7 +588,7 @@ static void do_unlinkat(QVirtio9P *v9p, const char *atp= ath, const char *rpath, uint32_t fid; P9Req *req; =20 - fid =3D do_walk(v9p, atpath); + fid =3D twalk({ .client =3D v9p, .path =3D atpath }).newfid; =20 req =3D v9fs_tunlinkat(v9p, fid, name, flags, 0); v9fs_req_wait_for_reply(req, NULL); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610416; cv=none; d=zohomail.com; s=zohoarc; b=hMD1UYw2tviGLDyHBE3qGKzjGNeCXzRNkV6qWZ1tu7+M+vNq65NyksMfxgbJUbkghtOo/vih8Tpx85EMOMVS3IUxEmqVvm/wjJFna4KbJTGF2L1YNctTQ3WKSNxqFVDIB91z6K9ofNP1LfUnuAhunHqysnnZx48xkx+Xcb/t/Rk= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610416; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=j1qMYwjqZSsvOmRZN4Bn0S5B3o5/LmFGW4XKgo5pJBI=; b=Cqd3XAmEsEb//KqnTKOpsE4lBUBh2Rs9JtWMx8EAHxPW5Q9mPyEG6J4pSQ87NcriCvvwvDh0tkd+E9FB2wWt4PEDVyzW8M3CNg4Vo9Oz3suk+CPkGlBSv5L0IzY7mZfJmbi1uQy+zGTSiOfhVErQteykO/XtNjB64MOxtBL+Dhs= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610416374858.560753731876; Mon, 24 Oct 2022 04:20:16 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMi-0000ef-W3; Mon, 24 Oct 2022 07:11:33 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3f3e9232207fc4f0e5cb5cf63f11ed9449efeefa@lizzy.crudebyte.com>) id 1omvLu-0000O3-UQ for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:42 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3f3e9232207fc4f0e5cb5cf63f11ed9449efeefa@lizzy.crudebyte.com>) id 1omvLg-0006np-1X for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:42 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=j1qMYwjqZSsvOmRZN4Bn0S5B3o5/LmFGW4XKgo5pJBI=; b=DF7Ls HoJ0CRoDFRLEqh4Y5dtrKUiOJ48GgQ7PUGAnhp/8img65DNcb6pFlHlkK5+wQHvpxkvybqbu+h9kB w0aE4XlyJq6tPpS3FNq8C6Nl6YM70HhBJN2iMp4r9z18bCLvmGv7EAV52GLpUziOYX0miGk7DOqpU 2cuFBCZv229bf8IeRWijQFbD1XoT6AUoKWNza/4B/KJyhK0PgYd019U+pJqDDsc89FdfQ+MXAXhNU CDHFG/NJRvLCOBGzugg82Jy4AwIJugxzxB7TdAc52+SB1vHN3CBRiFCLcSucCLliRDwKUsdWgrjRD y7Otum9nhrELqqd8YLsLIx5sz1kMQ==; Message-Id: <3f3e9232207fc4f0e5cb5cf63f11ed9449efeefa.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 05/23] tests/9p: simplify callers of twalk() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=3f3e9232207fc4f0e5cb5cf63f11ed9449efeefa@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610418425100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Now as twalk() is using a declarative approach, simplify the code of callers of this function. Signed-off-by: Christian Schoenebeck Message-Id: <8b9d3c656ad43b6c953d6bdacd8d9f4c8e599b2a.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/virtio-9p-test.c | 92 +++++++++++++----------------------- 1 file changed, 32 insertions(+), 60 deletions(-) diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index cf5d6146ad..3c326451b1 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -90,19 +90,17 @@ static void fs_walk(void *obj, void *data, QGuestAlloca= tor *t_alloc) uint16_t nwqid; g_autofree v9fs_qid *wqid =3D NULL; int i; - P9Req *req; =20 for (i =3D 0; i < P9_MAXWELEM; i++) { wnames[i] =3D g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i); } =20 do_attach(v9p); - req =3D twalk({ + twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, - .nwname =3D P9_MAXWELEM, .wnames =3D wnames, .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, &nwqid, &wqid); + .nwname =3D P9_MAXWELEM, .wnames =3D wnames, + .rwalk =3D { .nwqid =3D &nwqid, .wqid =3D &wqid } + }); =20 g_assert_cmpint(nwqid, =3D=3D, P9_MAXWELEM); =20 @@ -134,12 +132,10 @@ static void fs_readdir(void *obj, void *data, QGuestA= llocator *t_alloc) P9Req *req; =20 do_attach(v9p); - req =3D twalk({ + twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, - .nwname =3D 1, .wnames =3D wnames, .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, &nqid, NULL); + .nwname =3D 1, .wnames =3D wnames, .rwalk.nwqid =3D &nqid + }); g_assert_cmpint(nqid, =3D=3D, 1); =20 req =3D v9fs_tlopen(v9p, 1, O_DIRECTORY, 0); @@ -198,12 +194,10 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t= count) nentries =3D 0; tail =3D NULL; =20 - req =3D twalk({ + twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D fid, - .nwname =3D 1, .wnames =3D wnames, .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, &nqid, NULL); + .nwname =3D 1, .wnames =3D wnames, .rwalk.nwqid =3D &nqid + }); g_assert_cmpint(nqid, =3D=3D, 1); =20 req =3D v9fs_tlopen(v9p, fid, O_DIRECTORY, 0); @@ -266,18 +260,12 @@ static void fs_walk_no_slash(void *obj, void *data, Q= GuestAllocator *t_alloc) QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); char *wnames[] =3D { g_strdup(" /") }; - P9Req *req; - uint32_t err; =20 do_attach(v9p); - req =3D twalk({ + twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlerror(req, &err); - - g_assert_cmpint(err, =3D=3D, ENOENT); + .expectErr =3D ENOENT + }); =20 g_free(wnames[0]); } @@ -312,7 +300,7 @@ static void fs_walk_2nd_nonexistent(void *obj, void *da= ta, do_attach_rqid(v9p, &root_qid); fid =3D twalk({ .client =3D v9p, .path =3D path, - .rwalk.nwqid =3D &nwqid, .rwalk.wqid =3D &wqid + .rwalk =3D { .nwqid =3D &nwqid, .wqid =3D &wqid } }).newfid; /* * The 9p2000 protocol spec says: "nwqid is therefore either nwname or= the @@ -345,12 +333,10 @@ static void fs_walk_none(void *obj, void *data, QGues= tAllocator *t_alloc) v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); =20 - req =3D twalk({ + twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 0, .wnames= =3D NULL, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, NULL, &wqid); + .rwalk.wqid =3D &wqid + }); =20 /* special case: no QID is returned if nwname=3D0 was sent */ g_assert(wqid =3D=3D NULL); @@ -376,12 +362,10 @@ static void fs_walk_dotdot(void *obj, void *data, QGu= estAllocator *t_alloc) v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); =20 - req =3D twalk({ + twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, NULL, &wqid); /* We now we'll get one qid */ + .rwalk.wqid =3D &wqid /* We now we'll get one qid */ + }); =20 g_assert_cmpmem(&root_qid, 13, wqid[0], 13); =20 @@ -396,12 +380,9 @@ static void fs_lopen(void *obj, void *data, QGuestAllo= cator *t_alloc) P9Req *req; =20 do_attach(v9p); - req =3D twalk({ - .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, NULL, NULL); + twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames + }); =20 req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); v9fs_req_wait_for_reply(req, NULL); @@ -421,12 +402,9 @@ static void fs_write(void *obj, void *data, QGuestAllo= cator *t_alloc) P9Req *req; =20 do_attach(v9p); - req =3D twalk({ - .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, NULL, NULL); + twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames + }); =20 req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); v9fs_req_wait_for_reply(req, NULL); @@ -450,12 +428,9 @@ static void fs_flush_success(void *obj, void *data, QG= uestAllocator *t_alloc) uint8_t should_block; =20 do_attach(v9p); - req =3D twalk({ - .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, NULL, NULL); + twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames + }); =20 req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); v9fs_req_wait_for_reply(req, NULL); @@ -490,12 +465,9 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) uint8_t should_block; =20 do_attach(v9p); - req =3D twalk({ - .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwalk(req, NULL, NULL); + twalk({ + .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames + }); =20 req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); v9fs_req_wait_for_reply(req, NULL); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666612042; cv=none; d=zohomail.com; s=zohoarc; b=mpgg7Y6JQrnLG3xpKfXanNE43ai2HxsqhKoz/5fo8kDlsc2lmKcijhLYX8WpOvXhrtQCv3wbrC9GR1fjI/ZO7wvCRuW7KaTZQJItbHsZzEjMWg2W3hHqlo1fRmTdmOmkzX7LFVxabsiOaZZcRoNxA+Cwch7FtviPO/pA1er/9eU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666612042; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=xCkdo5peA33lJZKtjxM1AMV+H50jJVmmMaGtECC6tsA=; b=mCDW1aBiROtz5hP+VAnTBVMMPHXXsU81AKz+1u6OgaUPnvm+bqdD3mFipzBin2vJGhJGSh4c+7su8TQKN9zVFpMioHkAf66UzF3VgIhM9gTYoV0U3SyTxY1sTJlaVuzinU+Om85tD1XMp6SHWgXqHK8RBX2LAanm81kr1fhpr6o= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 16666120424553.5830197199267104; Mon, 24 Oct 2022 04:47:22 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvLt-0000KZ-K3; Mon, 24 Oct 2022 07:10:41 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvLs-0000Ir-7P for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:40 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvLm-0006oG-F3 for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:40 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=xCkdo5peA33lJZKtjxM1AMV+H50jJVmmMaGtECC6tsA=; b=DjTB4 NO2vkkceh1SyJvRV26C5FXbwVFdYOJGfPXA9ZStUwElXsp09Stbb5HgWCrJPC+KMJNMxEMrCYWxhq UHLRoC5DvgjL/v6CmMqHrD1/x/TNZNFNVUIztT31iNxXlp+DCHpDXW7kfVr+pjl92kEiJXDLrVZiA M7OiC8VK182w5r8AP1CS5nTNH7POuzYfLRs8qJT7M9mLgIJIOB5FV3PFYYgYcww56kHBnfITaasnJ GB/4YAKtHKxbOukrLd/KrL+M7M5Tayz1/1+98sBv7+h2s32EaO7dU1lhiylt6meiOYIdATzxzT5o4 0ahJD2WTYlJzsVuXHUlGGcNzPEq2Q==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 06/23] tests/9p: merge v9fs_tversion() and do_version() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=bee8fda2f9841cc8d76fbe60f65f9aeb29fce1c2@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666612044041100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" As with previous patches, unify functions v9fs_tversion() and do_version() into a single function v9fs_tversion() by using a declarative function arguments approach. Signed-off-by: Christian Schoenebeck Message-Id: <2d253491aaffd267ec295f056dda47456692cd0c.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 47 +++++++++++++++++++++++---- tests/qtest/libqos/virtio-9p-client.h | 25 ++++++++++++-- tests/qtest/virtio-9p-test.c | 23 +++---------- 3 files changed, 68 insertions(+), 27 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index a95bbad9c8..e8364f8d64 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -291,21 +291,54 @@ void v9fs_rlerror(P9Req *req, uint32_t *err) } =20 /* size[4] Tversion tag[2] msize[4] version[s] */ -P9Req *v9fs_tversion(QVirtio9P *v9p, uint32_t msize, const char *version, - uint16_t tag) +TVersionRes v9fs_tversion(TVersionOpt opt) { P9Req *req; + uint32_t err; uint32_t body_size =3D 4; - uint16_t string_size =3D v9fs_string_size(version); + uint16_t string_size; + uint16_t server_len; + g_autofree char *server_version =3D NULL; =20 + g_assert(opt.client); + + if (!opt.msize) { + opt.msize =3D P9_MAX_SIZE; + } + + if (!opt.tag) { + opt.tag =3D P9_NOTAG; + } + + if (!opt.version) { + opt.version =3D "9P2000.L"; + } + + string_size =3D v9fs_string_size(opt.version); g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; - req =3D v9fs_req_init(v9p, body_size, P9_TVERSION, tag); + req =3D v9fs_req_init(opt.client, body_size, P9_TVERSION, opt.tag); =20 - v9fs_uint32_write(req, msize); - v9fs_string_write(req, version); + v9fs_uint32_write(req, opt.msize); + v9fs_string_write(req, opt.version); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rversion(req, &server_len, &server_version); + g_assert_cmpmem(server_version, server_len, + opt.version, strlen(opt.version)); + } + req =3D NULL; /* request was freed */ + } + + return (TVersionRes) { + .req =3D req, + }; } =20 /* size[4] Rversion tag[2] msize[4] version[s] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index 8c6abbb173..fcde849b5d 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -106,6 +106,28 @@ typedef struct TWalkRes { P9Req *req; } TWalkRes; =20 +/* options for 'Tversion' 9p request */ +typedef struct TVersionOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* maximum message size that can be handled by client (optional) */ + uint32_t msize; + /* protocol version (optional) */ + const char *version; + /* only send Tversion request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TVersionOpt; + +/* result of 'Tversion' 9p request */ +typedef struct TVersionRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TVersionRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -127,8 +149,7 @@ void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len); void v9fs_req_recv(P9Req *req, uint8_t id); void v9fs_req_free(P9Req *req); void v9fs_rlerror(P9Req *req, uint32_t *err); -P9Req *v9fs_tversion(QVirtio9P *v9p, uint32_t msize, const char *version, - uint16_t tag); +TVersionRes v9fs_tversion(TVersionOpt); void v9fs_rversion(P9Req *req, uint16_t *len, char **version); P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 3c326451b1..f2907c8026 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -17,6 +17,7 @@ #include "libqos/virtio-9p-client.h" =20 #define twalk(...) v9fs_twalk((TWalkOpt) __VA_ARGS__) +#define tversion(...) v9fs_tversion((TVersionOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -41,31 +42,17 @@ static inline bool is_same_qid(v9fs_qid a, v9fs_qid b) return a[0] =3D=3D b[0] && memcmp(&a[5], &b[5], 8) =3D=3D 0; } =20 -static void do_version(QVirtio9P *v9p) -{ - const char *version =3D "9P2000.L"; - uint16_t server_len; - g_autofree char *server_version =3D NULL; - P9Req *req; - - req =3D 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)); -} - static void fs_version(void *obj, void *data, QGuestAllocator *t_alloc) { v9fs_set_allocator(t_alloc); - do_version(obj); + tversion({ .client =3D obj }); } =20 static void do_attach_rqid(QVirtio9P *v9p, v9fs_qid *qid) { P9Req *req; =20 - do_version(v9p); + tversion({ .client =3D v9p }); req =3D v9fs_tattach(v9p, 0, getuid(), 0); v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, qid); @@ -328,7 +315,7 @@ static void fs_walk_none(void *obj, void *data, QGuestA= llocator *t_alloc) P9Req *req; struct v9fs_attr attr; =20 - do_version(v9p); + tversion({ .client =3D v9p }); req =3D v9fs_tattach(v9p, 0, getuid(), 0); v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); @@ -357,7 +344,7 @@ static void fs_walk_dotdot(void *obj, void *data, QGues= tAllocator *t_alloc) g_autofree v9fs_qid *wqid =3D NULL; P9Req *req; =20 - do_version(v9p); + tversion({ .client =3D v9p }); req =3D v9fs_tattach(v9p, 0, getuid(), 0); v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610382; cv=none; d=zohomail.com; s=zohoarc; b=WsHo8LZS63cXLwyuYZ4eDU16kQKiZMqqE7XFsTMQE9p4OSXtrQBa/IGzQo4gEuMPMN3njxRBvEwiNopgZ4Dmki4D0VthK+NhCZhIkELHsae3WAadyXg/LXpbEoECxzt3U+vdHWryyYfRhWHKCGaS9kdsD0eJr0wqYmGQ80eWUSI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610382; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=k7R8IvFnpK0kCbKZeVVcf8F/z0I/9nioVhS1AU80bCE=; b=FuneJPSESbDv7zCDYTPBU1CSPoNe8PGKAroAb5MIYnhOd/B00WiXLHd0D4687qb5mo1L9IQNZ8g+FlL/foLlHGx+YZKwMSYRhY1GOm/3OV8qEIp8KXONBjlZVFcfo7SMMt4z50KUDragMxvym9x1tCXDEaAs6sAVEuPMe8Gm5Jk= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610382635186.66631034314844; Mon, 24 Oct 2022 04:19:42 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvM4-0000PM-NG; Mon, 24 Oct 2022 07:11:00 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <74a160aba921a2ca37b026dbfcdd03386bc05e85@lizzy.crudebyte.com>) id 1omvLu-0000Nr-QX for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:42 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <74a160aba921a2ca37b026dbfcdd03386bc05e85@lizzy.crudebyte.com>) id 1omvLs-0006oo-Oh for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:42 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=k7R8IvFnpK0kCbKZeVVcf8F/z0I/9nioVhS1AU80bCE=; b=QFVNC 7e1PB7dLXRHxDGDBAa/kl5+3EPY6rEXNir28VgUgZEP3ukNSA4c7G0WiUfH3MPyYXCLfe6dHKPTU6 KxouG2hJ/GUKdchDo7GD3eOdigXlKuzMABWukkFlUQmXwBAKmmDP88MdPG+1NNxwMI6BIa6zQDw1O twDMDOe9TBF2Qfk+9MUqtCh1G1aaQw4/7puekIzQWhBIXni16axrRMM8DNvBBF9Dkzzvrckp9aJKt Ex56r0TEp44sO471HAN1P/Xg4JHiB5+oYpAxvsrnXT6wJe8XT7xJRyoXZQN7XOXqkKtsLlOjnzWht +V8WIpqGcYV3Sms6L+/YOrfjYmj0g==; Message-Id: <74a160aba921a2ca37b026dbfcdd03386bc05e85.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 07/23] tests/9p: merge v9fs_tattach(), do_attach(), do_attach_rqid() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=74a160aba921a2ca37b026dbfcdd03386bc05e85@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610384192100007 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" As with previous patches, unify those 3 functions into a single function v9fs_tattach() by using a declarative function arguments approach. Signed-off-by: Christian Schoenebeck Message-Id: --- tests/qtest/libqos/virtio-9p-client.c | 40 ++++++++++++++--- tests/qtest/libqos/virtio-9p-client.h | 30 ++++++++++++- tests/qtest/virtio-9p-test.c | 62 +++++++++++---------------- 3 files changed, 88 insertions(+), 44 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index e8364f8d64..5e6bd6120c 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -359,20 +359,48 @@ void v9fs_rversion(P9Req *req, uint16_t *len, char **= version) } =20 /* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */ -P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname, - uint16_t tag) +TAttachRes v9fs_tattach(TAttachOpt opt) { + uint32_t err; const char *uname =3D ""; /* ignored by QEMU */ const char *aname =3D ""; /* ignored by QEMU */ - P9Req *req =3D v9fs_req_init(v9p, 4 + 4 + 2 + 2 + 4, P9_TATTACH, tag); =20 - v9fs_uint32_write(req, fid); + g_assert(opt.client); + /* expecting either Rattach or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !opt.rattach.qid); + + if (!opt.requestOnly) { + v9fs_tversion((TVersionOpt) { .client =3D opt.client }); + } + + if (!opt.n_uname) { + opt.n_uname =3D getuid(); + } + + P9Req *req =3D v9fs_req_init(opt.client, 4 + 4 + 2 + 2 + 4, P9_TATTACH, + opt.tag); + + v9fs_uint32_write(req, opt.fid); v9fs_uint32_write(req, P9_NOFID); v9fs_string_write(req, uname); v9fs_string_write(req, aname); - v9fs_uint32_write(req, n_uname); + v9fs_uint32_write(req, opt.n_uname); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rattach(req, opt.rattach.qid); + } + req =3D NULL; /* request was freed */ + } + + return (TAttachRes) { + .req =3D req, + }; } =20 /* size[4] Rattach tag[2] qid[13] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index fcde849b5d..64b97b229b 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -128,6 +128,33 @@ typedef struct TVersionRes { P9Req *req; } TVersionRes; =20 +/* options for 'Tattach' 9p request */ +typedef struct TAttachOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* file ID to be associated with root of file tree (optional) */ + uint32_t fid; + /* numerical uid of user being introduced to server (optional) */ + uint32_t n_uname; + /* data being received from 9p server as 'Rattach' response (optional)= */ + struct { + /* server's idea of the root of the file tree */ + v9fs_qid *qid; + } rattach; + /* only send Tattach request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TAttachOpt; + +/* result of 'Tattach' 9p request */ +typedef struct TAttachRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TAttachRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -151,8 +178,7 @@ void v9fs_req_free(P9Req *req); void v9fs_rlerror(P9Req *req, uint32_t *err); TVersionRes v9fs_tversion(TVersionOpt); void v9fs_rversion(P9Req *req, uint16_t *len, char **version); -P9Req *v9fs_tattach(QVirtio9P *v9p, uint32_t fid, uint32_t n_uname, - uint16_t tag); +TAttachRes v9fs_tattach(TAttachOpt); void v9fs_rattach(P9Req *req, v9fs_qid *qid); TWalkRes v9fs_twalk(TWalkOpt opt); void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index f2907c8026..271c42f6f9 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -18,6 +18,7 @@ =20 #define twalk(...) v9fs_twalk((TWalkOpt) __VA_ARGS__) #define tversion(...) v9fs_tversion((TVersionOpt) __VA_ARGS__) +#define tattach(...) v9fs_tattach((TAttachOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -48,25 +49,10 @@ static void fs_version(void *obj, void *data, QGuestAll= ocator *t_alloc) tversion({ .client =3D obj }); } =20 -static void do_attach_rqid(QVirtio9P *v9p, v9fs_qid *qid) -{ - P9Req *req; - - tversion({ .client =3D v9p }); - req =3D v9fs_tattach(v9p, 0, getuid(), 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_rattach(req, qid); -} - -static void do_attach(QVirtio9P *v9p) -{ - do_attach_rqid(v9p, NULL); -} - static void fs_attach(void *obj, void *data, QGuestAllocator *t_alloc) { v9fs_set_allocator(t_alloc); - do_attach(obj); + tattach({ .client =3D obj }); } =20 static void fs_walk(void *obj, void *data, QGuestAllocator *t_alloc) @@ -82,7 +68,7 @@ static void fs_walk(void *obj, void *data, QGuestAllocato= r *t_alloc) wnames[i] =3D g_strdup_printf(QTEST_V9FS_SYNTH_WALK_FILE, i); } =20 - do_attach(v9p); + tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D P9_MAXWELEM, .wnames =3D wnames, @@ -118,7 +104,7 @@ static void fs_readdir(void *obj, void *data, QGuestAll= ocator *t_alloc) struct V9fsDirent *entries =3D NULL; P9Req *req; =20 - do_attach(v9p); + tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames =3D wnames, .rwalk.nwqid =3D &nqid @@ -173,7 +159,7 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t c= ount) int fid; uint64_t offset; =20 - do_attach(v9p); + tattach({ .client =3D v9p }); =20 fid =3D 1; offset =3D 0; @@ -248,7 +234,7 @@ static void fs_walk_no_slash(void *obj, void *data, QGu= estAllocator *t_alloc) v9fs_set_allocator(t_alloc); char *wnames[] =3D { g_strdup(" /") }; =20 - do_attach(v9p); + tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, .expectErr =3D ENOENT @@ -262,7 +248,7 @@ static void fs_walk_nonexistent(void *obj, void *data, = QGuestAllocator *t_alloc) QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); /* * The 9p2000 protocol spec says: "If the first element cannot be walk= ed * for any reason, Rerror is returned." @@ -284,7 +270,7 @@ static void fs_walk_2nd_nonexistent(void *obj, void *da= ta, QTEST_V9FS_SYNTH_WALK_FILE "/non-existent", 0 ); =20 - do_attach_rqid(v9p, &root_qid); + tattach({ .client =3D v9p, .rattach.qid =3D &root_qid }); fid =3D twalk({ .client =3D v9p, .path =3D path, .rwalk =3D { .nwqid =3D &nwqid, .wqid =3D &wqid } @@ -316,7 +302,9 @@ static void fs_walk_none(void *obj, void *data, QGuestA= llocator *t_alloc) struct v9fs_attr attr; =20 tversion({ .client =3D v9p }); - req =3D v9fs_tattach(v9p, 0, getuid(), 0); + req =3D tattach({ + .client =3D v9p, .fid =3D 0, .n_uname =3D getuid(), .requestOnly = =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); =20 @@ -345,7 +333,9 @@ static void fs_walk_dotdot(void *obj, void *data, QGues= tAllocator *t_alloc) P9Req *req; =20 tversion({ .client =3D v9p }); - req =3D v9fs_tattach(v9p, 0, getuid(), 0); + req =3D tattach((TAttachOpt) { + .client =3D v9p, .fid =3D 0, .n_uname =3D getuid(), .requestOnly = =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rattach(req, &root_qid); =20 @@ -366,7 +356,7 @@ static void fs_lopen(void *obj, void *data, QGuestAlloc= ator *t_alloc) char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) }; P9Req *req; =20 - do_attach(v9p); + tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); @@ -388,7 +378,7 @@ static void fs_write(void *obj, void *data, QGuestAlloc= ator *t_alloc) uint32_t count; P9Req *req; =20 - do_attach(v9p); + tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); @@ -414,7 +404,7 @@ static void fs_flush_success(void *obj, void *data, QGu= estAllocator *t_alloc) uint32_t reply_len; uint8_t should_block; =20 - do_attach(v9p); + tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); @@ -451,7 +441,7 @@ static void fs_flush_ignored(void *obj, void *data, QGu= estAllocator *t_alloc) uint32_t count; uint8_t should_block; =20 - do_attach(v9p); + tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); @@ -588,7 +578,7 @@ static void fs_create_dir(void *obj, void *data, QGuest= Allocator *t_alloc) =20 g_assert(root_path !=3D NULL); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "01"); =20 /* check if created directory really exists now ... */ @@ -607,7 +597,7 @@ static void fs_unlinkat_dir(void *obj, void *data, QGue= stAllocator *t_alloc) =20 g_assert(root_path !=3D NULL); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "02"); =20 /* check if created directory really exists now ... */ @@ -627,7 +617,7 @@ static void fs_create_file(void *obj, void *data, QGues= tAllocator *t_alloc) struct stat st; g_autofree char *new_file =3D virtio_9p_test_path("03/1st_file"); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "03"); do_lcreate(v9p, "03", "1st_file"); =20 @@ -644,7 +634,7 @@ static void fs_unlinkat_file(void *obj, void *data, QGu= estAllocator *t_alloc) struct stat st; g_autofree char *new_file =3D virtio_9p_test_path("04/doa_file"); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "04"); do_lcreate(v9p, "04", "doa_file"); =20 @@ -666,7 +656,7 @@ static void fs_symlink_file(void *obj, void *data, QGue= stAllocator *t_alloc) g_autofree char *real_file =3D virtio_9p_test_path("05/real_file"); g_autofree char *symlink_file =3D virtio_9p_test_path("05/symlink_file= "); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "05"); do_lcreate(v9p, "05", "real_file"); g_assert(stat(real_file, &st) =3D=3D 0); @@ -687,7 +677,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, g_autofree char *real_file =3D virtio_9p_test_path("06/real_file"); g_autofree char *symlink_file =3D virtio_9p_test_path("06/symlink_file= "); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "06"); do_lcreate(v9p, "06", "real_file"); g_assert(stat(real_file, &st) =3D=3D 0); @@ -709,7 +699,7 @@ static void fs_hardlink_file(void *obj, void *data, QGu= estAllocator *t_alloc) g_autofree char *real_file =3D virtio_9p_test_path("07/real_file"); g_autofree char *hardlink_file =3D virtio_9p_test_path("07/hardlink_fi= le"); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "07"); do_lcreate(v9p, "07", "real_file"); g_assert(stat(real_file, &st_real) =3D=3D 0); @@ -734,7 +724,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, g_autofree char *real_file =3D virtio_9p_test_path("08/real_file"); g_autofree char *hardlink_file =3D virtio_9p_test_path("08/hardlink_fi= le"); =20 - do_attach(v9p); + tattach({ .client =3D v9p }); do_mkdir(v9p, "/", "08"); do_lcreate(v9p, "08", "real_file"); g_assert(stat(real_file, &st_real) =3D=3D 0); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611340; cv=none; d=zohomail.com; s=zohoarc; b=h+zNl+9iLGXmLzM4+DpAgCxYpDdCRls7i2J2jsDYnPVyiixiomizZ11S6T3OIX+IXnVKwlYrsDsfwDeV9+FHpTHmQ/MhNAKiU6a2fwQ2etGwJAqMg8PAsu737I9ibSxt53R2EG4eR3+qjfrriszes4UZGWBMr3i7n2VHi5lTj6c= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611340; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=bidGNUANNm8clwXP9H0NxxwzaxNI/qeKWRH/eaPplbI=; b=lraqEDhfAURVXCbshZfUxz8G9lic/EESVjobiPAvXNOZzGmiyzh3JvEYagTeSDr+MaBE7uIMNcFOUGDxzBxLrcbQbi1zKAulku3lHUgI4EDx7D+RDblZrRhKZQOtQZVheUncexAh4daZncSuXKciW3Wp6OU0KCzVD9Ms/RNAWOE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611340375742.0803776715712; Mon, 24 Oct 2022 04:35:40 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMj-0000hc-Ks; Mon, 24 Oct 2022 07:11:33 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <1125ddf66f47dc4986d97948253890fdb3c0a6d6@lizzy.crudebyte.com>) id 1omvM1-0000PZ-1x for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:50 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <1125ddf66f47dc4986d97948253890fdb3c0a6d6@lizzy.crudebyte.com>) id 1omvLz-0006p1-MC for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:48 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=bidGNUANNm8clwXP9H0NxxwzaxNI/qeKWRH/eaPplbI=; b=YvZpF OO+Lg2sMWd7XGXXoQ6/C3hxXKCxlTS58R2yMU66GzHWhkIGJBptTZ4TzVV76fYjZBgGc+PHkU4ja6 UjGow13ogYkcrkz9MQpKIsb70M4/UrPFrtz1IAYI24oPJZYLx37mRz92xUMWZq/6j8av4qtPP6giS aVCz5pwJMK/bvKOfMMZN4uwH8Ji7INun7pS9WFAXqq33XzSFCJdzj9GWwM00uNbwKn9zoLagWLTrl 45E3iSa2yw9hREmnbagnzkEXlFDpejmGNZFbbcYUl9ponLeRLXx/Y6AOsnbo97ydgXS/SaMUrw5kN iWtx+xRXLptMnpCGs9wpHxcrRhHUg==; Message-Id: <1125ddf66f47dc4986d97948253890fdb3c0a6d6.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 08/23] tests/9p: simplify callers of tattach() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=1125ddf66f47dc4986d97948253890fdb3c0a6d6@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611342381100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Now as tattach() is using a declarative approach, simplify the code of callers of this function. Signed-off-by: Christian Schoenebeck Message-Id: <9b50e5b89a0072e84a9191d18c19a53546a28bba.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/virtio-9p-test.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 271c42f6f9..46bb189b81 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -302,11 +302,10 @@ static void fs_walk_none(void *obj, void *data, QGues= tAllocator *t_alloc) struct v9fs_attr attr; =20 tversion({ .client =3D v9p }); - req =3D tattach({ - .client =3D v9p, .fid =3D 0, .n_uname =3D getuid(), .requestOnly = =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rattach(req, &root_qid); + tattach({ + .client =3D v9p, .fid =3D 0, .n_uname =3D getuid(), + .rattach.qid =3D &root_qid + }); =20 twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 0, .wnames= =3D NULL, @@ -330,14 +329,12 @@ static void fs_walk_dotdot(void *obj, void *data, QGu= estAllocator *t_alloc) char *wnames[] =3D { g_strdup("..") }; v9fs_qid root_qid; g_autofree v9fs_qid *wqid =3D NULL; - P9Req *req; =20 tversion({ .client =3D v9p }); - req =3D tattach((TAttachOpt) { - .client =3D v9p, .fid =3D 0, .n_uname =3D getuid(), .requestOnly = =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rattach(req, &root_qid); + tattach({ + .client =3D v9p, .fid =3D 0, .n_uname =3D getuid(), + .rattach.qid =3D &root_qid + }); =20 twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames, --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610758; cv=none; d=zohomail.com; s=zohoarc; b=hYKvlnxoByOCkdlVounn8zveXxIJ6slmXL6hAeVQv+iUZA6GVj2PcE5mobuC6P4hbs+nlui3a+a1AnHNphn3Bvg6tR1x+xY8Jp6EWZ8+bpSYNimwaQPxGLjxPdLR3RGCYndj1b7zY6u044nhQ/u2gRUGF2q1aIRyurPYELrG7r8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610758; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=hI9kImIbspr68mmFCTnv2ZHLqfOxZWPcjTlKjtj4HHg=; b=k7/zQ6ZoTfNB4m1Lyy49Bsqcr/8yjWmhpGqUkBGcJSMG3tsYze0MCJAOIShqAyxMz5q5Xsq81FzmHPXJabCr7trZqaoReWDmy6okwM298Gpay1V2EWbaCd9No3B48mbZX7+T3GNG3cBCOQsda9OjcDvLBpOeI/lo/eIKXfPK5tU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 166661075859011.267331088329115; Mon, 24 Oct 2022 04:25:58 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMk-0000hx-DV; Mon, 24 Oct 2022 07:11:34 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <2af5be47b9ba264f31f5594e587207cd854e01cc@lizzy.crudebyte.com>) id 1omvM7-0000S3-6z for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:08 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <2af5be47b9ba264f31f5594e587207cd854e01cc@lizzy.crudebyte.com>) id 1omvM5-0006ph-Ji for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:10:54 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=hI9kImIbspr68mmFCTnv2ZHLqfOxZWPcjTlKjtj4HHg=; b=Zxt1c 1sIl0653HRd0zgYkB2/5JuoZwxQkxgEqHg3g7RYZsAG4rDljXP/VvcBMVB5LPf66j+70yL4ldDotU TTHEnXxH04lZCwbf2GnUKoYi/yPqSXeewnsfSSAtQFgPzr7+nNSPnZMUTvstWfgf8UfA2Somh+HpY KLEVNxeq3HllSKzpubd5+bJ1yErPepre2bVVsDG2AOwUcc3f1ACdXJ4jy2sEvH317S4CLVgvt8jfD s+cjCJErngUctSJ7wYGBnQnj2zQY4NaajOzp3aZL9whGDqIw3lYJkmC8Na4DyR/ZJnPHKBgRsIGP3 MWAFAX+gVVa7BYV158+HRfS7oJl9g==; Message-Id: <2af5be47b9ba264f31f5594e587207cd854e01cc.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 09/23] tests/9p: convert v9fs_tgetattr() to declarative arguments To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=2af5be47b9ba264f31f5594e587207cd854e01cc@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610761229100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Use declarative function arguments for function v9fs_tgetattr(). Signed-off-by: Christian Schoenebeck Message-Id: --- tests/qtest/libqos/virtio-9p-client.c | 32 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 30 +++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 11 +++++++-- 3 files changed, 63 insertions(+), 10 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 5e6bd6120c..29916a23b5 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -489,16 +489,36 @@ void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid= **wqid) } =20 /* size[4] Tgetattr tag[2] fid[4] request_mask[8] */ -P9Req *v9fs_tgetattr(QVirtio9P *v9p, uint32_t fid, uint64_t request_mask, - uint16_t tag) +TGetAttrRes v9fs_tgetattr(TGetAttrOpt opt) { P9Req *req; + uint32_t err; =20 - req =3D v9fs_req_init(v9p, 4 + 8, P9_TGETATTR, tag); - v9fs_uint32_write(req, fid); - v9fs_uint64_write(req, request_mask); + g_assert(opt.client); + /* expecting either Rgetattr or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !opt.rgetattr.attr); + + if (!opt.request_mask) { + opt.request_mask =3D P9_GETATTR_ALL; + } + + req =3D v9fs_req_init(opt.client, 4 + 8, P9_TGETATTR, opt.tag); + v9fs_uint32_write(req, opt.fid); + v9fs_uint64_write(req, opt.request_mask); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rgetattr(req, opt.rgetattr.attr); + } + req =3D NULL; /* request was freed */ + } + + return (TGetAttrRes) { .req =3D req }; } =20 /* diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index 64b97b229b..f7b1bfc79a 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -63,6 +63,7 @@ typedef struct v9fs_attr { } v9fs_attr; =20 #define P9_GETATTR_BASIC 0x000007ffULL /* Mask for fields up to BLOCKS = */ +#define P9_GETATTR_ALL 0x00003fffULL /* Mask for ALL fields */ =20 struct V9fsDirent { v9fs_qid qid; @@ -155,6 +156,32 @@ typedef struct TAttachRes { P9Req *req; } TAttachRes; =20 +/* options for 'Tgetattr' 9p request */ +typedef struct TGetAttrOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* file ID of file/dir whose attributes shall be retrieved (required) = */ + uint32_t fid; + /* bitmask indicating attribute fields to be retrieved (optional) */ + uint64_t request_mask; + /* data being received from 9p server as 'Rgetattr' response (optional= ) */ + struct { + v9fs_attr *attr; + } rgetattr; + /* only send Tgetattr request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TGetAttrOpt; + +/* result of 'Tgetattr' 9p request */ +typedef struct TGetAttrRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TGetAttrRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -182,8 +209,7 @@ TAttachRes v9fs_tattach(TAttachOpt); void v9fs_rattach(P9Req *req, v9fs_qid *qid); TWalkRes v9fs_twalk(TWalkOpt opt); void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid); -P9Req *v9fs_tgetattr(QVirtio9P *v9p, uint32_t fid, uint64_t request_mask, - uint16_t tag); +TGetAttrRes v9fs_tgetattr(TGetAttrOpt); void v9fs_rgetattr(P9Req *req, v9fs_attr *attr); P9Req *v9fs_treaddir(QVirtio9P *v9p, uint32_t fid, uint64_t offset, uint32_t count, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 46bb189b81..9c1219db33 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -19,6 +19,7 @@ #define twalk(...) v9fs_twalk((TWalkOpt) __VA_ARGS__) #define tversion(...) v9fs_tversion((TVersionOpt) __VA_ARGS__) #define tattach(...) v9fs_tattach((TAttachOpt) __VA_ARGS__) +#define tgetattr(...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -285,7 +286,10 @@ static void fs_walk_2nd_nonexistent(void *obj, void *d= ata, g_assert(wqid && wqid[0] && !is_same_qid(root_qid, wqid[0])); =20 /* expect fid being unaffected by walk above */ - req =3D v9fs_tgetattr(v9p, fid, P9_GETATTR_BASIC, 0); + req =3D tgetattr({ + .client =3D v9p, .fid =3D fid, .request_mask =3D P9_GETATTR_BASIC, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlerror(req, &err); =20 @@ -315,7 +319,10 @@ static void fs_walk_none(void *obj, void *data, QGuest= Allocator *t_alloc) /* special case: no QID is returned if nwname=3D0 was sent */ g_assert(wqid =3D=3D NULL); =20 - req =3D v9fs_tgetattr(v9p, 1, P9_GETATTR_BASIC, 0); + req =3D tgetattr({ + .client =3D v9p, .fid =3D 1, .request_mask =3D P9_GETATTR_BASIC, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rgetattr(req, &attr); =20 --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611374; cv=none; d=zohomail.com; s=zohoarc; b=oIs43zyG9itBveZOqbV5sXfvs+kFkTxxksmSVCOpe5tc0J69MfCTIxXHKSSje1bDLhIn6AFD+/B8bZmX1fqzojlUpIdpMEz6ojHv6fceIw7WokJGz/HjfMZefq1NlVTu1/ixfEWf+hv3ySb7Qyu3T+4p7S0tGckWYp6vXTLtXjA= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611374; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=vesG7fpTJO7/Ux70A/tOkL9a3DqIlneVwqfLChoP7NI=; b=kxI3oOSZpV9rZa7sOKlroUqy5OyqUkYCgvkxj1vIOouDohVFkn4PekF3v/sYPdQJRgyL835k5MG1gCCxe/xHoCJu7iO61qiF3VgvEnTX6JT31+CnLFzTv4cxU6cfrO6yWS6xRhReHDVux7LnYVsIq+v9iPDqlh/2TCfb933ySe8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611374679165.56485083936172; Mon, 24 Oct 2022 04:36:14 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMl-0000ix-RV; Mon, 24 Oct 2022 07:11:35 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <28c736709b82c8f47edf3cb18b9fb601fdab9151@lizzy.crudebyte.com>) id 1omvMF-0000SR-OW for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:13 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <28c736709b82c8f47edf3cb18b9fb601fdab9151@lizzy.crudebyte.com>) id 1omvMC-0006qa-9d for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:03 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=vesG7fpTJO7/Ux70A/tOkL9a3DqIlneVwqfLChoP7NI=; b=DU6FF t3Y0JmjqHZAVsTdnoDG5GBXhmsR0yFxM8n5bBGBiPbVqAOsO23WS5s9HYfUoTFBcc+cVJChR8tYgi D52XWiIlpmyoPqWeL2ruA45+Rmv7wdLfjuq9+LsP89BO3/Fset6ZNNmPozv153S9d5PNW495GZs/q uW4bWBGScB5J+i+beba53o7BtnpBWLuGD69aIr8LeIcGujCt8J2N9ypU2OPXRQcRI4HZlrF6iYEir 9oysao2XKdaBYwHoopQiBMda9ad4U3D71HqvVyoTkgFEvulD3XX8mZ+pF+mYR/Ncq2UpkuHLnEixc q1grb+5fo/YhHRuW3Cu63bg8BhD4A==; Message-Id: <28c736709b82c8f47edf3cb18b9fb601fdab9151.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 10/23] tests/9p: simplify callers of tgetattr() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=28c736709b82c8f47edf3cb18b9fb601fdab9151@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611376604100005 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Now as tgetattr() is using a declarative approach, simplify the code of callers of this function. Signed-off-by: Christian Schoenebeck Message-Id: <60c6a083f320b86f3172951445df7bbc895932e2.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/virtio-9p-test.c | 22 +++++++--------------- 1 file changed, 7 insertions(+), 15 deletions(-) diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 9c1219db33..ae1220d0cb 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -264,8 +264,7 @@ static void fs_walk_2nd_nonexistent(void *obj, void *da= ta, v9fs_set_allocator(t_alloc); v9fs_qid root_qid; uint16_t nwqid; - uint32_t fid, err; - P9Req *req; + uint32_t fid; g_autofree v9fs_qid *wqid =3D NULL; g_autofree char *path =3D g_strdup_printf( QTEST_V9FS_SYNTH_WALK_FILE "/non-existent", 0 @@ -286,14 +285,10 @@ static void fs_walk_2nd_nonexistent(void *obj, void *= data, g_assert(wqid && wqid[0] && !is_same_qid(root_qid, wqid[0])); =20 /* expect fid being unaffected by walk above */ - req =3D tgetattr({ + tgetattr({ .client =3D v9p, .fid =3D fid, .request_mask =3D P9_GETATTR_BASIC, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlerror(req, &err); - - g_assert_cmpint(err, =3D=3D, ENOENT); + .expectErr =3D ENOENT + }); } =20 static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc) @@ -302,7 +297,6 @@ static void fs_walk_none(void *obj, void *data, QGuestA= llocator *t_alloc) v9fs_set_allocator(t_alloc); v9fs_qid root_qid; g_autofree v9fs_qid *wqid =3D NULL; - P9Req *req; struct v9fs_attr attr; =20 tversion({ .client =3D v9p }); @@ -319,12 +313,10 @@ static void fs_walk_none(void *obj, void *data, QGues= tAllocator *t_alloc) /* special case: no QID is returned if nwname=3D0 was sent */ g_assert(wqid =3D=3D NULL); =20 - req =3D tgetattr({ + tgetattr({ .client =3D v9p, .fid =3D 1, .request_mask =3D P9_GETATTR_BASIC, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rgetattr(req, &attr); + .rgetattr.attr =3D &attr + }); =20 g_assert(is_same_qid(root_qid, attr.qid)); } --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666612570; cv=none; d=zohomail.com; s=zohoarc; b=VcARpvpDGrlksV+fBbfyNBQydnAnQhwVkFo72ahpYt4A6xO6Zj6dd0lzpbyXhUTu2gRyO4RYMP/j37wJ9INtf3EJixE3ZX38+PPwDVJ3CkKnnPaWS16qekC8J4jki8SP/7NVWsiVoWMeGjoKJyWKarkK/jHcQlEzusjMXbx7QXs= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666612570; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=XC8UVl5vRCl7diWbPgGipvNeEWETBhkDQgpl1FpLEJc=; b=Mo/ziO7+RryMN/3PfKvbUXrVGa1shM0gkv+XzfENfXgTJ6iFs4FWn3dBJCpd3xMIhybiO/lWmoXOmE/sTiC7YdZc00IFZxd/36QDzn6+ohhtLTyXjsisPqN+7gIidjoplFyJ9Mw3vsLiA2lZmX2tzDsY/BuOdSpPwcVHq0F8GUg= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 166661257042778.74899725965395; Mon, 24 Oct 2022 04:56:10 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMm-0000jE-Ft; Mon, 24 Oct 2022 07:11:36 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <1ebacc40ca925626cf601543326066434c7c1a7f@lizzy.crudebyte.com>) id 1omvMP-0000Y0-GW for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:21 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <1ebacc40ca925626cf601543326066434c7c1a7f@lizzy.crudebyte.com>) id 1omvMI-000737-Gp for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:12 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=XC8UVl5vRCl7diWbPgGipvNeEWETBhkDQgpl1FpLEJc=; b=A09jG 3UIx9N24tjlLIa2IOiz/JTqM0e/b2d+KewY8GNDO/N9Ws+3WZyqEPhaUr2BtURZHI36Wv5jBTkdUm uk6C8zWbpESjzDVAWB9tc8c+QNDfcVr6Be6Vprw8hL4sN7m+cTTrM0Ozm17DrfTJZh5JaBccthaWd Dd2HWwgJrPksh+2nz7OcRHQ5cYJka3vnHDfYG5Mn3T0jcNhmSxQsjCUrxDhRvrgJ8tIU8432VBJOj PjlWVttkbLwsYeA7VVcUPcEE3Pd3hF7IXGk9djeOagcsJKYvy7DJnYJyovxLA+l/4Eh5eOdCK13J2 p7UzrKK7GbZ+FJF/EUOGk3Gkd1jWw==; Message-Id: <1ebacc40ca925626cf601543326066434c7c1a7f.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 11/23] tests/9p: convert v9fs_treaddir() to declarative arguments To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=1ebacc40ca925626cf601543326066434c7c1a7f@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -16 X-Spam_score: -1.7 X-Spam_bar: - X-Spam_report: (-1.7 / 5.0 requ) BAYES_00=-1.9, DKIM_INVALID=0.1, DKIM_SIGNED=0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666612571940100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Use declarative function arguments for function v9fs_treaddir(). Signed-off-by: Christian Schoenebeck Message-Id: --- tests/qtest/libqos/virtio-9p-client.c | 32 ++++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 33 +++++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 11 +++++++-- 3 files changed, 65 insertions(+), 11 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 29916a23b5..047c8993b6 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -557,17 +557,35 @@ void v9fs_rgetattr(P9Req *req, v9fs_attr *attr) } =20 /* size[4] Treaddir tag[2] fid[4] offset[8] count[4] */ -P9Req *v9fs_treaddir(QVirtio9P *v9p, uint32_t fid, uint64_t offset, - uint32_t count, uint16_t tag) +TReadDirRes v9fs_treaddir(TReadDirOpt opt) { P9Req *req; + uint32_t err; =20 - req =3D v9fs_req_init(v9p, 4 + 8 + 4, P9_TREADDIR, tag); - v9fs_uint32_write(req, fid); - v9fs_uint64_write(req, offset); - v9fs_uint32_write(req, count); + g_assert(opt.client); + /* expecting either Rreaddir or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !(opt.rreaddir.count || + opt.rreaddir.nentries || opt.rreaddir.entries)); + + req =3D v9fs_req_init(opt.client, 4 + 8 + 4, P9_TREADDIR, opt.tag); + v9fs_uint32_write(req, opt.fid); + v9fs_uint64_write(req, opt.offset); + v9fs_uint32_write(req, opt.count); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rreaddir(req, opt.rreaddir.count, opt.rreaddir.nentries, + opt.rreaddir.entries); + } + req =3D NULL; /* request was freed */ + } + + return (TReadDirRes) { .req =3D req }; } =20 /* size[4] Rreaddir tag[2] count[4] data[count] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index f7b1bfc79a..2bf649085f 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -182,6 +182,36 @@ typedef struct TGetAttrRes { P9Req *req; } TGetAttrRes; =20 +/* options for 'Treaddir' 9p request */ +typedef struct TReadDirOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* file ID of directory whose entries shall be retrieved (required) */ + uint32_t fid; + /* offset in entries stream, i.e. for multiple requests (optional) */ + uint64_t offset; + /* maximum bytes to be returned by server (required) */ + uint32_t count; + /* data being received from 9p server as 'Rreaddir' response (optional= ) */ + struct { + uint32_t *count; + uint32_t *nentries; + struct V9fsDirent **entries; + } rreaddir; + /* only send Treaddir request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TReadDirOpt; + +/* result of 'Treaddir' 9p request */ +typedef struct TReadDirRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TReadDirRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -211,8 +241,7 @@ TWalkRes v9fs_twalk(TWalkOpt opt); void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid); TGetAttrRes v9fs_tgetattr(TGetAttrOpt); void v9fs_rgetattr(P9Req *req, v9fs_attr *attr); -P9Req *v9fs_treaddir(QVirtio9P *v9p, uint32_t fid, uint64_t offset, - uint32_t count, uint16_t tag); +TReadDirRes v9fs_treaddir(TReadDirOpt); void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_t *nentries, struct V9fsDirent **entries); void v9fs_free_dirents(struct V9fsDirent *e); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index ae1220d0cb..e5c174c218 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -20,6 +20,7 @@ #define tversion(...) v9fs_tversion((TVersionOpt) __VA_ARGS__) #define tattach(...) v9fs_tattach((TAttachOpt) __VA_ARGS__) #define tgetattr(...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__) +#define treaddir(...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -119,7 +120,10 @@ static void fs_readdir(void *obj, void *data, QGuestAl= locator *t_alloc) /* * submit count =3D msize - 11, because 11 is the header size of Rread= dir */ - req =3D v9fs_treaddir(v9p, 1, 0, P9_MAX_SIZE - 11, 0); + req =3D treaddir({ + .client =3D v9p, .fid =3D 1, .offset =3D 0, .count =3D P9_MAX_SIZE= - 11, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rreaddir(req, &count, &nentries, &entries); =20 @@ -186,7 +190,10 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t = count) npartialentries =3D 0; partialentries =3D NULL; =20 - req =3D v9fs_treaddir(v9p, fid, offset, count, 0); + req =3D treaddir({ + .client =3D v9p, .fid =3D fid, .offset =3D offset, .count =3D = count, + .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rreaddir(req, &count, &npartialentries, &partialentries); if (npartialentries > 0 && partialentries) { --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610052; cv=none; d=zohomail.com; s=zohoarc; b=atkcxxDr260jHalduQG0itCA7QWApiEaV51/O4Pg/XWjKRiCcepfOB0qBYJPZWvJ7WFSOEOiJxXoEG8kSet2Ijn5wSeJst9zEuj6Z/kMXlFhtEXDBRYzd7yt0/f91SC3umkOMNcVV/LT/KLdbFlkcBcVggRZj1R90MvcGplVPgg= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610052; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=2wzS8k/qPl/+/ZL57BA2KxhB7eOcnLEEIO3NGg9aUtY=; b=jbh6kk1HRmwUtcMuVzEmMsfJgm0vNX18/3Y11+tMabAIZIT3M0LCB+c4/VIvLMLPnA6/sShs6ck/zncaPr3GkmlGMIlnJJbdRWPqCzoSBWc1ORjWS14BECSc2B9w+We7p9CXfpL+ftC03D89wVxE1qeS1l5fOU6j6iy2H8OgXJ0= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610052031789.3064187743906; Mon, 24 Oct 2022 04:14:12 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMn-0000jO-Hn; Mon, 24 Oct 2022 07:11:37 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvMW-0000aa-2m for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:23 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvMQ-00074M-E0 for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:15 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=2wzS8k/qPl/+/ZL57BA2KxhB7eOcnLEEIO3NGg9aUtY=; b=ozyXF XUBlzISm87W+ALuaGL7JWntRQSqNYvUPu4UK0AiFi8EAjgwiizSxvLsL9iPLoHuYaEEijJw4ShaE9 HM15BBHKtuwv5FlHAsCsfzdL9P/f4gVAMBeJZbbWnFJ6lzIbNjCMosnEk2zFwjUSaZ+wOA/G1ieI1 uNPq3/YFjz+kEtTaP1kC2f+KHBc8gltZwWL1PzhalQ5A8Hk3sbkba01Wtk6wonbSnt/QYwEJsHrWU k92E+1tN/WSQdokSd+Arwb8kJ8V5obG6HP+9yXfQq1i8IKet1elZbrkOCwTl/9WQOVP0AQJp9fNvc ZMuCFamOpR2zizmmuhZyLg9ofVwlQ==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 12/23] tests/9p: simplify callers of treaddir() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=a9a53769318503c4d8884e642e00603ea6885cb1@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610052553100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Now as treaddir() is using a declarative approach, simplify the code of callers of this function. Signed-off-by: Christian Schoenebeck Message-Id: <7cec6f2c7011a481806c34908893b7282702a7a6.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/virtio-9p-test.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index e5c174c218..99e24fce0b 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -120,12 +120,12 @@ static void fs_readdir(void *obj, void *data, QGuestA= llocator *t_alloc) /* * submit count =3D msize - 11, because 11 is the header size of Rread= dir */ - req =3D treaddir({ + treaddir({ .client =3D v9p, .fid =3D 1, .offset =3D 0, .count =3D P9_MAX_SIZE= - 11, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rreaddir(req, &count, &nentries, &entries); + .rreaddir =3D { + .count =3D &count, .nentries =3D &nentries, .entries =3D &entr= ies + } + }); =20 /* * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all @@ -190,12 +190,13 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t= count) npartialentries =3D 0; partialentries =3D NULL; =20 - req =3D treaddir({ + treaddir({ .client =3D v9p, .fid =3D fid, .offset =3D offset, .count =3D = count, - .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rreaddir(req, &count, &npartialentries, &partialentries); + .rreaddir =3D { + .count =3D &count, .nentries =3D &npartialentries, + .entries =3D &partialentries + } + }); if (npartialentries > 0 && partialentries) { if (!entries) { entries =3D partialentries; --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611152; cv=none; d=zohomail.com; s=zohoarc; b=J/6RIFugO9IMjr4zaNJmqt2KidwWhNrVaWV4jI76VJAOxX5s7hnXiCDXbq2eLSgmNBM5A6SpTTKDf/d2V2KCcaXgKAR/ddAV5uZCn1LTB0evTt5rSPvGr74+7tu7vzztYABZI7Limf6Ne+405879n3DNRmJW6IGNlimT7PeAnXM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611152; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=cTq3UQRNdh+VE+aZQAjEzLjqWzECnmb+BeQ7jA1tVZk=; b=cS9drtA9VymJkbzssMPVosXlIboiNFoMh8tQw3P/jpugmz8j3INahEXagUnVJXjzwCLr1MOIvOBVZ8xdvMCmnOM0C9nv3d6PjnUoFIAFRAEM+xwvyefzkzDcNcqeWO5UJZZT+ctkj+QDsYSZCNa31tqGgPV1VGa4hlh/QJXZDEI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611152235219.792193350219; Mon, 24 Oct 2022 04:32:32 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMo-0000jk-Nc; Mon, 24 Oct 2022 07:11:38 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3878ce4cc2f1cb9e802076c827834c34d3788b78@lizzy.crudebyte.com>) id 1omvMZ-0000bR-Ji for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:26 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3878ce4cc2f1cb9e802076c827834c34d3788b78@lizzy.crudebyte.com>) id 1omvMW-00076H-OJ for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:23 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=cTq3UQRNdh+VE+aZQAjEzLjqWzECnmb+BeQ7jA1tVZk=; b=UH3qq 7l95Iy4D9qHb2M0NP5pUw56nvrnBLXpbCuXg6ga8yzqUQwWl3uzwc32AzwP+6ba66oNLmyqPec1MU qFkSgc3ywjwRZybuF9xACBJzZbIJdnXwUyiQQLdiA9obcFUBfYpDkVud+3l9CsB8/UOA8RNlmCvO2 HxmM/xen13U0tVdstfGZh+ZxmqPXNZYKNSBb5FWt4UnBNiUgDd3sfbdwn9jzogPa+w1Hs2Fw2uXP/ tOIhnv7QJeCqoNBLh/E7ZDpKTnYnY4BvcjD9Wlxg4gtpFqKGfyS5BULWuXekDXMN8eJb7/t+vjcXV 87sj7due4mnMLTy7dNSi1BIcj6QcA==; Message-Id: <3878ce4cc2f1cb9e802076c827834c34d3788b78.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 13/23] tests/9p: convert v9fs_tlopen() to declarative arguments To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=3878ce4cc2f1cb9e802076c827834c34d3788b78@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611153347100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Use declarative function arguments for function v9fs_tlopen(). Signed-off-by: Christian Schoenebeck Message-Id: <765ab515353c56f88f0a163631f626a44e9565d6.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 28 +++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 30 +++++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 25 ++++++++++++++++------ 3 files changed, 69 insertions(+), 14 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 047c8993b6..15fde54d63 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -643,16 +643,32 @@ void v9fs_free_dirents(struct V9fsDirent *e) } =20 /* size[4] Tlopen tag[2] fid[4] flags[4] */ -P9Req *v9fs_tlopen(QVirtio9P *v9p, uint32_t fid, uint32_t flags, - uint16_t tag) +TLOpenRes v9fs_tlopen(TLOpenOpt opt) { P9Req *req; + uint32_t err; =20 - req =3D v9fs_req_init(v9p, 4 + 4, P9_TLOPEN, tag); - v9fs_uint32_write(req, fid); - v9fs_uint32_write(req, flags); + g_assert(opt.client); + /* expecting either Rlopen or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !(opt.rlopen.qid || opt.rlopen.iounit)); + + req =3D v9fs_req_init(opt.client, 4 + 4, P9_TLOPEN, opt.tag); + v9fs_uint32_write(req, opt.fid); + v9fs_uint32_write(req, opt.flags); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rlopen(req, opt.rlopen.qid, opt.rlopen.iounit); + } + req =3D NULL; /* request was freed */ + } + + return (TLOpenRes) { .req =3D req }; } =20 /* size[4] Rlopen tag[2] qid[13] iounit[4] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index 2bf649085f..3b70aef51e 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -212,6 +212,33 @@ typedef struct TReadDirRes { P9Req *req; } TReadDirRes; =20 +/* options for 'Tlopen' 9p request */ +typedef struct TLOpenOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* file ID of file / directory to be opened (required) */ + uint32_t fid; + /* Linux open(2) flags such as O_RDONLY, O_RDWR, O_WRONLY (optional) */ + uint32_t flags; + /* data being received from 9p server as 'Rlopen' response (optional) = */ + struct { + v9fs_qid *qid; + uint32_t *iounit; + } rlopen; + /* only send Tlopen request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TLOpenOpt; + +/* result of 'Tlopen' 9p request */ +typedef struct TLOpenRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TLOpenRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -245,8 +272,7 @@ TReadDirRes v9fs_treaddir(TReadDirOpt); void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_t *nentries, struct V9fsDirent **entries); void v9fs_free_dirents(struct V9fsDirent *e); -P9Req *v9fs_tlopen(QVirtio9P *v9p, uint32_t fid, uint32_t flags, - uint16_t tag); +TLOpenRes v9fs_tlopen(TLOpenOpt); void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *iounit); P9Req *v9fs_twrite(QVirtio9P *v9p, uint32_t fid, uint64_t offset, uint32_t count, const void *data, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 99e24fce0b..0455c3a094 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -21,6 +21,7 @@ #define tattach(...) v9fs_tattach((TAttachOpt) __VA_ARGS__) #define tgetattr(...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__) #define treaddir(...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__) +#define tlopen(...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -113,7 +114,9 @@ static void fs_readdir(void *obj, void *data, QGuestAll= ocator *t_alloc) }); g_assert_cmpint(nqid, =3D=3D, 1); =20 - req =3D v9fs_tlopen(v9p, 1, O_DIRECTORY, 0); + req =3D tlopen({ + .client =3D v9p, .fid =3D 1, .flags =3D O_DIRECTORY, .requestOnly = =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlopen(req, &qid, NULL); =20 @@ -178,7 +181,9 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t c= ount) }); g_assert_cmpint(nqid, =3D=3D, 1); =20 - req =3D v9fs_tlopen(v9p, fid, O_DIRECTORY, 0); + req =3D tlopen({ + .client =3D v9p, .fid =3D fid, .flags =3D O_DIRECTORY, .requestOnl= y =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlopen(req, &qid, NULL); =20 @@ -365,7 +370,9 @@ static void fs_lopen(void *obj, void *data, QGuestAlloc= ator *t_alloc) .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); + req =3D tlopen({ + .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlopen(req, NULL, NULL); =20 @@ -387,7 +394,9 @@ static void fs_write(void *obj, void *data, QGuestAlloc= ator *t_alloc) .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); + req =3D tlopen({ + .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlopen(req, NULL, NULL); =20 @@ -413,7 +422,9 @@ static void fs_flush_success(void *obj, void *data, QGu= estAllocator *t_alloc) .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); + req =3D tlopen({ + .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlopen(req, NULL, NULL); =20 @@ -450,7 +461,9 @@ static void fs_flush_ignored(void *obj, void *data, QGu= estAllocator *t_alloc) .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D v9fs_tlopen(v9p, 1, O_WRONLY, 0); + req =3D tlopen({ + .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rlopen(req, NULL, NULL); =20 --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610280; cv=none; d=zohomail.com; s=zohoarc; b=VoC7rvIjKBZQvF86x/jA7FG13Nk+f2QYfq89oczJLjUdkWNoOg4AvQmfkI7fJUr6EtwhW14Slh9DA0NU3YD2P8c/71k5Rb260H6cuS+95425IMD5OCgR3OLDuVnpWSb49ZIyxc7+0bM5LJ0LDegYWGRbZTMMY4c5wJjRWKSomG0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610280; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=CeHtuR5SWe3A/AmP2z5ZDNoepvaxVnrEVDW+XfndFNI=; b=LvhpARP0qCq+Ijq5At2lUscwh/BFFdCEqrBHpwFOCwv4H//4mnbiCv0OmUd8716HObaw1Ub0OdO92Sl1x9Wt1zj4abIGn8+Vvg71fG3tbVpNoKrIN4Pb87hUHAb1m8DUTFtMEk/HbUdfzSPQSbeRBaShYLGf4D0yRN6aNPvqAw8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610279995747.7497076012736; Mon, 24 Oct 2022 04:17:59 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvN4-0000ro-BD; Mon, 24 Oct 2022 07:11:54 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <0e4c4ff02aecaa3cea3e583d07509378b7783307@lizzy.crudebyte.com>) id 1omvMt-0000o0-PN for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:46 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <0e4c4ff02aecaa3cea3e583d07509378b7783307@lizzy.crudebyte.com>) id 1omvMf-0007Fm-1v for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:40 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=CeHtuR5SWe3A/AmP2z5ZDNoepvaxVnrEVDW+XfndFNI=; b=NHHuV MxjLbC5bQ3DQOKkhY2Fe5JkZHLrQA3K113n2hhA3MChrvEqztG7GQfEEVxOxPc4UoKkq+osqBTdyc 7zPCixXziR4magqZibb4KhEuYUI2je9bIfthheo0hNMWEndX0unvCNG+HuxPD5KTCpzUf6XNZ8sXR jeKukLziVvCe9G6FPgZeYT6bToz1O3oorQbkAn6GjoXd96XcJf3v3hiQXEngp0jTc9vzz8r91bYhM Xb4H6ZSZIaRoWdpQ1Ug1X4iPjUKd3RjPkNDcG6SdN/JKFA/m18frg0WkdE3pg7RLpmO6cCwNs13sb z4xARZrBUXorAU4Yr+/o1vYyD+XvA==; Message-Id: <0e4c4ff02aecaa3cea3e583d07509378b7783307.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 14/23] tests/9p: simplify callers of tlopen() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=0e4c4ff02aecaa3cea3e583d07509378b7783307@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610281838100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Now as tlopen() is using a declarative approach, simplify the code of callers of this function. Signed-off-by: Christian Schoenebeck Message-Id: --- tests/qtest/virtio-9p-test.c | 43 +++++++++--------------------------- 1 file changed, 10 insertions(+), 33 deletions(-) diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 0455c3a094..60a030b877 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -105,7 +105,6 @@ static void fs_readdir(void *obj, void *data, QGuestAll= ocator *t_alloc) v9fs_qid qid; uint32_t count, nentries; struct V9fsDirent *entries =3D NULL; - P9Req *req; =20 tattach({ .client =3D v9p }); twalk({ @@ -114,11 +113,9 @@ static void fs_readdir(void *obj, void *data, QGuestAl= locator *t_alloc) }); g_assert_cmpint(nqid, =3D=3D, 1); =20 - req =3D tlopen({ - .client =3D v9p, .fid =3D 1, .flags =3D O_DIRECTORY, .requestOnly = =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlopen(req, &qid, NULL); + tlopen({ + .client =3D v9p, .fid =3D 1, .flags =3D O_DIRECTORY, .rlopen.qid = =3D &qid + }); =20 /* * submit count =3D msize - 11, because 11 is the header size of Rread= dir @@ -163,7 +160,6 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t c= ount) v9fs_qid qid; uint32_t nentries, npartialentries; struct V9fsDirent *entries, *tail, *partialentries; - P9Req *req; int fid; uint64_t offset; =20 @@ -181,11 +177,9 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t = count) }); g_assert_cmpint(nqid, =3D=3D, 1); =20 - req =3D tlopen({ - .client =3D v9p, .fid =3D fid, .flags =3D O_DIRECTORY, .requestOnl= y =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlopen(req, &qid, NULL); + tlopen({ + .client =3D v9p, .fid =3D fid, .flags =3D O_DIRECTORY, .rlopen.qid= =3D &qid + }); =20 /* * send as many Treaddir requests as required to get all directory @@ -363,18 +357,13 @@ static void fs_lopen(void *obj, void *data, QGuestAll= ocator *t_alloc) QVirtio9P *v9p =3D obj; v9fs_set_allocator(t_alloc); char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_LOPEN_FILE) }; - P9Req *req; =20 tattach({ .client =3D v9p }); twalk({ .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D tlopen({ - .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlopen(req, NULL, NULL); + tlopen({ .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY }); =20 g_free(wnames[0]); } @@ -394,11 +383,7 @@ static void fs_write(void *obj, void *data, QGuestAllo= cator *t_alloc) .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D tlopen({ - .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlopen(req, NULL, NULL); + tlopen({ .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY }); =20 req =3D v9fs_twrite(v9p, 1, 0, write_count, buf, 0); v9fs_req_wait_for_reply(req, NULL); @@ -422,11 +407,7 @@ static void fs_flush_success(void *obj, void *data, QG= uestAllocator *t_alloc) .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D tlopen({ - .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlopen(req, NULL, NULL); + tlopen({ .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY }); =20 /* This will cause the 9p server to try to write data to the backend, * until the write request gets cancelled. @@ -461,11 +442,7 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) .client =3D v9p, .fid =3D 0, .newfid =3D 1, .nwname =3D 1, .wnames= =3D wnames }); =20 - req =3D tlopen({ - .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY, .requestOnly =3D= true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlopen(req, NULL, NULL); + tlopen({ .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY }); =20 /* This will cause the write request to complete right away, before it * could be actually cancelled. --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610150; cv=none; d=zohomail.com; s=zohoarc; b=EfVrEZU//mtOZWs040De2lSndhEfnp+mhKkmwBpd4Yv2UNmrGnWoaXPq96dyL0JFmclGRJ8lMC+6Q1/YGG9nmjXzkzs9HdGk3mihRLWLxPhpA3fo6Lh1p48jBnUJpVEb82gxnWCUwvxY9PNms/tOFZSQpYfO2SJKH8qkaauAftI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610150; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=4v5VrMMNwy2ZaFxlnEyXkHc8E3xWz+kmzNWy7gqyTgY=; b=YEk7ldCet0oDgOSUTeQTwLobVeilPdeI6YJ8h171QTRVOguWPmBS7Rdj2PdjxGt8agZPtjE33wTlRQa8x81ylctY8UI371TOPqaa93Apix7kndUQ5NZOwHD0Zg70Qeu/7U8duG/yV30xmMoehdZh1laDCiVb8iOvHLuEiXaTDkE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610150263774.4416458140654; Mon, 24 Oct 2022 04:15:50 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvMy-0000pC-Jw; Mon, 24 Oct 2022 07:11:48 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvMm-0000j5-5A for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:36 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvMj-0007JI-Sl for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:35 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=4v5VrMMNwy2ZaFxlnEyXkHc8E3xWz+kmzNWy7gqyTgY=; b=BhWfm RuyP6HbJ1kLFt4KHaEFkd7k+WNZ3rsLxlyYZd6x0NWLQBCBbcd2axXuBhZYeR+dF2txudHXoTJ05+ uKuo5j3IlfADCItRWrdoGhmsk20hBosSR2lozV0uynfT/qBg5lVuBrRzJrUzXzrBtyQ7XBZwqKwds FS1pX+iLDkG1MkCAMa5d+lskVKXlMBbY7HkZ3X4ZFQ5itSI70c+lc0AQpj+M4S/lsyvQg9pIt6Bi/ 9qKufxvsOH6oYrCPSGMA+gD+TQdLc3rpdqsvaYdNVIhCp2flQ69lrcxgzMR4XbGCATSxzCU+NaKnt CiyQIx9poswx2hon/4IcY7gP/34qA==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 15/23] tests/9p: convert v9fs_twrite() to declarative arguments To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=ac9e4e6185f0f5090d18dce2dd3f60d9660be496@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610151410100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Use declarative function arguments for function v9fs_twrite(). Signed-off-by: Christian Schoenebeck Message-Id: --- tests/qtest/libqos/virtio-9p-client.c | 38 ++++++++++++++++++++------- tests/qtest/libqos/virtio-9p-client.h | 31 ++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 18 ++++++++++--- 3 files changed, 72 insertions(+), 15 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 15fde54d63..9ae347fad5 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -687,21 +687,39 @@ void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t = *iounit) } =20 /* size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count] */ -P9Req *v9fs_twrite(QVirtio9P *v9p, uint32_t fid, uint64_t offset, - uint32_t count, const void *data, uint16_t tag) +TWriteRes v9fs_twrite(TWriteOpt opt) { P9Req *req; + uint32_t err; uint32_t body_size =3D 4 + 8 + 4; + uint32_t written =3D 0; =20 - g_assert_cmpint(body_size, <=3D, UINT32_MAX - count); - body_size +=3D count; - req =3D 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); + g_assert(opt.client); + + g_assert_cmpint(body_size, <=3D, UINT32_MAX - opt.count); + body_size +=3D opt.count; + req =3D v9fs_req_init(opt.client, body_size, P9_TWRITE, opt.tag); + v9fs_uint32_write(req, opt.fid); + v9fs_uint64_write(req, opt.offset); + v9fs_uint32_write(req, opt.count); + v9fs_memwrite(req, opt.data, opt.count); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rwrite(req, &written); + } + req =3D NULL; /* request was freed */ + } + + return (TWriteRes) { + .req =3D req, + .count =3D written + }; } =20 /* size[4] Rwrite tag[2] count[4] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index 3b70aef51e..dda371c054 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -239,6 +239,34 @@ typedef struct TLOpenRes { P9Req *req; } TLOpenRes; =20 +/* options for 'Twrite' 9p request */ +typedef struct TWriteOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* file ID of file to write to (required) */ + uint32_t fid; + /* start position of write from beginning of file (optional) */ + uint64_t offset; + /* how many bytes to write */ + uint32_t count; + /* data to be written */ + const void *data; + /* only send Twrite request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TWriteOpt; + +/* result of 'Twrite' 9p request */ +typedef struct TWriteRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; + /* amount of bytes written */ + uint32_t count; +} TWriteRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -274,8 +302,7 @@ void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_= t *nentries, void v9fs_free_dirents(struct V9fsDirent *e); TLOpenRes v9fs_tlopen(TLOpenOpt); void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *iounit); -P9Req *v9fs_twrite(QVirtio9P *v9p, uint32_t fid, uint64_t offset, - uint32_t count, const void *data, uint16_t tag); +TWriteRes v9fs_twrite(TWriteOpt); void v9fs_rwrite(P9Req *req, uint32_t *count); P9Req *v9fs_tflush(QVirtio9P *v9p, uint16_t oldtag, uint16_t tag); void v9fs_rflush(P9Req *req); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 60a030b877..a5b9284acb 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -22,6 +22,7 @@ #define tgetattr(...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__) #define treaddir(...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__) #define tlopen(...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__) +#define twrite(...) v9fs_twrite((TWriteOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -385,7 +386,10 @@ static void fs_write(void *obj, void *data, QGuestAllo= cator *t_alloc) =20 tlopen({ .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY }); =20 - req =3D v9fs_twrite(v9p, 1, 0, write_count, buf, 0); + req =3D twrite({ + .client =3D v9p, .fid =3D 1, .offset =3D 0, .count =3D write_count, + .data =3D buf, .requestOnly =3D true + }).req; v9fs_req_wait_for_reply(req, NULL); v9fs_rwrite(req, &count); g_assert_cmpint(count, =3D=3D, write_count); @@ -413,7 +417,11 @@ static void fs_flush_success(void *obj, void *data, QG= uestAllocator *t_alloc) * until the write request gets cancelled. */ should_block =3D 1; - req =3D v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0); + req =3D twrite({ + .client =3D v9p, .fid =3D 1, .offset =3D 0, + .count =3D sizeof(should_block), .data =3D &should_block, + .requestOnly =3D true + }).req; =20 flush_req =3D v9fs_tflush(v9p, req->tag, 1); =20 @@ -448,7 +456,11 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) * could be actually cancelled. */ should_block =3D 0; - req =3D v9fs_twrite(v9p, 1, 0, sizeof(should_block), &should_block, 0); + req =3D twrite({ + .client =3D v9p, .fid =3D 1, .offset =3D 0, + .count =3D sizeof(should_block), .data =3D &should_block, + .requestOnly =3D true + }).req; =20 flush_req =3D v9fs_tflush(v9p, req->tag, 1); =20 --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666613723; cv=none; d=zohomail.com; s=zohoarc; b=ZgCwPbttrAPZluMHLhW2b9pbU3qe25Y9/yDvw/aUJ+9lEtQwvbgUAfMN1wWNmSql80QEPze8i1oUKldf51Mx0sFM+I/I3qfS4+cslvhq9WGbynOUoqKPvRLu24SUu5XUY/euZO6ODsRh3+VzdTzBc2jg4j7Ie+whFGU6XOVH8rU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666613723; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=0kFzIHpJ65NpGxpwkyahaB5OiazqJwfq8ejhmsUIJe4=; b=GomieimOiHrHIj0dyF0o0x97akiV+25qsA0v/Uno1vOFXjTrunWV/cmtD7Kf3kX2gqwjoo962LHjbM2V4sC0nUmIVCpX/upKkAFauSB5J2/Yb/kmeEe/s+TbDM6BSEfYDAvpQK55+sXDHDEMvFk+qfwvrVvn9Rz+6jrgt8+Da8s= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666613723747481.5546367359524; Mon, 24 Oct 2022 05:15:23 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvN5-0000wk-DO; Mon, 24 Oct 2022 07:11:55 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvMu-0000o3-UO for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:46 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvMr-0007PP-SL for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:44 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=0kFzIHpJ65NpGxpwkyahaB5OiazqJwfq8ejhmsUIJe4=; b=A+adG DB48W6uGp2VDH4x7XeNvWmFjBj7HECbrmhi+U56tbvZgxYLBhIqBcLueDQ0e9ie0FHNdCcoy/2pOt 6PQLQZrtmeh1bXASOD8GmD6bW3J/e5uEG3SmusDArPitO+ikwGyzUpwLgnnxTQeFd9GAw4EyQiCtn ZRYxz6p7DSF41jaTzEx+YBZxfkx4aKsNFytcmc0aa5gP0J7JTkJ6vZuHtH0Ft6GuH0Ij6rqqP0UHX Ng+dNaIhLKabS1vdfJA9kG2XMrk5EUqKywzQiYnrKubQs074HV52PFERjoSy9OWhrakuCb6dAY9Qk Mzn/FT6SgIvuprqsDrHcbgMJux2NQ==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 16/23] tests/9p: simplify callers of twrite() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=bb286ff8e85dcc222c93c9f3a164034561d1f585@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666613725655100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Now as twrite() is using a declarative approach, simplify the code of callers of this function. Signed-off-by: Christian Schoenebeck Message-Id: <7f280ec6a1f9d8afed46567a796562c4dc28afa9.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/virtio-9p-test.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index a5b9284acb..5ad7bebec7 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -377,7 +377,6 @@ static void fs_write(void *obj, void *data, QGuestAlloc= ator *t_alloc) char *wnames[] =3D { g_strdup(QTEST_V9FS_SYNTH_WRITE_FILE) }; g_autofree char *buf =3D g_malloc0(write_count); uint32_t count; - P9Req *req; =20 tattach({ .client =3D v9p }); twalk({ @@ -386,12 +385,10 @@ static void fs_write(void *obj, void *data, QGuestAll= ocator *t_alloc) =20 tlopen({ .client =3D v9p, .fid =3D 1, .flags =3D O_WRONLY }); =20 - req =3D twrite({ + count =3D twrite({ .client =3D v9p, .fid =3D 1, .offset =3D 0, .count =3D write_count, - .data =3D buf, .requestOnly =3D true - }).req; - v9fs_req_wait_for_reply(req, NULL); - v9fs_rwrite(req, &count); + .data =3D buf + }).count; g_assert_cmpint(count, =3D=3D, write_count); =20 g_free(wnames[0]); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611826; cv=none; d=zohomail.com; s=zohoarc; b=ngAgryMH/Rb/1eBgtBL7qnQdpqh9+iZZPxRtZJbgNOxPPVMVql4nkE1utpDBWAxuqnnZu+zz2yKp5Ie8wtMFh2IvsoaEyp5XOZlYJK0qvzhVnLIgCPbJ9Ivxf+05NUYdaCGnoKH7MzN+5gD8Z8q9ttJqNYbF5mFfB4uNkFQScm4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611826; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=c+RgxXEi7Zp1wwxeFMLC79N+UQRwAA0ALFNoqbWfM+M=; b=lk5Ye6Iw5KxIGYKGTLC+vozYaI6m1uJnynkXDk49T5NCPs8GbAj4UOviYXCXw9L0ITha+fD6g9vL2HPnmBPhTrWlA11zrfsFdvQu2ipqed0ATmKdsrkct3/htrZv6s5D3R4oL9ByKi71zW6uCu1bTVyJ5VqLYBYC+FmHNGsKVLM= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611826220445.114971063016; Mon, 24 Oct 2022 04:43:46 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvN6-00011V-Cd; Mon, 24 Oct 2022 07:11:56 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvN0-0000qr-FI for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:51 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvMx-0007Q9-SE for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:49 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=c+RgxXEi7Zp1wwxeFMLC79N+UQRwAA0ALFNoqbWfM+M=; b=G5NtW 0GDVTTwoUS7g+PAit6JHCR5Yyi/1fCbrbbAMG039IFftwHA6hOfN4kvwjPvtJFWpmrlu5GzC5TLro /jlELQlRps6rZd8ZAblUAeTkQjOAfKs/jYhCKU/IjIWtvD3LoWnKuBVuHm2olDfKptN3MpX8xIl23 KfsKcZMBvSK6PDpiMYkY/NKC7W2JCrEa02zl8KulTByp1sEYFU8vRR0HGzzuyRz/bPcCrH32P6mlq CO/nNeZU4RucqzHaQUegkB/lAM000UryKtRHOi/gBHEGH0C5KLYtHr9Bi+0GGcKnOAkf5EYmQfCsN vMeCcfHNdxbUn+IW1GTTViWZv4bmQ==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 17/23] tests/9p: convert v9fs_tflush() to declarative arguments To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=d89146fd16775aa734b1e67b8fdee0301ad80cf5@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611827004100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Use declarative function arguments for function v9fs_tflush(). Signed-off-by: Christian Schoenebeck Message-Id: <91b7b154298c500d100b05137146c2905c3acdec.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 23 +++++++++++++++++++---- tests/qtest/libqos/virtio-9p-client.h | 22 +++++++++++++++++++++- tests/qtest/virtio-9p-test.c | 9 +++++++-- 3 files changed, 47 insertions(+), 7 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 9ae347fad5..3be0ffc7da 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -733,14 +733,29 @@ void v9fs_rwrite(P9Req *req, uint32_t *count) } =20 /* size[4] Tflush tag[2] oldtag[2] */ -P9Req *v9fs_tflush(QVirtio9P *v9p, uint16_t oldtag, uint16_t tag) +TFlushRes v9fs_tflush(TFlushOpt opt) { P9Req *req; + uint32_t err; =20 - req =3D v9fs_req_init(v9p, 2, P9_TFLUSH, tag); - v9fs_uint32_write(req, oldtag); + g_assert(opt.client); + + req =3D v9fs_req_init(opt.client, 2, P9_TFLUSH, opt.tag); + v9fs_uint32_write(req, opt.oldtag); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rflush(req); + } + req =3D NULL; /* request was freed */ + } + + return (TFlushRes) { .req =3D req }; } =20 /* size[4] Rflush tag[2] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index dda371c054..b22b54c720 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -267,6 +267,26 @@ typedef struct TWriteRes { uint32_t count; } TWriteRes; =20 +/* options for 'Tflush' 9p request */ +typedef struct TFlushOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* message to flush (required) */ + uint16_t oldtag; + /* only send Tflush request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TFlushOpt; + +/* result of 'Tflush' 9p request */ +typedef struct TFlushRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TFlushRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -304,7 +324,7 @@ TLOpenRes v9fs_tlopen(TLOpenOpt); void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *iounit); TWriteRes v9fs_twrite(TWriteOpt); void v9fs_rwrite(P9Req *req, uint32_t *count); -P9Req *v9fs_tflush(QVirtio9P *v9p, uint16_t oldtag, uint16_t tag); +TFlushRes v9fs_tflush(TFlushOpt); void v9fs_rflush(P9Req *req); P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name, uint32_t mode, uint32_t gid, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 5ad7bebec7..5544998bac 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -23,6 +23,7 @@ #define treaddir(...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__) #define tlopen(...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__) #define twrite(...) v9fs_twrite((TWriteOpt) __VA_ARGS__) +#define tflush(...) v9fs_tflush((TFlushOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -420,7 +421,9 @@ static void fs_flush_success(void *obj, void *data, QGu= estAllocator *t_alloc) .requestOnly =3D true }).req; =20 - flush_req =3D v9fs_tflush(v9p, req->tag, 1); + flush_req =3D tflush({ + .client =3D v9p, .oldtag =3D req->tag, .tag =3D 1, .requestOnly = =3D true + }).req; =20 /* The write request is supposed to be flushed: the server should just * mark the write request as used and reply to the flush request. @@ -459,7 +462,9 @@ static void fs_flush_ignored(void *obj, void *data, QGu= estAllocator *t_alloc) .requestOnly =3D true }).req; =20 - flush_req =3D v9fs_tflush(v9p, req->tag, 1); + flush_req =3D tflush({ + .client =3D v9p, .oldtag =3D req->tag, .tag =3D 1, .requestOnly = =3D true + }).req; =20 /* The write request is supposed to complete. The server should * reply to the write request and the flush request. --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611617; cv=none; d=zohomail.com; s=zohoarc; b=Ux9G8tzBE0ATAOkh1nIdvEMSA+d1xQd9cN+WdWff1O/s5H68SEicIjTZ6Q68M71Wt9H1TeI1yL7iMcTnYztYuwTeuYnH3F6W810pAVcQl4ODkxj8CKmHGsu7EyrpRNM7iDIBu7rvfRPKjKLKhyE53vh0+MZpI51icByuGMgu2Ic= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611617; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=jUls6/y9esxRDFCxtCfStb+XE9xSYXdI6Fy1YzanfOw=; b=AcaKO/7pfYe3yopTEBGskLjHhYOlmiTfUEe1fjk0naJnYh7S7RBk2WctKbJYJY21GSed9sGJy9Ss3etvjhdRa7dgz/YPG/wyZFahajFPxbHRsjZasBFBCSolUc38B4R4iVTMZ1ZVTxV7nW7akh1y4YmGVhoJU4VciVzx1bxWT4k= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611617167337.17232549795835; Mon, 24 Oct 2022 04:40:17 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvN9-00015W-9e; Mon, 24 Oct 2022 07:11:59 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvN7-00014D-7o for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:57 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvN5-0007WF-65 for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:11:57 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=jUls6/y9esxRDFCxtCfStb+XE9xSYXdI6Fy1YzanfOw=; b=Upjy8 xFSbBPdKt2GiWlN50Ctj1Kgvakm4go8+uOjbQGxIYTlj8yjTHK0rHjmXyKI/coJUdRLMuVSC7VluL yJ+qciH9CKzib3dOddmuNPgJ8gIr5tKcWZmSZStEAMWRA38jWWpHNxbyzepe4E4tc2BqzFoKj7QFc 2CCxYGRG3+9AjPJly8D5NArmpc2Pb818cyKyZXB9pt/KUMAb/kpsLLfLTvBG724oZavU/ozkzOq7y NJ/P6OyrtMr6e2DTbdRSifyHQmYAOgJXKIcbC/3iaq9GwoH0q9H62k7VDcPo1h3pgIkPafwft1Hwi uxHfHZJwF9HFJZZzGY8etEL4onv5g==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 18/23] tests/9p: merge v9fs_tmkdir() and do_mkdir() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=e11680102af6a9f42ab198a77015696820a1993e@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611617915100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" As with previous patches, unify those 2 functions into a single function v9fs_tmkdir() by using a declarative function arguments approach. Signed-off-by: Christian Schoenebeck Message-Id: --- tests/qtest/libqos/virtio-9p-client.c | 42 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 36 +++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 30 ++++++------------- 3 files changed, 78 insertions(+), 30 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 3be0ffc7da..c374ba2048 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -766,10 +766,26 @@ void v9fs_rflush(P9Req *req) } =20 /* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */ -P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name, - uint32_t mode, uint32_t gid, uint16_t tag) +TMkdirRes v9fs_tmkdir(TMkdirOpt opt) { P9Req *req; + uint32_t err; + g_autofree char *name =3D g_strdup(opt.name); + + g_assert(opt.client); + /* expecting either hi-level atPath or low-level dfid, but not both */ + g_assert(!opt.atPath || !opt.dfid); + /* expecting either Rmkdir or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !opt.rmkdir.qid); + + if (opt.atPath) { + opt.dfid =3D v9fs_twalk((TWalkOpt) { .client =3D opt.client, + .path =3D opt.atPath }).newfid; + } + + if (!opt.mode) { + opt.mode =3D 0750; + } =20 uint32_t body_size =3D 4 + 4 + 4; uint16_t string_size =3D v9fs_string_size(name); @@ -777,13 +793,25 @@ P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, con= st char *name, g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 - req =3D v9fs_req_init(v9p, body_size, P9_TMKDIR, tag); - v9fs_uint32_write(req, dfid); + req =3D v9fs_req_init(opt.client, body_size, P9_TMKDIR, opt.tag); + v9fs_uint32_write(req, opt.dfid); v9fs_string_write(req, name); - v9fs_uint32_write(req, mode); - v9fs_uint32_write(req, gid); + v9fs_uint32_write(req, opt.mode); + v9fs_uint32_write(req, opt.gid); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rmkdir(req, opt.rmkdir.qid); + } + req =3D NULL; /* request was freed */ + } + + return (TMkdirRes) { .req =3D req }; } =20 /* size[4] Rmkdir tag[2] qid[13] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index b22b54c720..ae44f95a4d 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -287,6 +287,39 @@ typedef struct TFlushRes { P9Req *req; } TFlushRes; =20 +/* options for 'Tmkdir' 9p request */ +typedef struct TMkdirOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* low level variant of directory where new one shall be created */ + uint32_t dfid; + /* high-level variant of directory where new one shall be created */ + const char *atPath; + /* New directory's name (required) */ + const char *name; + /* Linux mkdir(2) mode bits (optional) */ + uint32_t mode; + /* effective group ID of caller */ + uint32_t gid; + /* data being received from 9p server as 'Rmkdir' response (optional) = */ + struct { + /* QID of newly created directory */ + v9fs_qid *qid; + } rmkdir; + /* only send Tmkdir request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TMkdirOpt; + +/* result of 'TMkdir' 9p request */ +typedef struct TMkdirRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TMkdirRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -326,8 +359,7 @@ TWriteRes v9fs_twrite(TWriteOpt); void v9fs_rwrite(P9Req *req, uint32_t *count); TFlushRes v9fs_tflush(TFlushOpt); void v9fs_rflush(P9Req *req); -P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name, - uint32_t mode, uint32_t gid, uint16_t tag); +TMkdirRes v9fs_tmkdir(TMkdirOpt); void v9fs_rmkdir(P9Req *req, v9fs_qid *qid); P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, uint32_t flags, uint32_t mode, uint32_t gid, diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 5544998bac..6d75afee87 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -24,6 +24,7 @@ #define tlopen(...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__) #define twrite(...) v9fs_twrite((TWriteOpt) __VA_ARGS__) #define tflush(...) v9fs_tflush((TFlushOpt) __VA_ARGS__) +#define tmkdir(...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -477,19 +478,6 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) g_free(wnames[0]); } =20 -static void do_mkdir(QVirtio9P *v9p, const char *path, const char *cname) -{ - g_autofree char *name =3D g_strdup(cname); - uint32_t fid; - P9Req *req; - - fid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; - - req =3D v9fs_tmkdir(v9p, fid, name, 0750, 0, 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_rmkdir(req, NULL); -} - /* create a regular file with Tlcreate and return file's fid */ static uint32_t do_lcreate(QVirtio9P *v9p, const char *path, const char *cname) @@ -587,7 +575,7 @@ static void fs_create_dir(void *obj, void *data, QGuest= Allocator *t_alloc) g_assert(root_path !=3D NULL); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "01"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "01" }); =20 /* check if created directory really exists now ... */ g_assert(stat(new_dir, &st) =3D=3D 0); @@ -606,7 +594,7 @@ static void fs_unlinkat_dir(void *obj, void *data, QGue= stAllocator *t_alloc) g_assert(root_path !=3D NULL); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "02"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "02" }); =20 /* check if created directory really exists now ... */ g_assert(stat(new_dir, &st) =3D=3D 0); @@ -626,7 +614,7 @@ static void fs_create_file(void *obj, void *data, QGues= tAllocator *t_alloc) g_autofree char *new_file =3D virtio_9p_test_path("03/1st_file"); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "03"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "03" }); do_lcreate(v9p, "03", "1st_file"); =20 /* check if created file exists now ... */ @@ -643,7 +631,7 @@ static void fs_unlinkat_file(void *obj, void *data, QGu= estAllocator *t_alloc) g_autofree char *new_file =3D virtio_9p_test_path("04/doa_file"); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "04"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "04" }); do_lcreate(v9p, "04", "doa_file"); =20 /* check if created file exists now ... */ @@ -665,7 +653,7 @@ static void fs_symlink_file(void *obj, void *data, QGue= stAllocator *t_alloc) g_autofree char *symlink_file =3D virtio_9p_test_path("05/symlink_file= "); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "05"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "05" }); do_lcreate(v9p, "05", "real_file"); g_assert(stat(real_file, &st) =3D=3D 0); g_assert((st.st_mode & S_IFMT) =3D=3D S_IFREG); @@ -686,7 +674,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, g_autofree char *symlink_file =3D virtio_9p_test_path("06/symlink_file= "); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "06"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "06" }); do_lcreate(v9p, "06", "real_file"); g_assert(stat(real_file, &st) =3D=3D 0); g_assert((st.st_mode & S_IFMT) =3D=3D S_IFREG); @@ -708,7 +696,7 @@ static void fs_hardlink_file(void *obj, void *data, QGu= estAllocator *t_alloc) g_autofree char *hardlink_file =3D virtio_9p_test_path("07/hardlink_fi= le"); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "07"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "07" }); do_lcreate(v9p, "07", "real_file"); g_assert(stat(real_file, &st_real) =3D=3D 0); g_assert((st_real.st_mode & S_IFMT) =3D=3D S_IFREG); @@ -733,7 +721,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, g_autofree char *hardlink_file =3D virtio_9p_test_path("08/hardlink_fi= le"); =20 tattach({ .client =3D v9p }); - do_mkdir(v9p, "/", "08"); + tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "08" }); do_lcreate(v9p, "08", "real_file"); g_assert(stat(real_file, &st_real) =3D=3D 0); g_assert((st_real.st_mode & S_IFMT) =3D=3D S_IFREG); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611055; cv=none; d=zohomail.com; s=zohoarc; b=n7NKPtUsDPswo5os6Fi1ILmk1d0YWZ7WkQgYr53zEiHGXTOoQPwV+6cbGYni5ScCRLtBL2AMmtDlwhcnPbf2w0XAf5SxjxJeK+mkHK69H5zPT02t3pk0/Dl4/e+OqGLwsNVH68GHikgM03XFjAgKfmavrezo1mzNbbeUP8MByj0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611055; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=fC9EpIJKMHiKa72B2csPLQ/AHAzN/0eyQEaoVk2XwOo=; b=E2fpZbnZvosb9KTy7buOxXOc96P2QLiVxA9CP7Dxyc35qMR3pz62udhANdgDJM8gs4QNVczYtlWCVS3+FN5I1sQ/tJHz8d3Vdmnj5q28zW+nimRDibJDTZmHS04rUgRjRymalYI70ORWJJB+7D7v7iMt6FGoIImhEcndunbqOA8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611055935624.2946211545565; Mon, 24 Oct 2022 04:30:55 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvNR-000180-Fj; Mon, 24 Oct 2022 07:12:17 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvNH-00016B-R4 for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:07 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvNC-0007dF-BM for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:07 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=fC9EpIJKMHiKa72B2csPLQ/AHAzN/0eyQEaoVk2XwOo=; b=GRSaf ZwbOgFpez0HI5qf/9o1zh/IDwqg2zB0xB7yh/OsVnkbDj67l9FpY//l7u/bgA0ctasH2ZY1D3pChy gyRBAGXcMAJnXj6Puha+6B3XIc7KI6ZPb0RP+IzInZTGZyWyyWnOirZhCcEVYrvS9VnM++qS2L8aM Os6+6oLGPJ9u0fUzr1zLIRSrQ/RvwFvgJ5PVZh6tQF8tMN7nl2zRl34Q0rumcel2j/A4QvpUx0jwZ pjunz6XVSyTvIz1mcJopZmRswiD3T6jet7xnX18FreA8B+AQsAjRNc08m4dwfFKgVj8aEvoS/ag7V +mz/csm7efxRmDXJj7aqWef/9CBDA==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 19/23] tests/9p: merge v9fs_tlcreate() and do_lcreate() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=bd4660d49ac64886fb27649138e52d81be161fee@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611056783100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" As with previous patches, unify those 2 functions into a single function v9fs_tlcreate() by using a declarative function arguments approach. Signed-off-by: Christian Schoenebeck Message-Id: <4c01b2caa5f5b54a2020fc92701deadd2abf0571.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 45 +++++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 39 +++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 30 +++++------------- 3 files changed, 79 insertions(+), 35 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index c374ba2048..5c805a133c 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -827,11 +827,26 @@ void v9fs_rmkdir(P9Req *req, v9fs_qid *qid) } =20 /* size[4] Tlcreate tag[2] fid[4] name[s] flags[4] mode[4] gid[4] */ -P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, - uint32_t flags, uint32_t mode, uint32_t gid, - uint16_t tag) +TlcreateRes v9fs_tlcreate(TlcreateOpt opt) { P9Req *req; + uint32_t err; + g_autofree char *name =3D g_strdup(opt.name); + + g_assert(opt.client); + /* expecting either hi-level atPath or low-level fid, but not both */ + g_assert(!opt.atPath || !opt.fid); + /* expecting either Rlcreate or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !(opt.rlcreate.qid || opt.rlcreate.iounit)); + + if (opt.atPath) { + opt.fid =3D v9fs_twalk((TWalkOpt) { .client =3D opt.client, + .path =3D opt.atPath }).newfid; + } + + if (!opt.mode) { + opt.mode =3D 0750; + } =20 uint32_t body_size =3D 4 + 4 + 4 + 4; uint16_t string_size =3D v9fs_string_size(name); @@ -839,14 +854,26 @@ P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, co= nst char *name, g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 - req =3D v9fs_req_init(v9p, body_size, P9_TLCREATE, tag); - v9fs_uint32_write(req, fid); + req =3D v9fs_req_init(opt.client, body_size, P9_TLCREATE, opt.tag); + v9fs_uint32_write(req, opt.fid); v9fs_string_write(req, name); - v9fs_uint32_write(req, flags); - v9fs_uint32_write(req, mode); - v9fs_uint32_write(req, gid); + v9fs_uint32_write(req, opt.flags); + v9fs_uint32_write(req, opt.mode); + v9fs_uint32_write(req, opt.gid); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rlcreate(req, opt.rlcreate.qid, opt.rlcreate.iounit); + } + req =3D NULL; /* request was freed */ + } + + return (TlcreateRes) { .req =3D req }; } =20 /* size[4] Rlcreate tag[2] qid[13] iounit[4] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index ae44f95a4d..8916b1c7aa 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -320,6 +320,41 @@ typedef struct TMkdirRes { P9Req *req; } TMkdirRes; =20 +/* options for 'Tlcreate' 9p request */ +typedef struct TlcreateOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* low-level variant of directory where new file shall be created */ + uint32_t fid; + /* high-level variant of directory where new file shall be created */ + const char *atPath; + /* name of new file (required) */ + const char *name; + /* Linux kernel intent bits */ + uint32_t flags; + /* Linux create(2) mode bits */ + uint32_t mode; + /* effective group ID of caller */ + uint32_t gid; + /* data being received from 9p server as 'Rlcreate' response (optional= ) */ + struct { + v9fs_qid *qid; + uint32_t *iounit; + } rlcreate; + /* only send Tlcreate request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TlcreateOpt; + +/* result of 'Tlcreate' 9p request */ +typedef struct TlcreateRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TlcreateRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -361,9 +396,7 @@ TFlushRes v9fs_tflush(TFlushOpt); void v9fs_rflush(P9Req *req); TMkdirRes v9fs_tmkdir(TMkdirOpt); void v9fs_rmkdir(P9Req *req, v9fs_qid *qid); -P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, - uint32_t flags, uint32_t mode, uint32_t gid, - uint16_t tag); +TlcreateRes v9fs_tlcreate(TlcreateOpt); void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_t *iounit); P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, const char *name, const char *symtgt, uint32_t gid, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 6d75afee87..d13b27bd2e 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -25,6 +25,7 @@ #define twrite(...) v9fs_twrite((TWriteOpt) __VA_ARGS__) #define tflush(...) v9fs_tflush((TFlushOpt) __VA_ARGS__) #define tmkdir(...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__) +#define tlcreate(...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -478,23 +479,6 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) g_free(wnames[0]); } =20 -/* create a regular file with Tlcreate and return file's fid */ -static uint32_t do_lcreate(QVirtio9P *v9p, const char *path, - const char *cname) -{ - g_autofree char *name =3D g_strdup(cname); - uint32_t fid; - P9Req *req; - - fid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; - - req =3D v9fs_tlcreate(v9p, fid, name, 0, 0750, 0, 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlcreate(req, NULL, NULL); - - return fid; -} - /* create symlink named @a clink in directory @a path pointing to @a to */ static void do_symlink(QVirtio9P *v9p, const char *path, const char *clink, const char *to) @@ -615,7 +599,7 @@ static void fs_create_file(void *obj, void *data, QGues= tAllocator *t_alloc) =20 tattach({ .client =3D v9p }); tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "03" }); - do_lcreate(v9p, "03", "1st_file"); + tlcreate({ .client =3D v9p, .atPath =3D "03", .name =3D "1st_file" }); =20 /* check if created file exists now ... */ g_assert(stat(new_file, &st) =3D=3D 0); @@ -632,7 +616,7 @@ static void fs_unlinkat_file(void *obj, void *data, QGu= estAllocator *t_alloc) =20 tattach({ .client =3D v9p }); tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "04" }); - do_lcreate(v9p, "04", "doa_file"); + tlcreate({ .client =3D v9p, .atPath =3D "04", .name =3D "doa_file" }); =20 /* check if created file exists now ... */ g_assert(stat(new_file, &st) =3D=3D 0); @@ -654,7 +638,7 @@ static void fs_symlink_file(void *obj, void *data, QGue= stAllocator *t_alloc) =20 tattach({ .client =3D v9p }); tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "05" }); - do_lcreate(v9p, "05", "real_file"); + tlcreate({ .client =3D v9p, .atPath =3D "05", .name =3D "real_file" }); g_assert(stat(real_file, &st) =3D=3D 0); g_assert((st.st_mode & S_IFMT) =3D=3D S_IFREG); =20 @@ -675,7 +659,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, =20 tattach({ .client =3D v9p }); tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "06" }); - do_lcreate(v9p, "06", "real_file"); + tlcreate({ .client =3D v9p, .atPath =3D "06", .name =3D "real_file" }); g_assert(stat(real_file, &st) =3D=3D 0); g_assert((st.st_mode & S_IFMT) =3D=3D S_IFREG); =20 @@ -697,7 +681,7 @@ static void fs_hardlink_file(void *obj, void *data, QGu= estAllocator *t_alloc) =20 tattach({ .client =3D v9p }); tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "07" }); - do_lcreate(v9p, "07", "real_file"); + tlcreate({ .client =3D v9p, .atPath =3D "07", .name =3D "real_file" }); g_assert(stat(real_file, &st_real) =3D=3D 0); g_assert((st_real.st_mode & S_IFMT) =3D=3D S_IFREG); =20 @@ -722,7 +706,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, =20 tattach({ .client =3D v9p }); tmkdir({ .client =3D v9p, .atPath =3D "/", .name =3D "08" }); - do_lcreate(v9p, "08", "real_file"); + tlcreate({ .client =3D v9p, .atPath =3D "08", .name =3D "real_file" }); g_assert(stat(real_file, &st_real) =3D=3D 0); g_assert((st_real.st_mode & S_IFMT) =3D=3D S_IFREG); =20 --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666611237; cv=none; d=zohomail.com; s=zohoarc; b=YC5tu79kshgAk0MljMqabKix5QUzvk8FiytUVWsDas6n14dBrNMatTfPCVEDMRt/c+Rm6k3EJfTJb74pvMb0W6JbaBbTU7pdde4qGT8QnWZu+tIkKowE4650WhjVfiQOF1SOzbRdVL913QRjc+3axferI6Qh46zUo6iG7kfaxaI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666611237; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=BEtTOUeD/jH0dPsqOv2nbWpaJhOfjmOB4J26UFiGjkw=; b=fksg+bbjPeR7vy87byaTLWlNg9WQHHLHw7Ouv6kEiveMjr2UqFqOsNXcjYlcpZD0W2KU5glr6m24jLHthx2qO4d1RMfsK//hbkjELiAwphgn25oXbpPeOQAUmnQZJOnlcWnSL4YG2GlIegZs2TwHMDJa2ZdTiuBIVbRsETBAAtw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666611237295702.2124534140862; Mon, 24 Oct 2022 04:33:57 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvNc-0001Bt-AM; Mon, 24 Oct 2022 07:12:28 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <9beabfa52cb17fad0e8211031f301f12281d65f8@lizzy.crudebyte.com>) id 1omvNa-0001BH-S4 for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:26 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <9beabfa52cb17fad0e8211031f301f12281d65f8@lizzy.crudebyte.com>) id 1omvNJ-0007hx-3q for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:26 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=BEtTOUeD/jH0dPsqOv2nbWpaJhOfjmOB4J26UFiGjkw=; b=A7nQN muXf+fWr1m+BnivQdV1Jz2Act+0QCe+h8bgCBWsMDhatAfbDCmW2o7uY30ZtCrSMkoHY5oCCuixrq Q/m+AqUCLmS1T+7YK7RMn1UYfKj5D/6dmgGsGhXfk9Xc/0d3UcYToQVJOrS4UaemJxL77JRn9f8EH rxaTtqeq2SLO9mnUQ83lrjPEeaXOaACdwVZ+HS0KgeaNpwvCMNKKhrEZNhCD4nwGoObuOQRNkE7LO TfTBRg+f+QwgDCJgy+LV1pN/Y2k4QiRXNTsK2UcG7UuTftSSNV4obTXW3xxbdgG42qZemMutXw7Tp /vjrgQurrhzqhtGzIKnXVaQryAwiQ==; Message-Id: <9beabfa52cb17fad0e8211031f301f12281d65f8.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 20/23] tests/9p: merge v9fs_tsymlink() and do_symlink() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=9beabfa52cb17fad0e8211031f301f12281d65f8@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666611237739100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" As with previous patches, unify those 2 functions into a single function v9fs_tsymlink() by using a declarative function arguments approach. Signed-off-by: Christian Schoenebeck Message-Id: <563f3ad04fe596ce0ae1e2654d1d08237f18c830.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 37 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 35 +++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 27 +++++++------------ 3 files changed, 73 insertions(+), 26 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 5c805a133c..89eaf50355 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -892,10 +892,23 @@ void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_= t *iounit) } =20 /* size[4] Tsymlink tag[2] fid[4] name[s] symtgt[s] gid[4] */ -P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, const char *name, - const char *symtgt, uint32_t gid, uint16_t tag) +TsymlinkRes v9fs_tsymlink(TsymlinkOpt opt) { P9Req *req; + uint32_t err; + g_autofree char *name =3D g_strdup(opt.name); + g_autofree char *symtgt =3D g_strdup(opt.symtgt); + + g_assert(opt.client); + /* expecting either hi-level atPath or low-level fid, but not both */ + g_assert(!opt.atPath || !opt.fid); + /* expecting either Rsymlink or Rlerror, but obviously not both */ + g_assert(!opt.expectErr || !opt.rsymlink.qid); + + if (opt.atPath) { + opt.fid =3D v9fs_twalk((TWalkOpt) { .client =3D opt.client, + .path =3D opt.atPath }).newfid; + } =20 uint32_t body_size =3D 4 + 4; uint16_t string_size =3D v9fs_string_size(name) + v9fs_string_size(sym= tgt); @@ -903,13 +916,25 @@ P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, co= nst char *name, g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 - req =3D v9fs_req_init(v9p, body_size, P9_TSYMLINK, tag); - v9fs_uint32_write(req, fid); + req =3D v9fs_req_init(opt.client, body_size, P9_TSYMLINK, opt.tag); + v9fs_uint32_write(req, opt.fid); v9fs_string_write(req, name); v9fs_string_write(req, symtgt); - v9fs_uint32_write(req, gid); + v9fs_uint32_write(req, opt.gid); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rsymlink(req, opt.rsymlink.qid); + } + req =3D NULL; /* request was freed */ + } + + return (TsymlinkRes) { .req =3D req }; } =20 /* size[4] Rsymlink tag[2] qid[13] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index 8916b1c7aa..b905a54966 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -355,6 +355,38 @@ typedef struct TlcreateRes { P9Req *req; } TlcreateRes; =20 +/* options for 'Tsymlink' 9p request */ +typedef struct TsymlinkOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* low-level variant of directory where symlink shall be created */ + uint32_t fid; + /* high-level variant of directory where symlink shall be created */ + const char *atPath; + /* name of symlink (required) */ + const char *name; + /* where symlink will point to (required) */ + const char *symtgt; + /* effective group ID of caller */ + uint32_t gid; + /* data being received from 9p server as 'Rsymlink' response (optional= ) */ + struct { + v9fs_qid *qid; + } rsymlink; + /* only send Tsymlink request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TsymlinkOpt; + +/* result of 'Tsymlink' 9p request */ +typedef struct TsymlinkRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TsymlinkRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -398,8 +430,7 @@ TMkdirRes v9fs_tmkdir(TMkdirOpt); void v9fs_rmkdir(P9Req *req, v9fs_qid *qid); TlcreateRes v9fs_tlcreate(TlcreateOpt); void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_t *iounit); -P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, const char *name, - const char *symtgt, uint32_t gid, uint16_t tag); +TsymlinkRes v9fs_tsymlink(TsymlinkOpt); void v9fs_rsymlink(P9Req *req, v9fs_qid *qid); P9Req *v9fs_tlink(QVirtio9P *v9p, uint32_t dfid, uint32_t fid, const char *name, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index d13b27bd2e..c7213d6caf 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -26,6 +26,7 @@ #define tflush(...) v9fs_tflush((TFlushOpt) __VA_ARGS__) #define tmkdir(...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__) #define tlcreate(...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__) +#define tsymlink(...) v9fs_tsymlink((TsymlinkOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -479,22 +480,6 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) g_free(wnames[0]); } =20 -/* create symlink named @a clink in directory @a path pointing to @a to */ -static void do_symlink(QVirtio9P *v9p, const char *path, const char *clink, - const char *to) -{ - g_autofree char *name =3D g_strdup(clink); - g_autofree char *dst =3D g_strdup(to); - uint32_t fid; - P9Req *req; - - fid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; - - req =3D v9fs_tsymlink(v9p, fid, name, dst, 0, 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_rsymlink(req, NULL); -} - /* create a hard link named @a clink in directory @a path pointing to @a t= o */ static void do_hardlink(QVirtio9P *v9p, const char *path, const char *clin= k, const char *to) @@ -642,7 +627,10 @@ static void fs_symlink_file(void *obj, void *data, QGu= estAllocator *t_alloc) g_assert(stat(real_file, &st) =3D=3D 0); g_assert((st.st_mode & S_IFMT) =3D=3D S_IFREG); =20 - do_symlink(v9p, "05", "symlink_file", "real_file"); + tsymlink({ + .client =3D v9p, .atPath =3D "05", .name =3D "symlink_file", + .symtgt =3D "real_file" + }); =20 /* check if created link exists now */ g_assert(stat(symlink_file, &st) =3D=3D 0); @@ -663,7 +651,10 @@ static void fs_unlinkat_symlink(void *obj, void *data, g_assert(stat(real_file, &st) =3D=3D 0); g_assert((st.st_mode & S_IFMT) =3D=3D S_IFREG); =20 - do_symlink(v9p, "06", "symlink_file", "real_file"); + tsymlink({ + .client =3D v9p, .atPath =3D "06", .name =3D "symlink_file", + .symtgt =3D "real_file" + }); g_assert(stat(symlink_file, &st) =3D=3D 0); =20 do_unlinkat(v9p, "06", "symlink_file", 0); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610363; cv=none; d=zohomail.com; s=zohoarc; b=ZlU8/6y7AsmVUy9vdg3m4xIVrmFIAIOx32YXdFZRJAroyejZ9k0OLpt2HeL84GhrPX/vucSTNI7toQNPLBQifdY9Z8I+DzhjOGqKJAMRMrTbENJRfAG0X60rqkPMhJDnVl5lhyOhF4SuZJivtb6ODyb2DYYC/PKqbsvFOm6nRYo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610363; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=vChMvOV4Fs5nN+flMr1JIltDZPXWUAIVq6xErmq0yGg=; b=bznlvO9kEq4BsDRn5D0g5bBNiOkFyefrcnVCF3S664pIu3un4iWKvLgdxIbsyZhmpAa4aBEFuzKewkmdYszn00iTnyz6bzOHrB/7qSSYJj6RYs0gIDzy5evNhZUhFOin1kbgVxr6cSm5vgcrfiqBvzgZtrO6PI8UJHu/TI9UCv4= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610363603574.7337260297447; Mon, 24 Oct 2022 04:19:23 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvNn-0001EV-2y; Mon, 24 Oct 2022 07:12:39 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvNi-0001Ct-Er for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:37 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1omvNT-0007ir-8W for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:34 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=vChMvOV4Fs5nN+flMr1JIltDZPXWUAIVq6xErmq0yGg=; b=MNt75 ZLIn1CLhuFVKOzl7em7QCJeAEOUbPfUZEwzl0JMSzZlQPZ2cyl/myvR5dLMU9Zyp+Z2sS6WgWv1tT HaX905FgGM6C7zw0DdbWGE9iI47jEStQEXLRa+boQRM346evHRr39eosObHaM8l7zw9/8I1/Qf6f4 L4rWXGBgmdKuEH1NNh6I0HWPseQtafJVM6M5BPu+WWtY1Pe7NRtBCROfDddB1yp7nnOmHPZlxLGxb Nd1OOkcBx00Px2aruITIozmrFb9V29Ro9y4n2875FhcEbAM56FlsknqMwZAjGd6e0+hpqp4vePFyb 566X2dVNTt74lODlxDKJ0U/3DKi3Q==; Message-Id: In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 21/23] tests/9p: merge v9fs_tlink() and do_hardlink() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=d41a9462ea15f0e3ef789d496032536c33098275@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -16 X-Spam_score: -1.7 X-Spam_bar: - X-Spam_report: (-1.7 / 5.0 requ) BAYES_00=-1.9, DKIM_INVALID=0.1, DKIM_SIGNED=0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610364237100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" As with previous patches, unify those 2 functions into a single function v9fs_tlink() by using a declarative function arguments approach. Signed-off-by: Christian Schoenebeck Message-Id: --- tests/qtest/libqos/virtio-9p-client.c | 43 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 31 +++++++++++++++++-- tests/qtest/virtio-9p-test.c | 26 ++++++---------- 3 files changed, 73 insertions(+), 27 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index 89eaf50355..a2770719b9 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -950,23 +950,50 @@ void v9fs_rsymlink(P9Req *req, v9fs_qid *qid) } =20 /* size[4] Tlink tag[2] dfid[4] fid[4] name[s] */ -P9Req *v9fs_tlink(QVirtio9P *v9p, uint32_t dfid, uint32_t fid, - const char *name, uint16_t tag) +TlinkRes v9fs_tlink(TlinkOpt opt) { P9Req *req; + uint32_t err; + + g_assert(opt.client); + /* expecting either hi-level atPath or low-level dfid, but not both */ + g_assert(!opt.atPath || !opt.dfid); + /* expecting either hi-level toPath or low-level fid, but not both */ + g_assert(!opt.toPath || !opt.fid); + + if (opt.atPath) { + opt.dfid =3D v9fs_twalk((TWalkOpt) { .client =3D opt.client, + .path =3D opt.atPath }).newfid; + } + if (opt.toPath) { + opt.fid =3D v9fs_twalk((TWalkOpt) { .client =3D opt.client, + .path =3D opt.toPath }).newfid; + } =20 uint32_t body_size =3D 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); + uint16_t string_size =3D v9fs_string_size(opt.name); =20 g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 - req =3D v9fs_req_init(v9p, body_size, P9_TLINK, tag); - v9fs_uint32_write(req, dfid); - v9fs_uint32_write(req, fid); - v9fs_string_write(req, name); + req =3D v9fs_req_init(opt.client, body_size, P9_TLINK, opt.tag); + v9fs_uint32_write(req, opt.dfid); + v9fs_uint32_write(req, opt.fid); + v9fs_string_write(req, opt.name); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_rlink(req); + } + req =3D NULL; /* request was freed */ + } + + return (TlinkRes) { .req =3D req }; } =20 /* size[4] Rlink tag[2] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index b905a54966..49ffd0fc51 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -387,6 +387,34 @@ typedef struct TsymlinkRes { P9Req *req; } TsymlinkRes; =20 +/* options for 'Tlink' 9p request */ +typedef struct TlinkOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* low-level variant of directory where hard link shall be created */ + uint32_t dfid; + /* high-level variant of directory where hard link shall be created */ + const char *atPath; + /* low-level variant of target referenced by new hard link */ + uint32_t fid; + /* high-level variant of target referenced by new hard link */ + const char *toPath; + /* name of hard link (required) */ + const char *name; + /* only send Tlink request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TlinkOpt; + +/* result of 'Tlink' 9p request */ +typedef struct TlinkRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TlinkRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -432,8 +460,7 @@ TlcreateRes v9fs_tlcreate(TlcreateOpt); void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_t *iounit); TsymlinkRes v9fs_tsymlink(TsymlinkOpt); void v9fs_rsymlink(P9Req *req, v9fs_qid *qid); -P9Req *v9fs_tlink(QVirtio9P *v9p, uint32_t dfid, uint32_t fid, - const char *name, uint16_t tag); +TlinkRes v9fs_tlink(TlinkOpt); void v9fs_rlink(P9Req *req); P9Req *v9fs_tunlinkat(QVirtio9P *v9p, uint32_t dirfd, const char *name, uint32_t flags, uint16_t tag); diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index c7213d6caf..185eaf8b1e 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -27,6 +27,7 @@ #define tmkdir(...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__) #define tlcreate(...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__) #define tsymlink(...) v9fs_tsymlink((TsymlinkOpt) __VA_ARGS__) +#define tlink(...) v9fs_tlink((TlinkOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -480,21 +481,6 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) g_free(wnames[0]); } =20 -/* create a hard link named @a clink in directory @a path pointing to @a t= o */ -static void do_hardlink(QVirtio9P *v9p, const char *path, const char *clin= k, - const char *to) -{ - uint32_t dfid, fid; - P9Req *req; - - dfid =3D twalk({ .client =3D v9p, .path =3D path }).newfid; - fid =3D twalk({ .client =3D v9p, .path =3D to }).newfid; - - req =3D v9fs_tlink(v9p, dfid, fid, clink, 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_rlink(req); -} - static void do_unlinkat(QVirtio9P *v9p, const char *atpath, const char *rp= ath, uint32_t flags) { @@ -676,7 +662,10 @@ static void fs_hardlink_file(void *obj, void *data, QG= uestAllocator *t_alloc) g_assert(stat(real_file, &st_real) =3D=3D 0); g_assert((st_real.st_mode & S_IFMT) =3D=3D S_IFREG); =20 - do_hardlink(v9p, "07", "hardlink_file", "07/real_file"); + tlink({ + .client =3D v9p, .atPath =3D "07", .name =3D "hardlink_file", + .toPath =3D "07/real_file" + }); =20 /* check if link exists now ... */ g_assert(stat(hardlink_file, &st_link) =3D=3D 0); @@ -701,7 +690,10 @@ static void fs_unlinkat_hardlink(void *obj, void *data, g_assert(stat(real_file, &st_real) =3D=3D 0); g_assert((st_real.st_mode & S_IFMT) =3D=3D S_IFREG); =20 - do_hardlink(v9p, "08", "hardlink_file", "08/real_file"); + tlink({ + .client =3D v9p, .atPath =3D "08", .name =3D "hardlink_file", + .toPath =3D "08/real_file" + }); g_assert(stat(hardlink_file, &st_link) =3D=3D 0); =20 do_unlinkat(v9p, "08", "hardlink_file", 0); --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666610380; cv=none; d=zohomail.com; s=zohoarc; b=BtMq64Gax0daWITKV9UGF91/11Qu4Rj6pXuCEl15dtShYK/WMKtPIrDLhALFsyYAjNii7bMq+2sOF4oc66tFPVrAHyfly8l1T63P2zMd+KB8dBV/bgjW+/mGlVo0NjQ3bqpOPNraKPuJqkfrjYHteFDGMqUVggXB1axKeFZ4QR8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666610380; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=fqOvxrtxl0kAozVZf8lzZQlTXEjT9vupeLsdMhmgBW8=; b=a9I3qgw5qarJoSD3tgpFz1lbfUi1uIuY+CVVbnuQc4X1QFraYpqMuOG3C7bEKaFi8vkSHMBkWwS5paDZ8dH0OQCOUqOhh9dfOeMNYBoyethRKFTguQJtt9HidMjr2VacOacpX+n0WfCxi2LBlGNArulvxukieT/Utm2oRAYvaFk= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666610380310388.5648232397343; Mon, 24 Oct 2022 04:19:40 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvNn-0001Ec-JO; Mon, 24 Oct 2022 07:12:39 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <43e0d9fb358b01539d0de9494208e80ff84b5456@lizzy.crudebyte.com>) id 1omvNi-0001Cs-Au for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:37 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <43e0d9fb358b01539d0de9494208e80ff84b5456@lizzy.crudebyte.com>) id 1omvNX-0007lX-6P for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:34 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=fqOvxrtxl0kAozVZf8lzZQlTXEjT9vupeLsdMhmgBW8=; b=Jpmvw XV0IOfnqLeLszvCVFKfv+NF4yJaBfhe5Wh1H+wFWC4LImaSP53nD1Z+hB/NAB7DmhWDTu53xO7dtj xw6XEPEgVw2FdZbgxak6+5ZjJuetEo4kS4xfinM42KIdl5olrQBXWXTmiJiIU/z0feInHP0DBNwO2 qXNmdLcCp7NI6exwJZQ465OKlIywC/lANK6CqX7AiiM/NbOGnRBGGtLIpj3IWsUCpovtQF9fZaJLg 2CwVp4Mz3a9Z3l5a1fRSgvlfmFp+bqvqRoNOjQPTOQ1r2RXVRJlpJUlURYS3TWaFy25BDyGUS1dPW myiIBefD0i+/uiyCYsEbn469HIgrA==; Message-Id: <43e0d9fb358b01539d0de9494208e80ff84b5456.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 22/23] tests/9p: merge v9fs_tunlinkat() and do_unlinkat() To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=43e0d9fb358b01539d0de9494208e80ff84b5456@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666610382219100003 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" As with previous patches, unify those 2 functions into a single function v9fs_tunlinkat() by using a declarative function arguments approach. Signed-off-by: Christian Schoenebeck Message-Id: <1dea593edd464908d92501933c068388c01f1744.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 37 +++++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 29 +++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 26 ++++++------------- 3 files changed, 64 insertions(+), 28 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index a2770719b9..e017e030ec 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -1004,23 +1004,44 @@ void v9fs_rlink(P9Req *req) } =20 /* size[4] Tunlinkat tag[2] dirfd[4] name[s] flags[4] */ -P9Req *v9fs_tunlinkat(QVirtio9P *v9p, uint32_t dirfd, const char *name, - uint32_t flags, uint16_t tag) +TunlinkatRes v9fs_tunlinkat(TunlinkatOpt opt) { P9Req *req; + uint32_t err; + + g_assert(opt.client); + /* expecting either hi-level atPath or low-level dirfd, but not both */ + g_assert(!opt.atPath || !opt.dirfd); + + if (opt.atPath) { + opt.dirfd =3D v9fs_twalk((TWalkOpt) { .client =3D opt.client, + .path =3D opt.atPath }).newfid; + } =20 uint32_t body_size =3D 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); + uint16_t string_size =3D v9fs_string_size(opt.name); =20 g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 - req =3D v9fs_req_init(v9p, body_size, P9_TUNLINKAT, tag); - v9fs_uint32_write(req, dirfd); - v9fs_string_write(req, name); - v9fs_uint32_write(req, flags); + req =3D v9fs_req_init(opt.client, body_size, P9_TUNLINKAT, opt.tag); + v9fs_uint32_write(req, opt.dirfd); + v9fs_string_write(req, opt.name); + v9fs_uint32_write(req, opt.flags); v9fs_req_send(req); - return req; + + if (!opt.requestOnly) { + v9fs_req_wait_for_reply(req, NULL); + if (opt.expectErr) { + v9fs_rlerror(req, &err); + g_assert_cmpint(err, =3D=3D, opt.expectErr); + } else { + v9fs_runlinkat(req); + } + req =3D NULL; /* request was freed */ + } + + return (TunlinkatRes) { .req =3D req }; } =20 /* size[4] Runlinkat tag[2] */ diff --git a/tests/qtest/libqos/virtio-9p-client.h b/tests/qtest/libqos/vir= tio-9p-client.h index 49ffd0fc51..78228eb97d 100644 --- a/tests/qtest/libqos/virtio-9p-client.h +++ b/tests/qtest/libqos/virtio-9p-client.h @@ -415,6 +415,32 @@ typedef struct TlinkRes { P9Req *req; } TlinkRes; =20 +/* options for 'Tunlinkat' 9p request */ +typedef struct TunlinkatOpt { + /* 9P client being used (mandatory) */ + QVirtio9P *client; + /* user supplied tag number being returned with response (optional) */ + uint16_t tag; + /* low-level variant of directory where name shall be unlinked */ + uint32_t dirfd; + /* high-level variant of directory where name shall be unlinked */ + const char *atPath; + /* name of directory entry to be unlinked (required) */ + const char *name; + /* Linux unlinkat(2) flags */ + uint32_t flags; + /* only send Tunlinkat request but not wait for a reply? (optional) */ + bool requestOnly; + /* do we expect an Rlerror response, if yes which error code? (optiona= l) */ + uint32_t expectErr; +} TunlinkatOpt; + +/* result of 'Tunlinkat' 9p request */ +typedef struct TunlinkatRes { + /* if requestOnly was set: request object for further processing */ + P9Req *req; +} TunlinkatRes; + void v9fs_set_allocator(QGuestAllocator *t_alloc); void v9fs_memwrite(P9Req *req, const void *addr, size_t len); void v9fs_memskip(P9Req *req, size_t len); @@ -462,8 +488,7 @@ TsymlinkRes v9fs_tsymlink(TsymlinkOpt); void v9fs_rsymlink(P9Req *req, v9fs_qid *qid); TlinkRes v9fs_tlink(TlinkOpt); void v9fs_rlink(P9Req *req); -P9Req *v9fs_tunlinkat(QVirtio9P *v9p, uint32_t dirfd, const char *name, - uint32_t flags, uint16_t tag); +TunlinkatRes v9fs_tunlinkat(TunlinkatOpt); void v9fs_runlinkat(P9Req *req); =20 #endif diff --git a/tests/qtest/virtio-9p-test.c b/tests/qtest/virtio-9p-test.c index 185eaf8b1e..65e69491e5 100644 --- a/tests/qtest/virtio-9p-test.c +++ b/tests/qtest/virtio-9p-test.c @@ -28,6 +28,7 @@ #define tlcreate(...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__) #define tsymlink(...) v9fs_tsymlink((TsymlinkOpt) __VA_ARGS__) #define tlink(...) v9fs_tlink((TlinkOpt) __VA_ARGS__) +#define tunlinkat(...) v9fs_tunlinkat((TunlinkatOpt) __VA_ARGS__) =20 static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -481,20 +482,6 @@ static void fs_flush_ignored(void *obj, void *data, QG= uestAllocator *t_alloc) g_free(wnames[0]); } =20 -static void do_unlinkat(QVirtio9P *v9p, const char *atpath, const char *rp= ath, - uint32_t flags) -{ - g_autofree char *name =3D g_strdup(rpath); - uint32_t fid; - P9Req *req; - - fid =3D twalk({ .client =3D v9p, .path =3D atpath }).newfid; - - req =3D v9fs_tunlinkat(v9p, fid, name, flags, 0); - v9fs_req_wait_for_reply(req, NULL); - v9fs_runlinkat(req); -} - static void fs_readdir_split_128(void *obj, void *data, QGuestAllocator *t_alloc) { @@ -556,7 +543,10 @@ static void fs_unlinkat_dir(void *obj, void *data, QGu= estAllocator *t_alloc) /* ... and is actually a directory */ g_assert((st.st_mode & S_IFMT) =3D=3D S_IFDIR); =20 - do_unlinkat(v9p, "/", "02", P9_DOTL_AT_REMOVEDIR); + tunlinkat({ + .client =3D v9p, .atPath =3D "/", .name =3D "02", + .flags =3D P9_DOTL_AT_REMOVEDIR + }); /* directory should be gone now */ g_assert(stat(new_dir, &st) !=3D 0); } @@ -594,7 +584,7 @@ static void fs_unlinkat_file(void *obj, void *data, QGu= estAllocator *t_alloc) /* ... and is a regular file */ g_assert((st.st_mode & S_IFMT) =3D=3D S_IFREG); =20 - do_unlinkat(v9p, "04", "doa_file", 0); + tunlinkat({ .client =3D v9p, .atPath =3D "04", .name =3D "doa_file" }); /* file should be gone now */ g_assert(stat(new_file, &st) !=3D 0); } @@ -643,7 +633,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, }); g_assert(stat(symlink_file, &st) =3D=3D 0); =20 - do_unlinkat(v9p, "06", "symlink_file", 0); + tunlinkat({ .client =3D v9p, .atPath =3D "06", .name =3D "symlink_file= " }); /* symlink should be gone now */ g_assert(stat(symlink_file, &st) !=3D 0); } @@ -696,7 +686,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, }); g_assert(stat(hardlink_file, &st_link) =3D=3D 0); =20 - do_unlinkat(v9p, "08", "hardlink_file", 0); + tunlinkat({ .client =3D v9p, .atPath =3D "08", .name =3D "hardlink_fil= e" }); /* symlink should be gone now */ g_assert(stat(hardlink_file, &st_link) !=3D 0); /* and old file should still exist */ --=20 2.30.2 From nobody Sat May 18 09:22:57 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=quarantine dis=none) header.from=crudebyte.com ARC-Seal: i=1; a=rsa-sha256; t=1666613075; cv=none; d=zohomail.com; s=zohoarc; b=fgSmD3+uP7cv8b1Rk30UEYMc+wawgqvZeL/0t071T1eorhaY2RwVq89nVeuuDLt3Vo8mOX9ptsIhvfO99hXVFIah+LKn/jiQnezIgrsvZgI6e9KgFv8Ys3vCUEM2TqhwYPZtjNWvQ1y+wg9EDAEv0P4eFvrE0SAa34VRcsXypFE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1666613075; h=Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:Message-ID:References:Sender:Subject:To; bh=43qjrEU+qICoG2YcaXEhc530rA2w1ghXNbxEfdS/IhU=; b=CCnZvGChmpp/0WIVgnCLGO1ZrHqYjoVIEW9t+CFksQzyXUnK1AenFFGvcLxoxs1C4vnoI53aCsitXSnSheB0btRyiKoTo6U4RJU1xFs6nPsUlZRS9rC8yDnEONSZ67ScS1aPcxZplYkzMB3sJTGVd6p03F5GwlBm8R3DSR8FZ7I= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=quarantine dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1666613075679611.511275786647; Mon, 24 Oct 2022 05:04:35 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1omvNm-0001Dm-EK; Mon, 24 Oct 2022 07:12:38 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3ce77865bf813f313cf79c00fd951bfc95a50165@lizzy.crudebyte.com>) id 1omvNh-0001Cq-PT for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:37 -0400 Received: from lizzy.crudebyte.com ([91.194.90.13]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from <3ce77865bf813f313cf79c00fd951bfc95a50165@lizzy.crudebyte.com>) id 1omvNg-0007p0-6u for qemu-devel@nongnu.org; Mon, 24 Oct 2022 07:12:33 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=crudebyte.com; s=lizzy; h=Cc:To:Subject:Date:From:References:In-Reply-To: Message-Id:Content-Type:Content-Transfer-Encoding:MIME-Version:Content-ID: Content-Description; bh=43qjrEU+qICoG2YcaXEhc530rA2w1ghXNbxEfdS/IhU=; b=Ml1BT 4F/wMnC4/dmnoyqYMbcrYoA8cKhQmacRnqXlI1WYGK6sqyOObCJpSJv13EaQ03gu7UEA5FR5P6xMu P++wFGofIj8L6g1NxMuEFuyhEKlIPBh/dOy67Ef+4Dc4gcN/zKHRMB/AWcfaGU3NqdLW5yCd6u8Yn qIJdJrH84yNDRrdfaRKsAof31zMXXMuUwyhTXp864eg/ht/RZJErBI9WtCxXh0pzEW/U8H22Rlym6 n8O/TmSyLifuT2cw1kyUQEtNVQdhCxui9G7nn6sGLgD6R85eVr5fIh1+s305qSJ9U5OGKtxm3y5Ec dAcrrO2bcV9JLByu0eV9NM4WcCYlQ==; Message-Id: <3ce77865bf813f313cf79c00fd951bfc95a50165.1666608862.git.qemu_oss@crudebyte.com> In-Reply-To: References: From: Christian Schoenebeck Date: Mon, 24 Oct 2022 12:54:23 +0200 Subject: [PULL 23/23] tests/9p: remove unnecessary g_strdup() calls To: qemu-devel@nongnu.org, Stefan Hajnoczi Cc: Greg Kurz Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: none client-ip=91.194.90.13; envelope-from=3ce77865bf813f313cf79c00fd951bfc95a50165@lizzy.crudebyte.com; helo=lizzy.crudebyte.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, SPF_HELO_NONE=0.001, SPF_NONE=0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Qemu-devel" Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @crudebyte.com) X-ZM-MESSAGEID: 1666613077597100001 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" This is a leftover from before the recent function merge and refactoring patches: As these functions do not return control to the caller in between, it is not necessary to duplicate strings passed to them. Signed-off-by: Christian Schoenebeck Message-Id: <0f80141cde3904ed0591354059da49d1d60bcdbc.1664917004.git.qemu_o= ss@crudebyte.com> --- tests/qtest/libqos/virtio-9p-client.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/tests/qtest/libqos/virtio-9p-client.c b/tests/qtest/libqos/vir= tio-9p-client.c index e017e030ec..e4a368e036 100644 --- a/tests/qtest/libqos/virtio-9p-client.c +++ b/tests/qtest/libqos/virtio-9p-client.c @@ -770,7 +770,6 @@ TMkdirRes v9fs_tmkdir(TMkdirOpt opt) { P9Req *req; uint32_t err; - g_autofree char *name =3D g_strdup(opt.name); =20 g_assert(opt.client); /* expecting either hi-level atPath or low-level dfid, but not both */ @@ -788,14 +787,14 @@ TMkdirRes v9fs_tmkdir(TMkdirOpt opt) } =20 uint32_t body_size =3D 4 + 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); + uint16_t string_size =3D v9fs_string_size(opt.name); =20 g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 req =3D v9fs_req_init(opt.client, body_size, P9_TMKDIR, opt.tag); v9fs_uint32_write(req, opt.dfid); - v9fs_string_write(req, name); + v9fs_string_write(req, opt.name); v9fs_uint32_write(req, opt.mode); v9fs_uint32_write(req, opt.gid); v9fs_req_send(req); @@ -831,7 +830,6 @@ TlcreateRes v9fs_tlcreate(TlcreateOpt opt) { P9Req *req; uint32_t err; - g_autofree char *name =3D g_strdup(opt.name); =20 g_assert(opt.client); /* expecting either hi-level atPath or low-level fid, but not both */ @@ -849,14 +847,14 @@ TlcreateRes v9fs_tlcreate(TlcreateOpt opt) } =20 uint32_t body_size =3D 4 + 4 + 4 + 4; - uint16_t string_size =3D v9fs_string_size(name); + uint16_t string_size =3D v9fs_string_size(opt.name); =20 g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 req =3D v9fs_req_init(opt.client, body_size, P9_TLCREATE, opt.tag); v9fs_uint32_write(req, opt.fid); - v9fs_string_write(req, name); + v9fs_string_write(req, opt.name); v9fs_uint32_write(req, opt.flags); v9fs_uint32_write(req, opt.mode); v9fs_uint32_write(req, opt.gid); @@ -896,8 +894,6 @@ TsymlinkRes v9fs_tsymlink(TsymlinkOpt opt) { P9Req *req; uint32_t err; - g_autofree char *name =3D g_strdup(opt.name); - g_autofree char *symtgt =3D g_strdup(opt.symtgt); =20 g_assert(opt.client); /* expecting either hi-level atPath or low-level fid, but not both */ @@ -911,15 +907,16 @@ TsymlinkRes v9fs_tsymlink(TsymlinkOpt opt) } =20 uint32_t body_size =3D 4 + 4; - uint16_t string_size =3D v9fs_string_size(name) + v9fs_string_size(sym= tgt); + uint16_t string_size =3D v9fs_string_size(opt.name) + + v9fs_string_size(opt.symtgt); =20 g_assert_cmpint(body_size, <=3D, UINT32_MAX - string_size); body_size +=3D string_size; =20 req =3D v9fs_req_init(opt.client, body_size, P9_TSYMLINK, opt.tag); v9fs_uint32_write(req, opt.fid); - v9fs_string_write(req, name); - v9fs_string_write(req, symtgt); + v9fs_string_write(req, opt.name); + v9fs_string_write(req, opt.symtgt); v9fs_uint32_write(req, opt.gid); v9fs_req_send(req); =20 --=20 2.30.2