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