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

TOMOYO Linux Cross Reference
Linux/block/blk-zoned.c

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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 /*
  2  * Zoned block device handling
  3  *
  4  * Copyright (c) 2015, Hannes Reinecke
  5  * Copyright (c) 2015, SUSE Linux GmbH
  6  *
  7  * Copyright (c) 2016, Damien Le Moal
  8  * Copyright (c) 2016, Western Digital
  9  */
 10 
 11 #include <linux/kernel.h>
 12 #include <linux/module.h>
 13 #include <linux/rbtree.h>
 14 #include <linux/blkdev.h>
 15 #include <linux/blk-mq.h>
 16 
 17 #include "blk.h"
 18 
 19 static inline sector_t blk_zone_start(struct request_queue *q,
 20                                       sector_t sector)
 21 {
 22         sector_t zone_mask = blk_queue_zone_sectors(q) - 1;
 23 
 24         return sector & ~zone_mask;
 25 }
 26 
 27 /*
 28  * Return true if a request is a write requests that needs zone write locking.
 29  */
 30 bool blk_req_needs_zone_write_lock(struct request *rq)
 31 {
 32         if (!rq->q->seq_zones_wlock)
 33                 return false;
 34 
 35         if (blk_rq_is_passthrough(rq))
 36                 return false;
 37 
 38         switch (req_op(rq)) {
 39         case REQ_OP_WRITE_ZEROES:
 40         case REQ_OP_WRITE_SAME:
 41         case REQ_OP_WRITE:
 42                 return blk_rq_zone_is_seq(rq);
 43         default:
 44                 return false;
 45         }
 46 }
 47 EXPORT_SYMBOL_GPL(blk_req_needs_zone_write_lock);
 48 
 49 void __blk_req_zone_write_lock(struct request *rq)
 50 {
 51         if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq),
 52                                           rq->q->seq_zones_wlock)))
 53                 return;
 54 
 55         WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
 56         rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
 57 }
 58 EXPORT_SYMBOL_GPL(__blk_req_zone_write_lock);
 59 
 60 void __blk_req_zone_write_unlock(struct request *rq)
 61 {
 62         rq->rq_flags &= ~RQF_ZONE_WRITE_LOCKED;
 63         if (rq->q->seq_zones_wlock)
 64                 WARN_ON_ONCE(!test_and_clear_bit(blk_rq_zone_no(rq),
 65                                                  rq->q->seq_zones_wlock));
 66 }
 67 EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
 68 
 69 static inline unsigned int __blkdev_nr_zones(struct request_queue *q,
 70                                              sector_t nr_sectors)
 71 {
 72         unsigned long zone_sectors = blk_queue_zone_sectors(q);
 73 
 74         return (nr_sectors + zone_sectors - 1) >> ilog2(zone_sectors);
 75 }
 76 
 77 /**
 78  * blkdev_nr_zones - Get number of zones
 79  * @bdev:       Target block device
 80  *
 81  * Description:
 82  *    Return the total number of zones of a zoned block device.
 83  *    For a regular block device, the number of zones is always 0.
 84  */
 85 unsigned int blkdev_nr_zones(struct block_device *bdev)
 86 {
 87         struct request_queue *q = bdev_get_queue(bdev);
 88 
 89         if (!blk_queue_is_zoned(q))
 90                 return 0;
 91 
 92         return __blkdev_nr_zones(q, bdev->bd_part->nr_sects);
 93 }
 94 EXPORT_SYMBOL_GPL(blkdev_nr_zones);
 95 
 96 /*
 97  * Check that a zone report belongs to this partition, and if yes, fix its start
 98  * sector and write pointer and return true. Return false otherwise.
 99  */
