[linux-block.git] / block / blk-ia-ranges.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  Block device concurrent positioning ranges.
 *
 *  Copyright (C) 2021 Western Digital Corporation or its Affiliates.
 */
#include <linux/kernel.h>
#include <linux/blkdev.h>
#include <linux/slab.h>
#include <linux/init.h>

#include "blk.h"

static ssize_t
blk_ia_range_sector_show(struct blk_independent_access_range *iar,
			 char *buf)
{
	return sprintf(buf, "%llu\n", iar->sector);
}

static ssize_t
blk_ia_range_nr_sectors_show(struct blk_independent_access_range *iar,
			     char *buf)
{
	return sprintf(buf, "%llu\n", iar->nr_sectors);
}

struct blk_ia_range_sysfs_entry {
	struct attribute attr;
	ssize_t (*show)(struct blk_independent_access_range *iar, char *buf);
};

static struct blk_ia_range_sysfs_entry blk_ia_range_sector_entry = {
	.attr = { .name = "sector", .mode = 0444 },
	.show = blk_ia_range_sector_show,
};

static struct blk_ia_range_sysfs_entry blk_ia_range_nr_sectors_entry = {
	.attr = { .name = "nr_sectors", .mode = 0444 },
	.show = blk_ia_range_nr_sectors_show,
};

static struct attribute *blk_ia_range_attrs[] = {
	&blk_ia_range_sector_entry.attr,
	&blk_ia_range_nr_sectors_entry.attr,
	NULL,
};
ATTRIBUTE_GROUPS(blk_ia_range);

static ssize_t blk_ia_range_sysfs_show(struct kobject *kobj,
				      struct attribute *attr, char *buf)
{
	struct blk_ia_range_sysfs_entry *entry =
		container_of(attr, struct blk_ia_range_sysfs_entry, attr);
	struct blk_independent_access_range *iar =
		container_of(kobj, struct blk_independent_access_range, kobj);

	return entry->show(iar, buf);
}

static const struct sysfs_ops blk_ia_range_sysfs_ops = {
	.show	= blk_ia_range_sysfs_show,
};

/*
 * Independent access range entries are not freed individually, but alltogether
 * with struct blk_independent_access_ranges and its array of ranges. Since
 * kobject_add() takes a reference on the parent kobject contained in
 * struct blk_independent_access_ranges, the array of independent access range
 * 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 no-op release
 * operation to avoid complaints from the kobject code.
 */
static void blk_ia_range_sysfs_nop_release(struct kobject *kobj)
{
}

static struct kobj_type blk_ia_range_ktype = {
	.sysfs_ops	= &blk_ia_range_sysfs_ops,
	.default_groups	= blk_ia_range_groups,
	.release	= blk_ia_range_sysfs_nop_release,
};

/*
 * This will be executed only after all independent access range entries are
 * removed with kobject_del(), at which point, it is safe to free everything,
 * including the array of ranges.
 */
static void blk_ia_ranges_sysfs_release(struct kobject *kobj)
{
	struct blk_independent_access_ranges *iars =
		container_of(kobj, struct blk_independent_access_ranges, kobj);

	kfree(iars);
}

static struct kobj_type blk_ia_ranges_ktype = {
	.release	= blk_ia_ranges_sysfs_release,
};

/**
 * disk_register_independent_access_ranges - register with sysfs a set of
 *		independent access ranges
 * @disk:	Target disk
 * @new_iars:	New set of independent access ranges
 *
 * Register with sysfs a set of independent access ranges for @disk.
 * If @new_iars is not NULL, this set of ranges is registered and the old set
 * specified by disk->ia_ranges is unregistered. Otherwise, disk->ia_ranges is
 * registered if it is not already.
 */
