From patchwork Thu Aug 12 07:50:11 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Damien Le Moal X-Patchwork-Id: 12432751 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id F1108C43214 for ; Thu, 12 Aug 2021 07:50:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CCE5B6101E for ; Thu, 12 Aug 2021 07:50:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234826AbhHLHun (ORCPT ); Thu, 12 Aug 2021 03:50:43 -0400 Received: from esa6.hgst.iphmx.com ([216.71.154.45]:51846 "EHLO esa6.hgst.iphmx.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232348AbhHLHun (ORCPT ); Thu, 12 Aug 2021 03:50:43 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1628754619; x=1660290619; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=OaHm0g4Pt7Dgnern0abkbViMMO5KfKOhJvpYT/SNmVk=; b=T6w6cI7mUrVUAeV3vlxhD7Wi4cm32p2C3b/6mbBecUY2h+6WNNbzLSS5 H/TPjiFQTwn852XFxAkLeHPZafNvO0oepesEdlT+9ANP9dkBeNlbE4U09 TRWRIUuAJalmck9oUxdF8zilw0poE1E2kiO+STBHtVG5ADMv1O6ZiZmtg KJpt1mu3wtzhJp4F+HXfUGjreZLJC615TGxpIxbBez7k7oqFib1D9CrQf zAMu7xApDglGPu0mDCxIqTYzhT0UZ+4kUmy+31XZJfRwdkJjBFocn8J8S mznrSdnpCjvrnd/WX+8lLaUokUOD21h+8vCF2e6GSvciD0h+wMy212ajc Q==; X-IronPort-AV: E=Sophos;i="5.84,315,1620662400"; d="scan'208";a="177596933" Received: from uls-op-cesaip02.wdc.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 12 Aug 2021 15:50:19 +0800 IronPort-SDR: Ij36qF9yE8jXU460vT+rPgSIVA8s0cV7ZxtioXEBu+Z9fdaX/eYofklvUcgDK25TtJZXZ1Conw Im7F+j351ML7bQr0IvdeFLSYIcL15+D+PIjWmORWe5iBMITnA91CKEsgGZraafKO2KGuyycI2l c9UrZKo7vPUILzMjs5SJEQKZ5jj3chlIRMxKP/jZz1PJJ4vPF+lDVp4aoWAFRP0dS5EQykpmQj ZW0U010kGurSFjwc8gZ1lQLmqToQwrwzHGwRwuHBi7LmRR6VPYUC0IzMppKLs3SDC9gQAA+/mt zPIByNh2q6YINTG2IqU3BJI4 Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Aug 2021 00:25:47 -0700 IronPort-SDR: ZqKUMYfPgArYz2yrHzvCWLs/n/tInJNUysJkLhRAcIZa63y2kGmJNDyqZidldaCYCuN4ESY76J YW/Es8Ck5wkOgb7p6uWHHF7IMhhAdXI15035cGEo/6lSALjWN5H2D4EpSqlYjpXCjwUowG0TyX q4fdYDhH/B1qd1YoXrYLqO4l/csP/hm7x+xFbddpjYtKFFBqqdI8pYTash2odK90KZORDnH8wV F5+iq93cL0yEcpdkoSTNdwZc88XYcu4ylQISTXZtFDzZPXi1F4s+PLOWS8C2Q8BgBT6V8I2Gh+ pQU= WDCIronportException: Internal Received: from washi.fujisawa.hgst.com ([10.149.53.254]) by uls-op-cesaip02.wdc.com with ESMTP; 12 Aug 2021 00:50:17 -0700 From: Damien Le Moal To: Jens Axboe , linux-block@vger.kernel.org, "Martin K . Petersen" , linux-scsi@vger.kernel.org Subject: [PATCH v5 1/5] block: Add concurrent positioning ranges support Date: Thu, 12 Aug 2021 16:50:11 +0900 Message-Id: <20210812075015.1090959-2-damien.lemoal@wdc.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210812075015.1090959-1-damien.lemoal@wdc.com> References: <20210812075015.1090959-1-damien.lemoal@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org The Concurrent Positioning Ranges VPD page (for SCSI) and Log (for ATA) contain parameters describing the number of sets of contiguous LBAs that can be served independently by a single LUN multi-actuator disk. This patch provides the blk_queue_set_cranges() function allowing a device driver to signal to the block layer that a disk has multiple actuators, each one serving a contiguous range of sectors. To describe the set of sector ranges representing the different actuators of a device, the data type struct blk_cranges is introduced. For a device with multiple actuators, a struct blk_cranges is attached to the device request queue by the disk_set_cranges() function. The function disk_alloc_cranges() is provided for drivers to allocate this structure. The blk_cranges structure contains kobjects (struct kobject) to register with sysfs the set of sector ranges defined by a device. On initial device scan, this registration is done from blk_register_queue() using the block layer internal function disk_register_cranges(). If a driver calls disk_set_cranges() for a registered queue, e.g. when a device is revalidated, disk_set_cranges() will execute disk_register_cranges() to update the queue sysfs attribute files. The sysfs file structure created starts from the cranges sub-directory and contains the start sector and number of sectors served by an actuator, with the information for each actuator grouped in one directory per actuator. E.g. for a dual actuator drive, we have: $ tree /sys/block/sdk/queue/cranges/ /sys/block/sdk/queue/cranges/ |-- 0 | |-- nr_sectors | `-- sector `-- 1 |-- nr_sectors `-- sector For a regular single actuator device, the cranges directory does not exist. Device revalidation may lead to changes to this structure and to the attribute values. When manipulated, the queue sysfs_lock and sysfs_dir_lock are held for atomicity, similarly to how the blk-mq and elevator sysfs queue sub-directories are protected. The code related to the management of cranges is added in the new file block/blk-cranges.c. Signed-off-by: Damien Le Moal --- block/Makefile | 2 +- block/blk-cranges.c | 310 +++++++++++++++++++++++++++++++++++++++++ block/blk-sysfs.c | 26 ++-- block/blk.h | 4 + include/linux/blkdev.h | 29 ++++ 5 files changed, 362 insertions(+), 9 deletions(-) create mode 100644 block/blk-cranges.c diff --git a/block/Makefile b/block/Makefile index 0d951adce796..7b8a2b969537 100644 --- a/block/Makefile +++ b/block/Makefile @@ -9,7 +9,7 @@ obj-$(CONFIG_BLOCK) := bio.o elevator.o blk-core.o blk-sysfs.o \ blk-lib.o blk-mq.o blk-mq-tag.o blk-stat.o \ blk-mq-sysfs.o blk-mq-cpumap.o blk-mq-sched.o ioctl.o \ genhd.o ioprio.o badblocks.o partitions/ blk-rq-qos.o \ - disk-events.o + disk-events.o blk-cranges.o obj-$(CONFIG_BOUNCE) += bounce.o obj-$(CONFIG_BLK_SCSI_REQUEST) += scsi_ioctl.o diff --git a/block/blk-cranges.c b/block/blk-cranges.c new file mode 100644 index 000000000000..9994301414ee --- /dev/null +++ b/block/blk-cranges.c @@ -0,0 +1,310 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Block device concurrent positioning ranges. + * + * Copyright (C) 2021 Western Digital Corporation or its Affiliates. + */ +#include +#include +#include +#include + +#include "blk.h" + +static ssize_t blk_crange_sector_show(struct blk_crange *cr, char *page) +{ + return sprintf(page, "%llu\n", cr->sector); +} + +static ssize_t blk_crange_nr_sectors_show(struct blk_crange *cr, char *page) +{ + return sprintf(page, "%llu\n", cr->nr_sectors); +} + +struct blk_crange_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct blk_crange *cr, char *page); +}; + +static struct blk_crange_sysfs_entry blk_crange_sector_entry = { + .attr = { .name = "sector", .mode = 0444 }, + .show = blk_crange_sector_show, +}; + +static struct blk_crange_sysfs_entry blk_crange_nr_sectors_entry = { + .attr = { .name = "nr_sectors", .mode = 0444 }, + .show = blk_crange_nr_sectors_show, +}; + +static struct attribute *blk_crange_attrs[] = { + &blk_crange_sector_entry.attr, + &blk_crange_nr_sectors_entry.attr, + NULL, +}; +ATTRIBUTE_GROUPS(blk_crange); + +static ssize_t blk_crange_sysfs_show(struct kobject *kobj, + struct attribute *attr, char *page) +{ + struct blk_crange_sysfs_entry *entry = + container_of(attr, struct blk_crange_sysfs_entry, attr); + struct blk_crange *cr = container_of(kobj, struct blk_crange, kobj); + ssize_t ret; + + mutex_lock(&cr->queue->sysfs_lock); + ret = entry->show(cr, page); + mutex_unlock(&cr->queue->sysfs_lock); + + return ret; +} + +static const struct sysfs_ops blk_crange_sysfs_ops = { + .show = blk_crange_sysfs_show, +}; + +/* + * crange entries are not freed individually, but alltogether with the + * struct blk_cranges and its array of range entries. since kobject_add() + * takes a reference on the parent struct blk_cranges kobj, the array of + * crange entries cannot be freed until kobject_del() is called for all entries. + * So we do not need to do anything here, but still need this nop release + * operation to avoid complaints from the kobject code. + */ +static void blk_crange_sysfs_nop_release(struct kobject *kobj) +{ +} + +static struct kobj_type blk_crange_ktype = { + .sysfs_ops = &blk_crange_sysfs_ops, + .default_groups = blk_crange_groups, + .release = blk_crange_sysfs_nop_release, +}; + +/* + * This will be executed only after all range entries are removed + * with kobject_del(), at which point, it is safe to free everything, + * including the array of range entries. + */ +static void blk_cranges_sysfs_release(struct kobject *kobj) +{ + struct blk_cranges *cranges = + container_of(kobj, struct blk_cranges, kobj); + + kfree(cranges); +} + +static struct kobj_type blk_cranges_ktype = { + .release = blk_cranges_sysfs_release, +}; + +/** + * disk_register_cranges - register with sysfs a set of concurrent ranges + * @disk: Target disk + * @new_cranges: New set of concurrent ranges + * + * Register with sysfs a set of concurrent ranges for @disk. If @new_cranges + * is not NULL, this set of concurrent ranges is registered and the + * old set specified by q->cranges is unregistered. Otherwise, q->cranges + * is registered if it is not already. + */ +int disk_register_cranges(struct gendisk *disk, struct blk_cranges *new_cranges) +{ + struct request_queue *q = disk->queue; + struct blk_cranges *cranges; + int i, ret; + + lockdep_assert_held(&q->sysfs_dir_lock); + lockdep_assert_held(&q->sysfs_lock); + + /* If a new range set is specified, unregister the old one */ + if (new_cranges) { + if (q->cranges) + disk_unregister_cranges(disk); + q->cranges = new_cranges; + } + + cranges = q->cranges; + if (!cranges) + return 0; + + /* + * At this point, cranges is the new set of sector ranges that needs + * to be registered with sysfs. + */ + WARN_ON(cranges->sysfs_registered); + ret = kobject_init_and_add(&cranges->kobj, &blk_cranges_ktype, + &q->kobj, "%s", "cranges"); + if (ret) { + q->cranges = NULL; + kfree(cranges); + return ret; + } + + for (i = 0; i < cranges->nr_ranges; i++) { + cranges->ranges[i].queue = q; + ret = kobject_init_and_add(&cranges->ranges[i].kobj, + &blk_crange_ktype, &cranges->kobj, + "%d", i); + if (ret) { + while (--i >= 0) + kobject_del(&cranges->ranges[i].kobj); + kobject_del(&cranges->kobj); + kobject_put(&cranges->kobj); + return ret; + } + } + + cranges->sysfs_registered = true; + + return 0; +} + +void disk_unregister_cranges(struct gendisk *disk) +{ + struct request_queue *q = disk->queue; + struct blk_cranges *cranges = q->cranges; + int i; + + lockdep_assert_held(&q->sysfs_dir_lock); + lockdep_assert_held(&q->sysfs_lock); + + if (!cranges) + return; + + if (cranges->sysfs_registered) { + for (i = 0; i < cranges->nr_ranges; i++) + kobject_del(&cranges->ranges[i].kobj); + kobject_del(&cranges->kobj); + kobject_put(&cranges->kobj); + } else { + kfree(cranges); + } + + q->cranges = NULL; +} + +static bool disk_check_ranges(struct gendisk *disk, struct blk_cranges *cr) +{ + sector_t capacity = get_capacity(disk); + sector_t min_sector = (sector_t)-1; + sector_t max_sector = 0; + int i; + + /* + * Sector ranges may overlap but should overall contain all sectors + * within the disk capacity. + */ + for (i = 0; i < cr->nr_ranges; i++) { + min_sector = min(min_sector, cr->ranges[i].sector); + max_sector = max(max_sector, cr->ranges[i].sector + + cr->ranges[i].nr_sectors); + } + + if (min_sector != 0 || max_sector < capacity) { + pr_warn("Invalid concurrent ranges: missing sectors\n"); + return false; + } + + if (max_sector > capacity) { + pr_warn("Invalid concurrent ranges: beyond capacity\n"); + return false; + } + + return true; +} + +static bool disk_cranges_changed(struct gendisk *disk, struct blk_cranges *new) +{ + struct blk_cranges *old = disk->queue->cranges; + int i; + + if (!old) + return true; + + if (old->nr_ranges != new->nr_ranges) + return true; + + for (i = 0; i < old->nr_ranges; i++) { + if (new->ranges[i].sector != old->ranges[i].sector || + new->ranges[i].nr_sectors != old->ranges[i].nr_sectors) + return true; + } + + return false; +} + +/** + * disk_alloc_cranges - Allocate a concurrent positioning range structure + * @disk: target disk + * @nr_ranges: Number of concurrent ranges + * + * Allocate a struct blk_cranges structure with @nr_ranges range descriptors. + */ +struct blk_cranges *disk_alloc_cranges(struct gendisk *disk, int nr_ranges) +{ + struct blk_cranges *cr; + + cr = kzalloc_node(struct_size(cr, ranges, nr_ranges), GFP_KERNEL, + disk->queue->node); + if (cr) + cr->nr_ranges = nr_ranges; + return cr; +} +EXPORT_SYMBOL_GPL(disk_alloc_cranges); + +/** + * disk_set_cranges - Set a disk concurrent positioning ranges + * @disk: target disk + * @cr: concurrent ranges structure + * + * Set the concurrant positioning ranges information of the request queue + * of @disk to @cr. If @cr is NULL and the concurrent ranges structure + * already set, if any, is cleared. If there are no differences between + * @cr and the concurrent ranges structure already set, @cr is freed. + */ +void disk_set_cranges(struct gendisk *disk, struct blk_cranges *cr) +{ + struct request_queue *q = disk->queue; + + if (WARN_ON_ONCE(cr && !cr->nr_ranges)) { + kfree(cr); + cr = NULL; + } + + mutex_lock(&q->sysfs_dir_lock); + mutex_lock(&q->sysfs_lock); + + if (cr) { + if (!disk_check_ranges(disk, cr)) { + kfree(cr); + cr = NULL; + goto reg; + } + + if (!disk_cranges_changed(disk, cr)) { + kfree(cr); + goto unlock; + } + } + + /* + * This may be called for a registered queue. E.g. during a device + * revalidation. If that is the case, we need to unregister the old + * set of concurrent ranges and register the new set. If the queue + * is not registered, the device request queue registration will + * register the ranges, so only swap in the new set and free the + * old one. + */ +reg: + if (blk_queue_registered(q)) { + disk_register_cranges(disk, cr); + } else { + swap(q->cranges, cr); + kfree(cr); + } + +unlock: + mutex_unlock(&q->sysfs_lock); + mutex_unlock(&q->sysfs_dir_lock); +} +EXPORT_SYMBOL_GPL(disk_set_cranges); diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c index 1832587dce3a..be8e02356a26 100644 --- a/block/blk-sysfs.c +++ b/block/blk-sysfs.c @@ -897,16 +897,15 @@ int blk_register_queue(struct gendisk *disk) } mutex_lock(&q->sysfs_lock); + + ret = disk_register_cranges(disk, NULL); + if (ret) + goto put_dev; + if (q->elevator) { ret = elv_register_queue(q, false); - if (ret) { - mutex_unlock(&q->sysfs_lock); - mutex_unlock(&q->sysfs_dir_lock); - kobject_del(&q->kobj); - blk_trace_remove_sysfs(dev); - kobject_put(&dev->kobj); - return ret; - } + if (ret) + goto put_dev; } blk_queue_flag_set(QUEUE_FLAG_REGISTERED, q); @@ -937,6 +936,16 @@ int blk_register_queue(struct gendisk *disk) percpu_ref_switch_to_percpu(&q->q_usage_counter); } + return ret; + +put_dev: + disk_unregister_cranges(disk); + mutex_unlock(&q->sysfs_lock); + mutex_unlock(&q->sysfs_dir_lock); + kobject_del(&q->kobj); + blk_trace_remove_sysfs(dev); + kobject_put(&dev->kobj); + return ret; } EXPORT_SYMBOL_GPL(blk_register_queue); @@ -983,6 +992,7 @@ void blk_unregister_queue(struct gendisk *disk) mutex_lock(&q->sysfs_lock); if (q->elevator) elv_unregister_queue(q); + disk_unregister_cranges(disk); mutex_unlock(&q->sysfs_lock); mutex_unlock(&q->sysfs_dir_lock); diff --git a/block/blk.h b/block/blk.h index 56f33fbcde59..149cd5ef8eeb 100644 --- a/block/blk.h +++ b/block/blk.h @@ -367,4 +367,8 @@ extern struct device_attribute dev_attr_events; extern struct device_attribute dev_attr_events_async; extern struct device_attribute dev_attr_events_poll_msecs; +int disk_register_cranges(struct gendisk *disk, + struct blk_cranges *new_cranges); +void disk_unregister_cranges(struct gendisk *disk); + #endif /* BLK_INTERNAL_H */ diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index 07eef02325b4..476fc5104a95 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -377,6 +377,29 @@ static inline int blkdev_zone_mgmt_ioctl(struct block_device *bdev, #endif /* CONFIG_BLK_DEV_ZONED */ +/* + * Concurrent sector ranges: struct blk_crange describes range of + * contiguous sectors that can be served by independent resources on the + * device. The set of ranges defined in struct blk_cranges must overall + * include all sectors within the device capacity. + * For a device with multiple ranges, e.g. a single LUN multi-actuator HDD, + * requests targeting sectors in different ranges can be executed in parallel. + * A request can straddle a range boundary. + */ +struct blk_crange { + struct kobject kobj; + struct request_queue *queue; + sector_t sector; + sector_t nr_sectors; +}; + +struct blk_cranges { + struct kobject kobj; + bool sysfs_registered; + unsigned int nr_ranges; + struct blk_crange ranges[]; +}; + struct request_queue { struct request *last_merge; struct elevator_queue *elevator; @@ -567,6 +590,9 @@ struct request_queue { #define BLK_MAX_WRITE_HINTS 5 u64 write_hints[BLK_MAX_WRITE_HINTS]; + + /* Concurrent sector ranges */ + struct blk_cranges *cranges; }; /* Keep blk_queue_flag_name[] in sync with the definitions below */ @@ -1161,6 +1187,9 @@ extern void blk_queue_required_elevator_features(struct request_queue *q, extern bool blk_queue_can_use_dma_map_merging(struct request_queue *q, struct device *dev); +struct blk_cranges *disk_alloc_cranges(struct gendisk *disk, int nr_ranges); +void disk_set_cranges(struct gendisk *disk, struct blk_cranges *cr); + /* * Number of physical segments as sent to the device. * From patchwork Thu Aug 12 07:50:12 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Damien Le Moal X-Patchwork-Id: 12432753 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1B681C04FE3 for ; Thu, 12 Aug 2021 07:50:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EC8ED6101E for ; Thu, 12 Aug 2021 07:50:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234825AbhHLHuo (ORCPT ); Thu, 12 Aug 2021 03:50:44 -0400 Received: from esa6.hgst.iphmx.com ([216.71.154.45]:51846 "EHLO esa6.hgst.iphmx.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234835AbhHLHuo (ORCPT ); Thu, 12 Aug 2021 03:50:44 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1628754620; x=1660290620; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=rhENVR9t5E+3q6WsypqNKv3Sv5M/dUcXWGrLNHz3Cu8=; b=kfTsaG5KGICyY/4D8pxbc+1XLiEs7EldE2v6MVH8ypvb1T5F1aehyBnY PcewsTw6Jivs/zax4q8Dae3wujR6RPfB2mWDwbYySgOZPPYFXSSU/fe7e H6YpuU1geVQY6L8/SWp4SwO7k1SfVR85R+KyCgdAb8D2SyfxvulzfMV+Y VQCzWhbbpkFXjpDprSTLbh+hxpbMDKE47IoLSML/2K34zx0gPQKt74drc X4go7tFaJ0Kg0AWTERiClv7MYmfBUEOxRQb7VW5LOqhf+8+6jlDs6JpYX 9n8U/CHGDI/nhGmbZ94bgXPAivDwoKLrwEgyugHv04BTiS1qFos8hwWFt g==; X-IronPort-AV: E=Sophos;i="5.84,315,1620662400"; d="scan'208";a="177596934" Received: from uls-op-cesaip02.wdc.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 12 Aug 2021 15:50:20 +0800 IronPort-SDR: JLJbVB67WV7LjYoGGN0PlW0gGmrPQSWA/G08R00DNd+CGQ//HGnPS7AwPghX35O7rx8PtKaprY 5qPfG9nZxbxWq0BKryndjGnfU8kj9+kj8M6yjImstT0WPx0V14Q4xB74JiFRVlqjczYY9W6jPe wnyUJm4rwtx6remvGa3CM6Ib2WCJl8CjtoP7wAQBtm3hFVuz8hhw4bTUgsAK7Vtf/rJnz7vEAO GzEIJYPZ7hU/XSwlhfX/Ofc7l9kx5Ddbmu82k+5qsqk/li76MQhpIejr7R4XTC0jcpCK7q6Tan JCqCj96HiH/3mKXOW2vM2LXj Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Aug 2021 00:25:48 -0700 IronPort-SDR: Ybz0OWujfIJQNhJbVM+lyGtpEz7f/pFIoCUo632bOvlpuh6BT5C/3wvfI2N8uxXWKpMQMbU2Fh 5QCi7Z7yLJ8Yq6Sw2Vk269evFF2Sm2Ot7q3XLXiHygEkSRX1g4xKLReoHnFWqPWOgq44ZAdv3J A6Y1vfehxWTwP8UJ8y9AqebyjAXXj2G0w7lvBcQ+eTQXDM6eLJNUGRZ4dDuEL6oy70BI+cQvc7 ChTKp5xAMkQmf4nXm+M4L7gLC0zghbOextktNYpuefvk8pMpSTzIDetdmF4dVWrGHGbDvd55lS q2I= WDCIronportException: Internal Received: from washi.fujisawa.hgst.com ([10.149.53.254]) by uls-op-cesaip02.wdc.com with ESMTP; 12 Aug 2021 00:50:18 -0700 From: Damien Le Moal To: Jens Axboe , linux-block@vger.kernel.org, "Martin K . Petersen" , linux-scsi@vger.kernel.org Subject: [PATCH v5 2/5] scsi: sd: add concurrent positioning ranges support Date: Thu, 12 Aug 2021 16:50:12 +0900 Message-Id: <20210812075015.1090959-3-damien.lemoal@wdc.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210812075015.1090959-1-damien.lemoal@wdc.com> References: <20210812075015.1090959-1-damien.lemoal@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Add the sd_read_cpr() function to the sd scsi disk driver to discover if a device has multiple concurrent positioning ranges (i.e. multiple actuators on an HDD). This new function is called from sd_revalidate_disk() and uses the block layer functions blk_alloc_cranges() and blk_queue_set_cranges() to set a device cranges according to the information retrieved from log page B9h, if the device supports it. The format of the Concurrent Positioning Ranges VPD page B9h is defined in section 6.6.6 of SBC-5. Signed-off-by: Damien Le Moal Reviewed-by: Hannes Reinecke Reviewed-by: Christoph Hellwig --- drivers/scsi/sd.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++ drivers/scsi/sd.h | 1 + 2 files changed, 82 insertions(+) diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index b8d55af763f9..5480d75f4883 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -3125,6 +3125,86 @@ static void sd_read_security(struct scsi_disk *sdkp, unsigned char *buffer) sdkp->security = 1; } +static inline sector_t sd64_to_sectors(struct scsi_disk *sdkp, u8 *buf) +{ + return logical_to_sectors(sdkp->device, get_unaligned_be64(buf)); +} + +/** + * sd_read_cpr - Query concurrent positioning ranges + * @sdkp: disk to query + */ +static void sd_read_cpr(struct scsi_disk *sdkp) +{ + unsigned char *buffer = NULL; + struct blk_cranges *cr = NULL; + unsigned int nr_cpr = 0; + int i, vpd_len, buf_len = SD_BUF_SIZE; + u8 *desc; + + /* + * We need to have the capacity set first for the block layer to be + * able to check the ranges. + */ + if (sdkp->first_scan) + return; + + if (!sdkp->capacity) + goto out; + + /* + * Concurrent Positioning Ranges VPD: there can be at most 256 ranges, + * leading to a maximum page size of 64 + 256*32 bytes. + */ + buf_len = 64 + 256*32; + buffer = kmalloc(buf_len, GFP_KERNEL); + if (!buffer || scsi_get_vpd_page(sdkp->device, 0xb9, buffer, buf_len)) + goto out; + + /* We must have at least a 64B header and one 32B range descriptor */ + vpd_len = get_unaligned_be16(&buffer[2]) + 3; + if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) { + sd_printk(KERN_ERR, sdkp, + "Invalid Concurrent Positioning Ranges VPD page\n"); + goto out; + } + + nr_cpr = (vpd_len - 64) / 32; + if (nr_cpr == 1) { + nr_cpr = 0; + goto out; + } + + cr = disk_alloc_cranges(sdkp->disk, nr_cpr); + if (!cr) { + nr_cpr = 0; + goto out; + } + + desc = &buffer[64]; + for (i = 0; i < nr_cpr; i++, desc += 32) { + if (desc[0] != i) { + sd_printk(KERN_ERR, sdkp, + "Invalid Concurrent Positioning Range number\n"); + nr_cpr = 0; + break; + } + + cr->ranges[i].sector = sd64_to_sectors(sdkp, desc + 8); + cr->ranges[i].nr_sectors = sd64_to_sectors(sdkp, desc + 16); + } + +out: + disk_set_cranges(sdkp->disk, cr); + if (nr_cpr && sdkp->nr_actuators != nr_cpr) { + sd_printk(KERN_NOTICE, sdkp, + "%u concurrent positioning ranges\n", nr_cpr); + sdkp->nr_actuators = nr_cpr; + } + + kfree(buffer); +} + /* * Determine the device's preferred I/O size for reads and writes * unless the reported value is unreasonably small, large, not a @@ -3240,6 +3320,7 @@ static int sd_revalidate_disk(struct gendisk *disk) sd_read_app_tag_own(sdkp, buffer); sd_read_write_same(sdkp, buffer); sd_read_security(sdkp, buffer); + sd_read_cpr(sdkp); } /* diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h index b59136c4125b..2e5932bde43d 100644 --- a/drivers/scsi/sd.h +++ b/drivers/scsi/sd.h @@ -106,6 +106,7 @@ struct scsi_disk { u8 protection_type;/* Data Integrity Field */ u8 provisioning_mode; u8 zeroing_mode; + u8 nr_actuators; /* Number of actuators */ unsigned ATO : 1; /* state of disk ATO bit */ unsigned cache_override : 1; /* temp override of WCE,RCD */ unsigned WCE : 1; /* state of disk WCE bit */ From patchwork Thu Aug 12 07:50:13 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Damien Le Moal X-Patchwork-Id: 12432755 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 24730C432BE for ; Thu, 12 Aug 2021 07:50:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 02BD86101E for ; Thu, 12 Aug 2021 07:50:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234860AbhHLHup (ORCPT ); Thu, 12 Aug 2021 03:50:45 -0400 Received: from esa6.hgst.iphmx.com ([216.71.154.45]:51846 "EHLO esa6.hgst.iphmx.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234835AbhHLHup (ORCPT ); Thu, 12 Aug 2021 03:50:45 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1628754621; x=1660290621; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=Pct8EeEecztMeJWAOQS8KuUpCZvdxSholvmEQ5/zfBM=; b=UeG0GsCb+HHhfIVyfCRghf7pnDeJlyWTiO2ZACAzhFATNW5BHQQxjeCJ F1fQB+cETs7pundjox2KVEdHMuI/MFa4YR5tIuUJc9m/nu3ixK5SX3gdG nPdulztt7kSYEYHx/nif++pdnu65NDWNECOj0Imnzw0G/tsE3jb0QMi+c 5cF05rl+b07yevap1mNGmKRbnA7sKwu/c0o1qebMiTaoMLZniQpNdTT1/ fd52BH1JaBYVDSj4J/KzY8KBsE2DYTlxmkmn6pR+G9S1iCjybLWpg/8UR +9P6eyQmgsd7AKXaNVnORPpH+3/u6gl8EpDv+mFlp32xCw3QPBe96kcEU Q==; X-IronPort-AV: E=Sophos;i="5.84,315,1620662400"; d="scan'208";a="177596936" Received: from uls-op-cesaip02.wdc.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 12 Aug 2021 15:50:21 +0800 IronPort-SDR: q0L6kjlo9RdsWS+rp77jMzT2TvmhbMz0fU5wSxyuMUNKQhEl/N8tRMBeAB8X+pLjY8vQkWBPsI r7hAhJfJayNOW6nmELLRYNsxjgc/C8lrWNIYMhlI443j43LWSoLnKlQ2nf7mLBSrVExZobx1oP 8yHkRIPg3ZBZiFMS5mk3FZ/tv+ajOnIIwJtCVZtxYxZu3SDdlVdrWWc1Fj7hJmhMv5YkgFHxpJ +hQWC1X/5GdjqW+oVsie1Uiejn/LHaFpzCwOKTOJC+m/Dcio8WHJYNywmHhVQt6D2k71IvJPo6 4rmXlAfvgniceaE0GvM3hcUB Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Aug 2021 00:25:49 -0700 IronPort-SDR: HLNs5HCR3LeQ+yTMrakLhNuKolu8rZ9M5TSJmFB7sB0Xn9wPoiACZrKtWPAsXVasprFYoLJ2Fa KkoB3bFoJ33/1n4PRfWjwcPGzDLauVRddw72KdZbT7HjKX2BER/+krc7YW1CtFw4yBC+sKl0ao peFw1Y5SYcqfaaXdQGbek2vAVn+pKXzMZaQAJvW95VKbLndbLI9pfyOhqM/G9Ic8LLDWymKRxC 3PN8IZkICFBVIghtiyQRxR7Q2srWkot/4feKJIGlcBl5snF9CoN00lmFXXH/F8SZWDvEeEnxY9 Va8= WDCIronportException: Internal Received: from washi.fujisawa.hgst.com ([10.149.53.254]) by uls-op-cesaip02.wdc.com with ESMTP; 12 Aug 2021 00:50:19 -0700 From: Damien Le Moal To: Jens Axboe , linux-block@vger.kernel.org, "Martin K . Petersen" , linux-scsi@vger.kernel.org Subject: [PATCH v5 3/5] libata: support concurrent positioning ranges log Date: Thu, 12 Aug 2021 16:50:13 +0900 Message-Id: <20210812075015.1090959-4-damien.lemoal@wdc.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210812075015.1090959-1-damien.lemoal@wdc.com> References: <20210812075015.1090959-1-damien.lemoal@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Add support to discover if an ATA device supports the Concurrent Positioning Ranges Log (address 0x47), indicating that the device is capable of seeking to multiple different locations in parallel using multiple actuators serving different LBA ranges. Also add support to translate the concurrent positioning ranges log into its equivalent Concurrent Positioning Ranges VPD page B9h in libata-scsi.c. The format of the Concurrent Positioning Ranges Log is defined in ACS-5 r9. Signed-off-by: Damien Le Moal Reviewed-by: Hannes Reinecke Reviewed-by: Christoph Hellwig --- drivers/ata/libata-core.c | 52 +++++++++++++++++++++++++++++++++++++++ drivers/ata/libata-scsi.c | 48 +++++++++++++++++++++++++++++------- include/linux/ata.h | 1 + include/linux/libata.h | 15 +++++++++++ 4 files changed, 107 insertions(+), 9 deletions(-) diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c index 61c762961ca8..ab3f61ea743e 100644 --- a/drivers/ata/libata-core.c +++ b/drivers/ata/libata-core.c @@ -2363,6 +2363,57 @@ static void ata_dev_config_trusted(struct ata_device *dev) dev->flags |= ATA_DFLAG_TRUSTED; } +static void ata_dev_config_cpr(struct ata_device *dev) +{ + unsigned int err_mask; + size_t buf_len; + int i, nr_cpr = 0; + struct ata_cpr_log *cpr_log = NULL; + u8 *desc, *buf = NULL; + + if (!ata_identify_page_supported(dev, + ATA_LOG_CONCURRENT_POSITIONING_RANGES)) + goto out; + + /* + * Read IDENTIFY DEVICE data log, page 0x47 + * (concurrent positioning ranges). We can have at most 255 32B range + * descriptors plus a 64B header. + */ + buf_len = (64 + 255 * 32 + 511) & ~511; + buf = kzalloc(buf_len, GFP_KERNEL); + if (!buf) + goto out; + + err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, + ATA_LOG_CONCURRENT_POSITIONING_RANGES, + buf, buf_len >> 9); + if (err_mask) + goto out; + + nr_cpr = buf[0]; + if (!nr_cpr) + goto out; + + cpr_log = kzalloc(struct_size(cpr_log, cpr, nr_cpr), GFP_KERNEL); + if (!cpr_log) + goto out; + + cpr_log->nr_cpr = nr_cpr; + desc = &buf[64]; + for (i = 0; i < nr_cpr; i++, desc += 32) { + cpr_log->cpr[i].num = desc[0]; + cpr_log->cpr[i].num_storage_elements = desc[1]; + cpr_log->cpr[i].start_lba = get_unaligned_le64(&desc[8]); + cpr_log->cpr[i].num_lbas = get_unaligned_le64(&desc[16]); + } + +out: + swap(dev->cpr_log, cpr_log); + kfree(cpr_log); + kfree(buf); +} + /** * ata_dev_configure - Configure the specified ATA/ATAPI device * @dev: Target device to configure @@ -2591,6 +2642,7 @@ int ata_dev_configure(struct ata_device *dev) ata_dev_config_sense_reporting(dev); ata_dev_config_zac(dev); ata_dev_config_trusted(dev); + ata_dev_config_cpr(dev); dev->cdb_len = 32; } diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index b9588c52815d..5cadbb9a8bf2 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -1937,7 +1937,7 @@ static unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf) */ static unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf) { - int num_pages; + int i, num_pages = 0; static const u8 pages[] = { 0x00, /* page 0x00, this page */ 0x80, /* page 0x80, unit serial no page */ @@ -1947,13 +1947,17 @@ static unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf) 0xb1, /* page 0xb1, block device characteristics page */ 0xb2, /* page 0xb2, thin provisioning page */ 0xb6, /* page 0xb6, zoned block device characteristics */ + 0xb9, /* page 0xb9, concurrent positioning ranges */ }; - num_pages = sizeof(pages); - if (!(args->dev->flags & ATA_DFLAG_ZAC)) - num_pages--; + for (i = 0; i < sizeof(pages); i++) { + if (pages[i] == 0xb6 && + !(args->dev->flags & ATA_DFLAG_ZAC)) + continue; + rbuf[num_pages + 4] = pages[i]; + num_pages++; + } rbuf[3] = num_pages; /* number of supported VPD pages */ - memcpy(rbuf + 4, pages, num_pages); return 0; } @@ -2163,6 +2167,26 @@ static unsigned int ata_scsiop_inq_b6(struct ata_scsi_args *args, u8 *rbuf) return 0; } +static unsigned int ata_scsiop_inq_b9(struct ata_scsi_args *args, u8 *rbuf) +{ + struct ata_cpr_log *cpr_log = args->dev->cpr_log; + u8 *desc = &rbuf[64]; + int i; + + /* SCSI Concurrent Positioning Ranges VPD page: SBC-5 rev 1 or later */ + rbuf[1] = 0xb9; + put_unaligned_be16(64 + (int)cpr_log->nr_cpr * 32 - 4, &rbuf[3]); + + for (i = 0; i < cpr_log->nr_cpr; i++, desc += 32) { + desc[0] = cpr_log->cpr[i].num; + desc[1] = cpr_log->cpr[i].num_storage_elements; + put_unaligned_be64(cpr_log->cpr[i].start_lba, &desc[8]); + put_unaligned_be64(cpr_log->cpr[i].num_lbas, &desc[16]); + } + + return 0; +} + /** * modecpy - Prepare response for MODE SENSE * @dest: output buffer @@ -4162,11 +4186,17 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd) ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b2); break; case 0xb6: - if (dev->flags & ATA_DFLAG_ZAC) { + if (dev->flags & ATA_DFLAG_ZAC) ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b6); - break; - } - fallthrough; + else + ata_scsi_set_invalid_field(dev, cmd, 2, 0xff); + break; + case 0xb9: + if (dev->cpr_log) + ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b9); + else + ata_scsi_set_invalid_field(dev, cmd, 2, 0xff); + break; default: ata_scsi_set_invalid_field(dev, cmd, 2, 0xff); break; diff --git a/include/linux/ata.h b/include/linux/ata.h index 1b44f40c7700..199e47e97d64 100644 --- a/include/linux/ata.h +++ b/include/linux/ata.h @@ -329,6 +329,7 @@ enum { ATA_LOG_SECURITY = 0x06, ATA_LOG_SATA_SETTINGS = 0x08, ATA_LOG_ZONED_INFORMATION = 0x09, + ATA_LOG_CONCURRENT_POSITIONING_RANGES = 0x47, /* Identify device SATA settings log:*/ ATA_LOG_DEVSLP_OFFSET = 0x30, diff --git a/include/linux/libata.h b/include/linux/libata.h index 3fcd24236793..b159a245d88c 100644 --- a/include/linux/libata.h +++ b/include/linux/libata.h @@ -670,6 +670,18 @@ struct ata_ering { struct ata_ering_entry ring[ATA_ERING_SIZE]; }; +struct ata_cpr { + u8 num; + u8 num_storage_elements; + u64 start_lba; + u64 num_lbas; +}; + +struct ata_cpr_log { + u8 nr_cpr; + struct ata_cpr cpr[]; +}; + struct ata_device { struct ata_link *link; unsigned int devno; /* 0 or 1 */ @@ -729,6 +741,9 @@ struct ata_device { u32 zac_zones_optimal_nonseq; u32 zac_zones_max_open; + /* Concurrent positioning ranges */ + struct ata_cpr_log *cpr_log; + /* error history */ int spdn_cnt; /* ering is CLEAR_END, read comment above CLEAR_END */ From patchwork Thu Aug 12 07:50:14 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Damien Le Moal X-Patchwork-Id: 12432777 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1856DC4320A for ; Thu, 12 Aug 2021 07:50:24 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0182A60FC4 for ; Thu, 12 Aug 2021 07:50:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234889AbhHLHuq (ORCPT ); Thu, 12 Aug 2021 03:50:46 -0400 Received: from esa6.hgst.iphmx.com ([216.71.154.45]:51846 "EHLO esa6.hgst.iphmx.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234835AbhHLHuq (ORCPT ); Thu, 12 Aug 2021 03:50:46 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1628754622; x=1660290622; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=YlAMtc1NFjSacQjRaTROX9F+tPKC3ulFDw9e3bnV9hc=; b=Vm7+3fYEDsUDGjRIgh2yBAeCMsi514ySRNf59otq2mInB6FB024aTxS0 X548oAW8fScw8M6bLMDSaDqeNeD6M1PfaqDNt/1/izsS30EdoGAWPgaFq uJ8cp2DQdeTXeYNMu8jfRPjVXKiONrHKTD3Qg/Kz0EdRBYs6umxJaSvZE hOOZ4vEGZnjuFXHGYOaiTpmirh/QNQrQI/ysDx+NiGtXiHNA3lWmilvYX YjXEkhFMzwNHznA58OsWWzXDtOjEct1AgcRYrG4vHwkrBF0I9xYHrbOjW bdFsQMI3MWTqbhpwnhq/45p30vEN70XPt/nhdSxri4bNd2HP3kOiDXQ9F Q==; X-IronPort-AV: E=Sophos;i="5.84,315,1620662400"; d="scan'208";a="177596940" Received: from uls-op-cesaip02.wdc.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 12 Aug 2021 15:50:22 +0800 IronPort-SDR: 511GsPTHmc/zdqV5gAOTtCjQbfj1BOAP6+LhLMVoG1FzyUsYgBV5zx2oHEpGVlY20quHnnvwQ+ NLVcfSk6yyJnBYjvBZts+/BvIWrzWW0o7MRqLi0MWeYo44FB9Iw/R2iEXH3aAQAtqcviQkwUyS v0pATP5y6epbVrMssohp1d47GgU3RFMKJ0/K4YyrcYrWI1Z9ue3zM73yEKYZdbiyCi8rtUN41i 3YVKC8iJpG802o6Q9wd/PxNOl22p2kpDk5mwlEJyVwPoM17Vrv+xkwhhyfSMfrAIOdxk+5UpDh OQw46Ow+wsaF2Abs/CIigCxG Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Aug 2021 00:25:50 -0700 IronPort-SDR: 45mIB9a3kPaZT45ITWNTcPeuOKSyxNfYC91NcK604gespplMBM3w22tgseVEaWVa5nMU6D2pxv QQAMePXmBcorhCm6O0u8a9ulOpYtbaFnBcdvzS31wn2+X5JeeLmJATE3p9Hpd0mFD5+thuRFuK 4MTlvpGynw7jwhhNeDc9w8wQU/CowBzeftWYrEJS+dfaLIjJJX9LGtmHuISSfgQqW+MklhzQ4R DJgd7hMyaJPevSKlt6l8gvxkO+dDL3SMoTU1N7fF76yXjG9ZmONrAEH3ysbaj22w5Wy3q/9Kpi KHc= WDCIronportException: Internal Received: from washi.fujisawa.hgst.com ([10.149.53.254]) by uls-op-cesaip02.wdc.com with ESMTP; 12 Aug 2021 00:50:20 -0700 From: Damien Le Moal To: Jens Axboe , linux-block@vger.kernel.org, "Martin K . Petersen" , linux-scsi@vger.kernel.org Subject: [PATCH v5 4/5] doc: document sysfs queue/cranges attributes Date: Thu, 12 Aug 2021 16:50:14 +0900 Message-Id: <20210812075015.1090959-5-damien.lemoal@wdc.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210812075015.1090959-1-damien.lemoal@wdc.com> References: <20210812075015.1090959-1-damien.lemoal@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Update the file Documentation/block/queue-sysfs.rst to add a description of a device queue sysfs entries related to concurrent sector ranges (e.g. concurrent positioning ranges for multi-actuator hard-disks). While at it, also fix a typo in this file introduction paragraph. Signed-off-by: Damien Le Moal Reviewed-by: Hannes Reinecke Reviewed-by: Christoph Hellwig --- Documentation/block/queue-sysfs.rst | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/Documentation/block/queue-sysfs.rst b/Documentation/block/queue-sysfs.rst index 4dc7f0d499a8..757609bbb1e2 100644 --- a/Documentation/block/queue-sysfs.rst +++ b/Documentation/block/queue-sysfs.rst @@ -286,4 +286,32 @@ sequential zones of zoned block devices (devices with a zoned attributed that reports "host-managed" or "host-aware"). This value is always 0 for regular block devices. +cranges (RO) +------------ + +The presence of this sub-directory of the /sys/block/xxx/queue/ directory +indicates that the device is capable of executing requests targeting +different sector ranges in parallel. For instance, single LUN multi-actuator +hard-disks will likely have a cranges directory if the device correctly +advertizes the sector ranges of its actuators. + +The cranges directory contains one directory per concurrent range, with each +range described using the sector (RO) attribute file to indicate the first +sector of the range and the nr_sectors (RO) attribute file to indicate the +total number of sector in the range starting from the first sector. +For example, a dual-actuator hard disk will have the following cranges +entries.:: + + $ tree /sys/block//queue/cranges/ + /sys/block//queue/cranges/ + |-- 0 + | |-- nr_sectors + | `-- sector + `-- 1 + |-- nr_sectors + `-- sector + +The sector and nr_sectors attributes use 512B sector unit, regardless of +the actual block size of the device. + Jens Axboe , February 2009 From patchwork Thu Aug 12 07:50:15 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Damien Le Moal X-Patchwork-Id: 12432779 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 51AEEC4338F for ; Thu, 12 Aug 2021 07:50:27 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3A3D46101E for ; Thu, 12 Aug 2021 07:50:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234745AbhHLHuu (ORCPT ); Thu, 12 Aug 2021 03:50:50 -0400 Received: from esa6.hgst.iphmx.com ([216.71.154.45]:51846 "EHLO esa6.hgst.iphmx.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234907AbhHLHur (ORCPT ); Thu, 12 Aug 2021 03:50:47 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1628754623; x=1660290623; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=mhabWCigeMf23LkXW4lJkPoqzA+1/WMbsc4DZ/vq3tw=; b=SZUDLHH6LAGaGeKUER9HVRgAEdsUCFjMxA/LDudnQxEvLf0X4eEnQwwz Tun21mnBuwVSLI4ylQDcdCLXC/QrqwDJWzXeJPBoqbL1bKgGubX5owUvp eMxo/pdS9apGlRVA4bFSO8Y7NfLgkSoPr2Gj1pT6w8161d5gZNbJAgZQB GYHMK5iK0Nv45zS8sN0i24t0NFzf37VsIOBJ7SAIx6zvjizxnzcZKWSUp BrkhkQEvEdKKfmGCxxEy1KTrczLqC8aoGyS7Pvw21Ha1J0ahiso0rZPGY AMmE8pAOWu0vR7wUHh/OVVpSVlnjVERwpTZmvTPCWrCkKNfMzEfGhpDen g==; X-IronPort-AV: E=Sophos;i="5.84,315,1620662400"; d="scan'208";a="177596943" Received: from uls-op-cesaip02.wdc.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 12 Aug 2021 15:50:23 +0800 IronPort-SDR: 0OesJ+fSRYY3cqX0+jeNm7DsMQkidQUVOQSryo271WGxgQG5PNI88B25ftvv8y/XudWhoBKJ66 KyRVME5ajNA7uKdLt1/vh4ap6NslrPlTXUTmhvJAlw6lenk61d9R73GfYuOMXaOr5gdSNaR6/8 V9UCR6KwAXU7mWelm10emiFKORQkdnn+O2TMkdTi8lkcfs9oLAmoF/ZvgZ7MrhcCen8s/6uubD hKVzi5xwrBVPtEurFGYsPfYrqShiLSt+q0l+6d/mHS9JO22AWQ6Rc8HSrDQpEgOAV1omA6CwJV San/67ncuhc1Kfv73DbB/Ew1 Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Aug 2021 00:25:52 -0700 IronPort-SDR: Y1Ypfv0yVGZKC3DnoHshu9G/WDLsplaRQrBahece99Kn80KD8XrHeKc7bVYk+yO+l4pwn/bM0/ WrD3ecnXXu7gI46HrGZpwSsPKCRbBhbTAT5BElgs3AQbT9KtOlacMHJ+R3rPJIsXTNpCrUsKv/ cUVk57YcLhsIiAO2S9+BWQXsUvh5aMoCMzMm4KSaUoxyCOv5T61YCLy35a/GKl6ZOOSecQtPLX NF8Q6iTjXCRjykOjSL+3mZpMeAooJwdJO/mrxCZIngdu2XxZMP1uNvxZsMFO4564Gu1idxNYD3 0rA= WDCIronportException: Internal Received: from washi.fujisawa.hgst.com ([10.149.53.254]) by uls-op-cesaip02.wdc.com with ESMTP; 12 Aug 2021 00:50:21 -0700 From: Damien Le Moal To: Jens Axboe , linux-block@vger.kernel.org, "Martin K . Petersen" , linux-scsi@vger.kernel.org Subject: [PATCH v5 5/5] doc: Fix typo in request queue sysfs documentation Date: Thu, 12 Aug 2021 16:50:15 +0900 Message-Id: <20210812075015.1090959-6-damien.lemoal@wdc.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210812075015.1090959-1-damien.lemoal@wdc.com> References: <20210812075015.1090959-1-damien.lemoal@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Fix a typo (are -> as) in the introduction paragraph of Documentation/block/queue-sysfs.rst. Signed-off-by: Damien Le Moal --- Documentation/block/queue-sysfs.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Documentation/block/queue-sysfs.rst b/Documentation/block/queue-sysfs.rst index 757609bbb1e2..25f4a768f450 100644 --- a/Documentation/block/queue-sysfs.rst +++ b/Documentation/block/queue-sysfs.rst @@ -4,7 +4,7 @@ Queue sysfs files This text file will detail the queue files that are located in the sysfs tree for each block device. Note that stacked devices typically do not export -any settings, since their queue merely functions are a remapping target. +any settings, since their queue merely functions as a remapping target. These files are the ones found in the /sys/block/xxx/queue/ directory. Files denoted with a RO postfix are readonly and the RW postfix means