From nobody Sat May 18 06:04:19 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=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1678444401; cv=none; d=zohomail.com; s=zohoarc; b=MTyx2BDqRtw1mTG6EXAt6hIrXuB3kF2SceOIteNpcBsDE6aywRskyZI+sGscLjpUP7PGQdmswQqNOtPq43krYoa63rz2iMojrkuX1HVd8gqYIVLAdH+LwazZJPwuHu8yO+/UjeZggjPXLjL7hHPHWTE1xD7iSOyUwFF2ZklFBiw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1678444401; h=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=eASBV6a+3xRzDIo6K77PaLzMarbUsFxFX0l3oKWpYhc=; b=RmK+LDh02MzTV5MKkhObLbtDjSggZi90ppomE5Gh1ancxv3wyRexGJYkEm5KdwUrITF9O9PfR20Cp7oSf7FrPEYRVpjoqDd5MX8zPcgyQYatcjdrdVZ2sEoXoqu3HbwLlTdwZIvh0WnQLX+2C+4Mfq+yu+BXlohkxDXRzuBVSns= 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=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1678444401898385.02961195871194; Fri, 10 Mar 2023 02:33:21 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1paa1z-0007RW-84; Fri, 10 Mar 2023 05:31:23 -0500 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 1paa1x-0007Qq-7z; Fri, 10 Mar 2023 05:31:21 -0500 Received: from mail-pl1-x62b.google.com ([2607:f8b0:4864:20::62b]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1paa1u-0004Dm-Te; Fri, 10 Mar 2023 05:31:20 -0500 Received: by mail-pl1-x62b.google.com with SMTP id x11so5053951pln.12; Fri, 10 Mar 2023 02:31:18 -0800 (PST) Received: from fedlinux.. ([106.84.129.9]) by smtp.gmail.com with ESMTPSA id ke15-20020a170903340f00b0019a96d3b456sm1146930plb.44.2023.03.10.02.31.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Mar 2023 02:31:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1678444277; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=eASBV6a+3xRzDIo6K77PaLzMarbUsFxFX0l3oKWpYhc=; b=TU91raMGn/lL2L8KWwZBxHogS/Cs505iapKuhwo+Wqb39hv+z6INxuPBG6oPxTsDgi M4lYz21ESg0cYoN/RZYDx8+vK8H9irboWv56wyzSArd3BUPJ7sxfVnK+WEPTBEeHZVLr 3v8EecaJC3aFMmUmcgNYNO963unn0ZJjPv9mG8Q9qZibZALOL4h45fL65RLX3MYHPxUj dGJH3y8J3G+CaUripXGtqdnrgWNoQv50q3An/QiqajgMFhM1DS4+o3u9vLy/Ukuce9W9 Fxd0CcwD+7uIegu+vAPEfaDDY48acpKtQUIl15+c6cYZUCt5g/KABT+h91gII27UAlXH DVLw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678444277; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=eASBV6a+3xRzDIo6K77PaLzMarbUsFxFX0l3oKWpYhc=; b=pTt6kYPt11qyEtJkr0keKFox3z+H9R3/qO940aVM3kD+FMburK/wlCvKxr8XcxTdqI pELZYZ3epdYegssnYED+bZdxRzH0RlllM5khkQJxWu6s1eZMFXMhNB/CAzGMdIwSUs01 GJFWdQWWlxAuQe+9hu7LFqN7DRvw4qsVNbsk0HAhJNrrTB7xfy5W2er2pNv4THp2RYzY 5kfxUZtErKn7w9fLHyd2DyY9kOvjjJEbs6+wCSxCrtUrf7egsWiYkvydGi8zzcFnUJAV bhiwdLJfF+52UT4om/WkuClOL+Ks4hs2EPmR2v9eYoiyL7/sLiiXhUYR3yMHuzUV9reI FHLg== X-Gm-Message-State: AO0yUKVcIPNKcjV8fo//Ud+4zykDrr5sTjkaNw+fZwWJtoMwORL3nSu3 seFnt0PI+uv2k5liQaj+qZsEktRFMCrvvGaym+A= X-Google-Smtp-Source: AK7set+cWk9Brsa9xAhZ6VBvdm49lky/WEYcvfdVL6O/NPm+39A/e/guus5tuyVFIef4hF70SZBkpQ== X-Received: by 2002:a17:902:f552:b0:19e:6966:cddc with SMTP id h18-20020a170902f55200b0019e6966cddcmr5401666plf.1.1678444276498; Fri, 10 Mar 2023 02:31:16 -0800 (PST) From: Sam Li To: qemu-devel@nongnu.org Cc: Kevin Wolf , Fam Zheng , dmitry.fomichev@wdc.com, qemu-block@nongnu.org, stefanha@redhat.com, hare@suse.de, Julia Suvorova , Stefano Garzarella , Hanna Reitz , damien.lemoal@opensource.wdc.com, Aarushi Mehta , Sam Li Subject: [PATCH v6 1/4] file-posix: add tracking of the zone write pointers Date: Fri, 10 Mar 2023 18:31:03 +0800 Message-Id: <20230310103106.62124-2-faithilikerun@gmail.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230310103106.62124-1-faithilikerun@gmail.com> References: <20230310103106.62124-1-faithilikerun@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable 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: pass client-ip=2607:f8b0:4864:20::62b; envelope-from=faithilikerun@gmail.com; helo=mail-pl1-x62b.google.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, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-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: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1678444402148100001 Content-Type: text/plain; charset="utf-8" Since Linux doesn't have a user API to issue zone append operations to zoned devices from user space, the file-posix driver is modified to add zone append emulation using regular writes. To do this, the file-posix driver tracks the wp location of all zones of the device. It uses an array of uint64_t. The most significant bit of each wp location indicates if the zone type is conventional zones. The zones wp can be changed due to the following operations issued: - zone reset: change the wp to the start offset of that zone - zone finish: change to the end location of that zone - write to a zone - zone append Signed-off-by: Sam Li --- block/file-posix.c | 159 ++++++++++++++++++++++++++++++- include/block/block-common.h | 14 +++ include/block/block_int-common.h | 3 + 3 files changed, 172 insertions(+), 4 deletions(-) diff --git a/block/file-posix.c b/block/file-posix.c index 563acc76ae..61ed769ac8 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -1324,6 +1324,77 @@ static int hdev_get_max_segments(int fd, struct stat= *st) #endif } =20 +#if defined(CONFIG_BLKZONED) +static int get_zones_wp(int fd, BlockZoneWps *wps, int64_t offset, + unsigned int nrz) { + struct blk_zone *blkz; + size_t rep_size; + uint64_t sector =3D offset >> BDRV_SECTOR_BITS; + int ret, n =3D 0, i =3D 0; + rep_size =3D sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_= zone); + g_autofree struct blk_zone_report *rep =3D NULL; + + rep =3D g_malloc(rep_size); + blkz =3D (struct blk_zone *)(rep + 1); + while (n < nrz) { + memset(rep, 0, rep_size); + rep->sector =3D sector; + rep->nr_zones =3D nrz - n; + + do { + ret =3D ioctl(fd, BLKREPORTZONE, rep); + } while (ret !=3D 0 && errno =3D=3D EINTR); + if (ret !=3D 0) { + error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d= ", + fd, offset, errno); + return -errno; + } + + if (!rep->nr_zones) { + break; + } + + for (i =3D 0; i < rep->nr_zones; i++, n++) { + /* + * The wp tracking cares only about sequential writes required= and + * sequential write preferred zones so that the wp can advance= to + * the right location. + * Use the most significant bit of the wp location to indicate= the + * zone type: 0 for SWR/SWP zones and 1 for conventional zones. + */ + if (blkz[i].type =3D=3D BLK_ZONE_TYPE_CONVENTIONAL) { + wps->wp[i] =3D 1ULL << 63; + } else { + switch(blkz[i].cond) { + case BLK_ZONE_COND_FULL: + case BLK_ZONE_COND_READONLY: + /* Zone not writable */ + wps->wp[i] =3D (blkz[i].start + blkz[i].len) << BDRV_S= ECTOR_BITS; + break; + case BLK_ZONE_COND_OFFLINE: + /* Zone not writable nor readable */ + wps->wp[i] =3D (blkz[i].start) << BDRV_SECTOR_BITS; + break; + default: + wps->wp[i] =3D blkz[i].wp << BDRV_SECTOR_BITS; + break; + } + } + } + sector =3D blkz[i - 1].start + blkz[i - 1].len; + } + + return 0; +} + +static void update_zones_wp(int fd, BlockZoneWps *wps, int64_t offset, + unsigned int nrz) { + if (get_zones_wp(fd, wps, offset, nrz) < 0) { + error_report("update zone wp failed"); + } +} +#endif + static void raw_refresh_limits(BlockDriverState *bs, Error **errp) { BDRVRawState *s =3D bs->opaque; @@ -1413,6 +1484,21 @@ static void raw_refresh_limits(BlockDriverState *bs,= Error **errp) if (ret >=3D 0) { bs->bl.max_active_zones =3D ret; } + + ret =3D get_sysfs_long_val(&st, "physical_block_size"); + if (ret >=3D 0) { + bs->bl.write_granularity =3D ret; + } + + bs->bl.wps =3D g_malloc(sizeof(BlockZoneWps) + + sizeof(int64_t) * bs->bl.nr_zones); + ret =3D get_zones_wp(s->fd, bs->bl.wps, 0, bs->bl.nr_zones); + if (ret < 0) { + error_setg_errno(errp, -ret, "report wps failed"); + g_free(bs->bl.wps); + return; + } + qemu_co_mutex_init(&bs->bl.wps->colock); return; } out: @@ -2338,9 +2424,15 @@ static int coroutine_fn raw_co_prw(BlockDriverState = *bs, uint64_t offset, { BDRVRawState *s =3D bs->opaque; RawPosixAIOData acb; + int ret; =20 if (fd_open(bs) < 0) return -EIO; +#if defined(CONFIG_BLKZONED) + if (bs->bl.wps) { + qemu_co_mutex_lock(&bs->bl.wps->colock); + } +#endif =20 /* * When using O_DIRECT, the request must be aligned to be able to use @@ -2354,14 +2446,16 @@ static int coroutine_fn raw_co_prw(BlockDriverState= *bs, uint64_t offset, } else if (s->use_linux_io_uring) { LuringState *aio =3D aio_get_linux_io_uring(bdrv_get_aio_context(b= s)); assert(qiov->size =3D=3D bytes); - return luring_co_submit(bs, aio, s->fd, offset, qiov, type); + ret =3D luring_co_submit(bs, aio, s->fd, offset, qiov, type); + goto out; #endif #ifdef CONFIG_LINUX_AIO } else if (s->use_linux_aio) { LinuxAioState *aio =3D aio_get_linux_aio(bdrv_get_aio_context(bs)); assert(qiov->size =3D=3D bytes); - return laio_co_submit(bs, aio, s->fd, offset, qiov, type, + ret =3D laio_co_submit(bs, aio, s->fd, offset, qiov, type, s->aio_max_batch); + goto out; #endif } =20 @@ -2378,7 +2472,32 @@ static int coroutine_fn raw_co_prw(BlockDriverState = *bs, uint64_t offset, }; =20 assert(qiov->size =3D=3D bytes); - return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb); + ret =3D raw_thread_pool_submit(bs, handle_aiocb_rw, &acb); + +out: +#if defined(CONFIG_BLKZONED) + BlockZoneWps *wps =3D bs->bl.wps; + if (ret =3D=3D 0) { + if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) { + int index =3D offset / bs->bl.zone_size; + if (!BDRV_ZT_IS_CONV(wps->wp[index])) { + /* Advance the wp if needed */ + if (offset + bytes > wps->wp[index]) { + wps->wp[index] =3D offset + bytes; + } + } + } + } else { + if (type & QEMU_AIO_WRITE) { + update_zones_wp(s->fd, bs->bl.wps, 0, 1); + } + } + + if (wps) { + qemu_co_mutex_unlock(&wps->colock); + } +#endif + return ret; } =20 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset, @@ -2486,6 +2605,11 @@ static void raw_close(BlockDriverState *bs) BDRVRawState *s =3D bs->opaque; =20 if (s->fd >=3D 0) { +#if defined(CONFIG_BLKZONED) + if (bs->bl.wps) { + g_free(bs->bl.wps); + } +#endif qemu_close(s->fd); s->fd =3D -1; } @@ -3285,6 +3409,7 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverS= tate *bs, BlockZoneOp op, const char *op_name; unsigned long zo; int ret; + BlockZoneWps *wps =3D bs->bl.wps; int64_t capacity =3D bs->total_sectors << BDRV_SECTOR_BITS; =20 zone_size =3D bs->bl.zone_size; @@ -3302,6 +3427,14 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriver= State *bs, BlockZoneOp op, return -EINVAL; } =20 + qemu_co_mutex_lock(&wps->colock); + uint32_t index =3D offset / bs->bl.zone_size; + if (BDRV_ZT_IS_CONV(wps->wp[index]) && len !=3D capacity) { + error_report("zone mgmt operations are not allowed for conventiona= l zones"); + ret =3D -EIO; + goto out; + } + switch (op) { case BLK_ZO_OPEN: op_name =3D "BLKOPENZONE"; @@ -3321,7 +3454,8 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverS= tate *bs, BlockZoneOp op, break; default: error_report("Unsupported zone op: 0x%x", op); - return -ENOTSUP; + ret =3D -ENOTSUP; + goto out; } =20 acb =3D (RawPosixAIOData) { @@ -3339,10 +3473,27 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDrive= rState *bs, BlockZoneOp op, len >> BDRV_SECTOR_BITS); ret =3D raw_thread_pool_submit(bs, handle_aiocb_zone_mgmt, &acb); if (ret !=3D 0) { + update_zones_wp(s->fd, wps, offset, index); ret =3D -errno; error_report("ioctl %s failed %d", op_name, ret); + goto out; } =20 + if (zo =3D=3D BLKRESETZONE && len =3D=3D capacity) { + for (int i =3D 0; i < bs->bl.nr_zones; ++i) { + if (!BDRV_ZT_IS_CONV(wps->wp[i])) { + wps->wp[i] =3D i * bs->bl.zone_size; + } + } + } else if (zo =3D=3D BLKRESETZONE) { + wps->wp[index] =3D offset; + } else if (zo =3D=3D BLKFINISHZONE) { + /* The zoned device allows the last zone smaller that the zone siz= e. */ + wps->wp[index] =3D offset + len; + } + +out: + qemu_co_mutex_unlock(&wps->colock); return ret; } #endif diff --git a/include/block/block-common.h b/include/block/block-common.h index 1576fcf2ed..93196229ac 100644 --- a/include/block/block-common.h +++ b/include/block/block-common.h @@ -118,6 +118,14 @@ typedef struct BlockZoneDescriptor { BlockZoneState state; } BlockZoneDescriptor; =20 +/* + * Track write pointers of a zone in bytes. + */ +typedef struct BlockZoneWps { + CoMutex colock; + uint64_t wp[]; +} BlockZoneWps; + typedef struct BlockDriverInfo { /* in bytes, 0 if irrelevant */ int cluster_size; @@ -240,6 +248,12 @@ typedef enum { #define BDRV_SECTOR_BITS 9 #define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS) =20 +/* + * Get the first most significant bit of wp. If it is zero, then + * the zone type is SWR. + */ +#define BDRV_ZT_IS_CONV(wp) (wp & (1ULL << 63)) + #define BDRV_REQUEST_MAX_SECTORS MIN_CONST(SIZE_MAX >> BDRV_SECTOR_BITS, \ INT_MAX >> BDRV_SECTOR_BITS) #define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BI= TS) diff --git a/include/block/block_int-common.h b/include/block/block_int-com= mon.h index 1bd2aef4d5..19915b34af 100644 --- a/include/block/block_int-common.h +++ b/include/block/block_int-common.h @@ -884,6 +884,9 @@ typedef struct BlockLimits { =20 /* maximum number of active zones */ int64_t max_active_zones; + + /* array of write pointers' location of each zone in the zoned device.= */ + BlockZoneWps *wps; } BlockLimits; =20 typedef struct BdrvOpBlocker BdrvOpBlocker; --=20 2.39.2 From nobody Sat May 18 06:04:19 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=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1678444343; cv=none; d=zohomail.com; s=zohoarc; b=GylNE4UOB0M7p3j0Lvh9EuDIpzI6A2gXRlY3CgyP7D3cxx/o1Xssp4XBiKqrX4oC2W6fPjdGojKJ11qRqQ/pK9vFgSKr3usSt4gIaU3o+f5ehH0M6Z57JDNtklb/iDF5cNQSuqFP0iQhulh45HG7xMth2AuW2QxHrunf5Xl11D8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1678444343; h=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=3xjDyjJXzs2ujjd4nx+Q5VSThiBaKtTcVQ6pi070eQ0=; b=G2jJqI1Velusl8PjNBcLVmqbmM0nD5f9jV8z2Ziquwhrkdj+lfGUiBBxoJTiVuBFnnGit0m1asikuwpdk7ZKYBWIGie67g/xtAjHfzpJlPWhmvi+bl9PhPDwcDlbfwelUvzZc4jO5XguNx7bOAxZeNz//rim+utxRJWNLXR//Qk= 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=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 16784443438871002.6072391217588; Fri, 10 Mar 2023 02:32:23 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1paa23-0007S3-0V; Fri, 10 Mar 2023 05:31:27 -0500 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 1paa20-0007Rd-R4; Fri, 10 Mar 2023 05:31:25 -0500 Received: from mail-pl1-x62b.google.com ([2607:f8b0:4864:20::62b]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1paa1y-0004Dm-Fm; Fri, 10 Mar 2023 05:31:24 -0500 Received: by mail-pl1-x62b.google.com with SMTP id x11so5054111pln.12; Fri, 10 Mar 2023 02:31:21 -0800 (PST) Received: from fedlinux.. ([106.84.129.9]) by smtp.gmail.com with ESMTPSA id ke15-20020a170903340f00b0019a96d3b456sm1146930plb.44.2023.03.10.02.31.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Mar 2023 02:31:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1678444281; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=3xjDyjJXzs2ujjd4nx+Q5VSThiBaKtTcVQ6pi070eQ0=; b=k4YwU/FfwqrRtKcXFYHtL5fmpjDVVHK+x0UJVJ5icrFJAenVkyys58eGkSM7g28dEH 63UDoyx2qcCMNfnzVWcsmZMvvOYWWqY0365aHDzR0ykNZ4c9GOl0nSDTyGSPpE7+M9rb ytp3xgbybmLIL8qiK43b2KAVzsFH5e4pYmSfp8NtPphdiIYnoISDyWX3agXAsTu8qxqk Vhnl0rM6tbukqi3HiU75vVd0O0NVNePlrHQC9QLEeh7EadOtxbmRT6xTi7cObe7fp5zT ns2QCTHSVDcJ7QOz6zL1190u4ucbCB2pvxANmSZxbLexENWaIKbWg1cYotZIgjDAPaxK K/Kw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678444281; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=3xjDyjJXzs2ujjd4nx+Q5VSThiBaKtTcVQ6pi070eQ0=; b=pZHib0R83XuzErXYJEus/y/rH3fwLa0I2gSeGsojoJTyiktw+oLWosdscGun4i+yUf oZaLXiDPTQyis9P2RDoSE7f7cmoac6O/MCUrjWf+j/rnskOKyppFCLLHcwenGfTCpQx3 0VIwz/cpA06UNHgHlKvXZ1OIDYZ8RD7VBbWZrcwBoJmjVS+mhFEgQBYRG0m2gCCrCIPw JRLvrR3Jhl2QErAiq1WZpd41n2FOIz5fCzyYnRNi6aVgdJLNfcxTp9esT1Z3LrW2S+cJ yKNMLfVQgUIWE748VoQrdw69Uw/Sth/PALoJN91rgSESVLKbaoZuN37V8r2I0TRjCU2Y nwDQ== X-Gm-Message-State: AO0yUKVDEcGc29B8fV/j4KCEzw7FgfcWAXguMceD8up99oHlpfdzPEip XvEAHGgUGEX7Z0YNxbJIMaK1sH4eONj+tdV7AUY= X-Google-Smtp-Source: AK7set/CN0DFTs1SUMw/AYe0u2wCkb4aHHqybmOj+eLpk+6Oo87c3QYy97NA8eFash1xNpZ5gTwTbA== X-Received: by 2002:a17:902:dace:b0:19a:abb0:1e with SMTP id q14-20020a170902dace00b0019aabb0001emr29589277plx.38.1678444280594; Fri, 10 Mar 2023 02:31:20 -0800 (PST) From: Sam Li To: qemu-devel@nongnu.org Cc: Kevin Wolf , Fam Zheng , dmitry.fomichev@wdc.com, qemu-block@nongnu.org, stefanha@redhat.com, hare@suse.de, Julia Suvorova , Stefano Garzarella , Hanna Reitz , damien.lemoal@opensource.wdc.com, Aarushi Mehta , Sam Li Subject: [PATCH v6 2/4] block: introduce zone append write for zoned devices Date: Fri, 10 Mar 2023 18:31:04 +0800 Message-Id: <20230310103106.62124-3-faithilikerun@gmail.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230310103106.62124-1-faithilikerun@gmail.com> References: <20230310103106.62124-1-faithilikerun@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable 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: pass client-ip=2607:f8b0:4864:20::62b; envelope-from=faithilikerun@gmail.com; helo=mail-pl1-x62b.google.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, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-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: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1678444345107100001 Content-Type: text/plain; charset="utf-8" A zone append command is a write operation that specifies the first logical block of a zone as the write position. When writing to a zoned block device using zone append, the byte offset of writes is pointing to the write pointer of that zone. Upon completion the device will respond with the position the data has been written in the zone. Signed-off-by: Sam Li Reviewed-by: Dmitry Fomichev --- block/block-backend.c | 60 +++++++++++++++++++++++++++++++ block/file-posix.c | 54 +++++++++++++++++++++++++--- block/io.c | 21 +++++++++++ block/io_uring.c | 4 +++ block/linux-aio.c | 3 ++ block/raw-format.c | 8 +++++ include/block/block-io.h | 4 +++ include/block/block_int-common.h | 5 +++ include/block/raw-aio.h | 4 ++- include/sysemu/block-backend-io.h | 9 +++++ 10 files changed, 166 insertions(+), 6 deletions(-) diff --git a/block/block-backend.c b/block/block-backend.c index f70b08e3f6..28e8f5d778 100644 --- a/block/block-backend.c +++ b/block/block-backend.c @@ -1888,6 +1888,45 @@ BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, Blo= ckZoneOp op, return &acb->common; } =20 +static void coroutine_fn blk_aio_zone_append_entry(void *opaque) +{ + BlkAioEmAIOCB *acb =3D opaque; + BlkRwCo *rwco =3D &acb->rwco; + + rwco->ret =3D blk_co_zone_append(rwco->blk, &acb->bytes, + rwco->iobuf, rwco->flags); + blk_aio_complete(acb); +} + +BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset, + QEMUIOVector *qiov, BdrvRequestFlags flags, + BlockCompletionFunc *cb, void *opaque) { + BlkAioEmAIOCB *acb; + Coroutine *co; + IO_CODE(); + + blk_inc_in_flight(blk); + acb =3D blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque); + acb->rwco =3D (BlkRwCo) { + .blk =3D blk, + .ret =3D NOT_DONE, + .flags =3D flags, + .iobuf =3D qiov, + }; + acb->bytes =3D *offset; + acb->has_returned =3D false; + + co =3D qemu_coroutine_create(blk_aio_zone_append_entry, acb); + aio_co_enter(blk_get_aio_context(blk), co); + acb->has_returned =3D true; + if (acb->rwco.ret !=3D NOT_DONE) { + replay_bh_schedule_oneshot_event(blk_get_aio_context(blk), + blk_aio_complete_bh, acb); + } + + return &acb->common; +} + /* * Send a zone_report command. * offset is a byte offset from the start of the device. No alignment @@ -1939,6 +1978,27 @@ int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk,= BlockZoneOp op, return ret; } =20 +/* + * Send a zone_append command. + */ +int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset, + QEMUIOVector *qiov, BdrvRequestFlags flags) +{ + int ret; + IO_CODE(); + + blk_inc_in_flight(blk); + blk_wait_while_drained(blk); + if (!blk_is_available(blk)) { + blk_dec_in_flight(blk); + return -ENOMEDIUM; + } + + ret =3D bdrv_co_zone_append(blk_bs(blk), offset, qiov, flags); + blk_dec_in_flight(blk); + return ret; +} + void blk_drain(BlockBackend *blk) { BlockDriverState *bs =3D blk_bs(blk); diff --git a/block/file-posix.c b/block/file-posix.c index 61ed769ac8..2ba9174778 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -160,6 +160,7 @@ typedef struct BDRVRawState { bool has_write_zeroes:1; bool use_linux_aio:1; bool use_linux_io_uring:1; + int64_t *offset; /* offset of zone append operation */ int page_cache_inconsistent; /* errno from fdatasync failure */ bool has_fallocate; bool needs_alignment; @@ -1672,7 +1673,7 @@ static ssize_t handle_aiocb_rw_vector(RawPosixAIOData= *aiocb) ssize_t len; =20 len =3D RETRY_ON_EINTR( - (aiocb->aio_type & QEMU_AIO_WRITE) ? + (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) ? qemu_pwritev(aiocb->aio_fildes, aiocb->io.iov, aiocb->io.niov, @@ -1701,7 +1702,7 @@ static ssize_t handle_aiocb_rw_linear(RawPosixAIOData= *aiocb, char *buf) ssize_t len; =20 while (offset < aiocb->aio_nbytes) { - if (aiocb->aio_type & QEMU_AIO_WRITE) { + if (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) { len =3D pwrite(aiocb->aio_fildes, (const char *)buf + offset, aiocb->aio_nbytes - offset, @@ -1794,7 +1795,7 @@ static int handle_aiocb_rw(void *opaque) } =20 nbytes =3D handle_aiocb_rw_linear(aiocb, buf); - if (!(aiocb->aio_type & QEMU_AIO_WRITE)) { + if (!(aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))) { char *p =3D buf; size_t count =3D aiocb->aio_nbytes, copy; int i; @@ -2431,6 +2432,10 @@ static int coroutine_fn raw_co_prw(BlockDriverState = *bs, uint64_t offset, #if defined(CONFIG_BLKZONED) if (bs->bl.wps) { qemu_co_mutex_lock(&bs->bl.wps->colock); + if (type & QEMU_AIO_ZONE_APPEND && bs->bl.zone_size) { + int index =3D offset / bs->bl.zone_size; + offset =3D bs->bl.wps->wp[index]; + } } #endif =20 @@ -2478,9 +2483,13 @@ out: #if defined(CONFIG_BLKZONED) BlockZoneWps *wps =3D bs->bl.wps; if (ret =3D=3D 0) { - if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) { + if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) + && wps && bs->bl.zone_size) { int index =3D offset / bs->bl.zone_size; if (!BDRV_ZT_IS_CONV(wps->wp[index])) { + if (type & QEMU_AIO_ZONE_APPEND) { + *s->offset =3D wps->wp[index]; + } /* Advance the wp if needed */ if (offset + bytes > wps->wp[index]) { wps->wp[index] =3D offset + bytes; @@ -2488,7 +2497,7 @@ out: } } } else { - if (type & QEMU_AIO_WRITE) { + if (type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) { update_zones_wp(s->fd, bs->bl.wps, 0, 1); } } @@ -3498,6 +3507,40 @@ out: } #endif =20 +#if defined(CONFIG_BLKZONED) +static int coroutine_fn raw_co_zone_append(BlockDriverState *bs, + int64_t *offset, + QEMUIOVector *qiov, + BdrvRequestFlags flags) { + assert(flags =3D=3D 0); + int64_t zone_size_mask =3D bs->bl.zone_size - 1; + int64_t iov_len =3D 0; + int64_t len =3D 0; + BDRVRawState *s =3D bs->opaque; + s->offset =3D offset; + + if (*offset & zone_size_mask) { + error_report("sector offset %" PRId64 " is not aligned to zone siz= e " + "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512); + return -EINVAL; + } + + int64_t wg =3D bs->bl.write_granularity; + int64_t wg_mask =3D wg - 1; + for (int i =3D 0; i < qiov->niov; i++) { + iov_len =3D qiov->iov[i].iov_len; + if (iov_len & wg_mask) { + error_report("len of IOVector[%d] %" PRId64 " is not aligned t= o " + "block size %" PRId64 "", i, iov_len, wg); + return -EINVAL; + } + len +=3D iov_len; + } + + return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND); +} +#endif + static coroutine_fn int raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes, bool blkdev) @@ -4259,6 +4302,7 @@ static BlockDriver bdrv_host_device =3D { /* zone management operations */ .bdrv_co_zone_report =3D raw_co_zone_report, .bdrv_co_zone_mgmt =3D raw_co_zone_mgmt, + .bdrv_co_zone_append =3D raw_co_zone_append, #endif }; =20 diff --git a/block/io.c b/block/io.c index 5dbf1e50f2..fe9cabaaf6 100644 --- a/block/io.c +++ b/block/io.c @@ -3152,6 +3152,27 @@ out: return co.ret; } =20 +int coroutine_fn bdrv_co_zone_append(BlockDriverState *bs, int64_t *offset, + QEMUIOVector *qiov, + BdrvRequestFlags flags) +{ + BlockDriver *drv =3D bs->drv; + CoroutineIOCompletion co =3D { + .coroutine =3D qemu_coroutine_self(), + }; + IO_CODE(); + + bdrv_inc_in_flight(bs); + if (!drv || !drv->bdrv_co_zone_append || bs->bl.zoned =3D=3D BLK_Z_NON= E) { + co.ret =3D -ENOTSUP; + goto out; + } + co.ret =3D drv->bdrv_co_zone_append(bs, offset, qiov, flags); +out: + bdrv_dec_in_flight(bs); + return co.ret; +} + void *qemu_blockalign(BlockDriverState *bs, size_t size) { IO_CODE(); diff --git a/block/io_uring.c b/block/io_uring.c index 973e15d876..f7488c241a 100644 --- a/block/io_uring.c +++ b/block/io_uring.c @@ -345,6 +345,10 @@ static int luring_do_submit(int fd, LuringAIOCB *lurin= gcb, LuringState *s, io_uring_prep_writev(sqes, fd, luringcb->qiov->iov, luringcb->qiov->niov, offset); break; + case QEMU_AIO_ZONE_APPEND: + io_uring_prep_writev(sqes, fd, luringcb->qiov->iov, + luringcb->qiov->niov, offset); + break; case QEMU_AIO_READ: io_uring_prep_readv(sqes, fd, luringcb->qiov->iov, luringcb->qiov->niov, offset); diff --git a/block/linux-aio.c b/block/linux-aio.c index d2cfb7f523..1959834156 100644 --- a/block/linux-aio.c +++ b/block/linux-aio.c @@ -389,6 +389,9 @@ static int laio_do_submit(int fd, struct qemu_laiocb *l= aiocb, off_t offset, case QEMU_AIO_WRITE: io_prep_pwritev(iocbs, fd, qiov->iov, qiov->niov, offset); break; + case QEMU_AIO_ZONE_APPEND: + io_prep_pwritev(iocbs, fd, qiov->iov, qiov->niov, offset); + break; case QEMU_AIO_READ: io_prep_preadv(iocbs, fd, qiov->iov, qiov->niov, offset); break; diff --git a/block/raw-format.c b/block/raw-format.c index 72e23e7b55..64e7d48d04 100644 --- a/block/raw-format.c +++ b/block/raw-format.c @@ -332,6 +332,13 @@ raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op, return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len); } =20 +static int coroutine_fn GRAPH_RDLOCK +raw_co_zone_append(BlockDriverState *bs,int64_t *offset, QEMUIOVector *qio= v, + BdrvRequestFlags flags) +{ + return bdrv_co_zone_append(bs->file->bs, offset, qiov, flags); +} + static int64_t coroutine_fn GRAPH_RDLOCK raw_co_getlength(BlockDriverState *bs) { @@ -635,6 +642,7 @@ BlockDriver bdrv_raw =3D { .bdrv_co_pdiscard =3D &raw_co_pdiscard, .bdrv_co_zone_report =3D &raw_co_zone_report, .bdrv_co_zone_mgmt =3D &raw_co_zone_mgmt, + .bdrv_co_zone_append =3D &raw_co_zone_append, .bdrv_co_block_status =3D &raw_co_block_status, .bdrv_co_copy_range_from =3D &raw_co_copy_range_from, .bdrv_co_copy_range_to =3D &raw_co_copy_range_to, diff --git a/include/block/block-io.h b/include/block/block-io.h index 19d1fad9cf..55fca02991 100644 --- a/include/block/block-io.h +++ b/include/block/block-io.h @@ -120,6 +120,10 @@ int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_report(Bloc= kDriverState *bs, int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op, int64_t offset, int64_t le= n); +int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_append(BlockDriverState *bs, + int64_t *offset, + QEMUIOVector *qiov, + BdrvRequestFlags flags); =20 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs); int bdrv_block_status(BlockDriverState *bs, int64_t offset, diff --git a/include/block/block_int-common.h b/include/block/block_int-com= mon.h index 19915b34af..ccd8811919 100644 --- a/include/block/block_int-common.h +++ b/include/block/block_int-common.h @@ -724,6 +724,9 @@ struct BlockDriver { BlockZoneDescriptor *zones); int coroutine_fn (*bdrv_co_zone_mgmt)(BlockDriverState *bs, BlockZoneO= p op, int64_t offset, int64_t len); + int coroutine_fn (*bdrv_co_zone_append)(BlockDriverState *bs, + int64_t *offset, QEMUIOVector *qiov, + BdrvRequestFlags flags); =20 /* removable device specific */ bool coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_is_inserted)( @@ -887,6 +890,8 @@ typedef struct BlockLimits { =20 /* array of write pointers' location of each zone in the zoned device.= */ BlockZoneWps *wps; + + int64_t write_granularity; } BlockLimits; =20 typedef struct BdrvOpBlocker BdrvOpBlocker; diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h index eda6a7a253..fb9c9f5a01 100644 --- a/include/block/raw-aio.h +++ b/include/block/raw-aio.h @@ -30,6 +30,7 @@ #define QEMU_AIO_TRUNCATE 0x0080 #define QEMU_AIO_ZONE_REPORT 0x0100 #define QEMU_AIO_ZONE_MGMT 0x0200 +#define QEMU_AIO_ZONE_APPEND 0x0400 #define QEMU_AIO_TYPE_MASK \ (QEMU_AIO_READ | \ QEMU_AIO_WRITE | \ @@ -40,7 +41,8 @@ QEMU_AIO_COPY_RANGE | \ QEMU_AIO_TRUNCATE | \ QEMU_AIO_ZONE_REPORT | \ - QEMU_AIO_ZONE_MGMT) + QEMU_AIO_ZONE_MGMT | \ + QEMU_AIO_ZONE_APPEND) =20 /* AIO flags */ #define QEMU_AIO_MISALIGNED 0x1000 diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backe= nd-io.h index f575ab5b6b..e716591a1a 100644 --- a/include/sysemu/block-backend-io.h +++ b/include/sysemu/block-backend-io.h @@ -53,6 +53,9 @@ BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_= t offset, BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op, int64_t offset, int64_t len, BlockCompletionFunc *cb, void *opaque); +BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset, + QEMUIOVector *qiov, BdrvRequestFlags flags, + BlockCompletionFunc *cb, void *opaque); BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk, int64_t offset, int64_t by= tes, BlockCompletionFunc *cb, void *opaque); void blk_aio_cancel_async(BlockAIOCB *acb); @@ -201,6 +204,12 @@ int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, B= lockZoneOp op, int64_t offset, int64_t len); int co_wrapper_mixed blk_zone_mgmt(BlockBackend *blk, BlockZoneOp op, int64_t offset, int64_t len); +int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset, + QEMUIOVector *qiov, + BdrvRequestFlags flags); +int co_wrapper_mixed blk_zone_append(BlockBackend *blk, int64_t *offset, + QEMUIOVector *qiov, + BdrvRequestFlags flags); =20 int co_wrapper_mixed blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes); --=20 2.39.2 From nobody Sat May 18 06:04:19 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=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1678444517; cv=none; d=zohomail.com; s=zohoarc; b=DVCqByHKcP9xhUoPsVYshJ9vk9OY20/4MqDhbgQZvvHpJYoxF3DMzKNAUp0UHVuY56zmM2dvxcnX8RJLA105kq2kOj3SGhGJ3zIy1xZ4W+IfJ8KerT1DjHm/Nj/mEaK8sWtUL8BSepJyNnDr7SUZDYcJSpuVH/+XhIdZTASI3sw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1678444517; h=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=VmozOyNwlvVr9QpT2aLte3LztUZpKB3jmOhQWmpI8Qk=; b=CmpilWEX7AXWUECDoL6hbGnm43UK1RW7GXg12hXlj6yDpN+w0cvo4qqpuoATMthxltgg3U2K64ZJDAHQdsgDMXX2SSqDqqyg4vEhEwKZX2838WeH/BSRcXykBZNox4/1VYmc0tEYaWni99gwKdqNFmWczwnTpapLRkWw1lF89so= 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=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 167844451709926.844681144828883; Fri, 10 Mar 2023 02:35:17 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1paa28-0007YR-M6; Fri, 10 Mar 2023 05:31:32 -0500 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 1paa26-0007V7-F3; Fri, 10 Mar 2023 05:31:31 -0500 Received: from mail-pj1-x1030.google.com ([2607:f8b0:4864:20::1030]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1paa23-0004Fm-5P; Fri, 10 Mar 2023 05:31:30 -0500 Received: by mail-pj1-x1030.google.com with SMTP id x34so4943099pjj.0; Fri, 10 Mar 2023 02:31:26 -0800 (PST) Received: from fedlinux.. ([106.84.129.9]) by smtp.gmail.com with ESMTPSA id ke15-20020a170903340f00b0019a96d3b456sm1146930plb.44.2023.03.10.02.31.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Mar 2023 02:31:24 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1678444285; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=VmozOyNwlvVr9QpT2aLte3LztUZpKB3jmOhQWmpI8Qk=; b=eys/4G1dIqBhRO2MlyMngcSvaPkYA4bL0sKxvOiQw7uS43uHJh4vtdU4MLz+nc24st d3/nNHoAR/uBq+HOYwZ6IKC+hWbV801kbnDD/R/Fqmk6/+H4wEx1QO0GoRRl2DRXGpNf XVWGNIVnPE7riAZrikH1tvRURLuADAlW6zPZ5tfxzBdqRC4qbl3/j43KnvfXJvFt/QAr AT/rNfGnYnGmA7/ndG3SzXDu5IL1iSpXZar4pikti1Xno/4DShGY252e+OJ4VLzKrU5c guZVvckjCMF6cntBUOUG6aOwnsn/S7OKT6rG4Wn8dJpYX1KD+DThPehSiyXa5LpJx7yN yOQQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678444285; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=VmozOyNwlvVr9QpT2aLte3LztUZpKB3jmOhQWmpI8Qk=; b=0YNod08GCIqls/sRJ/BcDfghrP1sP9vSEC7Om0aP3jt+vH6TFfFTlz5CYRAiGurevM UNT3e2VBqL6/3mHfuPo7MRKKEcOE7387lfdx8KhTFXHnsOXRpNWrl9dg3FjqI8Ikl4Vm /FCHdwiMwYwpDhRIbW3NNKXLD5D50lj4rxmnuJwMRHzMaCeDweYjIttGqhyUYd24d+mY xSzNIyfQxzZLufWuFUsw/Ly2Yzhz8kGSHlBnMfeYBDfCdLABjmygLgfecDD/BtkrphA5 crzTM2rUa8xGeBuE0VEHronp1hRKVdkEODFR4uh8ZWzAcRU3yL5G3cpVQt5YYPhtiAZW ysWw== X-Gm-Message-State: AO0yUKUqPydUoB0GjSRM4gvrFFdFwz5R1zu9kUHRZVz/sKeOf8vfdg37 2+VJ/6xe4P+fx3HoCjDIeddoqMqqhDB0+GQ4j1A= X-Google-Smtp-Source: AK7set8DwP9MewXwfFlLkSjpzSUQqkWLh+LrhOSb/dNrSk9q1g18qNCDa9/lbTmwemGcBB1DAInpQg== X-Received: by 2002:a17:90b:17c4:b0:234:e0c:caaa with SMTP id me4-20020a17090b17c400b002340e0ccaaamr26061822pjb.6.1678444284786; Fri, 10 Mar 2023 02:31:24 -0800 (PST) From: Sam Li To: qemu-devel@nongnu.org Cc: Kevin Wolf , Fam Zheng , dmitry.fomichev@wdc.com, qemu-block@nongnu.org, stefanha@redhat.com, hare@suse.de, Julia Suvorova , Stefano Garzarella , Hanna Reitz , damien.lemoal@opensource.wdc.com, Aarushi Mehta , Sam Li Subject: [PATCH v6 3/4] qemu-iotests: test zone append operation Date: Fri, 10 Mar 2023 18:31:05 +0800 Message-Id: <20230310103106.62124-4-faithilikerun@gmail.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230310103106.62124-1-faithilikerun@gmail.com> References: <20230310103106.62124-1-faithilikerun@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable 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: pass client-ip=2607:f8b0:4864:20::1030; envelope-from=faithilikerun@gmail.com; helo=mail-pj1-x1030.google.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, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-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: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1678444519153100002 Content-Type: text/plain; charset="utf-8" This tests is mainly a helper to indicate append writes in block layer behaves as expected. Signed-off-by: Sam Li --- qemu-io-cmds.c | 65 ++++++++++++++++++++++++++++++ tests/qemu-iotests/tests/zoned.out | 7 ++++ tests/qemu-iotests/tests/zoned.sh | 9 +++++ 3 files changed, 81 insertions(+) diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c index f35ea627d7..4159f41ab9 100644 --- a/qemu-io-cmds.c +++ b/qemu-io-cmds.c @@ -1874,6 +1874,70 @@ static const cmdinfo_t zone_reset_cmd =3D { .oneline =3D "reset a zone write pointer in zone block device", }; =20 +static int do_aio_zone_append(BlockBackend *blk, QEMUIOVector *qiov, + int64_t *offset, int flags, int *total) +{ + int async_ret =3D NOT_DONE; + + blk_aio_zone_append(blk, offset, qiov, flags, aio_rw_done, &async_ret); + while (async_ret =3D=3D NOT_DONE) { + main_loop_wait(false); + } + + *total =3D qiov->size; + return async_ret < 0 ? async_ret : 1; +} + +static int zone_append_f(BlockBackend *blk, int argc, char **argv) +{ + int ret; + int flags =3D 0; + int total =3D 0; + int64_t offset; + char *buf; + int nr_iov; + int pattern =3D 0xcd; + QEMUIOVector qiov; + + if (optind > argc - 2) { + return -EINVAL; + } + optind++; + offset =3D cvtnum(argv[optind]); + if (offset < 0) { + print_cvtnum_err(offset, argv[optind]); + return offset; + } + optind++; + nr_iov =3D argc - optind; + buf =3D create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern, + flags & BDRV_REQ_REGISTERED_BUF); + if (buf =3D=3D NULL) { + return -EINVAL; + } + ret =3D do_aio_zone_append(blk, &qiov, &offset, flags, &total); + if (ret < 0) { + printf("zone append failed: %s\n", strerror(-ret)); + goto out; + } + +out: + qemu_io_free(blk, buf, qiov.size, + flags & BDRV_REQ_REGISTERED_BUF); + qemu_iovec_destroy(&qiov); + return ret; +} + +static const cmdinfo_t zone_append_cmd =3D { + .name =3D "zone_append", + .altname =3D "zap", + .cfunc =3D zone_append_f, + .argmin =3D 3, + .argmax =3D 3, + .args =3D "offset len [len..]", + .oneline =3D "append write a number of bytes at a specified offset", +}; + static int truncate_f(BlockBackend *blk, int argc, char **argv); static const cmdinfo_t truncate_cmd =3D { .name =3D "truncate", @@ -2672,6 +2736,7 @@ static void __attribute((constructor)) init_qemuio_co= mmands(void) qemuio_add_command(&zone_close_cmd); qemuio_add_command(&zone_finish_cmd); qemuio_add_command(&zone_reset_cmd); + qemuio_add_command(&zone_append_cmd); qemuio_add_command(&truncate_cmd); qemuio_add_command(&length_cmd); qemuio_add_command(&info_cmd); diff --git a/tests/qemu-iotests/tests/zoned.out b/tests/qemu-iotests/tests/= zoned.out index 0c8f96deb9..b3b139b4ec 100644 --- a/tests/qemu-iotests/tests/zoned.out +++ b/tests/qemu-iotests/tests/zoned.out @@ -50,4 +50,11 @@ start: 0x80000, len 0x80000, cap 0x80000, wptr 0x100000,= zcond:14, [type: 2] (5) resetting the second zone After resetting a zone: start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2] + + +(6) append write +After appending the first zone: +start: 0x0, len 0x80000, cap 0x80000, wptr 0x18, zcond:2, [type: 2] +After appending the second zone: +start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80018, zcond:2, [type: 2] *** done diff --git a/tests/qemu-iotests/tests/zoned.sh b/tests/qemu-iotests/tests/z= oned.sh index 9d7c15dde6..6c3ded6c4c 100755 --- a/tests/qemu-iotests/tests/zoned.sh +++ b/tests/qemu-iotests/tests/zoned.sh @@ -79,6 +79,15 @@ echo "(5) resetting the second zone" sudo $QEMU_IO $IMG -c "zrs 268435456 268435456" echo "After resetting a zone:" sudo $QEMU_IO $IMG -c "zrp 268435456 1" +echo +echo +echo "(6) append write" # physical block size of the device is 4096 +sudo $QEMU_IO $IMG -c "zap 0 0x1000 0x2000" +echo "After appending the first zone:" +sudo $QEMU_IO $IMG -c "zrp 0 1" +sudo $QEMU_IO $IMG -c "zap 268435456 0x1000 0x2000" +echo "After appending the second zone:" +sudo $QEMU_IO $IMG -c "zrp 268435456 1" =20 # success, all done echo "*** done" --=20 2.39.2 From nobody Sat May 18 06:04:19 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=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1678444549; cv=none; d=zohomail.com; s=zohoarc; b=ndvXBWex6ybeQcJDfJn1S/Jv+eUjxnVXJs0mTkUUSEVev2CIrA1lnXiUbHUL9QbwxXmp+X5gebECyir0jIDqPbmfTBoZpuTf2QSNaFW2Z6ENbiqfp/YDaLIhrXKNuSmEb9SKsJQAMRq4+LJtItxzKYHuinvMbyyk70saWWVDQDE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1678444549; h=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=Egne3Xn+oSeQ2rsp/8Pj9qHVB+Me/dYC0IpKLswZwnw=; b=n7nfbeCPQpzdvnjUkj6EiTiXZYaVPq0OVIIWNWOOObuChkQsPF8zJqGwcsI8Ci8p1v9EK9fEERMYZ+Iymi1YEpM2TO7tSJGfXm4vqjpkKLUAlZn8sj/nlcrBCDSJMsxa1WiU2ue8Ag247WkGpP2JOTdJxzuqxPIzbZHn3U2qgfw= 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=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1678444549650763.4317531727806; Fri, 10 Mar 2023 02:35:49 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1paa2D-0007fV-Kn; Fri, 10 Mar 2023 05:31:37 -0500 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 1paa2A-0007cV-OC; Fri, 10 Mar 2023 05:31:34 -0500 Received: from mail-pl1-x635.google.com ([2607:f8b0:4864:20::635]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1paa27-0004Io-JC; Fri, 10 Mar 2023 05:31:34 -0500 Received: by mail-pl1-x635.google.com with SMTP id ky4so5102518plb.3; Fri, 10 Mar 2023 02:31:30 -0800 (PST) Received: from fedlinux.. ([106.84.129.9]) by smtp.gmail.com with ESMTPSA id ke15-20020a170903340f00b0019a96d3b456sm1146930plb.44.2023.03.10.02.31.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 10 Mar 2023 02:31:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1678444289; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Egne3Xn+oSeQ2rsp/8Pj9qHVB+Me/dYC0IpKLswZwnw=; b=VlVJQwvRO1blO7ij9D6jLCPzfPO1QFCDuYlDo58FhS8iA2vzyfznlNg6POaEo31SyU EYPORg/sqz1vvypZPErVpJ3pQBqVPk+VHm5HLTEQQpswDwKT0QHAxc8VHoxvDg0jbxqm U3qJRqVqWNIxYUCNj9FFIdI/xl9OeD6+357SuDw/SYzvmwIe3N3J2WvD3jn/CuvUXPyQ EfCCliH2rYouweKmvf2KAZ+ZIHaNvy2vxb7+FoQ17dxgR3xSnSECKG5FqY4m1g4Rbqxn 6IULp1G0TxWf72IRb6Qtn5QU5gSzdiSbH5uO6Y0v/y6/hoTHwjhAxmp/YA81Au2/jWaD zBbA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678444289; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Egne3Xn+oSeQ2rsp/8Pj9qHVB+Me/dYC0IpKLswZwnw=; b=ggtyW2pH9NzrGyGVWUF5H+aOrbMU8lJFwoDm2ibCsRtH/poiAA19P92nJIPXaW4a3w GubjkaSKdUzjEnRdMc7TRPFgabV7arkAXEK7sJAGW2wAayBOSgM4tD3a/nxJmS6J+LZw PisXyDGuYpLSZhACr4041QolR14iQqr+hIBOjiAyvtBe8JVUk1eBvWGkMcOewU/Sr4i4 fEHBcJEEV3byHe55ZuntbxuDTJ1exyUOdDhr+nXvgLVbVCRSfrmXgKrSouLFD5lFASAz SYvfq0xU/5H9Relizx0Y1ReyLbYX06937DvGZq3JNdGLRrHW8AjNoAPxfJNn1FrvO212 7Ktg== X-Gm-Message-State: AO0yUKV35FP+QCR0NJAXKrCoEnOIS7ckF8cx8AcKXuATak1WMDbXqKDM t2dWACbk/EtbYdkWWdZ6kK/euWHj+0jh648CSiI= X-Google-Smtp-Source: AK7set9Mb6LUSdQDnYXt04q6r0gEjFf4U1DtgV4AiECbsrMGDdZiUG4PKfgmTa/uf2vY8n5WJPMO7A== X-Received: by 2002:a17:902:ce92:b0:19e:27a1:dd94 with SMTP id f18-20020a170902ce9200b0019e27a1dd94mr30742102plg.35.1678444288838; Fri, 10 Mar 2023 02:31:28 -0800 (PST) From: Sam Li To: qemu-devel@nongnu.org Cc: Kevin Wolf , Fam Zheng , dmitry.fomichev@wdc.com, qemu-block@nongnu.org, stefanha@redhat.com, hare@suse.de, Julia Suvorova , Stefano Garzarella , Hanna Reitz , damien.lemoal@opensource.wdc.com, Aarushi Mehta , Sam Li Subject: [PATCH v6 4/4] block: add some trace events for zone append Date: Fri, 10 Mar 2023 18:31:06 +0800 Message-Id: <20230310103106.62124-5-faithilikerun@gmail.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230310103106.62124-1-faithilikerun@gmail.com> References: <20230310103106.62124-1-faithilikerun@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable 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: pass client-ip=2607:f8b0:4864:20::635; envelope-from=faithilikerun@gmail.com; helo=mail-pl1-x635.google.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, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-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: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @gmail.com) X-ZM-MESSAGEID: 1678444551250100003 Content-Type: text/plain; charset="utf-8" Signed-off-by: Sam Li Reviewed-by: Dmitry Fomichev --- block/file-posix.c | 3 +++ block/trace-events | 2 ++ 2 files changed, 5 insertions(+) diff --git a/block/file-posix.c b/block/file-posix.c index 2ba9174778..5187f810e5 100644 --- a/block/file-posix.c +++ b/block/file-posix.c @@ -2489,6 +2489,8 @@ out: if (!BDRV_ZT_IS_CONV(wps->wp[index])) { if (type & QEMU_AIO_ZONE_APPEND) { *s->offset =3D wps->wp[index]; + trace_zbd_zone_append_complete(bs, *s->offset + >> BDRV_SECTOR_BITS); } /* Advance the wp if needed */ if (offset + bytes > wps->wp[index]) { @@ -3537,6 +3539,7 @@ static int coroutine_fn raw_co_zone_append(BlockDrive= rState *bs, len +=3D iov_len; } =20 + trace_zbd_zone_append(bs, *offset >> BDRV_SECTOR_BITS); return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND); } #endif diff --git a/block/trace-events b/block/trace-events index 3f4e1d088a..32665158d6 100644 --- a/block/trace-events +++ b/block/trace-events @@ -211,6 +211,8 @@ file_hdev_is_sg(int type, int version) "SG device found= : type=3D%d, version=3D%d" file_flush_fdatasync_failed(int err) "errno %d" zbd_zone_report(void *bs, unsigned int nr_zones, int64_t sector) "bs %p re= port %d zones starting at sector offset 0x%" PRIx64 "" zbd_zone_mgmt(void *bs, const char *op_name, int64_t sector, int64_t len) = "bs %p %s starts at sector offset 0x%" PRIx64 " over a range of 0x%" PRIx64= " sectors" +zbd_zone_append(void *bs, int64_t sector) "bs %p append at sector offset 0= x%" PRIx64 "" +zbd_zone_append_complete(void *bs, int64_t sector) "bs %p returns append s= ector 0x%" PRIx64 "" =20 # ssh.c sftp_error(const char *op, const char *ssh_err, int ssh_err_code, int sftp= _err_code) "%s failed: %s (libssh error code: %d, sftp error code: %d)" --=20 2.39.2