int disk_register_independent_access_ranges(struct gendisk *disk,
				struct blk_independent_access_ranges *new_iars)
{
	struct request_queue *q = disk->queue;
	struct blk_independent_access_ranges *iars;
	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_iars) {
		if (disk->ia_ranges)
			disk_unregister_independent_access_ranges(disk);
		disk->ia_ranges = new_iars;
	}

	iars = disk->ia_ranges;
	if (!iars)
		return 0;

	/*
	 * At this point, iars is the new set of sector access ranges that needs
	 * to be registered with sysfs.
	 */
	WARN_ON(iars->sysfs_registered);
	ret = kobject_init_and_add(&iars->kobj, &blk_ia_ranges_ktype,
				   &q->kobj, "%s", "independent_access_ranges");
	if (ret) {
		disk->ia_ranges = NULL;
		kobject_put(&iars->kobj);
		return ret;
	}

	for (i = 0; i < iars->nr_ia_ranges; i++) {
		ret = kobject_init_and_add(&iars->ia_range[i].kobj,
					   &blk_ia_range_ktype, &iars->kobj,
					   "%d", i);
		if (ret) {
			while (--i >= 0)
				kobject_del(&iars->ia_range[i].kobj);
			kobject_del(&iars->kobj);
			kobject_put(&iars->kobj);
			return ret;
		}
	}

	iars->sysfs_registered = true;

	return 0;
}

void disk_unregister_independent_access_ranges(struct gendisk *disk)
{
	struct request_queue *q = disk->queue;
	struct blk_independent_access_ranges *iars = disk->ia_ranges;
	int i;

	lockdep_assert_held(&q->sysfs_dir_lock);
	lockdep_assert_held(&q->sysfs_lock);

	if (!iars)
		return;

	if (iars->sysfs_registered) {
		for (i = 0; i < iars->nr_ia_ranges; i++)
			kobject_del(&iars->ia_range[i].kobj);
		kobject_del(&iars->kobj);
		kobject_put(&iars->kobj);
	} else {
		kfree(iars);
	}

	disk->ia_ranges = NULL;
}

static struct blk_independent_access_range *
disk_find_ia_range(struct blk_independent_access_ranges *iars,
		  sector_t sector)
{
	struct blk_independent_access_range *iar;
	int i;

	for (i = 0; i < iars->nr_ia_ranges; i++) {
		iar = &iars->ia_range[i];
		if (sector >= iar->sector &&
		    sector < iar->sector + iar->nr_sectors)
			return iar;
	}

	return NULL;
}

static bool disk_check_ia_ranges(struct gendisk *disk,
				struct blk_independent_access_ranges *iars)
{
	struct blk_independent_access_range *iar, *tmp;
	sector_t capacity = get_capacity(disk);
	sector_t sector = 0;
	int i;

	/*
	 * While sorting the ranges in increasing LBA order, check that the
	 * ranges do not overlap, that there are no sector holes and that all
	 * sectors belong to one range.
	 */
	for (i = 0; i < iars->nr_ia_ranges; i++) {
		tmp = disk_find_ia_range(iars, sector);
		if (!tmp || tmp->sector != sector) {
			pr_warn("Invalid non-contiguous independent access ranges\n");
			return false;
		}

		iar = &iars->ia_range[i];
		if (tmp != iar) {
			swap(iar->sector, tmp->sector);
			swap(iar->nr_sectors, tmp->nr_sectors);
		}

		sector += iar->nr_sectors;
	}

	if (sector != capacity) {
		pr_warn("Independent access ranges do not match disk capacity\n");
		return false;
	}

	return true;
}

static bool disk_ia_ranges_changed(struct gendisk *disk,
				   struct blk_independent_access_ranges *new)
{
	struct blk_independent_access_ranges *old = disk->ia_ranges;
	int i;

	if (!old)
		return true;

	if (old->nr_ia_ranges != new->nr_ia_ranges)
		return true;

	for (i = 0; i < old->nr_ia_ranges; i++) {
		if (new->ia_range[i].sector != old->ia_range[i].sector ||
		    new->ia_range[i].nr_sectors != old->ia_range[i].nr_sectors)
			return true;
	}

