drivers/block/null_blk_zoned.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/vmalloc.h>
   3 #include <linux/bitmap.h>
   4 #include "null_blk.h"
   5
   6 #define CREATE_TRACE_POINTS
   7 #include "null_blk_trace.h"
   8
   9 /* zone_size in MBs to sectors. */
  10 #define ZONE_SIZE_SHIFT         11
  11
  12 static inline unsigned int null_zone_no(struct nullb_device *dev, sector_t sect)
  13 {
  14         return sect >> ilog2(dev->zone_size_sects);
  15 }
  16
  17 int null_init_zoned_dev(struct nullb_device *dev, struct request_queue *q)
  18 {
  19         sector_t dev_size = (sector_t)dev->size * 1024 * 1024;
  20         sector_t sector = 0;
  21         unsigned int i;
  22
  23         if (!is_power_of_2(dev->zone_size)) {
  24                 pr_err("zone_size must be power-of-two\n");
  25                 return -EINVAL;
  26         }
  27         if (dev->zone_size > dev->size) {
  28                 pr_err("Zone size larger than device capacity\n");
  29                 return -EINVAL;
  30         }
  31
  32         if (!dev->zone_capacity)
  33                 dev->zone_capacity = dev->zone_size;
  34
  35         if (dev->zone_capacity > dev->zone_size) {
  36                 pr_err("null_blk: zone capacity (%lu MB) larger than zone size (%lu MB)\n",
  37                                         dev->zone_capacity, dev->zone_size);
  38                 return -EINVAL;
  39         }
  40
  41         dev->zone_size_sects = dev->zone_size << ZONE_SIZE_SHIFT;
  42         dev->nr_zones = dev_size >>
  43                                 (SECTOR_SHIFT + ilog2(dev->zone_size_sects));
  44         dev->zones = kvmalloc_array(dev->nr_zones, sizeof(struct blk_zone),
  45                         GFP_KERNEL | __GFP_ZERO);
  46         if (!dev->zones)
  47                 return -ENOMEM;
  48
  49         spin_lock_init(&dev->zone_dev_lock);
  50         dev->zone_locks = bitmap_zalloc(dev->nr_zones, GFP_KERNEL);
  51         if (!dev->zone_locks) {
  52                 kvfree(dev->zones);
  53                 return -ENOMEM;
  54         }
  55
  56         if (dev->zone_nr_conv >= dev->nr_zones) {
  57                 dev->zone_nr_conv = dev->nr_zones - 1;
  58                 pr_info("changed the number of conventional zones to %u",
  59                         dev->zone_nr_conv);
  60         }
  61
  62         /* Max active zones has to be < nbr of seq zones in order to be enforceable */
  63         if (dev->zone_max_active >= dev->nr_zones - dev->zone_nr_conv) {
  64                 dev->zone_max_active = 0;
  65                 pr_info("zone_max_active limit disabled, limit >= zone count\n");
  66         }
  67
  68         /* Max open zones has to be <= max active zones */
  69         if (dev->zone_max_active && dev->zone_max_open > dev->zone_max_active) {
  70                 dev->zone_max_open = dev->zone_max_active;
  71                 pr_info("changed the maximum number of open zones to %u\n",
  72                         dev->nr_zones);
  73         } else if (dev->zone_max_open >= dev->nr_zones - dev->zone_nr_conv) {
  74                 dev->zone_max_open = 0;
  75                 pr_info("zone_max_open limit disabled, limit >= zone count\n");
  76         }
  77
  78         for (i = 0; i <  dev->zone_nr_conv; i++) {
  79                 struct blk_zone *zone = &dev->zones[i];
  80
  81                 zone->start = sector;
  82                 zone->len = dev->zone_size_sects;
  83                 zone->capacity = zone->len;
  84                 zone->wp = zone->start + zone->len;
  85                 zone->type = BLK_ZONE_TYPE_CONVENTIONAL;
  86                 zone->cond = BLK_ZONE_COND_NOT_WP;
  87
  88                 sector += dev->zone_size_sects;
  89         }
  90
  91         for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) {
  92                 struct blk_zone *zone = &dev->zones[i];
  93
  94                 zone->start = zone->wp = sector;
  95                 zone->len = dev->zone_size_sects;
  96                 zone->capacity = dev->zone_capacity << ZONE_SIZE_SHIFT;
  97                 zone->type = BLK_ZONE_TYPE_SEQWRITE_REQ;
  98                 zone->cond = BLK_ZONE_COND_EMPTY;
  99
 100                 sector += dev->zone_size_sects;
 101         }
 102
 103         q->limits.zoned = BLK_ZONED_HM;
 104         blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);
 105         blk_queue_required_elevator_features(q, ELEVATOR_F_ZBD_SEQ_WRITE);
 106
 107         return 0;
 108 }
 109
 110 int null_register_zoned_dev(struct nullb *nullb)
 111 {
 112         struct nullb_device *dev = nullb->dev;
 113         struct request_queue *q = nullb->q;
 114
 115         if (queue_is_mq(q)) {
 116                 int ret = blk_revalidate_disk_zones(nullb->disk, NULL);
 117
 118                 if (ret)
 119                         return ret;
 120         } else {
 121                 blk_queue_chunk_sectors(q, dev->zone_size_sects);
 122                 q->nr_zones = blkdev_nr_zones(nullb->disk);
 123         }
 124
 125         blk_queue_max_zone_append_sectors(q, dev->zone_size_sects);
 126         blk_queue_max_open_zones(q, dev->zone_max_open);
 127         blk_queue_max_active_zones(q, dev->zone_max_active);
 128
 129         return 0;
 130 }
 131
 132 void null_free_zoned_dev(struct nullb_device *dev)
 133 {
 134         bitmap_free(dev->zone_locks);
 135         kvfree(dev->zones);
 136 }
 137
 138 static inline void null_lock_zone(struct nullb_device *dev, unsigned int zno)
 139 {
 140         wait_on_bit_lock_io(dev->zone_locks, zno, TASK_UNINTERRUPTIBLE);
 141 }
 142
 143 static inline void null_unlock_zone(struct nullb_device *dev, unsigned int zno)
 144 {
 145         clear_and_wake_up_bit(zno, dev->zone_locks);
 146 }
 147
 148 int null_report_zones(struct gendisk *disk, sector_t sector,
 149                 unsigned int nr_zones, report_zones_cb cb, void *data)
 150 {
 151         struct nullb *nullb = disk->private_data;
 152         struct nullb_device *dev = nullb->dev;
 153         unsigned int first_zone, i, zno;
 154         struct blk_zone zone;
 155         int error;
 156
 157         first_zone = null_zone_no(dev, sector);
 158         if (first_zone >= dev->nr_zones)
 159                 return 0;
 160
 161         nr_zones = min(nr_zones, dev->nr_zones - first_zone);
 162         trace_nullb_report_zones(nullb, nr_zones);
 163
 164         zno = first_zone;
 165         for (i = 0; i < nr_zones; i++, zno++) {
 166                 /*
 167                  * Stacked DM target drivers will remap the zone information by
 168                  * modifying the zone information passed to the report callback.
 169                  * So use a local copy to avoid corruption of the device zone
 170                  * array.
 171                  */
 172                 null_lock_zone(dev, zno);
 173                 memcpy(&zone, &dev->zones[zno], sizeof(struct blk_zone));
 174                 null_unlock_zone(dev, zno);
 175
 176                 error = cb(&zone, i, data);
 177                 if (error)
 178                         return error;
 179         }
 180
 181         return nr_zones;
 182 }
 183
 184 /*
 185  * This is called in the case of memory backing from null_process_cmd()
 186  * with the target zone already locked.
 187  */
 188 size_t null_zone_valid_read_len(struct nullb *nullb,
 189                                 sector_t sector, unsigned int len)
 190 {
 191         struct nullb_device *dev = nullb->dev;
 192         struct blk_zone *zone = &dev->zones[null_zone_no(dev, sector)];
 193         unsigned int nr_sectors = len >> SECTOR_SHIFT;
 194
 195         /* Read must be below the write pointer position */
 196         if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL ||
 197             sector + nr_sectors <= zone->wp)
 198                 return len;
 199
 200         if (sector > zone->wp)
 201                 return 0;
 202
 203         return (zone->wp - sector) << SECTOR_SHIFT;
 204 }
 205
 206 static blk_status_t null_close_zone(struct nullb_device *dev, struct blk_zone *zone)
 207 {
 208         if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
 209                 return BLK_STS_IOERR;
 210
 211         switch (zone->cond) {
 212         case BLK_ZONE_COND_CLOSED:
 213                 /* close operation on closed is not an error */
 214                 return BLK_STS_OK;
 215         case BLK_ZONE_COND_IMP_OPEN:
 216                 dev->nr_zones_imp_open--;
 217                 break;
 218         case BLK_ZONE_COND_EXP_OPEN:
 219                 dev->nr_zones_exp_open--;
 220                 break;
 221         case BLK_ZONE_COND_EMPTY:
 222         case BLK_ZONE_COND_FULL:
 223         default:
 224                 return BLK_STS_IOERR;
 225         }
 226
 227         if (zone->wp == zone->start) {
 228                 zone->cond = BLK_ZONE_COND_EMPTY;
 229         } else {
 230                 zone->cond = BLK_ZONE_COND_CLOSED;
 231                 dev->nr_zones_closed++;
 232         }
 233
 234         return BLK_STS_OK;
 235 }
 236
 237 static void null_close_first_imp_zone(struct nullb_device *dev)
 238 {
 239         unsigned int i;
 240
 241         for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) {
 242                 if (dev->zones[i].cond == BLK_ZONE_COND_IMP_OPEN) {
 243                         null_close_zone(dev, &dev->zones[i]);
 244                         return;
 245                 }
 246         }
 247 }
 248
 249 static blk_status_t null_check_active(struct nullb_device *dev)
 250 {
 251         if (!dev->zone_max_active)
 252                 return BLK_STS_OK;
 253
 254         if (dev->nr_zones_exp_open + dev->nr_zones_imp_open +
 255                         dev->nr_zones_closed < dev->zone_max_active)
 256                 return BLK_STS_OK;
 257
 258         return BLK_STS_ZONE_ACTIVE_RESOURCE;
 259 }
 260
 261 static blk_status_t null_check_open(struct nullb_device *dev)
 262 {
 263         if (!dev->zone_max_open)
 264                 return BLK_STS_OK;
 265
 266         if (dev->nr_zones_exp_open + dev->nr_zones_imp_open < dev->zone_max_open)
 267                 return BLK_STS_OK;
 268
 269         if (dev->nr_zones_imp_open) {
 270                 if (null_check_active(dev) == BLK_STS_OK) {
 271                         null_close_first_imp_zone(dev);
 272                         return BLK_STS_OK;
 273                 }
 274         }
 275
 276         return BLK_STS_ZONE_OPEN_RESOURCE;
 277 }
 278
 279 /*
 280  * This function matches the manage open zone resources function in the ZBC standard,
 281  * with the addition of max active zones support (added in the ZNS standard).
 282  *
 283  * The function determines if a zone can transition to implicit open or explicit open,
 284  * while maintaining the max open zone (and max active zone) limit(s). It may close an
 285  * implicit open zone in order to make additional zone resources available.
 286  *
 287  * ZBC states that an implicit open zone shall be closed only if there is not
 288  * room within the open limit. However, with the addition of an active limit,
 289  * it is not certain that closing an implicit open zone will allow a new zone
 290  * to be opened, since we might already be at the active limit capacity.
 291  */
 292 static blk_status_t null_check_zone_resources(struct nullb_device *dev, struct blk_zone *zone)
 293 {
 294         blk_status_t ret;
 295
 296         switch (zone->cond) {
 297         case BLK_ZONE_COND_EMPTY:
 298                 ret = null_check_active(dev);
 299                 if (ret != BLK_STS_OK)
 300                         return ret;
 301                 fallthrough;
 302         case BLK_ZONE_COND_CLOSED:
 303                 return null_check_open(dev);
 304         default:
 305                 /* Should never be called for other states */
 306                 WARN_ON(1);
 307                 return BLK_STS_IOERR;
 308         }
 309 }
 310
 311 static blk_status_t null_zone_write(struct nullb_cmd *cmd, sector_t sector,
 312                                     unsigned int nr_sectors, bool append)
 313 {
 314         struct nullb_device *dev = cmd->nq->dev;
 315         unsigned int zno = null_zone_no(dev, sector);
 316         struct blk_zone *zone = &dev->zones[zno];
 317         blk_status_t ret;
 318
 319         trace_nullb_zone_op(cmd, zno, zone->cond);
 320
 321         if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
 322                 return null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors);
 323
 324         null_lock_zone(dev, zno);
 325         spin_lock(&dev->zone_dev_lock);
 326
 327         switch (zone->cond) {
 328         case BLK_ZONE_COND_FULL:
 329                 /* Cannot write to a full zone */
 330                 ret = BLK_STS_IOERR;
 331                 goto unlock;
 332         case BLK_ZONE_COND_EMPTY:
 333         case BLK_ZONE_COND_CLOSED:
 334                 ret = null_check_zone_resources(dev, zone);
 335                 if (ret != BLK_STS_OK)
 336                         goto unlock;
 337                 break;
 338         case BLK_ZONE_COND_IMP_OPEN:
 339         case BLK_ZONE_COND_EXP_OPEN:
 340                 break;
 341         default:
 342                 /* Invalid zone condition */
 343                 ret = BLK_STS_IOERR;
 344                 goto unlock;
 345         }
 346
 347         /*
 348          * Regular writes must be at the write pointer position.
 349          * Zone append writes are automatically issued at the write
 350          * pointer and the position returned using the request or BIO
 351          * sector.
 352          */
 353         if (append) {
 354                 sector = zone->wp;
 355                 if (cmd->bio)
 356                         cmd->bio->bi_iter.bi_sector = sector;
 357                 else
 358                         cmd->rq->__sector = sector;
 359         } else if (sector != zone->wp) {
 360                 ret = BLK_STS_IOERR;
 361                 goto unlock;
 362         }
 363
 364         if (zone->wp + nr_sectors > zone->start + zone->capacity) {
 365                 ret = BLK_STS_IOERR;
 366                 goto unlock;
 367         }
 368
 369         if (zone->cond == BLK_ZONE_COND_CLOSED) {
 370                 dev->nr_zones_closed--;
 371                 dev->nr_zones_imp_open++;
 372         } else if (zone->cond == BLK_ZONE_COND_EMPTY) {
 373                 dev->nr_zones_imp_open++;
 374         }
 375         if (zone->cond != BLK_ZONE_COND_EXP_OPEN)
 376                 zone->cond = BLK_ZONE_COND_IMP_OPEN;
 377
 378         spin_unlock(&dev->zone_dev_lock);
 379         ret = null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors);
 380         spin_lock(&dev->zone_dev_lock);
 381         if (ret != BLK_STS_OK)
 382                 goto unlock;
 383
 384         zone->wp += nr_sectors;
 385         if (zone->wp == zone->start + zone->capacity) {
 386                 if (zone->cond == BLK_ZONE_COND_EXP_OPEN)
 387                         dev->nr_zones_exp_open--;
 388                 else if (zone->cond == BLK_ZONE_COND_IMP_OPEN)
 389                         dev->nr_zones_imp_open--;
 390                 zone->cond = BLK_ZONE_COND_FULL;
 391         }
 392         ret = BLK_STS_OK;
 393
 394 unlock:
 395         spin_unlock(&dev->zone_dev_lock);
 396         null_unlock_zone(dev, zno);
 397
 398         return ret;
 399 }
 400
 401 static blk_status_t null_open_zone(struct nullb_device *dev, struct blk_zone *zone)
 402 {
 403         blk_status_t ret;
 404
 405         if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
 406                 return BLK_STS_IOERR;
 407
 408         switch (zone->cond) {
 409         case BLK_ZONE_COND_EXP_OPEN:
 410                 /* open operation on exp open is not an error */
 411                 return BLK_STS_OK;
 412         case BLK_ZONE_COND_EMPTY:
 413                 ret = null_check_zone_resources(dev, zone);
 414                 if (ret != BLK_STS_OK)
 415                         return ret;
 416                 break;
 417         case BLK_ZONE_COND_IMP_OPEN:
 418                 dev->nr_zones_imp_open--;
 419                 break;
 420         case BLK_ZONE_COND_CLOSED:
 421                 ret = null_check_zone_resources(dev, zone);
 422                 if (ret != BLK_STS_OK)
 423                         return ret;
 424                 dev->nr_zones_closed--;
 425                 break;
 426         case BLK_ZONE_COND_FULL:
 427         default:
 428                 return BLK_STS_IOERR;
 429         }
 430
 431         zone->cond = BLK_ZONE_COND_EXP_OPEN;
 432         dev->nr_zones_exp_open++;
 433
 434         return BLK_STS_OK;
 435 }
 436
 437 static blk_status_t null_finish_zone(struct nullb_device *dev, struct blk_zone *zone)
 438 {
 439         blk_status_t ret;
 440
 441         if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
 442                 return BLK_STS_IOERR;
 443
 444         switch (zone->cond) {
 445         case BLK_ZONE_COND_FULL:
 446                 /* finish operation on full is not an error */
 447                 return BLK_STS_OK;
 448         case BLK_ZONE_COND_EMPTY:
 449                 ret = null_check_zone_resources(dev, zone);
 450                 if (ret != BLK_STS_OK)
 451                         return ret;
 452                 break;
 453         case BLK_ZONE_COND_IMP_OPEN:
 454                 dev->nr_zones_imp_open--;
 455                 break;
 456         case BLK_ZONE_COND_EXP_OPEN:
 457                 dev->nr_zones_exp_open--;
 458                 break;
 459         case BLK_ZONE_COND_CLOSED:
 460                 ret = null_check_zone_resources(dev, zone);
 461                 if (ret != BLK_STS_OK)
 462                         return ret;
 463                 dev->nr_zones_closed--;
 464                 break;
 465         default:
 466                 return BLK_STS_IOERR;
 467         }
 468
 469         zone->cond = BLK_ZONE_COND_FULL;
 470         zone->wp = zone->start + zone->len;
 471
 472         return BLK_STS_OK;
 473 }
 474
 475 static blk_status_t null_reset_zone(struct nullb_device *dev, struct blk_zone *zone)
 476 {
 477         if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)
 478                 return BLK_STS_IOERR;
 479
 480         switch (zone->cond) {
 481         case BLK_ZONE_COND_EMPTY:
 482                 /* reset operation on empty is not an error */
 483                 return BLK_STS_OK;
 484         case BLK_ZONE_COND_IMP_OPEN:
 485                 dev->nr_zones_imp_open--;
 486                 break;
 487         case BLK_ZONE_COND_EXP_OPEN:
 488                 dev->nr_zones_exp_open--;
 489                 break;
 490         case BLK_ZONE_COND_CLOSED:
 491                 dev->nr_zones_closed--;
 492                 break;
 493         case BLK_ZONE_COND_FULL:
 494                 break;
 495         default:
 496                 return BLK_STS_IOERR;
 497         }
 498
 499         zone->cond = BLK_ZONE_COND_EMPTY;
 500         zone->wp = zone->start;
 501
 502         return BLK_STS_OK;
 503 }
 504
 505 static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_opf op,
 506                                    sector_t sector)
 507 {
 508         struct nullb_device *dev = cmd->nq->dev;
 509         unsigned int zone_no;
 510         struct blk_zone *zone;
 511         blk_status_t ret;
 512         size_t i;
 513
 514         if (op == REQ_OP_ZONE_RESET_ALL) {
 515                 for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) {
 516                         null_lock_zone(dev, i);
 517                         zone = &dev->zones[i];
 518                         if (zone->cond != BLK_ZONE_COND_EMPTY) {
 519                                 spin_lock(&dev->zone_dev_lock);
 520                                 null_reset_zone(dev, zone);
 521                                 spin_unlock(&dev->zone_dev_lock);
 522                                 trace_nullb_zone_op(cmd, i, zone->cond);
 523                         }
 524                         null_unlock_zone(dev, i);
 525                 }
 526                 return BLK_STS_OK;
 527         }
 528
 529         zone_no = null_zone_no(dev, sector);
 530         zone = &dev->zones[zone_no];
 531
 532         null_lock_zone(dev, zone_no);
 533         spin_lock(&dev->zone_dev_lock);
 534
 535         switch (op) {
 536         case REQ_OP_ZONE_RESET:
 537                 ret = null_reset_zone(dev, zone);
 538                 break;
 539         case REQ_OP_ZONE_OPEN:
 540                 ret = null_open_zone(dev, zone);
 541                 break;
 542         case REQ_OP_ZONE_CLOSE:
 543                 ret = null_close_zone(dev, zone);
 544                 break;
 545         case REQ_OP_ZONE_FINISH:
 546                 ret = null_finish_zone(dev, zone);
 547                 break;
 548         default:
 549                 ret = BLK_STS_NOTSUPP;
 550                 break;
 551         }
 552
 553         spin_unlock(&dev->zone_dev_lock);
 554
 555         if (ret == BLK_STS_OK)
 556                 trace_nullb_zone_op(cmd, zone_no, zone->cond);
 557
 558         null_unlock_zone(dev, zone_no);
 559
 560         return ret;
 561 }
 562
 563 blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_opf op,
 564                                     sector_t sector, sector_t nr_sectors)
 565 {
 566         struct nullb_device *dev = cmd->nq->dev;
 567         unsigned int zno = null_zone_no(dev, sector);
 568         blk_status_t sts;
 569
 570         switch (op) {
 571         case REQ_OP_WRITE:
 572                 sts = null_zone_write(cmd, sector, nr_sectors, false);
 573                 break;
 574         case REQ_OP_ZONE_APPEND:
 575                 sts = null_zone_write(cmd, sector, nr_sectors, true);
 576                 break;
 577         case REQ_OP_ZONE_RESET:
 578         case REQ_OP_ZONE_RESET_ALL:
 579         case REQ_OP_ZONE_OPEN:
 580         case REQ_OP_ZONE_CLOSE:
 581         case REQ_OP_ZONE_FINISH:
 582                 sts = null_zone_mgmt(cmd, op, sector);
 583                 break;
 584         default:
 585                 null_lock_zone(dev, zno);
 586                 sts = null_process_cmd(cmd, op, sector, nr_sectors);
 587                 null_unlock_zone(dev, zno);
 588         }
 589
 590         return sts;
 591 }