100 static bool blkdev_report_zone(struct block_device *bdev, struct blk_zone *rep)
101 {
102         sector_t offset = get_start_sect(bdev);
103 
104         if (rep->start < offset)
105                 return false;
106 
107         rep->start -= offset;
108         if (rep->start + rep->len > bdev->bd_part->nr_sects)
109                 return false;
110 
111         if (rep->type == BLK_ZONE_TYPE_CONVENTIONAL)
112                 rep->wp = rep->start + rep->len;
113         else
114                 rep->wp -= offset;
115         return true;
116 }
117 
118 static int blk_report_zones(struct gendisk *disk, sector_t sector,
119                             struct blk_zone *zones, unsigned int *nr_zones,
120                             gfp_t gfp_mask)
121 {
122         struct request_queue *q = disk->queue;
123         unsigned int z = 0, n, nrz = *nr_zones;
124         sector_t capacity = get_capacity(disk);
125         int ret;
126 
127         while (z < nrz && sector < capacity) {
128                 n = nrz - z;
129                 ret = disk->fops->report_zones(disk, sector, &zones[z], &n,
130                                                gfp_mask);
131                 if (ret)
132                         return ret;
133                 if (!n)
134                         break;
135                 sector += blk_queue_zone_sectors(q) * n;
136                 z += n;
137         }
138 
139         WARN_ON(z > *nr_zones);
140         *nr_zones = z;
141 
142         return 0;
143 }
144 
145 /**
146  * blkdev_report_zones - Get zones information
147  * @bdev:       Target block device
148  * @sector:     Sector from which to report zones
149  * @zones:      Array of zone structures where to return the zones information
150  * @nr_zones:   Number of zone structures in the zone array
151  * @gfp_mask:   Memory allocation flags (for bio_alloc)
152  *
153  * Description:
154  *    Get zone information starting from the zone containing @sector.
155  *    The number of zone information reported may be less than the number
156  *    requested by @nr_zones. The number of zones actually reported is
157  *    returned in @nr_zones.
158  */
159 int blkdev_report_zones(struct block_device *bdev, sector_t sector,
160                         struct blk_zone *zones, unsigned int *nr_zones,
161                         gfp_t gfp_mask)
162 {
163         struct request_queue *q = bdev_get_queue(bdev);
164         unsigned int i, nrz;
165         int ret;
166 
167         if (!blk_queue_is_zoned(q))
168                 return -EOPNOTSUPP;
169 
170         /*
171          * A block device that advertized itself as zoned must have a
172          * report_zones method. If it does not have one defined, the device
173          * driver has a bug. So warn about that.
174          */
175         if (WARN_ON_ONCE(!bdev->bd_disk->fops->report_zones))
176                 return -EOPNOTSUPP;
177 
178         if (!*nr_zones || sector >= bdev->bd_part->nr_sects) {
179                 *nr_zones = 0;
180                 return 0;
181         }
182 
183         nrz = min(*nr_zones,
184                   __blkdev_nr_zones(q, bdev->bd_part->nr_sects - sector));
185         ret = blk_report_zones(bdev->bd_disk, get_start_sect(bdev) + sector,
186                                zones, &nrz, gfp_mask);
187         if (ret)
188                 return ret;
189 
190         for (i = 0; i < nrz; i++) {
191                 if (!blkdev_report_zone(bdev, zones))
192                         break;
193                 zones++;
194         }
195 
196         *nr_zones = i;
197 
198         return 0;
199 }
200 EXPORT_SYMBOL_GPL(blkdev_report_zones);
201 
202 /**
203  * blkdev_reset_zones - Reset zones write pointer
204  * @bdev:       Target block device
205  * @sector:     Start sector of the first zone to reset
206  * @nr_sectors: Number of sectors, at least the length of one zone
207  * @gfp_mask:   Memory allocation flags (for bio_alloc)
208  *
209  * Description:
210  *    Reset the write pointer of the zones contained in the range
211  *    @sector..@sector+@nr_sectors. Specifying the entire disk sector range
212  *    is valid, but the specified range should not contain conventional zones.
213  */
214 int blkdev_reset_zones(struct block_device *bdev,
215                        sector_t sector, sector_t nr_sectors,
216                        gfp_t gfp_mask)
217 {
218         struct request_queue *q = bdev_get_queue(bdev);
219         sector_t zone_sectors;
220         sector_t end_sector = sector + nr_sectors;
221         struct bio *bio = NULL;
222         struct blk_plug plug;
223         int ret;
224 
225         if (!blk_queue_is_zoned(q))
226                 return -EOPNOTSUPP;
227 
228         if (bdev_read_only(bdev))
229                 return -EPERM;
230 
231         if (!nr_sectors || end_sector > bdev->bd_part->nr_sects)
232                 /* Out of range */
233                 return -EINVAL;
234 
235         /* Check alignment (handle eventual smaller last zone) */
236         zone_sectors = blk_queue_zone_sectors(q);
237         if (sector & (zone_sectors - 1))
238                 return -EINVAL;
239 
240         if ((nr_sectors & (zone_sectors - 1)) &&
241             end_sector != bdev->bd_part->nr_sects)
242                 return -EINVAL;
243 
244         blk_start_plug(&plug);
245         while (sector < end_sector) {
246 
247                 bio = blk_next_bio(bio, 0, gfp_mask);
248                 bio->bi_iter.bi_sector = sector;
249                 bio_set_dev(bio, bdev);
250                 bio_set_op_attrs(bio, REQ_OP_ZONE_RESET, 0);
251 
252                 sector += zone_sectors;
253 
254                 /* This may take a while, so be nice to others */
255                 cond_resched();
256 
257         }
258 
259         ret = submit_bio_wait(bio);
260         bio_put(bio);
261 
262         blk_finish_plug(&plug);
263 
264         return ret;
265 }
266 EXPORT_SYMBOL_GPL(blkdev_reset_zones);
267 
268 /*
269  * BLKREPORTZONE ioctl processing.
270  * Called from blkdev_ioctl.
271  */
272 int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
273                               unsigned int cmd, unsigned long arg)
274 {
275         void __user *argp = (void __user *)arg;
276         struct request_queue *q;
277         struct blk_zone_report rep;
278         struct blk_zone *zones;
279         int ret;
280 
281         if (!argp)
282                 return -EINVAL;
283 
284         q = bdev_get_queue(bdev);
285         if (!q)
286                 return -ENXIO;
287 
288         if (!blk_queue_is_zoned(q))
289                 return -ENOTTY;
290 
291         if (!capable(CAP_SYS_ADMIN))
292                 return -EACCES;
293 
294         if (copy_from_user(&rep, argp, sizeof(struct blk_zone_report)))
295                 return -EFAULT;
296 
297         if (!rep.nr_zones)
298                 return -EINVAL;
299 
300         rep.nr_zones = min(blkdev_nr_zones(bdev), rep.nr_zones);
301 
302         zones = kvmalloc_array(rep.nr_zones, sizeof(struct blk_zone),
303                                GFP_KERNEL | __GFP_ZERO);
304         if (!zones)
305                 return -ENOMEM;
306 
307         ret = blkdev_report_zones(bdev, rep.sector,
308                                   zones, &rep.nr_zones,
309                                   GFP_KERNEL);
310         if (ret)
311                 goto out;
312 
313         if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report))) {
314                 ret = -EFAULT;
315                 goto out;
316         }
317 
318         if (rep.nr_zones) {
319                 if (copy_to_user(argp + sizeof(struct blk_zone_report), zones,
320                                  sizeof(struct blk_zone) * rep.nr_zones))
321                         ret = -EFAULT;
322         }
323 
324  out:
325         kvfree(zones);
326 
327         return ret;
328 }
329 
330 /*
331  * BLKRESETZONE ioctl processing.
332  * Called from blkdev_ioctl.
333  */
334 int blkdev_reset_zones_ioctl(struct block_device *bdev, fmode_t mode,
335                              unsigned int cmd, unsigned long arg)
336 {
337         void __user *argp = (void __user *)arg;
338         struct request_queue *q;
339         struct blk_zone_range zrange;
340 
341         if (!argp)
342                 return -EINVAL;
343 
344         q = bdev_get_queue(bdev);
345         if (!q)
346                 return -ENXIO;
347 
348         if (!blk_queue_is_zoned(q))
349                 return -ENOTTY;
350 
351         if (!capable(CAP_SYS_ADMIN))
352                 return -EACCES;
353 
354         if (!(mode & FMODE_WRITE))
355                 return -EBADF;
356 
357         if (copy_from_user(&zrange, argp, sizeof(struct blk_zone_range)))
358                 return -EFAULT;
359 
360         return blkdev_reset_zones(bdev, zrange.sector, zrange.nr_sectors,
361                                   GFP_KERNEL);
362 }
363 
364 static inline unsigned long *blk_alloc_zone_bitmap(int node,
365                                                    unsigned int nr_zones)
366 {
367         return kcalloc_node(BITS_TO_LONGS(nr_zones), sizeof(unsigned long),
368                             GFP_NOIO, node);
369 }
370 
371 /*
372  * Allocate an array of struct blk_zone to get nr_zones zone information.
373  * The allocated array may be smaller than nr_zones.
374  */
375 static struct blk_zone *blk_alloc_zones(int node, unsigned int *nr_zones)
376 {
377         size_t size = *nr_zones * sizeof(struct blk_zone);
378         struct page *page;
379         int order;
380 
381         for (order = get_order(size); order >= 0; order--) {
382                 page = alloc_pages_node(node, GFP_NOIO | __GFP_ZERO, order);
383                 if (page) {
384                         *nr_zones = min_t(unsigned int, *nr_zones,
385                                 (PAGE_SIZE << order) / sizeof(struct blk_zone));
386                         return page_address(page);
387                 }
388         }
389 
390         return NULL;
391 }
392 
393 void blk_queue_free_zone_bitmaps(struct request_queue *q)
394 {
395         kfree(q->seq_zones_bitmap);
396         q->seq_zones_bitmap = NULL;
397         kfree(q->seq_zones_wlock);
398         q->seq_zones_wlock = NULL;
399 }
400 
401 /**
402  * blk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps
403  * @disk:       Target disk
404  *
405  * Helper function for low-level device drivers to (re) allocate and initialize
406  * a disk request queue zone bitmaps. This functions should normally be called
407  * within the disk ->revalidate method. For BIO based queues, no zone bitmap
408  * is allocated.
409  */
410 int blk_revalidate_disk_zones(struct gendisk *disk)
411 {
412         struct request_queue *q = disk->queue;
413         unsigned int nr_zones = __blkdev_nr_zones(q, get_capacity(disk));
414         unsigned long *seq_zones_wlock = NULL, *seq_zones_bitmap = NULL;
415         unsigned int i, rep_nr_zones = 0, z = 0, nrz;
416         struct blk_zone *zones = NULL;
417         sector_t sector = 0;
418         int ret = 0;
419 
420         /*
421          * BIO based queues do not use a scheduler so only q->nr_zones
422          * needs to be updated so that the sysfs exposed value is correct.
423          */
424         if (!queue_is_mq(q)) {
425                 q->nr_zones = nr_zones;
426                 return 0;
427         }
428 
429         if (!blk_queue_is_zoned(q) || !nr_zones) {
430                 nr_zones = 0;
431                 goto update;
432         }
433 
434         /* Allocate bitmaps */
435         ret = -ENOMEM;
436         seq_zones_wlock = blk_alloc_zone_bitmap(q->node, nr_zones);
437         if (!seq_zones_wlock)
438                 goto out;
439         seq_zones_bitmap = blk_alloc_zone_bitmap(q->node, nr_zones);
440         if (!seq_zones_bitmap)
441                 goto out;
442 
443         /* Get zone information and initialize seq_zones_bitmap */
444         rep_nr_zones = nr_zones;
445         zones = blk_alloc_zones(q->node, &rep_nr_zones);
446         if (!zones)
447                 goto out;
448 
449         while (z < nr_zones) {
450                 nrz = min(nr_zones - z, rep_nr_zones);
451                 ret = blk_report_zones(disk, sector, zones, &nrz, GFP_NOIO);
452                 if (ret)
453                         goto out;
454                 if (!nrz)
455                         break;
456                 for (i = 0; i < nrz; i++) {
457                         if (zones[i].type != BLK_ZONE_TYPE_CONVENTIONAL)
458                                 set_bit(z, seq_zones_bitmap);
459                         z++;
460                 }
461                 sector += nrz * blk_queue_zone_sectors(q);
462         }
463 
464         if (WARN_ON(z != nr_zones)) {
465                 ret = -EIO;
466                 goto out;
467         }
468 
469 update:
470         /*
471          * Install the new bitmaps, making sure the queue is stopped and
472          * all I/Os are completed (i.e. a scheduler is not referencing the
473          * bitmaps).
474          */
475         blk_mq_freeze_queue(q);
476         q->nr_zones = nr_zones;
477         swap(q->seq_zones_wlock, seq_zones_wlock);
478         swap(q->seq_zones_bitmap, seq_zones_bitmap);
479         blk_mq_unfreeze_queue(q);
480 
481 out:
482         free_pages((unsigned long)zones,
483                    get_order(rep_nr_zones * sizeof(struct blk_zone)));
484         kfree(seq_zones_wlock);
485         kfree(seq_zones_bitmap);
486 
487         if (ret) {
488                 pr_warn("%s: failed to revalidate zones\n", disk->disk_name);
489                 blk_mq_freeze_queue(q);
490                 blk_queue_free_zone_bitmaps(q);
491                 blk_mq_unfreeze_queue(q);
492         }
493 
494         return ret;
495 }
496 EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones);
497 
498 

~ [ 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