349 lines
9.1 KiB
C
349 lines
9.1 KiB
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);
|
|
ssize_t ret;
|
|
|
|
mutex_lock(&iar->queue->sysfs_lock);
|
|
ret = entry->show(iar, buf);
|
|
mutex_unlock(&iar->queue->sysfs_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
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 q->ia_ranges is unregistered. Otherwise, q->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 (q->ia_ranges)
|
|
disk_unregister_independent_access_ranges(disk);
|
|
q->ia_ranges = new_iars;
|
|
}
|
|
|
|
iars = q->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) {
|
|
q->ia_ranges = NULL;
|
|
kfree(iars);
|
|
return ret;
|
|
}
|
|
|
|
for (i = 0; i < iars->nr_ia_ranges; i++) {
|
|
iars->ia_range[i].queue = q;
|
|
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 = q->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);
|
|
}
|
|
|
|
q->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->queue->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(q->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);
|