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