~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/block/blk-ia-ranges.c

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp