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 |
103 | * independent access ranges | |
a2247f19 | 104 | * @disk: Target disk |
a2247f19 DLM |
105 | * |
106 | * Register with sysfs a set of independent access ranges for @disk. | |
a2247f19 | 107 | */ |
22d0c408 | 108 | int disk_register_independent_access_ranges(struct gendisk *disk) |
a2247f19 | 109 | { |
22d0c408 | 110 | struct blk_independent_access_ranges *iars = disk->ia_ranges; |
a2247f19 | 111 | struct request_queue *q = disk->queue; |
a2247f19 DLM |
112 | int i, ret; |
113 | ||
114 | lockdep_assert_held(&q->sysfs_dir_lock); | |
115 | lockdep_assert_held(&q->sysfs_lock); | |
116 | ||
a2247f19 DLM |
117 | if (!iars) |
118 | return 0; | |
119 | ||
120 | /* | |
121 | * At this point, iars is the new set of sector access ranges that needs | |
122 | * to be registered with sysfs. | |
123 | */ | |
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"); | |
127 | if (ret) { | |
6a27d28c | 128 | disk->ia_ranges = NULL; |
83114df3 | 129 | kobject_put(&iars->kobj); |
a2247f19 DLM |
130 | return ret; |
131 | } | |
132 | ||
133 | for (i = 0; i < iars->nr_ia_ranges; i++) { | |
a2247f19 DLM |
134 | ret = kobject_init_and_add(&iars->ia_range[i].kobj, |
135 | &blk_ia_range_ktype, &iars->kobj, | |
136 | "%d", i); | |
137 | if (ret) { | |
138 | while (--i >= 0) | |
139 | kobject_del(&iars->ia_range[i].kobj); | |
140 | kobject_del(&iars->kobj); | |
141 | kobject_put(&iars->kobj); | |
142 | return ret; | |
143 | } | |
144 | } | |
145 | ||
146 | iars->sysfs_registered = true; | |
147 | ||
148 | return 0; | |
149 | } | |
150 | ||
151 | void disk_unregister_independent_access_ranges(struct gendisk *disk) | |
152 | { | |
153 | struct request_queue *q = disk->queue; | |
6a27d28c | 154 | struct blk_independent_access_ranges *iars = disk->ia_ranges; |
a2247f19 DLM |
155 | int i; |
156 | ||
157 | lockdep_assert_held(&q->sysfs_dir_lock); | |
158 | lockdep_assert_held(&q->sysfs_lock); | |
159 | ||
160 | if (!iars) | |
161 | return; | |
162 | ||
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); | |
168 | } else { | |
169 | kfree(iars); | |
170 | } | |
171 | ||
6a27d28c | 172 | disk->ia_ranges = NULL; |
a2247f19 DLM |
173 | } |
174 | ||
175 | static struct blk_independent_access_range * | |
176 | disk_find_ia_range(struct blk_independent_access_ranges *iars, | |
177 | sector_t sector) | |
178 | { | |
179 | struct blk_independent_access_range *iar; | |
180 | int i; | |
181 | ||
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) | |
186 | return iar; | |
187 | } | |
188 | ||
189 | return NULL; | |
190 | } | |
191 | ||
192 | static bool disk_check_ia_ranges(struct gendisk *disk, | |
193 | struct blk_independent_access_ranges *iars) | |
194 | { | |
195 | struct blk_independent_access_range *iar, *tmp; | |
196 | sector_t capacity = get_capacity(disk); | |
197 | sector_t sector = 0; | |
198 | int i; | |
199 | ||
22d0c408 CH |
200 | if (WARN_ON_ONCE(!iars->nr_ia_ranges)) |
201 | return false; | |
202 | ||
a2247f19 DLM |
203 | /* |
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. | |
207 | */ | |
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"); | |
212 | return false; | |
213 | } | |
214 | ||
215 | iar = &iars->ia_range[i]; | |
216 | if (tmp != iar) { | |
217 | swap(iar->sector, tmp->sector); | |
218 | swap(iar->nr_sectors, tmp->nr_sectors); | |
219 | } | |
220 | ||
221 | sector += iar->nr_sectors; | |
222 | } | |
223 | ||
224 | if (sector != capacity) { | |
225 | pr_warn("Independent access ranges do not match disk capacity\n"); | |
226 | return false; | |
227 | } | |
228 | ||
229 | return true; | |
230 | } | |
231 | ||
232 | static bool disk_ia_ranges_changed(struct gendisk *disk, | |
233 | struct blk_independent_access_ranges *new) | |
234 | { | |
6a27d28c | 235 | struct blk_independent_access_ranges *old = disk->ia_ranges; |
a2247f19 DLM |
236 | int i; |
237 | ||
238 | if (!old) | |
239 | return true; | |
240 | ||
241 | if (old->nr_ia_ranges != new->nr_ia_ranges) | |
242 | return true; | |
243 | ||
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) | |
247 | return true; | |
248 | } | |
249 | ||
250 | return false; | |
251 | } | |
252 | ||
253 | /** | |
254 | * disk_alloc_independent_access_ranges - Allocate an independent access ranges | |
255 | * data structure | |
256 | * @disk: target disk | |
257 | * @nr_ia_ranges: Number of independent access ranges | |
258 | * | |
259 | * Allocate a struct blk_independent_access_ranges structure with @nr_ia_ranges | |
260 | * access range descriptors. | |
261 | */ | |
262 | struct blk_independent_access_ranges * | |
263 | disk_alloc_independent_access_ranges(struct gendisk *disk, int nr_ia_ranges) | |
264 | { | |
265 | struct blk_independent_access_ranges *iars; | |
266 | ||
267 | iars = kzalloc_node(struct_size(iars, ia_range, nr_ia_ranges), | |
268 | GFP_KERNEL, disk->queue->node); | |
269 | if (iars) | |
270 | iars->nr_ia_ranges = nr_ia_ranges; | |
271 | return iars; | |
272 | } | |
273 | EXPORT_SYMBOL_GPL(disk_alloc_independent_access_ranges); | |
274 | ||
275 | /** | |
276 | * disk_set_independent_access_ranges - Set a disk independent access ranges | |
277 | * @disk: target disk | |
278 | * @iars: independent access ranges structure | |
279 | * | |
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 | |
284 | * is freed. | |
285 | */ | |
286 | void disk_set_independent_access_ranges(struct gendisk *disk, | |
287 | struct blk_independent_access_ranges *iars) | |
288 | { | |
289 | struct request_queue *q = disk->queue; | |
290 | ||
22d0c408 CH |
291 | mutex_lock(&q->sysfs_dir_lock); |
292 | mutex_lock(&q->sysfs_lock); | |
293 | if (iars && !disk_check_ia_ranges(disk, iars)) { | |
a2247f19 DLM |
294 | kfree(iars); |
295 | iars = NULL; | |
296 | } | |
22d0c408 CH |
297 | if (iars && !disk_ia_ranges_changed(disk, iars)) { |
298 | kfree(iars); | |
299 | goto unlock; | |
a2247f19 DLM |
300 | } |
301 | ||
302 | /* | |
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 | |
22d0c408 | 307 | * will register the independent access ranges. |
a2247f19 | 308 | */ |
22d0c408 CH |
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); | |
a2247f19 DLM |
313 | unlock: |
314 | mutex_unlock(&q->sysfs_lock); | |
315 | mutex_unlock(&q->sysfs_dir_lock); | |
316 | } | |
317 | EXPORT_SYMBOL_GPL(disk_set_independent_access_ranges); |