	return false;
}

/**
 * disk_alloc_independent_access_ranges - Allocate an independent access ranges
 *                                        data structure
 * @disk:		target disk
 * @nr_ia_ranges:	Number of independent access ranges
 *
 * Allocate a struct blk_independent_access_ranges structure with @nr_ia_ranges
 * access range descriptors.
 */
struct blk_independent_access_ranges *
disk_alloc_independent_access_ranges(struct gendisk *disk, int nr_ia_ranges)
{
	struct blk_independent_access_ranges *iars;

	iars = kzalloc_node(struct_size(iars, ia_range, nr_ia_ranges),
			    GFP_KERNEL, disk->queue->node);
	if (iars)
		iars->nr_ia_ranges = nr_ia_ranges;
	return iars;
}
EXPORT_SYMBOL_GPL(disk_alloc_independent_access_ranges);

/**
 * disk_set_independent_access_ranges - Set a disk independent access ranges
 * @disk:	target disk
 * @iars:	independent access ranges structure
 *
 * Set the independent access ranges information of the request queue
 * of @disk to @iars. If @iars is NULL and the independent access ranges
 * structure already set is cleared. If there are no differences between
 * @iars and the independent access ranges structure already set, @iars
 * is freed.
 */
void disk_set_independent_access_ranges(struct gendisk *disk,
				struct blk_independent_access_ranges *iars)
{
	struct request_queue *q = disk->queue;

	if (WARN_ON_ONCE(iars && !iars->nr_ia_ranges)) {
		kfree(iars);
		iars = NULL;
	}

	mutex_lock(&q->sysfs_dir_lock);
	mutex_lock(&q->sysfs_lock);

