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 "trace.h" 8 9 #undef pr_fmt 10 #define pr_fmt(fmt) "null_blk: " fmt 11 12 #define NULL_ZONE_INVALID_WP ((sector_t)-1) 13 14 static inline sector_t mb_to_sects(unsigned long mb) 15 { 16 return ((sector_t)mb * SZ_1M) >> SECTOR_SHIFT; 17 } 18 19 static inline unsigned int null_zone_no(struct nullb_device *dev, sector_t sect) 20 { 21 return sect >> ilog2(dev->zone_size_sects); 22 } 23 24 static inline void null_init_zone_lock(struct nullb_device *dev, 25 struct nullb_zone *zone) 26 { 27 if (!dev->memory_backed) 28 spin_lock_init(&zone->spinlock); 29 else 30 mutex_init(&zone->mutex); 31 } 32 33 static inline void null_lock_zone(struct nullb_device *dev, 34 struct nullb_zone *zone) 35 { 36 if (!dev->memory_backed) 37 spin_lock_irq(&zone->spinlock); 38 else 39 mutex_lock(&zone->mutex); 40 } 41 42 static inline void null_unlock_zone(struct nullb_device *dev, 43 struct nullb_zone *zone) 44 { 45 if (!dev->memory_backed) 46 spin_unlock_irq(&zone->spinlock); 47 else 48 mutex_unlock(&zone->mutex); 49 } 50 51 int null_init_zoned_dev(struct nullb_device *dev, 52 struct queue_limits *lim) 53 { 54 sector_t dev_capacity_sects, zone_capacity_sects; 55 struct nullb_zone *zone; 56 sector_t sector = 0; 57 unsigned int i; 58 59 if (!is_power_of_2(dev->zone_size)) { 60 pr_err("zone_size must be power-of-two\n"); 61 return -EINVAL; 62 } 63 if (dev->zone_size > dev->size) { 64 pr_err("Zone size larger than device capacity\n"); 65 return -EINVAL; 66 } 67 68 if (!dev->zone_capacity) 69 dev->zone_capacity = dev->zone_size; 70 71 if (dev->zone_capacity > dev->zone_size) { 72 pr_err("zone capacity (%lu MB) larger than zone size (%lu MB)\n", 73 dev->zone_capacity, dev->zone_size); 74 return -EINVAL; 75 } 76 77 /* 78 * If a smaller zone capacity was requested, do not allow a smaller last 79 * zone at the same time as such zone configuration does not correspond 80 * to any real zoned device. 81 */ 82 if (dev->zone_capacity != dev->zone_size && 83 dev->size & (dev->zone_size - 1)) { 84 pr_err("A smaller last zone is not allowed with zone capacity smaller than zone size.\n"); 85 return -EINVAL; 86 } 87 88 zone_capacity_sects = mb_to_sects(dev->zone_capacity); 89 dev_capacity_sects = mb_to_sects(dev->size); 90 dev->zone_size_sects = mb_to_sects(dev->zone_size); 91 dev->nr_zones = round_up(dev_capacity_sects, dev->zone_size_sects) 92 >> ilog2(dev->zone_size_sects); 93 94 dev->zones = kvmalloc_array(dev->nr_zones, sizeof(struct nullb_zone), 95 GFP_KERNEL | __GFP_ZERO); 96 if (!dev->zones) 97 return -ENOMEM; 98 99 spin_lock_init(&dev->zone_res_lock); 100 101 if (dev->zone_nr_conv >= dev->nr_zones) { 102 dev->zone_nr_conv = dev->nr_zones - 1; 103 pr_info("changed the number of conventional zones to %u", 104 dev->zone_nr_conv); 105 } 106 107 dev->zone_append_max_sectors = 108 min(ALIGN_DOWN(dev->zone_append_max_sectors, 109 dev->blocksize >> SECTOR_SHIFT), 110 zone_capacity_sects); 111 112 /* Max active zones has to be < nbr of seq zones in order to be enforceable */ 113 if (dev->zone_max_active >= dev->nr_zones - dev->zone_nr_conv) { 114 dev->zone_max_active = 0; 115 pr_info("zone_max_active limit disabled, limit >= zone count\n"); 116 } 117 118 /* Max open zones has to be <= max active zones */ 119 if (dev->zone_max_active && dev->zone_max_open > dev->zone_max_active) { 120 dev->zone_max_open = dev->zone_max_active; 121 pr_info("changed the maximum number of open zones to %u\n", 122 dev->zone_max_open); 123 } else if (dev->zone_max_open >= dev->nr_zones - dev->zone_nr_conv) { 124 dev->zone_max_open = 0; 125 pr_info("zone_max_open limit disabled, limit >= zone count\n"); 126 } 127 dev->need_zone_res_mgmt = dev->zone_max_active || dev->zone_max_open; 128 dev->imp_close_zone_no = dev->zone_nr_conv; 129 130 for (i = 0; i < dev->zone_nr_conv; i++) { 131 zone = &dev->zones[i]; 132 133 null_init_zone_lock(dev, zone); 134 zone->start = sector; 135 zone->len = dev->zone_size_sects; 136 zone->capacity = zone->len; 137 zone->wp = zone->start + zone->len; 138 zone->type = BLK_ZONE_TYPE_CONVENTIONAL; 139 zone->cond = BLK_ZONE_COND_NOT_WP; 140 141 sector += dev->zone_size_sects; 142 } 143 144 for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { 145 zone = &dev->zones[i]; 146 147 null_init_zone_lock(dev, zone); 148 zone->start = sector; 149 if (zone->start + dev->zone_size_sects > dev_capacity_sects) 150 zone->len = dev_capacity_sects - zone->start; 151 else 152 zone->len = dev->zone_size_sects; 153 zone->capacity = 154 min_t(sector_t, zone->len, zone_capacity_sects); 155 zone->type = BLK_ZONE_TYPE_SEQWRITE_REQ; 156 if (dev->zone_full) { 157 zone->cond = BLK_ZONE_COND_FULL; 158 zone->wp = zone->start + zone->capacity; 159 } else{ 160 zone->cond = BLK_ZONE_COND_EMPTY; 161 zone->wp = zone->start; 162 } 163 164 sector += dev->zone_size_sects; 165 } 166 167 lim->features |= BLK_FEAT_ZONED; 168 lim->chunk_sectors = dev->zone_size_sects; 169 lim->max_zone_append_sectors = dev->zone_append_max_sectors; 170 lim->max_open_zones = dev->zone_max_open; 171 lim->max_active_zones = dev->zone_max_active; 172 return 0; 173 } 174 175 int null_register_zoned_dev(struct nullb *nullb) 176 { 177 struct request_queue *q = nullb->q; 178 struct gendisk *disk = nullb->disk; 179 180 pr_info("%s: using %s zone append\n", 181 disk->disk_name, 182 queue_emulates_zone_append(q) ? "emulated" : "native"); 183 184 return blk_revalidate_disk_zones(disk); 185 } 186 187 void null_free_zoned_dev(struct nullb_device *dev) 188 { 189 kvfree(dev->zones); 190 dev->zones = NULL; 191 } 192 193 int null_report_zones(struct gendisk *disk, sector_t sector, 194 unsigned int nr_zones, report_zones_cb cb, void *data) 195 { 196 struct nullb *nullb = disk->private_data; 197 struct nullb_device *dev = nullb->dev; 198 unsigned int first_zone, i; 199 struct nullb_zone *zone; 200 struct blk_zone blkz; 201 int error; 202 203 first_zone = null_zone_no(dev, sector); 204 if (first_zone >= dev->nr_zones) 205 return 0; 206 207 nr_zones = min(nr_zones, dev->nr_zones - first_zone); 208 trace_nullb_report_zones(nullb, nr_zones); 209 210 memset(&blkz, 0, sizeof(struct blk_zone)); 211 zone = &dev->zones[first_zone]; 212 for (i = 0; i < nr_zones; i++, zone++) { 213 /* 214 * Stacked DM target drivers will remap the zone information by 215 * modifying the zone information passed to the report callback. 216 * So use a local copy to avoid corruption of the device zone 217 * array. 218 */ 219 null_lock_zone(dev, zone); 220 blkz.start = zone->start; 221 blkz.len = zone->len; 222 blkz.wp = zone->wp; 223 blkz.type = zone->type; 224 blkz.cond = zone->cond; 225 blkz.capacity = zone->capacity; 226 null_unlock_zone(dev, zone); 227 228 error = cb(&blkz, i, data); 229 if (error) 230 return error; 231 } 232 233 return nr_zones; 234 } 235 236 /* 237 * This is called in the case of memory backing from null_process_cmd() 238 * with the target zone already locked. 239 */ 240 size_t null_zone_valid_read_len(struct nullb *nullb, 241 sector_t sector, unsigned int len) 242 { 243 struct nullb_device *dev = nullb->dev; 244 struct nullb_zone *zone = &dev->zones[null_zone_no(dev, sector)]; 245 unsigned int nr_sectors = len >> SECTOR_SHIFT; 246 247 /* Read must be below the write pointer position */ 248 if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL || 249 sector + nr_sectors <= zone->wp) 250 return len; 251 252 if (sector > zone->wp) 253 return 0; 254 255 return (zone->wp - sector) << SECTOR_SHIFT; 256 } 257 258 static void null_close_imp_open_zone(struct nullb_device *dev) 259 { 260 struct nullb_zone *zone; 261 unsigned int zno, i; 262 263 zno = dev->imp_close_zone_no; 264 if (zno >= dev->nr_zones) 265 zno = dev->zone_nr_conv; 266 267 for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { 268 zone = &dev->zones[zno]; 269 zno++; 270 if (zno >= dev->nr_zones) 271 zno = dev->zone_nr_conv; 272 273 if (zone->cond == BLK_ZONE_COND_IMP_OPEN) { 274 dev->nr_zones_imp_open--; 275 if (zone->wp == zone->start) { 276 zone->cond = BLK_ZONE_COND_EMPTY; 277 } else { 278 zone->cond = BLK_ZONE_COND_CLOSED; 279 dev->nr_zones_closed++; 280 } 281 dev->imp_close_zone_no = zno; 282 return; 283 } 284 } 285 } 286 287 static blk_status_t null_check_active(struct nullb_device *dev) 288 { 289 if (!dev->zone_max_active) 290 return BLK_STS_OK; 291 292 if (dev->nr_zones_exp_open + dev->nr_zones_imp_open + 293 dev->nr_zones_closed < dev->zone_max_active) 294 return BLK_STS_OK; 295 296 return BLK_STS_ZONE_ACTIVE_RESOURCE; 297 } 298 299 static blk_status_t null_check_open(struct nullb_device *dev) 300 { 301 if (!dev->zone_max_open) 302 return BLK_STS_OK; 303 304 if (dev->nr_zones_exp_open + dev->nr_zones_imp_open < dev->zone_max_open) 305 return BLK_STS_OK; 306 307 if (dev->nr_zones_imp_open) { 308 if (null_check_active(dev) == BLK_STS_OK) { 309 null_close_imp_open_zone(dev); 310 return BLK_STS_OK; 311 } 312 } 313 314 return BLK_STS_ZONE_OPEN_RESOURCE; 315 } 316 317 /* 318 * This function matches the manage open zone resources function in the ZBC standard, 319 * with the addition of max active zones support (added in the ZNS standard). 320 * 321 * The function determines if a zone can transition to implicit open or explicit open, 322 * while maintaining the max open zone (and max active zone) limit(s). It may close an 323 * implicit open zone in order to make additional zone resources available. 324 * 325 * ZBC states that an implicit open zone shall be closed only if there is not 326 * room within the open limit. However, with the addition of an active limit, 327 * it is not certain that closing an implicit open zone will allow a new zone 328 * to be opened, since we might already be at the active limit capacity. 329 */ 330 static blk_status_t null_check_zone_resources(struct nullb_device *dev, 331 struct nullb_zone *zone) 332 { 333 blk_status_t ret; 334 335 switch (zone->cond) { 336 case BLK_ZONE_COND_EMPTY: 337 ret = null_check_active(dev); 338 if (ret != BLK_STS_OK) 339 return ret; 340 fallthrough; 341 case BLK_ZONE_COND_CLOSED: 342 return null_check_open(dev); 343 default: 344 /* Should never be called for other states */ 345 WARN_ON(1); 346 return BLK_STS_IOERR; 347 } 348 } 349 350 static blk_status_t null_zone_write(struct nullb_cmd *cmd, sector_t sector, 351 unsigned int nr_sectors, bool append) 352 { 353 struct nullb_device *dev = cmd->nq->dev; 354 unsigned int zno = null_zone_no(dev, sector); 355 struct nullb_zone *zone = &dev->zones[zno]; 356 blk_status_t ret; 357 358 trace_nullb_zone_op(cmd, zno, zone->cond); 359 360 if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) { 361 if (append) 362 return BLK_STS_IOERR; 363 return null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors); 364 } 365 366 null_lock_zone(dev, zone); 367 368 /* 369 * Regular writes must be at the write pointer position. Zone append 370 * writes are automatically issued at the write pointer and the position 371 * returned using the request sector. Note that we do not check the zone 372 * condition because for FULL, READONLY and OFFLINE zones, the sector 373 * check against the zone write pointer will always result in failing 374 * the command. 375 */ 376 if (append) { 377 if (WARN_ON_ONCE(!dev->zone_append_max_sectors) || 378 zone->wp == NULL_ZONE_INVALID_WP) { 379 ret = BLK_STS_IOERR; 380 goto unlock_zone; 381 } 382 sector = zone->wp; 383 blk_mq_rq_from_pdu(cmd)->__sector = sector; 384 } 385 386 if (sector != zone->wp || 387 zone->wp + nr_sectors > zone->start + zone->capacity) { 388 ret = BLK_STS_IOERR; 389 goto unlock_zone; 390 } 391 392 if (zone->cond == BLK_ZONE_COND_CLOSED || 393 zone->cond == BLK_ZONE_COND_EMPTY) { 394 if (dev->need_zone_res_mgmt) { 395 spin_lock(&dev->zone_res_lock); 396 397 ret = null_check_zone_resources(dev, zone); 398 if (ret != BLK_STS_OK) { 399 spin_unlock(&dev->zone_res_lock); 400 goto unlock_zone; 401 } 402 if (zone->cond == BLK_ZONE_COND_CLOSED) { 403 dev->nr_zones_closed--; 404 dev->nr_zones_imp_open++; 405 } else if (zone->cond == BLK_ZONE_COND_EMPTY) { 406 dev->nr_zones_imp_open++; 407 } 408 409 spin_unlock(&dev->zone_res_lock); 410 } 411 412 zone->cond = BLK_ZONE_COND_IMP_OPEN; 413 } 414 415 ret = null_process_cmd(cmd, REQ_OP_WRITE, sector, nr_sectors); 416 if (ret != BLK_STS_OK) 417 goto unlock_zone; 418 419 zone->wp += nr_sectors; 420 if (zone->wp == zone->start + zone->capacity) { 421 if (dev->need_zone_res_mgmt) { 422 spin_lock(&dev->zone_res_lock); 423 if (zone->cond == BLK_ZONE_COND_EXP_OPEN) 424 dev->nr_zones_exp_open--; 425 else if (zone->cond == BLK_ZONE_COND_IMP_OPEN) 426 dev->nr_zones_imp_open--; 427 spin_unlock(&dev->zone_res_lock); 428 } 429 zone->cond = BLK_ZONE_COND_FULL; 430 } 431 432 ret = BLK_STS_OK; 433 434 unlock_zone: 435 null_unlock_zone(dev, zone); 436 437 return ret; 438 } 439 440 static blk_status_t null_open_zone(struct nullb_device *dev, 441 struct nullb_zone *zone) 442 { 443 blk_status_t ret = BLK_STS_OK; 444 445 if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) 446 return BLK_STS_IOERR; 447 448 switch (zone->cond) { 449 case BLK_ZONE_COND_EXP_OPEN: 450 /* Open operation on exp open is not an error */ 451 return BLK_STS_OK; 452 case BLK_ZONE_COND_EMPTY: 453 case BLK_ZONE_COND_IMP_OPEN: 454 case BLK_ZONE_COND_CLOSED: 455 break; 456 case BLK_ZONE_COND_FULL: 457 default: 458 return BLK_STS_IOERR; 459 } 460 461 if (dev->need_zone_res_mgmt) { 462 spin_lock(&dev->zone_res_lock); 463 464 switch (zone->cond) { 465 case BLK_ZONE_COND_EMPTY: 466 ret = null_check_zone_resources(dev, zone); 467 if (ret != BLK_STS_OK) { 468 spin_unlock(&dev->zone_res_lock); 469 return ret; 470 } 471 break; 472 case BLK_ZONE_COND_IMP_OPEN: 473 dev->nr_zones_imp_open--; 474 break; 475 case BLK_ZONE_COND_CLOSED: 476 ret = null_check_zone_resources(dev, zone); 477 if (ret != BLK_STS_OK) { 478 spin_unlock(&dev->zone_res_lock); 479 return ret; 480 } 481 dev->nr_zones_closed--; 482 break; 483 default: 484 break; 485 } 486 487 dev->nr_zones_exp_open++; 488 489 spin_unlock(&dev->zone_res_lock); 490 } 491 492 zone->cond = BLK_ZONE_COND_EXP_OPEN; 493 494 return BLK_STS_OK; 495 } 496 497 static blk_status_t null_close_zone(struct nullb_device *dev, 498 struct nullb_zone *zone) 499 { 500 if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) 501 return BLK_STS_IOERR; 502 503 switch (zone->cond) { 504 case BLK_ZONE_COND_CLOSED: 505 /* close operation on closed is not an error */ 506 return BLK_STS_OK; 507 case BLK_ZONE_COND_IMP_OPEN: 508 case BLK_ZONE_COND_EXP_OPEN: 509 break; 510 case BLK_ZONE_COND_EMPTY: 511 case BLK_ZONE_COND_FULL: 512 default: 513 return BLK_STS_IOERR; 514 } 515 516 if (dev->need_zone_res_mgmt) { 517 spin_lock(&dev->zone_res_lock); 518 519 switch (zone->cond) { 520 case BLK_ZONE_COND_IMP_OPEN: 521 dev->nr_zones_imp_open--; 522 break; 523 case BLK_ZONE_COND_EXP_OPEN: 524 dev->nr_zones_exp_open--; 525 break; 526 default: 527 break; 528 } 529 530 if (zone->wp > zone->start) 531 dev->nr_zones_closed++; 532 533 spin_unlock(&dev->zone_res_lock); 534 } 535 536 if (zone->wp == zone->start) 537 zone->cond = BLK_ZONE_COND_EMPTY; 538 else 539 zone->cond = BLK_ZONE_COND_CLOSED; 540 541 return BLK_STS_OK; 542 } 543 544 static blk_status_t null_finish_zone(struct nullb_device *dev, 545 struct nullb_zone *zone) 546 { 547 blk_status_t ret = BLK_STS_OK; 548 549 if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) 550 return BLK_STS_IOERR; 551 552 if (dev->need_zone_res_mgmt) { 553 spin_lock(&dev->zone_res_lock); 554 555 switch (zone->cond) { 556 case BLK_ZONE_COND_FULL: 557 /* Finish operation on full is not an error */ 558 spin_unlock(&dev->zone_res_lock); 559 return BLK_STS_OK; 560 case BLK_ZONE_COND_EMPTY: 561 ret = null_check_zone_resources(dev, zone); 562 if (ret != BLK_STS_OK) { 563 spin_unlock(&dev->zone_res_lock); 564 return ret; 565 } 566 break; 567 case BLK_ZONE_COND_IMP_OPEN: 568 dev->nr_zones_imp_open--; 569 break; 570 case BLK_ZONE_COND_EXP_OPEN: 571 dev->nr_zones_exp_open--; 572 break; 573 case BLK_ZONE_COND_CLOSED: 574 ret = null_check_zone_resources(dev, zone); 575 if (ret != BLK_STS_OK) { 576 spin_unlock(&dev->zone_res_lock); 577 return ret; 578 } 579 dev->nr_zones_closed--; 580 break; 581 default: 582 spin_unlock(&dev->zone_res_lock); 583 return BLK_STS_IOERR; 584 } 585 586 spin_unlock(&dev->zone_res_lock); 587 } 588 589 zone->cond = BLK_ZONE_COND_FULL; 590 zone->wp = zone->start + zone->len; 591 592 return BLK_STS_OK; 593 } 594 595 static blk_status_t null_reset_zone(struct nullb_device *dev, 596 struct nullb_zone *zone) 597 { 598 if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL) 599 return BLK_STS_IOERR; 600 601 if (dev->need_zone_res_mgmt) { 602 spin_lock(&dev->zone_res_lock); 603 604 switch (zone->cond) { 605 case BLK_ZONE_COND_IMP_OPEN: 606 dev->nr_zones_imp_open--; 607 break; 608 case BLK_ZONE_COND_EXP_OPEN: 609 dev->nr_zones_exp_open--; 610 break; 611 case BLK_ZONE_COND_CLOSED: 612 dev->nr_zones_closed--; 613 break; 614 case BLK_ZONE_COND_EMPTY: 615 case BLK_ZONE_COND_FULL: 616 break; 617 default: 618 spin_unlock(&dev->zone_res_lock); 619 return BLK_STS_IOERR; 620 } 621 622 spin_unlock(&dev->zone_res_lock); 623 } 624 625 zone->cond = BLK_ZONE_COND_EMPTY; 626 zone->wp = zone->start; 627 628 if (dev->memory_backed) 629 return null_handle_discard(dev, zone->start, zone->len); 630 631 return BLK_STS_OK; 632 } 633 634 static blk_status_t null_zone_mgmt(struct nullb_cmd *cmd, enum req_op op, 635 sector_t sector) 636 { 637 struct nullb_device *dev = cmd->nq->dev; 638 unsigned int zone_no; 639 struct nullb_zone *zone; 640 blk_status_t ret; 641 size_t i; 642 643 if (op == REQ_OP_ZONE_RESET_ALL) { 644 for (i = dev->zone_nr_conv; i < dev->nr_zones; i++) { 645 zone = &dev->zones[i]; 646 null_lock_zone(dev, zone); 647 if (zone->cond != BLK_ZONE_COND_EMPTY && 648 zone->cond != BLK_ZONE_COND_READONLY && 649 zone->cond != BLK_ZONE_COND_OFFLINE) { 650 null_reset_zone(dev, zone); 651 trace_nullb_zone_op(cmd, i, zone->cond); 652 } 653 null_unlock_zone(dev, zone); 654 } 655 return BLK_STS_OK; 656 } 657 658 zone_no = null_zone_no(dev, sector); 659 zone = &dev->zones[zone_no]; 660 661 null_lock_zone(dev, zone); 662 663 if (zone->cond == BLK_ZONE_COND_READONLY || 664 zone->cond == BLK_ZONE_COND_OFFLINE) { 665 ret = BLK_STS_IOERR; 666 goto unlock; 667 } 668 669 switch (op) { 670 case REQ_OP_ZONE_RESET: 671 ret = null_reset_zone(dev, zone); 672 break; 673 case REQ_OP_ZONE_OPEN: 674 ret = null_open_zone(dev, zone); 675 break; 676 case REQ_OP_ZONE_CLOSE: 677 ret = null_close_zone(dev, zone); 678 break; 679 case REQ_OP_ZONE_FINISH: 680 ret = null_finish_zone(dev, zone); 681 break; 682 default: 683 ret = BLK_STS_NOTSUPP; 684 break; 685 } 686 687 if (ret == BLK_STS_OK) 688 trace_nullb_zone_op(cmd, zone_no, zone->cond); 689 690 unlock: 691 null_unlock_zone(dev, zone); 692 693 return ret; 694 } 695 696 blk_status_t null_process_zoned_cmd(struct nullb_cmd *cmd, enum req_op op, 697 sector_t sector, sector_t nr_sectors) 698 { 699 struct nullb_device *dev; 700 struct nullb_zone *zone; 701 blk_status_t sts; 702 703 switch (op) { 704 case REQ_OP_WRITE: 705 return null_zone_write(cmd, sector, nr_sectors, false); 706 case REQ_OP_ZONE_APPEND: 707 return null_zone_write(cmd, sector, nr_sectors, true); 708 case REQ_OP_ZONE_RESET: 709 case REQ_OP_ZONE_RESET_ALL: 710 case REQ_OP_ZONE_OPEN: 711 case REQ_OP_ZONE_CLOSE: 712 case REQ_OP_ZONE_FINISH: 713 return null_zone_mgmt(cmd, op, sector); 714 default: 715 dev = cmd->nq->dev; 716 zone = &dev->zones[null_zone_no(dev, sector)]; 717 if (zone->cond == BLK_ZONE_COND_OFFLINE) 718 return BLK_STS_IOERR; 719 720 null_lock_zone(dev, zone); 721 sts = null_process_cmd(cmd, op, sector, nr_sectors); 722 null_unlock_zone(dev, zone); 723 return sts; 724 } 725 } 726 727 /* 728 * Set a zone in the read-only or offline condition. 729 */ 730 static void null_set_zone_cond(struct nullb_device *dev, 731 struct nullb_zone *zone, enum blk_zone_cond cond) 732 { 733 if (WARN_ON_ONCE(cond != BLK_ZONE_COND_READONLY && 734 cond != BLK_ZONE_COND_OFFLINE)) 735 return; 736 737 null_lock_zone(dev, zone); 738 739 /* 740 * If the read-only condition is requested again to zones already in 741 * read-only condition, restore back normal empty condition. Do the same 742 * if the offline condition is requested for offline zones. Otherwise, 743 * set the specified zone condition to the zones. Finish the zones 744 * beforehand to free up zone resources. 745 */ 746 if (zone->cond == cond) { 747 zone->cond = BLK_ZONE_COND_EMPTY; 748 zone->wp = zone->start; 749 if (dev->memory_backed) 750 null_handle_discard(dev, zone->start, zone->len); 751 } else { 752 if (zone->cond != BLK_ZONE_COND_READONLY && 753 zone->cond != BLK_ZONE_COND_OFFLINE) 754 null_finish_zone(dev, zone); 755 zone->cond = cond; 756 zone->wp = NULL_ZONE_INVALID_WP; 757 } 758 759 null_unlock_zone(dev, zone); 760 } 761 762 /* 763 * Identify a zone from the sector written to configfs file. Then set zone 764 * condition to the zone. 765 */ 766 ssize_t zone_cond_store(struct nullb_device *dev, const char *page, 767 size_t count, enum blk_zone_cond cond) 768 { 769 unsigned long long sector; 770 unsigned int zone_no; 771 int ret; 772 773 if (!dev->zoned) { 774 pr_err("null_blk device is not zoned\n"); 775 return -EINVAL; 776 } 777 778 if (!dev->zones) { 779 pr_err("null_blk device is not yet powered\n"); 780 return -EINVAL; 781 } 782 783 ret = kstrtoull(page, 0, §or); 784 if (ret < 0) 785 return ret; 786 787 zone_no = null_zone_no(dev, sector); 788 if (zone_no >= dev->nr_zones) { 789 pr_err("Sector out of range\n"); 790 return -EINVAL; 791 } 792 793 if (dev->zones[zone_no].type == BLK_ZONE_TYPE_CONVENTIONAL) { 794 pr_err("Can not change condition of conventional zones\n"); 795 return -EINVAL; 796 } 797 798 null_set_zone_cond(dev, &dev->zones[zone_no], cond); 799 800 return count; 801 } 802