1 // SPDX-License-Identifier: GPL-2.0
3 * Block device concurrent positioning ranges.
5 * Copyright (C) 2021 Western Digital Corporation or its Affiliates.
7 #include <linux/kernel.h>
8 #include <linux/blkdev.h>
9 #include <linux/slab.h>
10 #include <linux/init.h>
15 blk_ia_range_sector_show(struct blk_independent_access_range
*iar
,
18 return sprintf(buf
, "%llu\n", iar
->sector
);
22 blk_ia_range_nr_sectors_show(struct blk_independent_access_range
*iar
,
25 return sprintf(buf
, "%llu\n", iar
->nr_sectors
);
28 struct blk_ia_range_sysfs_entry
{
29 struct attribute attr
;
30 ssize_t (*show
)(struct blk_independent_access_range
*iar
, char *buf
);
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
,
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
,
43 static struct attribute
*blk_ia_range_attrs
[] = {
44 &blk_ia_range_sector_entry
.attr
,
45 &blk_ia_range_nr_sectors_entry
.attr
,
48 ATTRIBUTE_GROUPS(blk_ia_range
);
50 static ssize_t
blk_ia_range_sysfs_show(struct kobject
*kobj
,
51 struct attribute
*attr
, char *buf
)
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
);
58 return entry
->show(iar
, buf
);
61 static const struct sysfs_ops blk_ia_range_sysfs_ops
= {
62 .show
= blk_ia_range_sysfs_show
,
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.
74 static void blk_ia_range_sysfs_nop_release(struct kobject
*kobj
)
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
,
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.
89 static void blk_ia_ranges_sysfs_release(struct kobject
*kobj
)
91 struct blk_independent_access_ranges
*iars
=
92 container_of(kobj
, struct blk_independent_access_ranges
, kobj
);
97 static struct kobj_type blk_ia_ranges_ktype
= {
98 .release
= blk_ia_ranges_sysfs_release
,
102 * disk_register_independent_access_ranges - register with sysfs a set of
103 * independent access ranges
106 * Register with sysfs a set of independent access ranges for @disk.
108 int disk_register_independent_access_ranges(struct gendisk
*disk
)
110 struct blk_independent_access_ranges
*iars
= disk
->ia_ranges
;
111 struct request_queue
*q
= disk
->queue
;
114 lockdep_assert_held(&q
->sysfs_dir_lock
);
115 lockdep_assert_held(&q
->sysfs_lock
);
121 * At this point, iars is the new set of sector access ranges that needs
122 * to be registered with sysfs.
124 WARN_ON(iars
->sysfs_registered
);
125 ret
= kobject_init_and_add(&iars
->kobj
, &blk_ia_ranges_ktype
,
126 &q
->kobj
, "%s", "independent_access_ranges");
128 disk
->ia_ranges
= NULL
;
129 kobject_put(&iars
->kobj
);
133 for (i
= 0; i
< iars
->nr_ia_ranges
; i
++) {
134 ret
= kobject_init_and_add(&iars
->ia_range
[i
].kobj
,
135 &blk_ia_range_ktype
, &iars
->kobj
,
139 kobject_del(&iars
->ia_range
[i
].kobj
);
140 kobject_del(&iars
->kobj
);
141 kobject_put(&iars
->kobj
);
146 iars
->sysfs_registered
= true;
151 void disk_unregister_independent_access_ranges(struct gendisk
*disk
)
153 struct request_queue
*q
= disk
->queue
;
154 struct blk_independent_access_ranges
*iars
= disk
->ia_ranges
;
157 lockdep_assert_held(&q
->sysfs_dir_lock
);
158 lockdep_assert_held(&q
->sysfs_lock
);
163 if (iars
->sysfs_registered
) {
164 for (i
= 0; i
< iars
->nr_ia_ranges
; i
++)
165 kobject_del(&iars
->ia_range
[i
].kobj
);
166 kobject_del(&iars
->kobj
);
167 kobject_put(&iars
->kobj
);
172 disk
->ia_ranges
= NULL
;
175 static struct blk_independent_access_range
*
176 disk_find_ia_range(struct blk_independent_access_ranges
*iars
,
179 struct blk_independent_access_range
*iar
;
182 for (i
= 0; i
< iars
->nr_ia_ranges
; i
++) {
183 iar
= &iars
->ia_range
[i
];
184 if (sector
>= iar
->sector
&&
185 sector
< iar
->sector
+ iar
->nr_sectors
)
192 static bool disk_check_ia_ranges(struct gendisk
*disk
,
193 struct blk_independent_access_ranges
*iars
)
195 struct blk_independent_access_range
*iar
, *tmp
;
196 sector_t capacity
= get_capacity(disk
);
200 if (WARN_ON_ONCE(!iars
->nr_ia_ranges
))
204 * While sorting the ranges in increasing LBA order, check that the
205 * ranges do not overlap, that there are no sector holes and that all
206 * sectors belong to one range.
208 for (i
= 0; i
< iars
->nr_ia_ranges
; i
++) {
209 tmp
= disk_find_ia_range(iars
, sector
);
210 if (!tmp
|| tmp
->sector
!= sector
) {
211 pr_warn("Invalid non-contiguous independent access ranges\n");
215 iar
= &iars
->ia_range
[i
];
217 swap(iar
->sector
, tmp
->sector
);
218 swap(iar
->nr_sectors
, tmp
->nr_sectors
);
221 sector
+= iar
->nr_sectors
;
224 if (sector
!= capacity
) {
225 pr_warn("Independent access ranges do not match disk capacity\n");
232 static bool disk_ia_ranges_changed(struct gendisk
*disk
,
233 struct blk_independent_access_ranges
*new)
235 struct blk_independent_access_ranges
*old
= disk
->ia_ranges
;
241 if (old
->nr_ia_ranges
!= new->nr_ia_ranges
)
244 for (i
= 0; i
< old
->nr_ia_ranges
; i
++) {
245 if (new->ia_range
[i
].sector
!= old
->ia_range
[i
].sector
||
246 new->ia_range
[i
].nr_sectors
!= old
->ia_range
[i
].nr_sectors
)
254 * disk_alloc_independent_access_ranges - Allocate an independent access ranges
257 * @nr_ia_ranges: Number of independent access ranges
259 * Allocate a struct blk_independent_access_ranges structure with @nr_ia_ranges
260 * access range descriptors.
262 struct blk_independent_access_ranges
*
263 disk_alloc_independent_access_ranges(struct gendisk
*disk
, int nr_ia_ranges
)
265 struct blk_independent_access_ranges
*iars
;
267 iars
= kzalloc_node(struct_size(iars
, ia_range
, nr_ia_ranges
),
268 GFP_KERNEL
, disk
->queue
->node
);
270 iars
->nr_ia_ranges
= nr_ia_ranges
;
273 EXPORT_SYMBOL_GPL(disk_alloc_independent_access_ranges
);
276 * disk_set_independent_access_ranges - Set a disk independent access ranges
278 * @iars: independent access ranges structure
280 * Set the independent access ranges information of the request queue
281 * of @disk to @iars. If @iars is NULL and the independent access ranges
282 * structure already set is cleared. If there are no differences between
283 * @iars and the independent access ranges structure already set, @iars
286 void disk_set_independent_access_ranges(struct gendisk
*disk
,
287 struct blk_independent_access_ranges
*iars
)
289 struct request_queue
*q
= disk
->queue
;
291 mutex_lock(&q
->sysfs_dir_lock
);
292 mutex_lock(&q
->sysfs_lock
);
293 if (iars
&& !disk_check_ia_ranges(disk
, iars
)) {
297 if (iars
&& !disk_ia_ranges_changed(disk
, iars
)) {
303 * This may be called for a registered queue. E.g. during a device
304 * revalidation. If that is the case, we need to unregister the old
305 * set of independent access ranges and register the new set. If the
306 * queue is not registered, registration of the device request queue
307 * will register the independent access ranges.
309 disk_unregister_independent_access_ranges(disk
);
310 disk
->ia_ranges
= iars
;
311 if (blk_queue_registered(q
))
312 disk_register_independent_access_ranges(disk
);
314 mutex_unlock(&q
->sysfs_lock
);
315 mutex_unlock(&q
->sysfs_dir_lock
);
317 EXPORT_SYMBOL_GPL(disk_set_independent_access_ranges
);