block/blk-zoned.c

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