1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <linux/bitops.h> 4 #include <linux/slab.h> 5 #include <linux/blkdev.h> 6 #include <linux/sched/mm.h> 7 #include <linux/atomic.h> 8 #include <linux/vmalloc.h> 9 #include "ctree.h" 10 #include "volumes.h" 11 #include "zoned.h" 12 #include "rcu-string.h" 13 #include "disk-io.h" 14 #include "block-group.h" 15 #include "transaction.h" 16 #include "dev-replace.h" 17 #include "space-info.h" 18 #include "super.h" 19 #include "fs.h" 20 #include "accessors.h" 21 #include "bio.h" 22 23 /* Maximum number of zones to report per blkdev_report_zones() call */ 24 #define BTRFS_REPORT_NR_ZONES 4096 25 /* Invalid allocation pointer value for missing devices */ 26 #define WP_MISSING_DEV ((u64)-1) 27 /* Pseudo write pointer value for conventional zone */ 28 #define WP_CONVENTIONAL ((u64)-2) 29 30 /* 31 * Location of the first zone of superblock logging zone pairs. 32 * 33 * - primary superblock: 0B (zone 0) 34 * - first copy: 512G (zone starting at that offset) 35 * - second copy: 4T (zone starting at that offset) 36 */ 37 #define BTRFS_SB_LOG_PRIMARY_OFFSET (0ULL) 38 #define BTRFS_SB_LOG_FIRST_OFFSET (512ULL * SZ_1G) 39 #define BTRFS_SB_LOG_SECOND_OFFSET (4096ULL * SZ_1G) 40 41 #define BTRFS_SB_LOG_FIRST_SHIFT const_ilog2(BTRFS_SB_LOG_FIRST_OFFSET) 42 #define BTRFS_SB_LOG_SECOND_SHIFT const_ilog2(BTRFS_SB_LOG_SECOND_OFFSET) 43 44 /* Number of superblock log zones */ 45 #define BTRFS_NR_SB_LOG_ZONES 2 46 47 /* 48 * Minimum of active zones we need: 49 * 50 * - BTRFS_SUPER_MIRROR_MAX zones for superblock mirrors 51 * - 3 zones to ensure at least one zone per SYSTEM, META and DATA block group 52 * - 1 zone for tree-log dedicated block group 53 * - 1 zone for relocation 54 */ 55 #define BTRFS_MIN_ACTIVE_ZONES (BTRFS_SUPER_MIRROR_MAX + 5) 56 57 /* 58 * Minimum / maximum supported zone size. Currently, SMR disks have a zone 59 * size of 256MiB, and we are expecting ZNS drives to be in the 1-4GiB range. 60 * We do not expect the zone size to become larger than 8GiB or smaller than 61 * 4MiB in the near future. 62 */ 63 #define BTRFS_MAX_ZONE_SIZE SZ_8G 64 #define BTRFS_MIN_ZONE_SIZE SZ_4M 65 66 #define SUPER_INFO_SECTORS ((u64)BTRFS_SUPER_INFO_SIZE >> SECTOR_SHIFT) 67 68 static inline bool sb_zone_is_full(const struct blk_zone *zone) 69 { 70 return (zone->cond == BLK_ZONE_COND_FULL) || 71 (zone->wp + SUPER_INFO_SECTORS > zone->start + zone->capacity); 72 } 73 74 static int copy_zone_info_cb(struct blk_zone *zone, unsigned int idx, void *data) 75 { 76 struct blk_zone *zones = data; 77 78 memcpy(&zones[idx], zone, sizeof(*zone)); 79 80 return 0; 81 } 82 83 static int sb_write_pointer(struct block_device *bdev, struct blk_zone *zones, 84 u64 *wp_ret) 85 { 86 bool empty[BTRFS_NR_SB_LOG_ZONES]; 87 bool full[BTRFS_NR_SB_LOG_ZONES]; 88 sector_t sector; 89 int i; 90 91 for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++) { 92 ASSERT(zones[i].type != BLK_ZONE_TYPE_CONVENTIONAL); 93 empty[i] = (zones[i].cond == BLK_ZONE_COND_EMPTY); 94 full[i] = sb_zone_is_full(&zones[i]); 95 } 96 97 /* 98 * Possible states of log buffer zones 99 * 100 * Empty[0] In use[0] Full[0] 101 * Empty[1] * 0 1 102 * In use[1] x x 1 103 * Full[1] 0 0 C 104 * 105 * Log position: 106 * *: Special case, no superblock is written 107 * 0: Use write pointer of zones[0] 108 * 1: Use write pointer of zones[1] 109 * C: Compare super blocks from zones[0] and zones[1], use the latest 110 * one determined by generation 111 * x: Invalid state 112 */ 113 114 if (empty[0] && empty[1]) { 115 /* Special case to distinguish no superblock to read */ 116 *wp_ret = zones[0].start << SECTOR_SHIFT; 117 return -ENOENT; 118 } else if (full[0] && full[1]) { 119 /* Compare two super blocks */ 120 struct address_space *mapping = bdev->bd_inode->i_mapping; 121 struct page *page[BTRFS_NR_SB_LOG_ZONES]; 122 struct btrfs_super_block *super[BTRFS_NR_SB_LOG_ZONES]; 123 int i; 124 125 for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++) { 126 u64 zone_end = (zones[i].start + zones[i].capacity) << SECTOR_SHIFT; 127 u64 bytenr = ALIGN_DOWN(zone_end, BTRFS_SUPER_INFO_SIZE) - 128 BTRFS_SUPER_INFO_SIZE; 129 130 page[i] = read_cache_page_gfp(mapping, 131 bytenr >> PAGE_SHIFT, GFP_NOFS); 132 if (IS_ERR(page[i])) { 133 if (i == 1) 134 btrfs_release_disk_super(super[0]); 135 return PTR_ERR(page[i]); 136 } 137 super[i] = page_address(page[i]); 138 } 139 140 if (btrfs_super_generation(super[0]) > 141 btrfs_super_generation(super[1])) 142 sector = zones[1].start; 143 else 144 sector = zones[0].start; 145 146 for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++) 147 btrfs_release_disk_super(super[i]); 148 } else if (!full[0] && (empty[1] || full[1])) { 149 sector = zones[0].wp; 150 } else if (full[0]) { 151 sector = zones[1].wp; 152 } else { 153 return -EUCLEAN; 154 } 155 *wp_ret = sector << SECTOR_SHIFT; 156 return 0; 157 } 158 159 /* 160 * Get the first zone number of the superblock mirror 161 */ 162 static inline u32 sb_zone_number(int shift, int mirror) 163 { 164 u64 zone = U64_MAX; 165 166 ASSERT(mirror < BTRFS_SUPER_MIRROR_MAX); 167 switch (mirror) { 168 case 0: zone = 0; break; 169 case 1: zone = 1ULL << (BTRFS_SB_LOG_FIRST_SHIFT - shift); break; 170 case 2: zone = 1ULL << (BTRFS_SB_LOG_SECOND_SHIFT - shift); break; 171 } 172 173 ASSERT(zone <= U32_MAX); 174 175 return (u32)zone; 176 } 177 178 static inline sector_t zone_start_sector(u32 zone_number, 179 struct block_device *bdev) 180 { 181 return (sector_t)zone_number << ilog2(bdev_zone_sectors(bdev)); 182 } 183 184 static inline u64 zone_start_physical(u32 zone_number, 185 struct btrfs_zoned_device_info *zone_info) 186 { 187 return (u64)zone_number << zone_info->zone_size_shift; 188 } 189 190 /* 191 * Emulate blkdev_report_zones() for a non-zoned device. It slices up the block 192 * device into static sized chunks and fake a conventional zone on each of 193 * them. 194 */ 195 static int emulate_report_zones(struct btrfs_device *device, u64 pos, 196 struct blk_zone *zones, unsigned int nr_zones) 197 { 198 const sector_t zone_sectors = device->fs_info->zone_size >> SECTOR_SHIFT; 199 sector_t bdev_size = bdev_nr_sectors(device->bdev); 200 unsigned int i; 201 202 pos >>= SECTOR_SHIFT; 203 for (i = 0; i < nr_zones; i++) { 204 zones[i].start = i * zone_sectors + pos; 205 zones[i].len = zone_sectors; 206 zones[i].capacity = zone_sectors; 207 zones[i].wp = zones[i].start + zone_sectors; 208 zones[i].type = BLK_ZONE_TYPE_CONVENTIONAL; 209 zones[i].cond = BLK_ZONE_COND_NOT_WP; 210 211 if (zones[i].wp >= bdev_size) { 212 i++; 213 break; 214 } 215 } 216 217 return i; 218 } 219 220 static int btrfs_get_dev_zones(struct btrfs_device *device, u64 pos, 221 struct blk_zone *zones, unsigned int *nr_zones) 222 { 223 struct btrfs_zoned_device_info *zinfo = device->zone_info; 224 int ret; 225 226 if (!*nr_zones) 227 return 0; 228 229 if (!bdev_is_zoned(device->bdev)) { 230 ret = emulate_report_zones(device, pos, zones, *nr_zones); 231 *nr_zones = ret; 232 return 0; 233 } 234 235 /* Check cache */ 236 if (zinfo->zone_cache) { 237 unsigned int i; 238 u32 zno; 239 240 ASSERT(IS_ALIGNED(pos, zinfo->zone_size)); 241 zno = pos >> zinfo->zone_size_shift; 242 /* 243 * We cannot report zones beyond the zone end. So, it is OK to 244 * cap *nr_zones to at the end. 245 */ 246 *nr_zones = min_t(u32, *nr_zones, zinfo->nr_zones - zno); 247 248 for (i = 0; i < *nr_zones; i++) { 249 struct blk_zone *zone_info; 250 251 zone_info = &zinfo->zone_cache[zno + i]; 252 if (!zone_info->len) 253 break; 254 } 255 256 if (i == *nr_zones) { 257 /* Cache hit on all the zones */ 258 memcpy(zones, zinfo->zone_cache + zno, 259 sizeof(*zinfo->zone_cache) * *nr_zones); 260 return 0; 261 } 262 } 263 264 ret = blkdev_report_zones(device->bdev, pos >> SECTOR_SHIFT, *nr_zones, 265 copy_zone_info_cb, zones); 266 if (ret < 0) { 267 btrfs_err_in_rcu(device->fs_info, 268 "zoned: failed to read zone %llu on %s (devid %llu)", 269 pos, rcu_str_deref(device->name), 270 device->devid); 271 return ret; 272 } 273 *nr_zones = ret; 274 if (!ret) 275 return -EIO; 276 277 /* Populate cache */ 278 if (zinfo->zone_cache) { 279 u32 zno = pos >> zinfo->zone_size_shift; 280 281 memcpy(zinfo->zone_cache + zno, zones, 282 sizeof(*zinfo->zone_cache) * *nr_zones); 283 } 284 285 return 0; 286 } 287 288 /* The emulated zone size is determined from the size of device extent */ 289 static int calculate_emulated_zone_size(struct btrfs_fs_info *fs_info) 290 { 291 struct btrfs_path *path; 292 struct btrfs_root *root = fs_info->dev_root; 293 struct btrfs_key key; 294 struct extent_buffer *leaf; 295 struct btrfs_dev_extent *dext; 296 int ret = 0; 297 298 key.objectid = 1; 299 key.type = BTRFS_DEV_EXTENT_KEY; 300 key.offset = 0; 301 302 path = btrfs_alloc_path(); 303 if (!path) 304 return -ENOMEM; 305 306 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 307 if (ret < 0) 308 goto out; 309 310 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) { 311 ret = btrfs_next_leaf(root, path); 312 if (ret < 0) 313 goto out; 314 /* No dev extents at all? Not good */ 315 if (ret > 0) { 316 ret = -EUCLEAN; 317 goto out; 318 } 319 } 320 321 leaf = path->nodes[0]; 322 dext = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent); 323 fs_info->zone_size = btrfs_dev_extent_length(leaf, dext); 324 ret = 0; 325 326 out: 327 btrfs_free_path(path); 328 329 return ret; 330 } 331 332 int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info) 333 { 334 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 335 struct btrfs_device *device; 336 int ret = 0; 337 338 /* fs_info->zone_size might not set yet. Use the incomapt flag here. */ 339 if (!btrfs_fs_incompat(fs_info, ZONED)) 340 return 0; 341 342 mutex_lock(&fs_devices->device_list_mutex); 343 list_for_each_entry(device, &fs_devices->devices, dev_list) { 344 /* We can skip reading of zone info for missing devices */ 345 if (!device->bdev) 346 continue; 347 348 ret = btrfs_get_dev_zone_info(device, true); 349 if (ret) 350 break; 351 } 352 mutex_unlock(&fs_devices->device_list_mutex); 353 354 return ret; 355 } 356 357 int btrfs_get_dev_zone_info(struct btrfs_device *device, bool populate_cache) 358 { 359 struct btrfs_fs_info *fs_info = device->fs_info; 360 struct btrfs_zoned_device_info *zone_info = NULL; 361 struct block_device *bdev = device->bdev; 362 unsigned int max_active_zones; 363 unsigned int nactive; 364 sector_t nr_sectors; 365 sector_t sector = 0; 366 struct blk_zone *zones = NULL; 367 unsigned int i, nreported = 0, nr_zones; 368 sector_t zone_sectors; 369 char *model, *emulated; 370 int ret; 371 372 /* 373 * Cannot use btrfs_is_zoned here, since fs_info::zone_size might not 374 * yet be set. 375 */ 376 if (!btrfs_fs_incompat(fs_info, ZONED)) 377 return 0; 378 379 if (device->zone_info) 380 return 0; 381 382 zone_info = kzalloc(sizeof(*zone_info), GFP_KERNEL); 383 if (!zone_info) 384 return -ENOMEM; 385 386 device->zone_info = zone_info; 387 388 if (!bdev_is_zoned(bdev)) { 389 if (!fs_info->zone_size) { 390 ret = calculate_emulated_zone_size(fs_info); 391 if (ret) 392 goto out; 393 } 394 395 ASSERT(fs_info->zone_size); 396 zone_sectors = fs_info->zone_size >> SECTOR_SHIFT; 397 } else { 398 zone_sectors = bdev_zone_sectors(bdev); 399 } 400 401 ASSERT(is_power_of_two_u64(zone_sectors)); 402 zone_info->zone_size = zone_sectors << SECTOR_SHIFT; 403 404 /* We reject devices with a zone size larger than 8GB */ 405 if (zone_info->zone_size > BTRFS_MAX_ZONE_SIZE) { 406 btrfs_err_in_rcu(fs_info, 407 "zoned: %s: zone size %llu larger than supported maximum %llu", 408 rcu_str_deref(device->name), 409 zone_info->zone_size, BTRFS_MAX_ZONE_SIZE); 410 ret = -EINVAL; 411 goto out; 412 } else if (zone_info->zone_size < BTRFS_MIN_ZONE_SIZE) { 413 btrfs_err_in_rcu(fs_info, 414 "zoned: %s: zone size %llu smaller than supported minimum %u", 415 rcu_str_deref(device->name), 416 zone_info->zone_size, BTRFS_MIN_ZONE_SIZE); 417 ret = -EINVAL; 418 goto out; 419 } 420 421 nr_sectors = bdev_nr_sectors(bdev); 422 zone_info->zone_size_shift = ilog2(zone_info->zone_size); 423 zone_info->nr_zones = nr_sectors >> ilog2(zone_sectors); 424 if (!IS_ALIGNED(nr_sectors, zone_sectors)) 425 zone_info->nr_zones++; 426 427 max_active_zones = bdev_max_active_zones(bdev); 428 if (max_active_zones && max_active_zones < BTRFS_MIN_ACTIVE_ZONES) { 429 btrfs_err_in_rcu(fs_info, 430 "zoned: %s: max active zones %u is too small, need at least %u active zones", 431 rcu_str_deref(device->name), max_active_zones, 432 BTRFS_MIN_ACTIVE_ZONES); 433 ret = -EINVAL; 434 goto out; 435 } 436 zone_info->max_active_zones = max_active_zones; 437 438 zone_info->seq_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL); 439 if (!zone_info->seq_zones) { 440 ret = -ENOMEM; 441 goto out; 442 } 443 444 zone_info->empty_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL); 445 if (!zone_info->empty_zones) { 446 ret = -ENOMEM; 447 goto out; 448 } 449 450 zone_info->active_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL); 451 if (!zone_info->active_zones) { 452 ret = -ENOMEM; 453 goto out; 454 } 455 456 zones = kvcalloc(BTRFS_REPORT_NR_ZONES, sizeof(struct blk_zone), GFP_KERNEL); 457 if (!zones) { 458 ret = -ENOMEM; 459 goto out; 460 } 461 462 /* 463 * Enable zone cache only for a zoned device. On a non-zoned device, we 464 * fill the zone info with emulated CONVENTIONAL zones, so no need to 465 * use the cache. 466 */ 467 if (populate_cache && bdev_is_zoned(device->bdev)) { 468 zone_info->zone_cache = vzalloc(sizeof(struct blk_zone) * 469 zone_info->nr_zones); 470 if (!zone_info->zone_cache) { 471 btrfs_err_in_rcu(device->fs_info, 472 "zoned: failed to allocate zone cache for %s", 473 rcu_str_deref(device->name)); 474 ret = -ENOMEM; 475 goto out; 476 } 477 } 478 479 /* Get zones type */ 480 nactive = 0; 481 while (sector < nr_sectors) { 482 nr_zones = BTRFS_REPORT_NR_ZONES; 483 ret = btrfs_get_dev_zones(device, sector << SECTOR_SHIFT, zones, 484 &nr_zones); 485 if (ret) 486 goto out; 487 488 for (i = 0; i < nr_zones; i++) { 489 if (zones[i].type == BLK_ZONE_TYPE_SEQWRITE_REQ) 490 __set_bit(nreported, zone_info->seq_zones); 491 switch (zones[i].cond) { 492 case BLK_ZONE_COND_EMPTY: 493 __set_bit(nreported, zone_info->empty_zones); 494 break; 495 case BLK_ZONE_COND_IMP_OPEN: 496 case BLK_ZONE_COND_EXP_OPEN: 497 case BLK_ZONE_COND_CLOSED: 498 __set_bit(nreported, zone_info->active_zones); 499 nactive++; 500 break; 501 } 502 nreported++; 503 } 504 sector = zones[nr_zones - 1].start + zones[nr_zones - 1].len; 505 } 506 507 if (nreported != zone_info->nr_zones) { 508 btrfs_err_in_rcu(device->fs_info, 509 "inconsistent number of zones on %s (%u/%u)", 510 rcu_str_deref(device->name), nreported, 511 zone_info->nr_zones); 512 ret = -EIO; 513 goto out; 514 } 515 516 if (max_active_zones) { 517 if (nactive > max_active_zones) { 518 btrfs_err_in_rcu(device->fs_info, 519 "zoned: %u active zones on %s exceeds max_active_zones %u", 520 nactive, rcu_str_deref(device->name), 521 max_active_zones); 522 ret = -EIO; 523 goto out; 524 } 525 atomic_set(&zone_info->active_zones_left, 526 max_active_zones - nactive); 527 set_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags); 528 } 529 530 /* Validate superblock log */ 531 nr_zones = BTRFS_NR_SB_LOG_ZONES; 532 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { 533 u32 sb_zone; 534 u64 sb_wp; 535 int sb_pos = BTRFS_NR_SB_LOG_ZONES * i; 536 537 sb_zone = sb_zone_number(zone_info->zone_size_shift, i); 538 if (sb_zone + 1 >= zone_info->nr_zones) 539 continue; 540 541 ret = btrfs_get_dev_zones(device, 542 zone_start_physical(sb_zone, zone_info), 543 &zone_info->sb_zones[sb_pos], 544 &nr_zones); 545 if (ret) 546 goto out; 547 548 if (nr_zones != BTRFS_NR_SB_LOG_ZONES) { 549 btrfs_err_in_rcu(device->fs_info, 550 "zoned: failed to read super block log zone info at devid %llu zone %u", 551 device->devid, sb_zone); 552 ret = -EUCLEAN; 553 goto out; 554 } 555 556 /* 557 * If zones[0] is conventional, always use the beginning of the 558 * zone to record superblock. No need to validate in that case. 559 */ 560 if (zone_info->sb_zones[BTRFS_NR_SB_LOG_ZONES * i].type == 561 BLK_ZONE_TYPE_CONVENTIONAL) 562 continue; 563 564 ret = sb_write_pointer(device->bdev, 565 &zone_info->sb_zones[sb_pos], &sb_wp); 566 if (ret != -ENOENT && ret) { 567 btrfs_err_in_rcu(device->fs_info, 568 "zoned: super block log zone corrupted devid %llu zone %u", 569 device->devid, sb_zone); 570 ret = -EUCLEAN; 571 goto out; 572 } 573 } 574 575 576 kvfree(zones); 577 578 switch (bdev_zoned_model(bdev)) { 579 case BLK_ZONED_HM: 580 model = "host-managed zoned"; 581 emulated = ""; 582 break; 583 case BLK_ZONED_HA: 584 model = "host-aware zoned"; 585 emulated = ""; 586 break; 587 case BLK_ZONED_NONE: 588 model = "regular"; 589 emulated = "emulated "; 590 break; 591 default: 592 /* Just in case */ 593 btrfs_err_in_rcu(fs_info, "zoned: unsupported model %d on %s", 594 bdev_zoned_model(bdev), 595 rcu_str_deref(device->name)); 596 ret = -EOPNOTSUPP; 597 goto out_free_zone_info; 598 } 599 600 btrfs_info_in_rcu(fs_info, 601 "%s block device %s, %u %szones of %llu bytes", 602 model, rcu_str_deref(device->name), zone_info->nr_zones, 603 emulated, zone_info->zone_size); 604 605 return 0; 606 607 out: 608 kvfree(zones); 609 out_free_zone_info: 610 btrfs_destroy_dev_zone_info(device); 611 612 return ret; 613 } 614 615 void btrfs_destroy_dev_zone_info(struct btrfs_device *device) 616 { 617 struct btrfs_zoned_device_info *zone_info = device->zone_info; 618 619 if (!zone_info) 620 return; 621 622 bitmap_free(zone_info->active_zones); 623 bitmap_free(zone_info->seq_zones); 624 bitmap_free(zone_info->empty_zones); 625 vfree(zone_info->zone_cache); 626 kfree(zone_info); 627 device->zone_info = NULL; 628 } 629 630 struct btrfs_zoned_device_info *btrfs_clone_dev_zone_info(struct btrfs_device *orig_dev) 631 { 632 struct btrfs_zoned_device_info *zone_info; 633 634 zone_info = kmemdup(orig_dev->zone_info, sizeof(*zone_info), GFP_KERNEL); 635 if (!zone_info) 636 return NULL; 637 638 zone_info->seq_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL); 639 if (!zone_info->seq_zones) 640 goto out; 641 642 bitmap_copy(zone_info->seq_zones, orig_dev->zone_info->seq_zones, 643 zone_info->nr_zones); 644 645 zone_info->empty_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL); 646 if (!zone_info->empty_zones) 647 goto out; 648 649 bitmap_copy(zone_info->empty_zones, orig_dev->zone_info->empty_zones, 650 zone_info->nr_zones); 651 652 zone_info->active_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL); 653 if (!zone_info->active_zones) 654 goto out; 655 656 bitmap_copy(zone_info->active_zones, orig_dev->zone_info->active_zones, 657 zone_info->nr_zones); 658 zone_info->zone_cache = NULL; 659 660 return zone_info; 661 662 out: 663 bitmap_free(zone_info->seq_zones); 664 bitmap_free(zone_info->empty_zones); 665 bitmap_free(zone_info->active_zones); 666 kfree(zone_info); 667 return NULL; 668 } 669 670 int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos, 671 struct blk_zone *zone) 672 { 673 unsigned int nr_zones = 1; 674 int ret; 675 676 ret = btrfs_get_dev_zones(device, pos, zone, &nr_zones); 677 if (ret != 0 || !nr_zones) 678 return ret ? ret : -EIO; 679 680 return 0; 681 } 682 683 static int btrfs_check_for_zoned_device(struct btrfs_fs_info *fs_info) 684 { 685 struct btrfs_device *device; 686 687 list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) { 688 if (device->bdev && 689 bdev_zoned_model(device->bdev) == BLK_ZONED_HM) { 690 btrfs_err(fs_info, 691 "zoned: mode not enabled but zoned device found: %pg", 692 device->bdev); 693 return -EINVAL; 694 } 695 } 696 697 return 0; 698 } 699 700 int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info) 701 { 702 struct queue_limits *lim = &fs_info->limits; 703 struct btrfs_device *device; 704 u64 zone_size = 0; 705 int ret; 706 707 /* 708 * Host-Managed devices can't be used without the ZONED flag. With the 709 * ZONED all devices can be used, using zone emulation if required. 710 */ 711 if (!btrfs_fs_incompat(fs_info, ZONED)) 712 return btrfs_check_for_zoned_device(fs_info); 713 714 blk_set_stacking_limits(lim); 715 716 list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) { 717 struct btrfs_zoned_device_info *zone_info = device->zone_info; 718 719 if (!device->bdev) 720 continue; 721 722 if (!zone_size) { 723 zone_size = zone_info->zone_size; 724 } else if (zone_info->zone_size != zone_size) { 725 btrfs_err(fs_info, 726 "zoned: unequal block device zone sizes: have %llu found %llu", 727 zone_info->zone_size, zone_size); 728 return -EINVAL; 729 } 730 731 /* 732 * With the zoned emulation, we can have non-zoned device on the 733 * zoned mode. In this case, we don't have a valid max zone 734 * append size. 735 */ 736 if (bdev_is_zoned(device->bdev)) { 737 blk_stack_limits(lim, 738 &bdev_get_queue(device->bdev)->limits, 739 0); 740 } 741 } 742 743 /* 744 * stripe_size is always aligned to BTRFS_STRIPE_LEN in 745 * btrfs_create_chunk(). Since we want stripe_len == zone_size, 746 * check the alignment here. 747 */ 748 if (!IS_ALIGNED(zone_size, BTRFS_STRIPE_LEN)) { 749 btrfs_err(fs_info, 750 "zoned: zone size %llu not aligned to stripe %u", 751 zone_size, BTRFS_STRIPE_LEN); 752 return -EINVAL; 753 } 754 755 if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) { 756 btrfs_err(fs_info, "zoned: mixed block groups not supported"); 757 return -EINVAL; 758 } 759 760 fs_info->zone_size = zone_size; 761 /* 762 * Also limit max_zone_append_size by max_segments * PAGE_SIZE. 763 * Technically, we can have multiple pages per segment. But, since 764 * we add the pages one by one to a bio, and cannot increase the 765 * metadata reservation even if it increases the number of extents, it 766 * is safe to stick with the limit. 767 */ 768 fs_info->max_zone_append_size = ALIGN_DOWN( 769 min3((u64)lim->max_zone_append_sectors << SECTOR_SHIFT, 770 (u64)lim->max_sectors << SECTOR_SHIFT, 771 (u64)lim->max_segments << PAGE_SHIFT), 772 fs_info->sectorsize); 773 fs_info->fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_ZONED; 774 if (fs_info->max_zone_append_size < fs_info->max_extent_size) 775 fs_info->max_extent_size = fs_info->max_zone_append_size; 776 777 /* 778 * Check mount options here, because we might change fs_info->zoned 779 * from fs_info->zone_size. 780 */ 781 ret = btrfs_check_mountopts_zoned(fs_info); 782 if (ret) 783 return ret; 784 785 btrfs_info(fs_info, "zoned mode enabled with zone size %llu", zone_size); 786 return 0; 787 } 788 789 int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info) 790 { 791 if (!btrfs_is_zoned(info)) 792 return 0; 793 794 /* 795 * Space cache writing is not COWed. Disable that to avoid write errors 796 * in sequential zones. 797 */ 798 if (btrfs_test_opt(info, SPACE_CACHE)) { 799 btrfs_err(info, "zoned: space cache v1 is not supported"); 800 return -EINVAL; 801 } 802 803 if (btrfs_test_opt(info, NODATACOW)) { 804 btrfs_err(info, "zoned: NODATACOW not supported"); 805 return -EINVAL; 806 } 807 808 return 0; 809 } 810 811 static int sb_log_location(struct block_device *bdev, struct blk_zone *zones, 812 int rw, u64 *bytenr_ret) 813 { 814 u64 wp; 815 int ret; 816 817 if (zones[0].type == BLK_ZONE_TYPE_CONVENTIONAL) { 818 *bytenr_ret = zones[0].start << SECTOR_SHIFT; 819 return 0; 820 } 821 822 ret = sb_write_pointer(bdev, zones, &wp); 823 if (ret != -ENOENT && ret < 0) 824 return ret; 825 826 if (rw == WRITE) { 827 struct blk_zone *reset = NULL; 828 829 if (wp == zones[0].start << SECTOR_SHIFT) 830 reset = &zones[0]; 831 else if (wp == zones[1].start << SECTOR_SHIFT) 832 reset = &zones[1]; 833 834 if (reset && reset->cond != BLK_ZONE_COND_EMPTY) { 835 ASSERT(sb_zone_is_full(reset)); 836 837 ret = blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET, 838 reset->start, reset->len, 839 GFP_NOFS); 840 if (ret) 841 return ret; 842 843 reset->cond = BLK_ZONE_COND_EMPTY; 844 reset->wp = reset->start; 845 } 846 } else if (ret != -ENOENT) { 847 /* 848 * For READ, we want the previous one. Move write pointer to 849 * the end of a zone, if it is at the head of a zone. 850 */ 851 u64 zone_end = 0; 852 853 if (wp == zones[0].start << SECTOR_SHIFT) 854 zone_end = zones[1].start + zones[1].capacity; 855 else if (wp == zones[1].start << SECTOR_SHIFT) 856 zone_end = zones[0].start + zones[0].capacity; 857 if (zone_end) 858 wp = ALIGN_DOWN(zone_end << SECTOR_SHIFT, 859 BTRFS_SUPER_INFO_SIZE); 860 861 wp -= BTRFS_SUPER_INFO_SIZE; 862 } 863 864 *bytenr_ret = wp; 865 return 0; 866 867 } 868 869 int btrfs_sb_log_location_bdev(struct block_device *bdev, int mirror, int rw, 870 u64 *bytenr_ret) 871 { 872 struct blk_zone zones[BTRFS_NR_SB_LOG_ZONES]; 873 sector_t zone_sectors; 874 u32 sb_zone; 875 int ret; 876 u8 zone_sectors_shift; 877 sector_t nr_sectors; 878 u32 nr_zones; 879 880 if (!bdev_is_zoned(bdev)) { 881 *bytenr_ret = btrfs_sb_offset(mirror); 882 return 0; 883 } 884 885 ASSERT(rw == READ || rw == WRITE); 886 887 zone_sectors = bdev_zone_sectors(bdev); 888 if (!is_power_of_2(zone_sectors)) 889 return -EINVAL; 890 zone_sectors_shift = ilog2(zone_sectors); 891 nr_sectors = bdev_nr_sectors(bdev); 892 nr_zones = nr_sectors >> zone_sectors_shift; 893 894 sb_zone = sb_zone_number(zone_sectors_shift + SECTOR_SHIFT, mirror); 895 if (sb_zone + 1 >= nr_zones) 896 return -ENOENT; 897 898 ret = blkdev_report_zones(bdev, zone_start_sector(sb_zone, bdev), 899 BTRFS_NR_SB_LOG_ZONES, copy_zone_info_cb, 900 zones); 901 if (ret < 0) 902 return ret; 903 if (ret != BTRFS_NR_SB_LOG_ZONES) 904 return -EIO; 905 906 return sb_log_location(bdev, zones, rw, bytenr_ret); 907 } 908 909 int btrfs_sb_log_location(struct btrfs_device *device, int mirror, int rw, 910 u64 *bytenr_ret) 911 { 912 struct btrfs_zoned_device_info *zinfo = device->zone_info; 913 u32 zone_num; 914 915 /* 916 * For a zoned filesystem on a non-zoned block device, use the same 917 * super block locations as regular filesystem. Doing so, the super 918 * block can always be retrieved and the zoned flag of the volume 919 * detected from the super block information. 920 */ 921 if (!bdev_is_zoned(device->bdev)) { 922 *bytenr_ret = btrfs_sb_offset(mirror); 923 return 0; 924 } 925 926 zone_num = sb_zone_number(zinfo->zone_size_shift, mirror); 927 if (zone_num + 1 >= zinfo->nr_zones) 928 return -ENOENT; 929 930 return sb_log_location(device->bdev, 931 &zinfo->sb_zones[BTRFS_NR_SB_LOG_ZONES * mirror], 932 rw, bytenr_ret); 933 } 934 935 static inline bool is_sb_log_zone(struct btrfs_zoned_device_info *zinfo, 936 int mirror) 937 { 938 u32 zone_num; 939 940 if (!zinfo) 941 return false; 942 943 zone_num = sb_zone_number(zinfo->zone_size_shift, mirror); 944 if (zone_num + 1 >= zinfo->nr_zones) 945 return false; 946 947 if (!test_bit(zone_num, zinfo->seq_zones)) 948 return false; 949 950 return true; 951 } 952 953 int btrfs_advance_sb_log(struct btrfs_device *device, int mirror) 954 { 955 struct btrfs_zoned_device_info *zinfo = device->zone_info; 956 struct blk_zone *zone; 957 int i; 958 959 if (!is_sb_log_zone(zinfo, mirror)) 960 return 0; 961 962 zone = &zinfo->sb_zones[BTRFS_NR_SB_LOG_ZONES * mirror]; 963 for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++) { 964 /* Advance the next zone */ 965 if (zone->cond == BLK_ZONE_COND_FULL) { 966 zone++; 967 continue; 968 } 969 970 if (zone->cond == BLK_ZONE_COND_EMPTY) 971 zone->cond = BLK_ZONE_COND_IMP_OPEN; 972 973 zone->wp += SUPER_INFO_SECTORS; 974 975 if (sb_zone_is_full(zone)) { 976 /* 977 * No room left to write new superblock. Since 978 * superblock is written with REQ_SYNC, it is safe to 979 * finish the zone now. 980 * 981 * If the write pointer is exactly at the capacity, 982 * explicit ZONE_FINISH is not necessary. 983 */ 984 if (zone->wp != zone->start + zone->capacity) { 985 int ret; 986 987 ret = blkdev_zone_mgmt(device->bdev, 988 REQ_OP_ZONE_FINISH, zone->start, 989 zone->len, GFP_NOFS); 990 if (ret) 991 return ret; 992 } 993 994 zone->wp = zone->start + zone->len; 995 zone->cond = BLK_ZONE_COND_FULL; 996 } 997 return 0; 998 } 999 1000 /* All the zones are FULL. Should not reach here. */ 1001 ASSERT(0); 1002 return -EIO; 1003 } 1004 1005 int btrfs_reset_sb_log_zones(struct block_device *bdev, int mirror) 1006 { 1007 sector_t zone_sectors; 1008 sector_t nr_sectors; 1009 u8 zone_sectors_shift; 1010 u32 sb_zone; 1011 u32 nr_zones; 1012 1013 zone_sectors = bdev_zone_sectors(bdev); 1014 zone_sectors_shift = ilog2(zone_sectors); 1015 nr_sectors = bdev_nr_sectors(bdev); 1016 nr_zones = nr_sectors >> zone_sectors_shift; 1017 1018 sb_zone = sb_zone_number(zone_sectors_shift + SECTOR_SHIFT, mirror); 1019 if (sb_zone + 1 >= nr_zones) 1020 return -ENOENT; 1021 1022 return blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET, 1023 zone_start_sector(sb_zone, bdev), 1024 zone_sectors * BTRFS_NR_SB_LOG_ZONES, GFP_NOFS); 1025 } 1026 1027 /* 1028 * Find allocatable zones within a given region. 1029 * 1030 * @device: the device to allocate a region on 1031 * @hole_start: the position of the hole to allocate the region 1032 * @num_bytes: size of wanted region 1033 * @hole_end: the end of the hole 1034 * @return: position of allocatable zones 1035 * 1036 * Allocatable region should not contain any superblock locations. 1037 */ 1038 u64 btrfs_find_allocatable_zones(struct btrfs_device *device, u64 hole_start, 1039 u64 hole_end, u64 num_bytes) 1040 { 1041 struct btrfs_zoned_device_info *zinfo = device->zone_info; 1042 const u8 shift = zinfo->zone_size_shift; 1043 u64 nzones = num_bytes >> shift; 1044 u64 pos = hole_start; 1045 u64 begin, end; 1046 bool have_sb; 1047 int i; 1048 1049 ASSERT(IS_ALIGNED(hole_start, zinfo->zone_size)); 1050 ASSERT(IS_ALIGNED(num_bytes, zinfo->zone_size)); 1051 1052 while (pos < hole_end) { 1053 begin = pos >> shift; 1054 end = begin + nzones; 1055 1056 if (end > zinfo->nr_zones) 1057 return hole_end; 1058 1059 /* Check if zones in the region are all empty */ 1060 if (btrfs_dev_is_sequential(device, pos) && 1061 !bitmap_test_range_all_set(zinfo->empty_zones, begin, nzones)) { 1062 pos += zinfo->zone_size; 1063 continue; 1064 } 1065 1066 have_sb = false; 1067 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { 1068 u32 sb_zone; 1069 u64 sb_pos; 1070 1071 sb_zone = sb_zone_number(shift, i); 1072 if (!(end <= sb_zone || 1073 sb_zone + BTRFS_NR_SB_LOG_ZONES <= begin)) { 1074 have_sb = true; 1075 pos = zone_start_physical( 1076 sb_zone + BTRFS_NR_SB_LOG_ZONES, zinfo); 1077 break; 1078 } 1079 1080 /* We also need to exclude regular superblock positions */ 1081 sb_pos = btrfs_sb_offset(i); 1082 if (!(pos + num_bytes <= sb_pos || 1083 sb_pos + BTRFS_SUPER_INFO_SIZE <= pos)) { 1084 have_sb = true; 1085 pos = ALIGN(sb_pos + BTRFS_SUPER_INFO_SIZE, 1086 zinfo->zone_size); 1087 break; 1088 } 1089 } 1090 if (!have_sb) 1091 break; 1092 } 1093 1094 return pos; 1095 } 1096 1097 static bool btrfs_dev_set_active_zone(struct btrfs_device *device, u64 pos) 1098 { 1099 struct btrfs_zoned_device_info *zone_info = device->zone_info; 1100 unsigned int zno = (pos >> zone_info->zone_size_shift); 1101 1102 /* We can use any number of zones */ 1103 if (zone_info->max_active_zones == 0) 1104 return true; 1105 1106 if (!test_bit(zno, zone_info->active_zones)) { 1107 /* Active zone left? */ 1108 if (atomic_dec_if_positive(&zone_info->active_zones_left) < 0) 1109 return false; 1110 if (test_and_set_bit(zno, zone_info->active_zones)) { 1111 /* Someone already set the bit */ 1112 atomic_inc(&zone_info->active_zones_left); 1113 } 1114 } 1115 1116 return true; 1117 } 1118 1119 static void btrfs_dev_clear_active_zone(struct btrfs_device *device, u64 pos) 1120 { 1121 struct btrfs_zoned_device_info *zone_info = device->zone_info; 1122 unsigned int zno = (pos >> zone_info->zone_size_shift); 1123 1124 /* We can use any number of zones */ 1125 if (zone_info->max_active_zones == 0) 1126 return; 1127 1128 if (test_and_clear_bit(zno, zone_info->active_zones)) 1129 atomic_inc(&zone_info->active_zones_left); 1130 } 1131 1132 int btrfs_reset_device_zone(struct btrfs_device *device, u64 physical, 1133 u64 length, u64 *bytes) 1134 { 1135 int ret; 1136 1137 *bytes = 0; 1138 ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_RESET, 1139 physical >> SECTOR_SHIFT, length >> SECTOR_SHIFT, 1140 GFP_NOFS); 1141 if (ret) 1142 return ret; 1143 1144 *bytes = length; 1145 while (length) { 1146 btrfs_dev_set_zone_empty(device, physical); 1147 btrfs_dev_clear_active_zone(device, physical); 1148 physical += device->zone_info->zone_size; 1149 length -= device->zone_info->zone_size; 1150 } 1151 1152 return 0; 1153 } 1154 1155 int btrfs_ensure_empty_zones(struct btrfs_device *device, u64 start, u64 size) 1156 { 1157 struct btrfs_zoned_device_info *zinfo = device->zone_info; 1158 const u8 shift = zinfo->zone_size_shift; 1159 unsigned long begin = start >> shift; 1160 unsigned long nbits = size >> shift; 1161 u64 pos; 1162 int ret; 1163 1164 ASSERT(IS_ALIGNED(start, zinfo->zone_size)); 1165 ASSERT(IS_ALIGNED(size, zinfo->zone_size)); 1166 1167 if (begin + nbits > zinfo->nr_zones) 1168 return -ERANGE; 1169 1170 /* All the zones are conventional */ 1171 if (bitmap_test_range_all_zero(zinfo->seq_zones, begin, nbits)) 1172 return 0; 1173 1174 /* All the zones are sequential and empty */ 1175 if (bitmap_test_range_all_set(zinfo->seq_zones, begin, nbits) && 1176 bitmap_test_range_all_set(zinfo->empty_zones, begin, nbits)) 1177 return 0; 1178 1179 for (pos = start; pos < start + size; pos += zinfo->zone_size) { 1180 u64 reset_bytes; 1181 1182 if (!btrfs_dev_is_sequential(device, pos) || 1183 btrfs_dev_is_empty_zone(device, pos)) 1184 continue; 1185 1186 /* Free regions should be empty */ 1187 btrfs_warn_in_rcu( 1188 device->fs_info, 1189 "zoned: resetting device %s (devid %llu) zone %llu for allocation", 1190 rcu_str_deref(device->name), device->devid, pos >> shift); 1191 WARN_ON_ONCE(1); 1192 1193 ret = btrfs_reset_device_zone(device, pos, zinfo->zone_size, 1194 &reset_bytes); 1195 if (ret) 1196 return ret; 1197 } 1198 1199 return 0; 1200 } 1201 1202 /* 1203 * Calculate an allocation pointer from the extent allocation information 1204 * for a block group consist of conventional zones. It is pointed to the 1205 * end of the highest addressed extent in the block group as an allocation 1206 * offset. 1207 */ 1208 static int calculate_alloc_pointer(struct btrfs_block_group *cache, 1209 u64 *offset_ret, bool new) 1210 { 1211 struct btrfs_fs_info *fs_info = cache->fs_info; 1212 struct btrfs_root *root; 1213 struct btrfs_path *path; 1214 struct btrfs_key key; 1215 struct btrfs_key found_key; 1216 int ret; 1217 u64 length; 1218 1219 /* 1220 * Avoid tree lookups for a new block group, there's no use for it. 1221 * It must always be 0. 1222 * 1223 * Also, we have a lock chain of extent buffer lock -> chunk mutex. 1224 * For new a block group, this function is called from 1225 * btrfs_make_block_group() which is already taking the chunk mutex. 1226 * Thus, we cannot call calculate_alloc_pointer() which takes extent 1227 * buffer locks to avoid deadlock. 1228 */ 1229 if (new) { 1230 *offset_ret = 0; 1231 return 0; 1232 } 1233 1234 path = btrfs_alloc_path(); 1235 if (!path) 1236 return -ENOMEM; 1237 1238 key.objectid = cache->start + cache->length; 1239 key.type = 0; 1240 key.offset = 0; 1241 1242 root = btrfs_extent_root(fs_info, key.objectid); 1243 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 1244 /* We should not find the exact match */ 1245 if (!ret) 1246 ret = -EUCLEAN; 1247 if (ret < 0) 1248 goto out; 1249 1250 ret = btrfs_previous_extent_item(root, path, cache->start); 1251 if (ret) { 1252 if (ret == 1) { 1253 ret = 0; 1254 *offset_ret = 0; 1255 } 1256 goto out; 1257 } 1258 1259 btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]); 1260 1261 if (found_key.type == BTRFS_EXTENT_ITEM_KEY) 1262 length = found_key.offset; 1263 else 1264 length = fs_info->nodesize; 1265 1266 if (!(found_key.objectid >= cache->start && 1267 found_key.objectid + length <= cache->start + cache->length)) { 1268 ret = -EUCLEAN; 1269 goto out; 1270 } 1271 *offset_ret = found_key.objectid + length - cache->start; 1272 ret = 0; 1273 1274 out: 1275 btrfs_free_path(path); 1276 return ret; 1277 } 1278 1279 int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache, bool new) 1280 { 1281 struct btrfs_fs_info *fs_info = cache->fs_info; 1282 struct extent_map_tree *em_tree = &fs_info->mapping_tree; 1283 struct extent_map *em; 1284 struct map_lookup *map; 1285 struct btrfs_device *device; 1286 u64 logical = cache->start; 1287 u64 length = cache->length; 1288 int ret; 1289 int i; 1290 unsigned int nofs_flag; 1291 u64 *alloc_offsets = NULL; 1292 u64 *caps = NULL; 1293 u64 *physical = NULL; 1294 unsigned long *active = NULL; 1295 u64 last_alloc = 0; 1296 u32 num_sequential = 0, num_conventional = 0; 1297 1298 if (!btrfs_is_zoned(fs_info)) 1299 return 0; 1300 1301 /* Sanity check */ 1302 if (!IS_ALIGNED(length, fs_info->zone_size)) { 1303 btrfs_err(fs_info, 1304 "zoned: block group %llu len %llu unaligned to zone size %llu", 1305 logical, length, fs_info->zone_size); 1306 return -EIO; 1307 } 1308 1309 /* Get the chunk mapping */ 1310 read_lock(&em_tree->lock); 1311 em = lookup_extent_mapping(em_tree, logical, length); 1312 read_unlock(&em_tree->lock); 1313 1314 if (!em) 1315 return -EINVAL; 1316 1317 map = em->map_lookup; 1318 1319 cache->physical_map = kmemdup(map, map_lookup_size(map->num_stripes), GFP_NOFS); 1320 if (!cache->physical_map) { 1321 ret = -ENOMEM; 1322 goto out; 1323 } 1324 1325 alloc_offsets = kcalloc(map->num_stripes, sizeof(*alloc_offsets), GFP_NOFS); 1326 if (!alloc_offsets) { 1327 ret = -ENOMEM; 1328 goto out; 1329 } 1330 1331 caps = kcalloc(map->num_stripes, sizeof(*caps), GFP_NOFS); 1332 if (!caps) { 1333 ret = -ENOMEM; 1334 goto out; 1335 } 1336 1337 physical = kcalloc(map->num_stripes, sizeof(*physical), GFP_NOFS); 1338 if (!physical) { 1339 ret = -ENOMEM; 1340 goto out; 1341 } 1342 1343 active = bitmap_zalloc(map->num_stripes, GFP_NOFS); 1344 if (!active) { 1345 ret = -ENOMEM; 1346 goto out; 1347 } 1348 1349 for (i = 0; i < map->num_stripes; i++) { 1350 bool is_sequential; 1351 struct blk_zone zone; 1352 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; 1353 int dev_replace_is_ongoing = 0; 1354 1355 device = map->stripes[i].dev; 1356 physical[i] = map->stripes[i].physical; 1357 1358 if (device->bdev == NULL) { 1359 alloc_offsets[i] = WP_MISSING_DEV; 1360 continue; 1361 } 1362 1363 is_sequential = btrfs_dev_is_sequential(device, physical[i]); 1364 if (is_sequential) 1365 num_sequential++; 1366 else 1367 num_conventional++; 1368 1369 /* 1370 * Consider a zone as active if we can allow any number of 1371 * active zones. 1372 */ 1373 if (!device->zone_info->max_active_zones) 1374 __set_bit(i, active); 1375 1376 if (!is_sequential) { 1377 alloc_offsets[i] = WP_CONVENTIONAL; 1378 continue; 1379 } 1380 1381 /* 1382 * This zone will be used for allocation, so mark this zone 1383 * non-empty. 1384 */ 1385 btrfs_dev_clear_zone_empty(device, physical[i]); 1386 1387 down_read(&dev_replace->rwsem); 1388 dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace); 1389 if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL) 1390 btrfs_dev_clear_zone_empty(dev_replace->tgtdev, physical[i]); 1391 up_read(&dev_replace->rwsem); 1392 1393 /* 1394 * The group is mapped to a sequential zone. Get the zone write 1395 * pointer to determine the allocation offset within the zone. 1396 */ 1397 WARN_ON(!IS_ALIGNED(physical[i], fs_info->zone_size)); 1398 nofs_flag = memalloc_nofs_save(); 1399 ret = btrfs_get_dev_zone(device, physical[i], &zone); 1400 memalloc_nofs_restore(nofs_flag); 1401 if (ret == -EIO || ret == -EOPNOTSUPP) { 1402 ret = 0; 1403 alloc_offsets[i] = WP_MISSING_DEV; 1404 continue; 1405 } else if (ret) { 1406 goto out; 1407 } 1408 1409 if (zone.type == BLK_ZONE_TYPE_CONVENTIONAL) { 1410 btrfs_err_in_rcu(fs_info, 1411 "zoned: unexpected conventional zone %llu on device %s (devid %llu)", 1412 zone.start << SECTOR_SHIFT, 1413 rcu_str_deref(device->name), device->devid); 1414 ret = -EIO; 1415 goto out; 1416 } 1417 1418 caps[i] = (zone.capacity << SECTOR_SHIFT); 1419 1420 switch (zone.cond) { 1421 case BLK_ZONE_COND_OFFLINE: 1422 case BLK_ZONE_COND_READONLY: 1423 btrfs_err(fs_info, 1424 "zoned: offline/readonly zone %llu on device %s (devid %llu)", 1425 physical[i] >> device->zone_info->zone_size_shift, 1426 rcu_str_deref(device->name), device->devid); 1427 alloc_offsets[i] = WP_MISSING_DEV; 1428 break; 1429 case BLK_ZONE_COND_EMPTY: 1430 alloc_offsets[i] = 0; 1431 break; 1432 case BLK_ZONE_COND_FULL: 1433 alloc_offsets[i] = caps[i]; 1434 break; 1435 default: 1436 /* Partially used zone */ 1437 alloc_offsets[i] = 1438 ((zone.wp - zone.start) << SECTOR_SHIFT); 1439 __set_bit(i, active); 1440 break; 1441 } 1442 } 1443 1444 if (num_sequential > 0) 1445 set_bit(BLOCK_GROUP_FLAG_SEQUENTIAL_ZONE, &cache->runtime_flags); 1446 1447 if (num_conventional > 0) { 1448 /* Zone capacity is always zone size in emulation */ 1449 cache->zone_capacity = cache->length; 1450 ret = calculate_alloc_pointer(cache, &last_alloc, new); 1451 if (ret) { 1452 btrfs_err(fs_info, 1453 "zoned: failed to determine allocation offset of bg %llu", 1454 cache->start); 1455 goto out; 1456 } else if (map->num_stripes == num_conventional) { 1457 cache->alloc_offset = last_alloc; 1458 set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &cache->runtime_flags); 1459 goto out; 1460 } 1461 } 1462 1463 switch (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) { 1464 case 0: /* single */ 1465 if (alloc_offsets[0] == WP_MISSING_DEV) { 1466 btrfs_err(fs_info, 1467 "zoned: cannot recover write pointer for zone %llu", 1468 physical[0]); 1469 ret = -EIO; 1470 goto out; 1471 } 1472 cache->alloc_offset = alloc_offsets[0]; 1473 cache->zone_capacity = caps[0]; 1474 if (test_bit(0, active)) 1475 set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &cache->runtime_flags); 1476 break; 1477 case BTRFS_BLOCK_GROUP_DUP: 1478 if (map->type & BTRFS_BLOCK_GROUP_DATA) { 1479 btrfs_err(fs_info, "zoned: profile DUP not yet supported on data bg"); 1480 ret = -EINVAL; 1481 goto out; 1482 } 1483 if (alloc_offsets[0] == WP_MISSING_DEV) { 1484 btrfs_err(fs_info, 1485 "zoned: cannot recover write pointer for zone %llu", 1486 physical[0]); 1487 ret = -EIO; 1488 goto out; 1489 } 1490 if (alloc_offsets[1] == WP_MISSING_DEV) { 1491 btrfs_err(fs_info, 1492 "zoned: cannot recover write pointer for zone %llu", 1493 physical[1]); 1494 ret = -EIO; 1495 goto out; 1496 } 1497 if (alloc_offsets[0] != alloc_offsets[1]) { 1498 btrfs_err(fs_info, 1499 "zoned: write pointer offset mismatch of zones in DUP profile"); 1500 ret = -EIO; 1501 goto out; 1502 } 1503 if (test_bit(0, active) != test_bit(1, active)) { 1504 if (!btrfs_zone_activate(cache)) { 1505 ret = -EIO; 1506 goto out; 1507 } 1508 } else { 1509 if (test_bit(0, active)) 1510 set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, 1511 &cache->runtime_flags); 1512 } 1513 cache->alloc_offset = alloc_offsets[0]; 1514 cache->zone_capacity = min(caps[0], caps[1]); 1515 break; 1516 case BTRFS_BLOCK_GROUP_RAID1: 1517 case BTRFS_BLOCK_GROUP_RAID0: 1518 case BTRFS_BLOCK_GROUP_RAID10: 1519 case BTRFS_BLOCK_GROUP_RAID5: 1520 case BTRFS_BLOCK_GROUP_RAID6: 1521 /* non-single profiles are not supported yet */ 1522 default: 1523 btrfs_err(fs_info, "zoned: profile %s not yet supported", 1524 btrfs_bg_type_to_raid_name(map->type)); 1525 ret = -EINVAL; 1526 goto out; 1527 } 1528 1529 out: 1530 if (cache->alloc_offset > fs_info->zone_size) { 1531 btrfs_err(fs_info, 1532 "zoned: invalid write pointer %llu in block group %llu", 1533 cache->alloc_offset, cache->start); 1534 ret = -EIO; 1535 } 1536 1537 if (cache->alloc_offset > cache->zone_capacity) { 1538 btrfs_err(fs_info, 1539 "zoned: invalid write pointer %llu (larger than zone capacity %llu) in block group %llu", 1540 cache->alloc_offset, cache->zone_capacity, 1541 cache->start); 1542 ret = -EIO; 1543 } 1544 1545 /* An extent is allocated after the write pointer */ 1546 if (!ret && num_conventional && last_alloc > cache->alloc_offset) { 1547 btrfs_err(fs_info, 1548 "zoned: got wrong write pointer in BG %llu: %llu > %llu", 1549 logical, last_alloc, cache->alloc_offset); 1550 ret = -EIO; 1551 } 1552 1553 if (!ret) { 1554 cache->meta_write_pointer = cache->alloc_offset + cache->start; 1555 if (test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &cache->runtime_flags)) { 1556 btrfs_get_block_group(cache); 1557 spin_lock(&fs_info->zone_active_bgs_lock); 1558 list_add_tail(&cache->active_bg_list, 1559 &fs_info->zone_active_bgs); 1560 spin_unlock(&fs_info->zone_active_bgs_lock); 1561 } 1562 } else { 1563 kfree(cache->physical_map); 1564 cache->physical_map = NULL; 1565 } 1566 bitmap_free(active); 1567 kfree(physical); 1568 kfree(caps); 1569 kfree(alloc_offsets); 1570 free_extent_map(em); 1571 1572 return ret; 1573 } 1574 1575 void btrfs_calc_zone_unusable(struct btrfs_block_group *cache) 1576 { 1577 u64 unusable, free; 1578 1579 if (!btrfs_is_zoned(cache->fs_info)) 1580 return; 1581 1582 WARN_ON(cache->bytes_super != 0); 1583 1584 /* Check for block groups never get activated */ 1585 if (test_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &cache->fs_info->flags) && 1586 cache->flags & (BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_SYSTEM) && 1587 !test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &cache->runtime_flags) && 1588 cache->alloc_offset == 0) { 1589 unusable = cache->length; 1590 free = 0; 1591 } else { 1592 unusable = (cache->alloc_offset - cache->used) + 1593 (cache->length - cache->zone_capacity); 1594 free = cache->zone_capacity - cache->alloc_offset; 1595 } 1596 1597 /* We only need ->free_space in ALLOC_SEQ block groups */ 1598 cache->cached = BTRFS_CACHE_FINISHED; 1599 cache->free_space_ctl->free_space = free; 1600 cache->zone_unusable = unusable; 1601 } 1602 1603 void btrfs_redirty_list_add(struct btrfs_transaction *trans, 1604 struct extent_buffer *eb) 1605 { 1606 if (!btrfs_is_zoned(eb->fs_info) || 1607 btrfs_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN)) 1608 return; 1609 1610 ASSERT(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)); 1611 1612 memzero_extent_buffer(eb, 0, eb->len); 1613 set_bit(EXTENT_BUFFER_NO_CHECK, &eb->bflags); 1614 set_extent_buffer_dirty(eb); 1615 set_extent_bit(&trans->dirty_pages, eb->start, eb->start + eb->len - 1, 1616 EXTENT_DIRTY | EXTENT_NOWAIT, NULL); 1617 } 1618 1619 bool btrfs_use_zone_append(struct btrfs_bio *bbio) 1620 { 1621 u64 start = (bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT); 1622 struct btrfs_inode *inode = bbio->inode; 1623 struct btrfs_fs_info *fs_info = bbio->fs_info; 1624 struct btrfs_block_group *cache; 1625 bool ret = false; 1626 1627 if (!btrfs_is_zoned(fs_info)) 1628 return false; 1629 1630 if (!inode || !is_data_inode(&inode->vfs_inode)) 1631 return false; 1632 1633 if (btrfs_op(&bbio->bio) != BTRFS_MAP_WRITE) 1634 return false; 1635 1636 /* 1637 * Using REQ_OP_ZONE_APPNED for relocation can break assumptions on the 1638 * extent layout the relocation code has. 1639 * Furthermore we have set aside own block-group from which only the 1640 * relocation "process" can allocate and make sure only one process at a 1641 * time can add pages to an extent that gets relocated, so it's safe to 1642 * use regular REQ_OP_WRITE for this special case. 1643 */ 1644 if (btrfs_is_data_reloc_root(inode->root)) 1645 return false; 1646 1647 cache = btrfs_lookup_block_group(fs_info, start); 1648 ASSERT(cache); 1649 if (!cache) 1650 return false; 1651 1652 ret = !!test_bit(BLOCK_GROUP_FLAG_SEQUENTIAL_ZONE, &cache->runtime_flags); 1653 btrfs_put_block_group(cache); 1654 1655 return ret; 1656 } 1657 1658 void btrfs_record_physical_zoned(struct btrfs_bio *bbio) 1659 { 1660 const u64 physical = bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT; 1661 struct btrfs_ordered_sum *sum = bbio->sums; 1662 1663 if (physical < bbio->orig_physical) 1664 sum->logical -= bbio->orig_physical - physical; 1665 else 1666 sum->logical += physical - bbio->orig_physical; 1667 } 1668 1669 static void btrfs_rewrite_logical_zoned(struct btrfs_ordered_extent *ordered, 1670 u64 logical) 1671 { 1672 struct extent_map_tree *em_tree = &BTRFS_I(ordered->inode)->extent_tree; 1673 struct extent_map *em; 1674 1675 ordered->disk_bytenr = logical; 1676 1677 write_lock(&em_tree->lock); 1678 em = search_extent_mapping(em_tree, ordered->file_offset, 1679 ordered->num_bytes); 1680 em->block_start = logical; 1681 free_extent_map(em); 1682 write_unlock(&em_tree->lock); 1683 } 1684 1685 static bool btrfs_zoned_split_ordered(struct btrfs_ordered_extent *ordered, 1686 u64 logical, u64 len) 1687 { 1688 struct btrfs_ordered_extent *new; 1689 1690 if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags) && 1691 split_extent_map(BTRFS_I(ordered->inode), ordered->file_offset, 1692 ordered->num_bytes, len, logical)) 1693 return false; 1694 1695 new = btrfs_split_ordered_extent(ordered, len); 1696 if (IS_ERR(new)) 1697 return false; 1698 new->disk_bytenr = logical; 1699 btrfs_finish_one_ordered(new); 1700 return true; 1701 } 1702 1703 void btrfs_finish_ordered_zoned(struct btrfs_ordered_extent *ordered) 1704 { 1705 struct btrfs_inode *inode = BTRFS_I(ordered->inode); 1706 struct btrfs_fs_info *fs_info = inode->root->fs_info; 1707 struct btrfs_ordered_sum *sum = 1708 list_first_entry(&ordered->list, typeof(*sum), list); 1709 u64 logical = sum->logical; 1710 u64 len = sum->len; 1711 1712 while (len < ordered->disk_num_bytes) { 1713 sum = list_next_entry(sum, list); 1714 if (sum->logical == logical + len) { 1715 len += sum->len; 1716 continue; 1717 } 1718 if (!btrfs_zoned_split_ordered(ordered, logical, len)) { 1719 set_bit(BTRFS_ORDERED_IOERR, &ordered->flags); 1720 btrfs_err(fs_info, "failed to split ordered extent"); 1721 goto out; 1722 } 1723 logical = sum->logical; 1724 len = sum->len; 1725 } 1726 1727 if (ordered->disk_bytenr != logical) 1728 btrfs_rewrite_logical_zoned(ordered, logical); 1729 1730 out: 1731 /* 1732 * If we end up here for nodatasum I/O, the btrfs_ordered_sum structures 1733 * were allocated by btrfs_alloc_dummy_sum only to record the logical 1734 * addresses and don't contain actual checksums. We thus must free them 1735 * here so that we don't attempt to log the csums later. 1736 */ 1737 if ((inode->flags & BTRFS_INODE_NODATASUM) || 1738 test_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state)) { 1739 while ((sum = list_first_entry_or_null(&ordered->list, 1740 typeof(*sum), list))) { 1741 list_del(&sum->list); 1742 kfree(sum); 1743 } 1744 } 1745 } 1746 1747 bool btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info, 1748 struct extent_buffer *eb, 1749 struct btrfs_block_group **cache_ret) 1750 { 1751 struct btrfs_block_group *cache; 1752 bool ret = true; 1753 1754 if (!btrfs_is_zoned(fs_info)) 1755 return true; 1756 1757 cache = btrfs_lookup_block_group(fs_info, eb->start); 1758 if (!cache) 1759 return true; 1760 1761 if (cache->meta_write_pointer != eb->start) { 1762 btrfs_put_block_group(cache); 1763 cache = NULL; 1764 ret = false; 1765 } else { 1766 cache->meta_write_pointer = eb->start + eb->len; 1767 } 1768 1769 *cache_ret = cache; 1770 1771 return ret; 1772 } 1773 1774 void btrfs_revert_meta_write_pointer(struct btrfs_block_group *cache, 1775 struct extent_buffer *eb) 1776 { 1777 if (!btrfs_is_zoned(eb->fs_info) || !cache) 1778 return; 1779 1780 ASSERT(cache->meta_write_pointer == eb->start + eb->len); 1781 cache->meta_write_pointer = eb->start; 1782 } 1783 1784 int btrfs_zoned_issue_zeroout(struct btrfs_device *device, u64 physical, u64 length) 1785 { 1786 if (!btrfs_dev_is_sequential(device, physical)) 1787 return -EOPNOTSUPP; 1788 1789 return blkdev_issue_zeroout(device->bdev, physical >> SECTOR_SHIFT, 1790 length >> SECTOR_SHIFT, GFP_NOFS, 0); 1791 } 1792 1793 static int read_zone_info(struct btrfs_fs_info *fs_info, u64 logical, 1794 struct blk_zone *zone) 1795 { 1796 struct btrfs_io_context *bioc = NULL; 1797 u64 mapped_length = PAGE_SIZE; 1798 unsigned int nofs_flag; 1799 int nmirrors; 1800 int i, ret; 1801 1802 ret = btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS, logical, 1803 &mapped_length, &bioc, NULL, NULL, 1); 1804 if (ret || !bioc || mapped_length < PAGE_SIZE) { 1805 ret = -EIO; 1806 goto out_put_bioc; 1807 } 1808 1809 if (bioc->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) { 1810 ret = -EINVAL; 1811 goto out_put_bioc; 1812 } 1813 1814 nofs_flag = memalloc_nofs_save(); 1815 nmirrors = (int)bioc->num_stripes; 1816 for (i = 0; i < nmirrors; i++) { 1817 u64 physical = bioc->stripes[i].physical; 1818 struct btrfs_device *dev = bioc->stripes[i].dev; 1819 1820 /* Missing device */ 1821 if (!dev->bdev) 1822 continue; 1823 1824 ret = btrfs_get_dev_zone(dev, physical, zone); 1825 /* Failing device */ 1826 if (ret == -EIO || ret == -EOPNOTSUPP) 1827 continue; 1828 break; 1829 } 1830 memalloc_nofs_restore(nofs_flag); 1831 out_put_bioc: 1832 btrfs_put_bioc(bioc); 1833 return ret; 1834 } 1835 1836 /* 1837 * Synchronize write pointer in a zone at @physical_start on @tgt_dev, by 1838 * filling zeros between @physical_pos to a write pointer of dev-replace 1839 * source device. 1840 */ 1841 int btrfs_sync_zone_write_pointer(struct btrfs_device *tgt_dev, u64 logical, 1842 u64 physical_start, u64 physical_pos) 1843 { 1844 struct btrfs_fs_info *fs_info = tgt_dev->fs_info; 1845 struct blk_zone zone; 1846 u64 length; 1847 u64 wp; 1848 int ret; 1849 1850 if (!btrfs_dev_is_sequential(tgt_dev, physical_pos)) 1851 return 0; 1852 1853 ret = read_zone_info(fs_info, logical, &zone); 1854 if (ret) 1855 return ret; 1856 1857 wp = physical_start + ((zone.wp - zone.start) << SECTOR_SHIFT); 1858 1859 if (physical_pos == wp) 1860 return 0; 1861 1862 if (physical_pos > wp) 1863 return -EUCLEAN; 1864 1865 length = wp - physical_pos; 1866 return btrfs_zoned_issue_zeroout(tgt_dev, physical_pos, length); 1867 } 1868 1869 /* 1870 * Activate block group and underlying device zones 1871 * 1872 * @block_group: the block group to activate 1873 * 1874 * Return: true on success, false otherwise 1875 */ 1876 bool btrfs_zone_activate(struct btrfs_block_group *block_group) 1877 { 1878 struct btrfs_fs_info *fs_info = block_group->fs_info; 1879 struct btrfs_space_info *space_info = block_group->space_info; 1880 struct map_lookup *map; 1881 struct btrfs_device *device; 1882 u64 physical; 1883 bool ret; 1884 int i; 1885 1886 if (!btrfs_is_zoned(block_group->fs_info)) 1887 return true; 1888 1889 map = block_group->physical_map; 1890 1891 spin_lock(&space_info->lock); 1892 spin_lock(&block_group->lock); 1893 if (test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags)) { 1894 ret = true; 1895 goto out_unlock; 1896 } 1897 1898 /* No space left */ 1899 if (btrfs_zoned_bg_is_full(block_group)) { 1900 ret = false; 1901 goto out_unlock; 1902 } 1903 1904 for (i = 0; i < map->num_stripes; i++) { 1905 device = map->stripes[i].dev; 1906 physical = map->stripes[i].physical; 1907 1908 if (device->zone_info->max_active_zones == 0) 1909 continue; 1910 1911 if (!btrfs_dev_set_active_zone(device, physical)) { 1912 /* Cannot activate the zone */ 1913 ret = false; 1914 goto out_unlock; 1915 } 1916 } 1917 1918 /* Successfully activated all the zones */ 1919 set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags); 1920 WARN_ON(block_group->alloc_offset != 0); 1921 if (block_group->zone_unusable == block_group->length) { 1922 block_group->zone_unusable = block_group->length - block_group->zone_capacity; 1923 space_info->bytes_zone_unusable -= block_group->zone_capacity; 1924 } 1925 spin_unlock(&block_group->lock); 1926 btrfs_try_granting_tickets(fs_info, space_info); 1927 spin_unlock(&space_info->lock); 1928 1929 /* For the active block group list */ 1930 btrfs_get_block_group(block_group); 1931 1932 spin_lock(&fs_info->zone_active_bgs_lock); 1933 list_add_tail(&block_group->active_bg_list, &fs_info->zone_active_bgs); 1934 spin_unlock(&fs_info->zone_active_bgs_lock); 1935 1936 return true; 1937 1938 out_unlock: 1939 spin_unlock(&block_group->lock); 1940 spin_unlock(&space_info->lock); 1941 return ret; 1942 } 1943 1944 static void wait_eb_writebacks(struct btrfs_block_group *block_group) 1945 { 1946 struct btrfs_fs_info *fs_info = block_group->fs_info; 1947 const u64 end = block_group->start + block_group->length; 1948 struct radix_tree_iter iter; 1949 struct extent_buffer *eb; 1950 void __rcu **slot; 1951 1952 rcu_read_lock(); 1953 radix_tree_for_each_slot(slot, &fs_info->buffer_radix, &iter, 1954 block_group->start >> fs_info->sectorsize_bits) { 1955 eb = radix_tree_deref_slot(slot); 1956 if (!eb) 1957 continue; 1958 if (radix_tree_deref_retry(eb)) { 1959 slot = radix_tree_iter_retry(&iter); 1960 continue; 1961 } 1962 1963 if (eb->start < block_group->start) 1964 continue; 1965 if (eb->start >= end) 1966 break; 1967 1968 slot = radix_tree_iter_resume(slot, &iter); 1969 rcu_read_unlock(); 1970 wait_on_extent_buffer_writeback(eb); 1971 rcu_read_lock(); 1972 } 1973 rcu_read_unlock(); 1974 } 1975 1976 static int do_zone_finish(struct btrfs_block_group *block_group, bool fully_written) 1977 { 1978 struct btrfs_fs_info *fs_info = block_group->fs_info; 1979 struct map_lookup *map; 1980 const bool is_metadata = (block_group->flags & 1981 (BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_SYSTEM)); 1982 int ret = 0; 1983 int i; 1984 1985 spin_lock(&block_group->lock); 1986 if (!test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags)) { 1987 spin_unlock(&block_group->lock); 1988 return 0; 1989 } 1990 1991 /* Check if we have unwritten allocated space */ 1992 if (is_metadata && 1993 block_group->start + block_group->alloc_offset > block_group->meta_write_pointer) { 1994 spin_unlock(&block_group->lock); 1995 return -EAGAIN; 1996 } 1997 1998 /* 1999 * If we are sure that the block group is full (= no more room left for 2000 * new allocation) and the IO for the last usable block is completed, we 2001 * don't need to wait for the other IOs. This holds because we ensure 2002 * the sequential IO submissions using the ZONE_APPEND command for data 2003 * and block_group->meta_write_pointer for metadata. 2004 */ 2005 if (!fully_written) { 2006 spin_unlock(&block_group->lock); 2007 2008 ret = btrfs_inc_block_group_ro(block_group, false); 2009 if (ret) 2010 return ret; 2011 2012 /* Ensure all writes in this block group finish */ 2013 btrfs_wait_block_group_reservations(block_group); 2014 /* No need to wait for NOCOW writers. Zoned mode does not allow that */ 2015 btrfs_wait_ordered_roots(fs_info, U64_MAX, block_group->start, 2016 block_group->length); 2017 /* Wait for extent buffers to be written. */ 2018 if (is_metadata) 2019 wait_eb_writebacks(block_group); 2020 2021 spin_lock(&block_group->lock); 2022 2023 /* 2024 * Bail out if someone already deactivated the block group, or 2025 * allocated space is left in the block group. 2026 */ 2027 if (!test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, 2028 &block_group->runtime_flags)) { 2029 spin_unlock(&block_group->lock); 2030 btrfs_dec_block_group_ro(block_group); 2031 return 0; 2032 } 2033 2034 if (block_group->reserved) { 2035 spin_unlock(&block_group->lock); 2036 btrfs_dec_block_group_ro(block_group); 2037 return -EAGAIN; 2038 } 2039 } 2040 2041 clear_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags); 2042 block_group->alloc_offset = block_group->zone_capacity; 2043 block_group->free_space_ctl->free_space = 0; 2044 btrfs_clear_treelog_bg(block_group); 2045 btrfs_clear_data_reloc_bg(block_group); 2046 spin_unlock(&block_group->lock); 2047 2048 map = block_group->physical_map; 2049 for (i = 0; i < map->num_stripes; i++) { 2050 struct btrfs_device *device = map->stripes[i].dev; 2051 const u64 physical = map->stripes[i].physical; 2052 2053 if (device->zone_info->max_active_zones == 0) 2054 continue; 2055 2056 ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_FINISH, 2057 physical >> SECTOR_SHIFT, 2058 device->zone_info->zone_size >> SECTOR_SHIFT, 2059 GFP_NOFS); 2060 2061 if (ret) 2062 return ret; 2063 2064 btrfs_dev_clear_active_zone(device, physical); 2065 } 2066 2067 if (!fully_written) 2068 btrfs_dec_block_group_ro(block_group); 2069 2070 spin_lock(&fs_info->zone_active_bgs_lock); 2071 ASSERT(!list_empty(&block_group->active_bg_list)); 2072 list_del_init(&block_group->active_bg_list); 2073 spin_unlock(&fs_info->zone_active_bgs_lock); 2074 2075 /* For active_bg_list */ 2076 btrfs_put_block_group(block_group); 2077 2078 clear_and_wake_up_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags); 2079 2080 return 0; 2081 } 2082 2083 int btrfs_zone_finish(struct btrfs_block_group *block_group) 2084 { 2085 if (!btrfs_is_zoned(block_group->fs_info)) 2086 return 0; 2087 2088 return do_zone_finish(block_group, false); 2089 } 2090 2091 bool btrfs_can_activate_zone(struct btrfs_fs_devices *fs_devices, u64 flags) 2092 { 2093 struct btrfs_fs_info *fs_info = fs_devices->fs_info; 2094 struct btrfs_device *device; 2095 bool ret = false; 2096 2097 if (!btrfs_is_zoned(fs_info)) 2098 return true; 2099 2100 /* Check if there is a device with active zones left */ 2101 mutex_lock(&fs_info->chunk_mutex); 2102 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) { 2103 struct btrfs_zoned_device_info *zinfo = device->zone_info; 2104 2105 if (!device->bdev) 2106 continue; 2107 2108 if (!zinfo->max_active_zones) { 2109 ret = true; 2110 break; 2111 } 2112 2113 switch (flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) { 2114 case 0: /* single */ 2115 ret = (atomic_read(&zinfo->active_zones_left) >= 1); 2116 break; 2117 case BTRFS_BLOCK_GROUP_DUP: 2118 ret = (atomic_read(&zinfo->active_zones_left) >= 2); 2119 break; 2120 } 2121 if (ret) 2122 break; 2123 } 2124 mutex_unlock(&fs_info->chunk_mutex); 2125 2126 if (!ret) 2127 set_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags); 2128 2129 return ret; 2130 } 2131 2132 void btrfs_zone_finish_endio(struct btrfs_fs_info *fs_info, u64 logical, u64 length) 2133 { 2134 struct btrfs_block_group *block_group; 2135 u64 min_alloc_bytes; 2136 2137 if (!btrfs_is_zoned(fs_info)) 2138 return; 2139 2140 block_group = btrfs_lookup_block_group(fs_info, logical); 2141 ASSERT(block_group); 2142 2143 /* No MIXED_BG on zoned btrfs. */ 2144 if (block_group->flags & BTRFS_BLOCK_GROUP_DATA) 2145 min_alloc_bytes = fs_info->sectorsize; 2146 else 2147 min_alloc_bytes = fs_info->nodesize; 2148 2149 /* Bail out if we can allocate more data from this block group. */ 2150 if (logical + length + min_alloc_bytes <= 2151 block_group->start + block_group->zone_capacity) 2152 goto out; 2153 2154 do_zone_finish(block_group, true); 2155 2156 out: 2157 btrfs_put_block_group(block_group); 2158 } 2159 2160 static void btrfs_zone_finish_endio_workfn(struct work_struct *work) 2161 { 2162 struct btrfs_block_group *bg = 2163 container_of(work, struct btrfs_block_group, zone_finish_work); 2164 2165 wait_on_extent_buffer_writeback(bg->last_eb); 2166 free_extent_buffer(bg->last_eb); 2167 btrfs_zone_finish_endio(bg->fs_info, bg->start, bg->length); 2168 btrfs_put_block_group(bg); 2169 } 2170 2171 void btrfs_schedule_zone_finish_bg(struct btrfs_block_group *bg, 2172 struct extent_buffer *eb) 2173 { 2174 if (!test_bit(BLOCK_GROUP_FLAG_SEQUENTIAL_ZONE, &bg->runtime_flags) || 2175 eb->start + eb->len * 2 <= bg->start + bg->zone_capacity) 2176 return; 2177 2178 if (WARN_ON(bg->zone_finish_work.func == btrfs_zone_finish_endio_workfn)) { 2179 btrfs_err(bg->fs_info, "double scheduling of bg %llu zone finishing", 2180 bg->start); 2181 return; 2182 } 2183 2184 /* For the work */ 2185 btrfs_get_block_group(bg); 2186 atomic_inc(&eb->refs); 2187 bg->last_eb = eb; 2188 INIT_WORK(&bg->zone_finish_work, btrfs_zone_finish_endio_workfn); 2189 queue_work(system_unbound_wq, &bg->zone_finish_work); 2190 } 2191 2192 void btrfs_clear_data_reloc_bg(struct btrfs_block_group *bg) 2193 { 2194 struct btrfs_fs_info *fs_info = bg->fs_info; 2195 2196 spin_lock(&fs_info->relocation_bg_lock); 2197 if (fs_info->data_reloc_bg == bg->start) 2198 fs_info->data_reloc_bg = 0; 2199 spin_unlock(&fs_info->relocation_bg_lock); 2200 } 2201 2202 void btrfs_free_zone_cache(struct btrfs_fs_info *fs_info) 2203 { 2204 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 2205 struct btrfs_device *device; 2206 2207 if (!btrfs_is_zoned(fs_info)) 2208 return; 2209 2210 mutex_lock(&fs_devices->device_list_mutex); 2211 list_for_each_entry(device, &fs_devices->devices, dev_list) { 2212 if (device->zone_info) { 2213 vfree(device->zone_info->zone_cache); 2214 device->zone_info->zone_cache = NULL; 2215 } 2216 } 2217 mutex_unlock(&fs_devices->device_list_mutex); 2218 } 2219 2220 bool btrfs_zoned_should_reclaim(struct btrfs_fs_info *fs_info) 2221 { 2222 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; 2223 struct btrfs_device *device; 2224 u64 used = 0; 2225 u64 total = 0; 2226 u64 factor; 2227 2228 ASSERT(btrfs_is_zoned(fs_info)); 2229 2230 if (fs_info->bg_reclaim_threshold == 0) 2231 return false; 2232 2233 mutex_lock(&fs_devices->device_list_mutex); 2234 list_for_each_entry(device, &fs_devices->devices, dev_list) { 2235 if (!device->bdev) 2236 continue; 2237 2238 total += device->disk_total_bytes; 2239 used += device->bytes_used; 2240 } 2241 mutex_unlock(&fs_devices->device_list_mutex); 2242 2243 factor = div64_u64(used * 100, total); 2244 return factor >= fs_info->bg_reclaim_threshold; 2245 } 2246 2247 void btrfs_zoned_release_data_reloc_bg(struct btrfs_fs_info *fs_info, u64 logical, 2248 u64 length) 2249 { 2250 struct btrfs_block_group *block_group; 2251 2252 if (!btrfs_is_zoned(fs_info)) 2253 return; 2254 2255 block_group = btrfs_lookup_block_group(fs_info, logical); 2256 /* It should be called on a previous data relocation block group. */ 2257 ASSERT(block_group && (block_group->flags & BTRFS_BLOCK_GROUP_DATA)); 2258 2259 spin_lock(&block_group->lock); 2260 if (!test_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags)) 2261 goto out; 2262 2263 /* All relocation extents are written. */ 2264 if (block_group->start + block_group->alloc_offset == logical + length) { 2265 /* Now, release this block group for further allocations. */ 2266 clear_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, 2267 &block_group->runtime_flags); 2268 } 2269 2270 out: 2271 spin_unlock(&block_group->lock); 2272 btrfs_put_block_group(block_group); 2273 } 2274 2275 int btrfs_zone_finish_one_bg(struct btrfs_fs_info *fs_info) 2276 { 2277 struct btrfs_block_group *block_group; 2278 struct btrfs_block_group *min_bg = NULL; 2279 u64 min_avail = U64_MAX; 2280 int ret; 2281 2282 spin_lock(&fs_info->zone_active_bgs_lock); 2283 list_for_each_entry(block_group, &fs_info->zone_active_bgs, 2284 active_bg_list) { 2285 u64 avail; 2286 2287 spin_lock(&block_group->lock); 2288 if (block_group->reserved || block_group->alloc_offset == 0 || 2289 (block_group->flags & BTRFS_BLOCK_GROUP_SYSTEM)) { 2290 spin_unlock(&block_group->lock); 2291 continue; 2292 } 2293 2294 avail = block_group->zone_capacity - block_group->alloc_offset; 2295 if (min_avail > avail) { 2296 if (min_bg) 2297 btrfs_put_block_group(min_bg); 2298 min_bg = block_group; 2299 min_avail = avail; 2300 btrfs_get_block_group(min_bg); 2301 } 2302 spin_unlock(&block_group->lock); 2303 } 2304 spin_unlock(&fs_info->zone_active_bgs_lock); 2305 2306 if (!min_bg) 2307 return 0; 2308 2309 ret = btrfs_zone_finish(min_bg); 2310 btrfs_put_block_group(min_bg); 2311 2312 return ret < 0 ? ret : 1; 2313 } 2314 2315 int btrfs_zoned_activate_one_bg(struct btrfs_fs_info *fs_info, 2316 struct btrfs_space_info *space_info, 2317 bool do_finish) 2318 { 2319 struct btrfs_block_group *bg; 2320 int index; 2321 2322 if (!btrfs_is_zoned(fs_info) || (space_info->flags & BTRFS_BLOCK_GROUP_DATA)) 2323 return 0; 2324 2325 for (;;) { 2326 int ret; 2327 bool need_finish = false; 2328 2329 down_read(&space_info->groups_sem); 2330 for (index = 0; index < BTRFS_NR_RAID_TYPES; index++) { 2331 list_for_each_entry(bg, &space_info->block_groups[index], 2332 list) { 2333 if (!spin_trylock(&bg->lock)) 2334 continue; 2335 if (btrfs_zoned_bg_is_full(bg) || 2336 test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, 2337 &bg->runtime_flags)) { 2338 spin_unlock(&bg->lock); 2339 continue; 2340 } 2341 spin_unlock(&bg->lock); 2342 2343 if (btrfs_zone_activate(bg)) { 2344 up_read(&space_info->groups_sem); 2345 return 1; 2346 } 2347 2348 need_finish = true; 2349 } 2350 } 2351 up_read(&space_info->groups_sem); 2352 2353 if (!do_finish || !need_finish) 2354 break; 2355 2356 ret = btrfs_zone_finish_one_bg(fs_info); 2357 if (ret == 0) 2358 break; 2359 if (ret < 0) 2360 return ret; 2361 } 2362 2363 return 0; 2364 } 2365