	if (iars) {
		if (!disk_check_ia_ranges(disk, iars)) {
			kfree(iars);
			iars = NULL;
			goto reg;
		}

		if (!disk_ia_ranges_changed(disk, iars)) {
			kfree(iars);
			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 independent access ranges and register the new set. If the
	 * queue is not registered, registration of the device request queue
	 * will register the independent access ranges, so only swap in the
	 * new set and free the old one.
	 */
reg:
	if (blk_queue_registered(q)) {
		disk_register_independent_access_ranges(disk, iars);
	} else {
		swap(disk->ia_ranges, iars);
		kfree(iars);
	}

unlock:
	mutex_unlock(&q->sysfs_lock);
	mutex_unlock(&q->sysfs_dir_lock);
}
EXPORT_SYMBOL_GPL(disk_set_independent_access_ranges);
Commit	Line	Data
a2247f19 DLM	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Block device concurrent positioning ranges.
	4	*
	5	* Copyright (C) 2021 Western Digital Corporation or its Affiliates.
	6	*/
	7	#include <linux/kernel.h>
	8	#include <linux/blkdev.h>
	9	#include <linux/slab.h>
	10	#include <linux/init.h>
	11
	12	#include "blk.h"
	13
	14	static ssize_t
	15	blk_ia_range_sector_show(struct blk_independent_access_range *iar,
	16	char *buf)
	17	{
	18	return sprintf(buf, "%llu\n", iar->sector);
	19	}
	20
	21	static ssize_t
	22	blk_ia_range_nr_sectors_show(struct blk_independent_access_range *iar,
	23	char *buf)
	24	{
	25	return sprintf(buf, "%llu\n", iar->nr_sectors);
	26	}
	27
	28	struct blk_ia_range_sysfs_entry {
	29	struct attribute attr;
	30	ssize_t (show)(struct blk_independent_access_range iar, char *buf);
	31	};
	32
	33	static struct blk_ia_range_sysfs_entry blk_ia_range_sector_entry = {
	34	.attr = { .name = "sector", .mode = 0444 },
	35	.show = blk_ia_range_sector_show,
	36	};
	37
	38	static struct blk_ia_range_sysfs_entry blk_ia_range_nr_sectors_entry = {
	39	.attr = { .name = "nr_sectors", .mode = 0444 },
	40	.show = blk_ia_range_nr_sectors_show,
	41	};
	42
	43	static struct attribute *blk_ia_range_attrs[] = {
	44	&blk_ia_range_sector_entry.attr,
	45	&blk_ia_range_nr_sectors_entry.attr,
	46	NULL,
	47	};
	48	ATTRIBUTE_GROUPS(blk_ia_range);
	49
	50	static ssize_t blk_ia_range_sysfs_show(struct kobject *kobj,
	51	struct attribute attr, char buf)
	52	{
	53	struct blk_ia_range_sysfs_entry *entry =
	54	container_of(attr, struct blk_ia_range_sysfs_entry, attr);
	55	struct blk_independent_access_range *iar =
	56	container_of(kobj, struct blk_independent_access_range, kobj);
a2247f19	57
41e46b3c	58	return entry->show(iar, buf);
a2247f19 DLM	59	}
	60
	61	static const struct sysfs_ops blk_ia_range_sysfs_ops = {
	62	.show = blk_ia_range_sysfs_show,
	63	};
	64
	65	/*
	66	* Independent access range entries are not freed individually, but alltogether
	67	* with struct blk_independent_access_ranges and its array of ranges. Since
	68	* kobject_add() takes a reference on the parent kobject contained in
	69	* struct blk_independent_access_ranges, the array of independent access range
	70	* entries cannot be freed until kobject_del() is called for all entries.
	71	* So we do not need to do anything here, but still need this no-op release
	72	* operation to avoid complaints from the kobject code.
	73	*/
	74	static void blk_ia_range_sysfs_nop_release(struct kobject *kobj)
	75	{
	76	}
	77
	78	static struct kobj_type blk_ia_range_ktype = {
	79	.sysfs_ops = &blk_ia_range_sysfs_ops,
	80	.default_groups = blk_ia_range_groups,
	81	.release = blk_ia_range_sysfs_nop_release,
	82	};
	83
	84	/*
	85	* This will be executed only after all independent access range entries are
	86	* removed with kobject_del(), at which point, it is safe to free everything,
	87	* including the array of ranges.
	88	*/
	89	static void blk_ia_ranges_sysfs_release(struct kobject *kobj)
	90	{
	91	struct blk_independent_access_ranges *iars =
	92	container_of(kobj, struct blk_independent_access_ranges, kobj);
	93
	94	kfree(iars);
	95	}
	96
	97	static struct kobj_type blk_ia_ranges_ktype = {
	98	.release = blk_ia_ranges_sysfs_release,
	99	};
	100
	101	/**
438cd742 JA	102	* disk_register_independent_access_ranges - register with sysfs a set of
438cd742 JA	103	* independent access ranges
a2247f19 DLM	104	* @disk: Target disk
	105	* @new_iars: New set of independent access ranges
	106	*
	107	* Register with sysfs a set of independent access ranges for @disk.
	108	* If @new_iars is not NULL, this set of ranges is registered and the old set
6a27d28c	109	* specified by disk->ia_ranges is unregistered. Otherwise, disk->ia_ranges is
a2247f19 DLM	110	* registered if it is not already.
	111	*/
	112	int disk_register_independent_access_ranges(struct gendisk *disk,
	113	struct blk_independent_access_ranges *new_iars)
	114	{
	115	struct request_queue *q = disk->queue;
	116	struct blk_independent_access_ranges *iars;
	117	int i, ret;
	118
	119	lockdep_assert_held(&q->sysfs_dir_lock);
	120	lockdep_assert_held(&q->sysfs_lock);
	121
	122	/* If a new range set is specified, unregister the old one */
	123	if (new_iars) {
6a27d28c	124	if (disk->ia_ranges)
a2247f19	125	disk_unregister_independent_access_ranges(disk);
6a27d28c	126	disk->ia_ranges = new_iars;
a2247f19 DLM	127	}
a2247f19 DLM	128
6a27d28c	129	iars = disk->ia_ranges;
a2247f19 DLM	130	if (!iars)
	131	return 0;
	132
	133	/*
	134	* At this point, iars is the new set of sector access ranges that needs
	135	* to be registered with sysfs.
	136	*/
	137	WARN_ON(iars->sysfs_registered);
	138	ret = kobject_init_and_add(&iars->kobj, &blk_ia_ranges_ktype,
	139	&q->kobj, "%s", "independent_access_ranges");
	140	if (ret) {
6a27d28c	141	disk->ia_ranges = NULL;
83114df3	142	kobject_put(&iars->kobj);
a2247f19 DLM	143	return ret;
	144	}
	145
	146	for (i = 0; i < iars->nr_ia_ranges; i++) {
a2247f19 DLM	147	ret = kobject_init_and_add(&iars->ia_range[i].kobj,
	148	&blk_ia_range_ktype, &iars->kobj,
	149	"%d", i);
	150	if (ret) {
	151	while (--i >= 0)
	152	kobject_del(&iars->ia_range[i].kobj);
	153	kobject_del(&iars->kobj);
	154	kobject_put(&iars->kobj);
	155	return ret;
	156	}
	157	}
	158
	159	iars->sysfs_registered = true;
	160
	161	return 0;
	162	}
	163
	164	void disk_unregister_independent_access_ranges(struct gendisk *disk)
	165	{
	166	struct request_queue *q = disk->queue;
6a27d28c	167	struct blk_independent_access_ranges *iars = disk->ia_ranges;
a2247f19 DLM	168	int i;
	169
	170	lockdep_assert_held(&q->sysfs_dir_lock);
	171	lockdep_assert_held(&q->sysfs_lock);
	172
	173	if (!iars)
	174	return;
	175
	176	if (iars->sysfs_registered) {
	177	for (i = 0; i < iars->nr_ia_ranges; i++)
	178	kobject_del(&iars->ia_range[i].kobj);
	179	kobject_del(&iars->kobj);
	180	kobject_put(&iars->kobj);
	181	} else {
	182	kfree(iars);
	183	}
	184
6a27d28c	185	disk->ia_ranges = NULL;
a2247f19 DLM	186	}
	187
	188	static struct blk_independent_access_range *
	189	disk_find_ia_range(struct blk_independent_access_ranges *iars,
	190	sector_t sector)
	191	{
	192	struct blk_independent_access_range *iar;
	193	int i;
	194
	195	for (i = 0; i < iars->nr_ia_ranges; i++) {
	196	iar = &iars->ia_range[i];
	197	if (sector >= iar->sector &&
	198	sector < iar->sector + iar->nr_sectors)
	199	return iar;
	200	}
	201
	202	return NULL;
	203	}
	204
	205	static bool disk_check_ia_ranges(struct gendisk *disk,
	206	struct blk_independent_access_ranges *iars)
	207	{
	208	struct blk_independent_access_range iar, tmp;
	209	sector_t capacity = get_capacity(disk);
	210	sector_t sector = 0;
	211	int i;
	212
	213	/*
	214	* While sorting the ranges in increasing LBA order, check that the
	215	* ranges do not overlap, that there are no sector holes and that all
	216	* sectors belong to one range.
	217	*/
	218	for (i = 0; i < iars->nr_ia_ranges; i++) {
	219	tmp = disk_find_ia_range(iars, sector);
	220	if (!tmp \|\| tmp->sector != sector) {
	221	pr_warn("Invalid non-contiguous independent access ranges\n");
	222	return false;
	223	}
	224
	225	iar = &iars->ia_range[i];
	226	if (tmp != iar) {
	227	swap(iar->sector, tmp->sector);
	228	swap(iar->nr_sectors, tmp->nr_sectors);
	229	}
	230
	231	sector += iar->nr_sectors;
	232	}
	233
	234	if (sector != capacity) {
	235	pr_warn("Independent access ranges do not match disk capacity\n");
	236	return false;
	237	}
	238
	239	return true;
	240	}
	241
	242	static bool disk_ia_ranges_changed(struct gendisk *disk,
	243	struct blk_independent_access_ranges *new)
	244	{
6a27d28c	245	struct blk_independent_access_ranges *old = disk->ia_ranges;
a2247f19 DLM	246	int i;
	247
	248	if (!old)
	249	return true;
	250
	251	if (old->nr_ia_ranges != new->nr_ia_ranges)
	252	return true;
	253
	254	for (i = 0; i < old->nr_ia_ranges; i++) {
	255	if (new->ia_range[i].sector != old->ia_range[i].sector \|\|
	256	new->ia_range[i].nr_sectors != old->ia_range[i].nr_sectors)
	257	return true;
	258	}
	259
	260	return false;
	261	}
	262
	263	/**
	264	* disk_alloc_independent_access_ranges - Allocate an independent access ranges
	265	* data structure
	266	* @disk: target disk
	267	* @nr_ia_ranges: Number of independent access ranges
	268	*
	269	* Allocate a struct blk_independent_access_ranges structure with @nr_ia_ranges
	270	* access range descriptors.
	271	*/
	272	struct blk_independent_access_ranges *
	273	disk_alloc_independent_access_ranges(struct gendisk *disk, int nr_ia_ranges)
	274	{
	275	struct blk_independent_access_ranges *iars;
	276
	277	iars = kzalloc_node(struct_size(iars, ia_range, nr_ia_ranges),
	278	GFP_KERNEL, disk->queue->node);
	279	if (iars)
	280	iars->nr_ia_ranges = nr_ia_ranges;
	281	return iars;
	282	}
	283	EXPORT_SYMBOL_GPL(disk_alloc_independent_access_ranges);
	284
	285	/**
	286	* disk_set_independent_access_ranges - Set a disk independent access ranges
	287	* @disk: target disk
	288	* @iars: independent access ranges structure
	289	*
	290	* Set the independent access ranges information of the request queue
	291	* of @disk to @iars. If @iars is NULL and the independent access ranges
	292	* structure already set is cleared. If there are no differences between
	293	* @iars and the independent access ranges structure already set, @iars
	294	* is freed.
	295	*/
	296	void disk_set_independent_access_ranges(struct gendisk *disk,
	297	struct blk_independent_access_ranges *iars)
	298	{
	299	struct request_queue *q = disk->queue;
	300
	301	if (WARN_ON_ONCE(iars && !iars->nr_ia_ranges)) {
	302	kfree(iars);
	303	iars = NULL;
	304	}
	305
	306	mutex_lock(&q->sysfs_dir_lock);
	307	mutex_lock(&q->sysfs_lock);
	308
	309	if (iars) {
310	if (!disk_check_ia_ranges(disk, iars)) {
311	kfree(iars);
312	iars = NULL;
313	goto reg;
314	}
315
316	if (!disk_ia_ranges_changed(disk, iars)) {
317	kfree(iars);
318	goto unlock;
319	}
320	}
321
322	/*
323	* This may be called for a registered queue. E.g. during a device
324	* revalidation. If that is the case, we need to unregister the old
325	* set of independent access ranges and register the new set. If the
326	* queue is not registered, registration of the device request queue
327	* will register the independent access ranges, so only swap in the
328	* new set and free the old one.
329	*/
330	reg:
331	if (blk_queue_registered(q)) {
332	disk_register_independent_access_ranges(disk, iars);
333	} else {
6a27d28c	334	swap(disk->ia_ranges, iars);
a2247f19 DLM	335	kfree(iars);
	336	}
	337
	338	unlock:
	339	mutex_unlock(&q->sysfs_lock);
	340	mutex_unlock(&q->sysfs_dir_lock);
	341	}
	342	EXPORT_SYMBOL_GPL(disk_set_independent_access_ranges);