1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2011 STRATO. All rights reserved. 4 */ 5 6 #include <linux/sched.h> 7 #include <linux/pagemap.h> 8 #include <linux/writeback.h> 9 #include <linux/blkdev.h> 10 #include <linux/rbtree.h> 11 #include <linux/slab.h> 12 #include <linux/workqueue.h> 13 #include <linux/btrfs.h> 14 #include <linux/sched/mm.h> 15 16 #include "ctree.h" 17 #include "transaction.h" 18 #include "disk-io.h" 19 #include "locking.h" 20 #include "ulist.h" 21 #include "backref.h" 22 #include "extent_io.h" 23 #include "qgroup.h" 24 #include "block-group.h" 25 #include "sysfs.h" 26 #include "tree-mod-log.h" 27 28 /* TODO XXX FIXME 29 * - subvol delete -> delete when ref goes to 0? delete limits also? 30 * - reorganize keys 31 * - compressed 32 * - sync 33 * - copy also limits on subvol creation 34 * - limit 35 * - caches for ulists 36 * - performance benchmarks 37 * - check all ioctl parameters 38 */ 39 40 /* 41 * Helpers to access qgroup reservation 42 * 43 * Callers should ensure the lock context and type are valid 44 */ 45 46 static u64 qgroup_rsv_total(const struct btrfs_qgroup *qgroup) 47 { 48 u64 ret = 0; 49 int i; 50 51 for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++) 52 ret += qgroup->rsv.values[i]; 53 54 return ret; 55 } 56 57 #ifdef CONFIG_BTRFS_DEBUG 58 static const char *qgroup_rsv_type_str(enum btrfs_qgroup_rsv_type type) 59 { 60 if (type == BTRFS_QGROUP_RSV_DATA) 61 return "data"; 62 if (type == BTRFS_QGROUP_RSV_META_PERTRANS) 63 return "meta_pertrans"; 64 if (type == BTRFS_QGROUP_RSV_META_PREALLOC) 65 return "meta_prealloc"; 66 return NULL; 67 } 68 #endif 69 70 static void qgroup_rsv_add(struct btrfs_fs_info *fs_info, 71 struct btrfs_qgroup *qgroup, u64 num_bytes, 72 enum btrfs_qgroup_rsv_type type) 73 { 74 trace_qgroup_update_reserve(fs_info, qgroup, num_bytes, type); 75 qgroup->rsv.values[type] += num_bytes; 76 } 77 78 static void qgroup_rsv_release(struct btrfs_fs_info *fs_info, 79 struct btrfs_qgroup *qgroup, u64 num_bytes, 80 enum btrfs_qgroup_rsv_type type) 81 { 82 trace_qgroup_update_reserve(fs_info, qgroup, -(s64)num_bytes, type); 83 if (qgroup->rsv.values[type] >= num_bytes) { 84 qgroup->rsv.values[type] -= num_bytes; 85 return; 86 } 87 #ifdef CONFIG_BTRFS_DEBUG 88 WARN_RATELIMIT(1, 89 "qgroup %llu %s reserved space underflow, have %llu to free %llu", 90 qgroup->qgroupid, qgroup_rsv_type_str(type), 91 qgroup->rsv.values[type], num_bytes); 92 #endif 93 qgroup->rsv.values[type] = 0; 94 } 95 96 static void qgroup_rsv_add_by_qgroup(struct btrfs_fs_info *fs_info, 97 struct btrfs_qgroup *dest, 98 struct btrfs_qgroup *src) 99 { 100 int i; 101 102 for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++) 103 qgroup_rsv_add(fs_info, dest, src->rsv.values[i], i); 104 } 105 106 static void qgroup_rsv_release_by_qgroup(struct btrfs_fs_info *fs_info, 107 struct btrfs_qgroup *dest, 108 struct btrfs_qgroup *src) 109 { 110 int i; 111 112 for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++) 113 qgroup_rsv_release(fs_info, dest, src->rsv.values[i], i); 114 } 115 116 static void btrfs_qgroup_update_old_refcnt(struct btrfs_qgroup *qg, u64 seq, 117 int mod) 118 { 119 if (qg->old_refcnt < seq) 120 qg->old_refcnt = seq; 121 qg->old_refcnt += mod; 122 } 123 124 static void btrfs_qgroup_update_new_refcnt(struct btrfs_qgroup *qg, u64 seq, 125 int mod) 126 { 127 if (qg->new_refcnt < seq) 128 qg->new_refcnt = seq; 129 qg->new_refcnt += mod; 130 } 131 132 static inline u64 btrfs_qgroup_get_old_refcnt(struct btrfs_qgroup *qg, u64 seq) 133 { 134 if (qg->old_refcnt < seq) 135 return 0; 136 return qg->old_refcnt - seq; 137 } 138 139 static inline u64 btrfs_qgroup_get_new_refcnt(struct btrfs_qgroup *qg, u64 seq) 140 { 141 if (qg->new_refcnt < seq) 142 return 0; 143 return qg->new_refcnt - seq; 144 } 145 146 /* 147 * glue structure to represent the relations between qgroups. 148 */ 149 struct btrfs_qgroup_list { 150 struct list_head next_group; 151 struct list_head next_member; 152 struct btrfs_qgroup *group; 153 struct btrfs_qgroup *member; 154 }; 155 156 static inline u64 qgroup_to_aux(struct btrfs_qgroup *qg) 157 { 158 return (u64)(uintptr_t)qg; 159 } 160 161 static inline struct btrfs_qgroup* unode_aux_to_qgroup(struct ulist_node *n) 162 { 163 return (struct btrfs_qgroup *)(uintptr_t)n->aux; 164 } 165 166 static int 167 qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid, 168 int init_flags); 169 static void qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info); 170 171 /* must be called with qgroup_ioctl_lock held */ 172 static struct btrfs_qgroup *find_qgroup_rb(struct btrfs_fs_info *fs_info, 173 u64 qgroupid) 174 { 175 struct rb_node *n = fs_info->qgroup_tree.rb_node; 176 struct btrfs_qgroup *qgroup; 177 178 while (n) { 179 qgroup = rb_entry(n, struct btrfs_qgroup, node); 180 if (qgroup->qgroupid < qgroupid) 181 n = n->rb_left; 182 else if (qgroup->qgroupid > qgroupid) 183 n = n->rb_right; 184 else 185 return qgroup; 186 } 187 return NULL; 188 } 189 190 /* must be called with qgroup_lock held */ 191 static struct btrfs_qgroup *add_qgroup_rb(struct btrfs_fs_info *fs_info, 192 u64 qgroupid) 193 { 194 struct rb_node **p = &fs_info->qgroup_tree.rb_node; 195 struct rb_node *parent = NULL; 196 struct btrfs_qgroup *qgroup; 197 198 while (*p) { 199 parent = *p; 200 qgroup = rb_entry(parent, struct btrfs_qgroup, node); 201 202 if (qgroup->qgroupid < qgroupid) 203 p = &(*p)->rb_left; 204 else if (qgroup->qgroupid > qgroupid) 205 p = &(*p)->rb_right; 206 else 207 return qgroup; 208 } 209 210 qgroup = kzalloc(sizeof(*qgroup), GFP_ATOMIC); 211 if (!qgroup) 212 return ERR_PTR(-ENOMEM); 213 214 qgroup->qgroupid = qgroupid; 215 INIT_LIST_HEAD(&qgroup->groups); 216 INIT_LIST_HEAD(&qgroup->members); 217 INIT_LIST_HEAD(&qgroup->dirty); 218 219 rb_link_node(&qgroup->node, parent, p); 220 rb_insert_color(&qgroup->node, &fs_info->qgroup_tree); 221 222 return qgroup; 223 } 224 225 static void __del_qgroup_rb(struct btrfs_fs_info *fs_info, 226 struct btrfs_qgroup *qgroup) 227 { 228 struct btrfs_qgroup_list *list; 229 230 list_del(&qgroup->dirty); 231 while (!list_empty(&qgroup->groups)) { 232 list = list_first_entry(&qgroup->groups, 233 struct btrfs_qgroup_list, next_group); 234 list_del(&list->next_group); 235 list_del(&list->next_member); 236 kfree(list); 237 } 238 239 while (!list_empty(&qgroup->members)) { 240 list = list_first_entry(&qgroup->members, 241 struct btrfs_qgroup_list, next_member); 242 list_del(&list->next_group); 243 list_del(&list->next_member); 244 kfree(list); 245 } 246 } 247 248 /* must be called with qgroup_lock held */ 249 static int del_qgroup_rb(struct btrfs_fs_info *fs_info, u64 qgroupid) 250 { 251 struct btrfs_qgroup *qgroup = find_qgroup_rb(fs_info, qgroupid); 252 253 if (!qgroup) 254 return -ENOENT; 255 256 rb_erase(&qgroup->node, &fs_info->qgroup_tree); 257 __del_qgroup_rb(fs_info, qgroup); 258 return 0; 259 } 260 261 /* must be called with qgroup_lock held */ 262 static int add_relation_rb(struct btrfs_fs_info *fs_info, 263 u64 memberid, u64 parentid) 264 { 265 struct btrfs_qgroup *member; 266 struct btrfs_qgroup *parent; 267 struct btrfs_qgroup_list *list; 268 269 member = find_qgroup_rb(fs_info, memberid); 270 parent = find_qgroup_rb(fs_info, parentid); 271 if (!member || !parent) 272 return -ENOENT; 273 274 list = kzalloc(sizeof(*list), GFP_ATOMIC); 275 if (!list) 276 return -ENOMEM; 277 278 list->group = parent; 279 list->member = member; 280 list_add_tail(&list->next_group, &member->groups); 281 list_add_tail(&list->next_member, &parent->members); 282 283 return 0; 284 } 285 286 /* must be called with qgroup_lock held */ 287 static int del_relation_rb(struct btrfs_fs_info *fs_info, 288 u64 memberid, u64 parentid) 289 { 290 struct btrfs_qgroup *member; 291 struct btrfs_qgroup *parent; 292 struct btrfs_qgroup_list *list; 293 294 member = find_qgroup_rb(fs_info, memberid); 295 parent = find_qgroup_rb(fs_info, parentid); 296 if (!member || !parent) 297 return -ENOENT; 298 299 list_for_each_entry(list, &member->groups, next_group) { 300 if (list->group == parent) { 301 list_del(&list->next_group); 302 list_del(&list->next_member); 303 kfree(list); 304 return 0; 305 } 306 } 307 return -ENOENT; 308 } 309 310 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 311 int btrfs_verify_qgroup_counts(struct btrfs_fs_info *fs_info, u64 qgroupid, 312 u64 rfer, u64 excl) 313 { 314 struct btrfs_qgroup *qgroup; 315 316 qgroup = find_qgroup_rb(fs_info, qgroupid); 317 if (!qgroup) 318 return -EINVAL; 319 if (qgroup->rfer != rfer || qgroup->excl != excl) 320 return -EINVAL; 321 return 0; 322 } 323 #endif 324 325 /* 326 * The full config is read in one go, only called from open_ctree() 327 * It doesn't use any locking, as at this point we're still single-threaded 328 */ 329 int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info) 330 { 331 struct btrfs_key key; 332 struct btrfs_key found_key; 333 struct btrfs_root *quota_root = fs_info->quota_root; 334 struct btrfs_path *path = NULL; 335 struct extent_buffer *l; 336 int slot; 337 int ret = 0; 338 u64 flags = 0; 339 u64 rescan_progress = 0; 340 341 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 342 return 0; 343 344 fs_info->qgroup_ulist = ulist_alloc(GFP_KERNEL); 345 if (!fs_info->qgroup_ulist) { 346 ret = -ENOMEM; 347 goto out; 348 } 349 350 path = btrfs_alloc_path(); 351 if (!path) { 352 ret = -ENOMEM; 353 goto out; 354 } 355 356 ret = btrfs_sysfs_add_qgroups(fs_info); 357 if (ret < 0) 358 goto out; 359 /* default this to quota off, in case no status key is found */ 360 fs_info->qgroup_flags = 0; 361 362 /* 363 * pass 1: read status, all qgroup infos and limits 364 */ 365 key.objectid = 0; 366 key.type = 0; 367 key.offset = 0; 368 ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 1); 369 if (ret) 370 goto out; 371 372 while (1) { 373 struct btrfs_qgroup *qgroup; 374 375 slot = path->slots[0]; 376 l = path->nodes[0]; 377 btrfs_item_key_to_cpu(l, &found_key, slot); 378 379 if (found_key.type == BTRFS_QGROUP_STATUS_KEY) { 380 struct btrfs_qgroup_status_item *ptr; 381 382 ptr = btrfs_item_ptr(l, slot, 383 struct btrfs_qgroup_status_item); 384 385 if (btrfs_qgroup_status_version(l, ptr) != 386 BTRFS_QGROUP_STATUS_VERSION) { 387 btrfs_err(fs_info, 388 "old qgroup version, quota disabled"); 389 goto out; 390 } 391 if (btrfs_qgroup_status_generation(l, ptr) != 392 fs_info->generation) { 393 flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 394 btrfs_err(fs_info, 395 "qgroup generation mismatch, marked as inconsistent"); 396 } 397 fs_info->qgroup_flags = btrfs_qgroup_status_flags(l, 398 ptr); 399 rescan_progress = btrfs_qgroup_status_rescan(l, ptr); 400 goto next1; 401 } 402 403 if (found_key.type != BTRFS_QGROUP_INFO_KEY && 404 found_key.type != BTRFS_QGROUP_LIMIT_KEY) 405 goto next1; 406 407 qgroup = find_qgroup_rb(fs_info, found_key.offset); 408 if ((qgroup && found_key.type == BTRFS_QGROUP_INFO_KEY) || 409 (!qgroup && found_key.type == BTRFS_QGROUP_LIMIT_KEY)) { 410 btrfs_err(fs_info, "inconsistent qgroup config"); 411 flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 412 } 413 if (!qgroup) { 414 qgroup = add_qgroup_rb(fs_info, found_key.offset); 415 if (IS_ERR(qgroup)) { 416 ret = PTR_ERR(qgroup); 417 goto out; 418 } 419 } 420 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup); 421 if (ret < 0) 422 goto out; 423 424 switch (found_key.type) { 425 case BTRFS_QGROUP_INFO_KEY: { 426 struct btrfs_qgroup_info_item *ptr; 427 428 ptr = btrfs_item_ptr(l, slot, 429 struct btrfs_qgroup_info_item); 430 qgroup->rfer = btrfs_qgroup_info_rfer(l, ptr); 431 qgroup->rfer_cmpr = btrfs_qgroup_info_rfer_cmpr(l, ptr); 432 qgroup->excl = btrfs_qgroup_info_excl(l, ptr); 433 qgroup->excl_cmpr = btrfs_qgroup_info_excl_cmpr(l, ptr); 434 /* generation currently unused */ 435 break; 436 } 437 case BTRFS_QGROUP_LIMIT_KEY: { 438 struct btrfs_qgroup_limit_item *ptr; 439 440 ptr = btrfs_item_ptr(l, slot, 441 struct btrfs_qgroup_limit_item); 442 qgroup->lim_flags = btrfs_qgroup_limit_flags(l, ptr); 443 qgroup->max_rfer = btrfs_qgroup_limit_max_rfer(l, ptr); 444 qgroup->max_excl = btrfs_qgroup_limit_max_excl(l, ptr); 445 qgroup->rsv_rfer = btrfs_qgroup_limit_rsv_rfer(l, ptr); 446 qgroup->rsv_excl = btrfs_qgroup_limit_rsv_excl(l, ptr); 447 break; 448 } 449 } 450 next1: 451 ret = btrfs_next_item(quota_root, path); 452 if (ret < 0) 453 goto out; 454 if (ret) 455 break; 456 } 457 btrfs_release_path(path); 458 459 /* 460 * pass 2: read all qgroup relations 461 */ 462 key.objectid = 0; 463 key.type = BTRFS_QGROUP_RELATION_KEY; 464 key.offset = 0; 465 ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 0); 466 if (ret) 467 goto out; 468 while (1) { 469 slot = path->slots[0]; 470 l = path->nodes[0]; 471 btrfs_item_key_to_cpu(l, &found_key, slot); 472 473 if (found_key.type != BTRFS_QGROUP_RELATION_KEY) 474 goto next2; 475 476 if (found_key.objectid > found_key.offset) { 477 /* parent <- member, not needed to build config */ 478 /* FIXME should we omit the key completely? */ 479 goto next2; 480 } 481 482 ret = add_relation_rb(fs_info, found_key.objectid, 483 found_key.offset); 484 if (ret == -ENOENT) { 485 btrfs_warn(fs_info, 486 "orphan qgroup relation 0x%llx->0x%llx", 487 found_key.objectid, found_key.offset); 488 ret = 0; /* ignore the error */ 489 } 490 if (ret) 491 goto out; 492 next2: 493 ret = btrfs_next_item(quota_root, path); 494 if (ret < 0) 495 goto out; 496 if (ret) 497 break; 498 } 499 out: 500 btrfs_free_path(path); 501 fs_info->qgroup_flags |= flags; 502 if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)) 503 clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags); 504 else if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN && 505 ret >= 0) 506 ret = qgroup_rescan_init(fs_info, rescan_progress, 0); 507 508 if (ret < 0) { 509 ulist_free(fs_info->qgroup_ulist); 510 fs_info->qgroup_ulist = NULL; 511 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 512 btrfs_sysfs_del_qgroups(fs_info); 513 } 514 515 return ret < 0 ? ret : 0; 516 } 517 518 /* 519 * Called in close_ctree() when quota is still enabled. This verifies we don't 520 * leak some reserved space. 521 * 522 * Return false if no reserved space is left. 523 * Return true if some reserved space is leaked. 524 */ 525 bool btrfs_check_quota_leak(struct btrfs_fs_info *fs_info) 526 { 527 struct rb_node *node; 528 bool ret = false; 529 530 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 531 return ret; 532 /* 533 * Since we're unmounting, there is no race and no need to grab qgroup 534 * lock. And here we don't go post-order to provide a more user 535 * friendly sorted result. 536 */ 537 for (node = rb_first(&fs_info->qgroup_tree); node; node = rb_next(node)) { 538 struct btrfs_qgroup *qgroup; 539 int i; 540 541 qgroup = rb_entry(node, struct btrfs_qgroup, node); 542 for (i = 0; i < BTRFS_QGROUP_RSV_LAST; i++) { 543 if (qgroup->rsv.values[i]) { 544 ret = true; 545 btrfs_warn(fs_info, 546 "qgroup %hu/%llu has unreleased space, type %d rsv %llu", 547 btrfs_qgroup_level(qgroup->qgroupid), 548 btrfs_qgroup_subvolid(qgroup->qgroupid), 549 i, qgroup->rsv.values[i]); 550 } 551 } 552 } 553 return ret; 554 } 555 556 /* 557 * This is called from close_ctree() or open_ctree() or btrfs_quota_disable(), 558 * first two are in single-threaded paths.And for the third one, we have set 559 * quota_root to be null with qgroup_lock held before, so it is safe to clean 560 * up the in-memory structures without qgroup_lock held. 561 */ 562 void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info) 563 { 564 struct rb_node *n; 565 struct btrfs_qgroup *qgroup; 566 567 while ((n = rb_first(&fs_info->qgroup_tree))) { 568 qgroup = rb_entry(n, struct btrfs_qgroup, node); 569 rb_erase(n, &fs_info->qgroup_tree); 570 __del_qgroup_rb(fs_info, qgroup); 571 btrfs_sysfs_del_one_qgroup(fs_info, qgroup); 572 kfree(qgroup); 573 } 574 /* 575 * We call btrfs_free_qgroup_config() when unmounting 576 * filesystem and disabling quota, so we set qgroup_ulist 577 * to be null here to avoid double free. 578 */ 579 ulist_free(fs_info->qgroup_ulist); 580 fs_info->qgroup_ulist = NULL; 581 btrfs_sysfs_del_qgroups(fs_info); 582 } 583 584 static int add_qgroup_relation_item(struct btrfs_trans_handle *trans, u64 src, 585 u64 dst) 586 { 587 int ret; 588 struct btrfs_root *quota_root = trans->fs_info->quota_root; 589 struct btrfs_path *path; 590 struct btrfs_key key; 591 592 path = btrfs_alloc_path(); 593 if (!path) 594 return -ENOMEM; 595 596 key.objectid = src; 597 key.type = BTRFS_QGROUP_RELATION_KEY; 598 key.offset = dst; 599 600 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 0); 601 602 btrfs_mark_buffer_dirty(path->nodes[0]); 603 604 btrfs_free_path(path); 605 return ret; 606 } 607 608 static int del_qgroup_relation_item(struct btrfs_trans_handle *trans, u64 src, 609 u64 dst) 610 { 611 int ret; 612 struct btrfs_root *quota_root = trans->fs_info->quota_root; 613 struct btrfs_path *path; 614 struct btrfs_key key; 615 616 path = btrfs_alloc_path(); 617 if (!path) 618 return -ENOMEM; 619 620 key.objectid = src; 621 key.type = BTRFS_QGROUP_RELATION_KEY; 622 key.offset = dst; 623 624 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1); 625 if (ret < 0) 626 goto out; 627 628 if (ret > 0) { 629 ret = -ENOENT; 630 goto out; 631 } 632 633 ret = btrfs_del_item(trans, quota_root, path); 634 out: 635 btrfs_free_path(path); 636 return ret; 637 } 638 639 static int add_qgroup_item(struct btrfs_trans_handle *trans, 640 struct btrfs_root *quota_root, u64 qgroupid) 641 { 642 int ret; 643 struct btrfs_path *path; 644 struct btrfs_qgroup_info_item *qgroup_info; 645 struct btrfs_qgroup_limit_item *qgroup_limit; 646 struct extent_buffer *leaf; 647 struct btrfs_key key; 648 649 if (btrfs_is_testing(quota_root->fs_info)) 650 return 0; 651 652 path = btrfs_alloc_path(); 653 if (!path) 654 return -ENOMEM; 655 656 key.objectid = 0; 657 key.type = BTRFS_QGROUP_INFO_KEY; 658 key.offset = qgroupid; 659 660 /* 661 * Avoid a transaction abort by catching -EEXIST here. In that 662 * case, we proceed by re-initializing the existing structure 663 * on disk. 664 */ 665 666 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 667 sizeof(*qgroup_info)); 668 if (ret && ret != -EEXIST) 669 goto out; 670 671 leaf = path->nodes[0]; 672 qgroup_info = btrfs_item_ptr(leaf, path->slots[0], 673 struct btrfs_qgroup_info_item); 674 btrfs_set_qgroup_info_generation(leaf, qgroup_info, trans->transid); 675 btrfs_set_qgroup_info_rfer(leaf, qgroup_info, 0); 676 btrfs_set_qgroup_info_rfer_cmpr(leaf, qgroup_info, 0); 677 btrfs_set_qgroup_info_excl(leaf, qgroup_info, 0); 678 btrfs_set_qgroup_info_excl_cmpr(leaf, qgroup_info, 0); 679 680 btrfs_mark_buffer_dirty(leaf); 681 682 btrfs_release_path(path); 683 684 key.type = BTRFS_QGROUP_LIMIT_KEY; 685 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 686 sizeof(*qgroup_limit)); 687 if (ret && ret != -EEXIST) 688 goto out; 689 690 leaf = path->nodes[0]; 691 qgroup_limit = btrfs_item_ptr(leaf, path->slots[0], 692 struct btrfs_qgroup_limit_item); 693 btrfs_set_qgroup_limit_flags(leaf, qgroup_limit, 0); 694 btrfs_set_qgroup_limit_max_rfer(leaf, qgroup_limit, 0); 695 btrfs_set_qgroup_limit_max_excl(leaf, qgroup_limit, 0); 696 btrfs_set_qgroup_limit_rsv_rfer(leaf, qgroup_limit, 0); 697 btrfs_set_qgroup_limit_rsv_excl(leaf, qgroup_limit, 0); 698 699 btrfs_mark_buffer_dirty(leaf); 700 701 ret = 0; 702 out: 703 btrfs_free_path(path); 704 return ret; 705 } 706 707 static int del_qgroup_item(struct btrfs_trans_handle *trans, u64 qgroupid) 708 { 709 int ret; 710 struct btrfs_root *quota_root = trans->fs_info->quota_root; 711 struct btrfs_path *path; 712 struct btrfs_key key; 713 714 path = btrfs_alloc_path(); 715 if (!path) 716 return -ENOMEM; 717 718 key.objectid = 0; 719 key.type = BTRFS_QGROUP_INFO_KEY; 720 key.offset = qgroupid; 721 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1); 722 if (ret < 0) 723 goto out; 724 725 if (ret > 0) { 726 ret = -ENOENT; 727 goto out; 728 } 729 730 ret = btrfs_del_item(trans, quota_root, path); 731 if (ret) 732 goto out; 733 734 btrfs_release_path(path); 735 736 key.type = BTRFS_QGROUP_LIMIT_KEY; 737 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1); 738 if (ret < 0) 739 goto out; 740 741 if (ret > 0) { 742 ret = -ENOENT; 743 goto out; 744 } 745 746 ret = btrfs_del_item(trans, quota_root, path); 747 748 out: 749 btrfs_free_path(path); 750 return ret; 751 } 752 753 static int update_qgroup_limit_item(struct btrfs_trans_handle *trans, 754 struct btrfs_qgroup *qgroup) 755 { 756 struct btrfs_root *quota_root = trans->fs_info->quota_root; 757 struct btrfs_path *path; 758 struct btrfs_key key; 759 struct extent_buffer *l; 760 struct btrfs_qgroup_limit_item *qgroup_limit; 761 int ret; 762 int slot; 763 764 key.objectid = 0; 765 key.type = BTRFS_QGROUP_LIMIT_KEY; 766 key.offset = qgroup->qgroupid; 767 768 path = btrfs_alloc_path(); 769 if (!path) 770 return -ENOMEM; 771 772 ret = btrfs_search_slot(trans, quota_root, &key, path, 0, 1); 773 if (ret > 0) 774 ret = -ENOENT; 775 776 if (ret) 777 goto out; 778 779 l = path->nodes[0]; 780 slot = path->slots[0]; 781 qgroup_limit = btrfs_item_ptr(l, slot, struct btrfs_qgroup_limit_item); 782 btrfs_set_qgroup_limit_flags(l, qgroup_limit, qgroup->lim_flags); 783 btrfs_set_qgroup_limit_max_rfer(l, qgroup_limit, qgroup->max_rfer); 784 btrfs_set_qgroup_limit_max_excl(l, qgroup_limit, qgroup->max_excl); 785 btrfs_set_qgroup_limit_rsv_rfer(l, qgroup_limit, qgroup->rsv_rfer); 786 btrfs_set_qgroup_limit_rsv_excl(l, qgroup_limit, qgroup->rsv_excl); 787 788 btrfs_mark_buffer_dirty(l); 789 790 out: 791 btrfs_free_path(path); 792 return ret; 793 } 794 795 static int update_qgroup_info_item(struct btrfs_trans_handle *trans, 796 struct btrfs_qgroup *qgroup) 797 { 798 struct btrfs_fs_info *fs_info = trans->fs_info; 799 struct btrfs_root *quota_root = fs_info->quota_root; 800 struct btrfs_path *path; 801 struct btrfs_key key; 802 struct extent_buffer *l; 803 struct btrfs_qgroup_info_item *qgroup_info; 804 int ret; 805 int slot; 806 807 if (btrfs_is_testing(fs_info)) 808 return 0; 809 810 key.objectid = 0; 811 key.type = BTRFS_QGROUP_INFO_KEY; 812 key.offset = qgroup->qgroupid; 813 814 path = btrfs_alloc_path(); 815 if (!path) 816 return -ENOMEM; 817 818 ret = btrfs_search_slot(trans, quota_root, &key, path, 0, 1); 819 if (ret > 0) 820 ret = -ENOENT; 821 822 if (ret) 823 goto out; 824 825 l = path->nodes[0]; 826 slot = path->slots[0]; 827 qgroup_info = btrfs_item_ptr(l, slot, struct btrfs_qgroup_info_item); 828 btrfs_set_qgroup_info_generation(l, qgroup_info, trans->transid); 829 btrfs_set_qgroup_info_rfer(l, qgroup_info, qgroup->rfer); 830 btrfs_set_qgroup_info_rfer_cmpr(l, qgroup_info, qgroup->rfer_cmpr); 831 btrfs_set_qgroup_info_excl(l, qgroup_info, qgroup->excl); 832 btrfs_set_qgroup_info_excl_cmpr(l, qgroup_info, qgroup->excl_cmpr); 833 834 btrfs_mark_buffer_dirty(l); 835 836 out: 837 btrfs_free_path(path); 838 return ret; 839 } 840 841 static int update_qgroup_status_item(struct btrfs_trans_handle *trans) 842 { 843 struct btrfs_fs_info *fs_info = trans->fs_info; 844 struct btrfs_root *quota_root = fs_info->quota_root; 845 struct btrfs_path *path; 846 struct btrfs_key key; 847 struct extent_buffer *l; 848 struct btrfs_qgroup_status_item *ptr; 849 int ret; 850 int slot; 851 852 key.objectid = 0; 853 key.type = BTRFS_QGROUP_STATUS_KEY; 854 key.offset = 0; 855 856 path = btrfs_alloc_path(); 857 if (!path) 858 return -ENOMEM; 859 860 ret = btrfs_search_slot(trans, quota_root, &key, path, 0, 1); 861 if (ret > 0) 862 ret = -ENOENT; 863 864 if (ret) 865 goto out; 866 867 l = path->nodes[0]; 868 slot = path->slots[0]; 869 ptr = btrfs_item_ptr(l, slot, struct btrfs_qgroup_status_item); 870 btrfs_set_qgroup_status_flags(l, ptr, fs_info->qgroup_flags); 871 btrfs_set_qgroup_status_generation(l, ptr, trans->transid); 872 btrfs_set_qgroup_status_rescan(l, ptr, 873 fs_info->qgroup_rescan_progress.objectid); 874 875 btrfs_mark_buffer_dirty(l); 876 877 out: 878 btrfs_free_path(path); 879 return ret; 880 } 881 882 /* 883 * called with qgroup_lock held 884 */ 885 static int btrfs_clean_quota_tree(struct btrfs_trans_handle *trans, 886 struct btrfs_root *root) 887 { 888 struct btrfs_path *path; 889 struct btrfs_key key; 890 struct extent_buffer *leaf = NULL; 891 int ret; 892 int nr = 0; 893 894 path = btrfs_alloc_path(); 895 if (!path) 896 return -ENOMEM; 897 898 key.objectid = 0; 899 key.offset = 0; 900 key.type = 0; 901 902 while (1) { 903 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 904 if (ret < 0) 905 goto out; 906 leaf = path->nodes[0]; 907 nr = btrfs_header_nritems(leaf); 908 if (!nr) 909 break; 910 /* 911 * delete the leaf one by one 912 * since the whole tree is going 913 * to be deleted. 914 */ 915 path->slots[0] = 0; 916 ret = btrfs_del_items(trans, root, path, 0, nr); 917 if (ret) 918 goto out; 919 920 btrfs_release_path(path); 921 } 922 ret = 0; 923 out: 924 btrfs_free_path(path); 925 return ret; 926 } 927 928 int btrfs_quota_enable(struct btrfs_fs_info *fs_info) 929 { 930 struct btrfs_root *quota_root; 931 struct btrfs_root *tree_root = fs_info->tree_root; 932 struct btrfs_path *path = NULL; 933 struct btrfs_qgroup_status_item *ptr; 934 struct extent_buffer *leaf; 935 struct btrfs_key key; 936 struct btrfs_key found_key; 937 struct btrfs_qgroup *qgroup = NULL; 938 struct btrfs_trans_handle *trans = NULL; 939 struct ulist *ulist = NULL; 940 int ret = 0; 941 int slot; 942 943 mutex_lock(&fs_info->qgroup_ioctl_lock); 944 if (fs_info->quota_root) 945 goto out; 946 947 ulist = ulist_alloc(GFP_KERNEL); 948 if (!ulist) { 949 ret = -ENOMEM; 950 goto out; 951 } 952 953 ret = btrfs_sysfs_add_qgroups(fs_info); 954 if (ret < 0) 955 goto out; 956 957 /* 958 * Unlock qgroup_ioctl_lock before starting the transaction. This is to 959 * avoid lock acquisition inversion problems (reported by lockdep) between 960 * qgroup_ioctl_lock and the vfs freeze semaphores, acquired when we 961 * start a transaction. 962 * After we started the transaction lock qgroup_ioctl_lock again and 963 * check if someone else created the quota root in the meanwhile. If so, 964 * just return success and release the transaction handle. 965 * 966 * Also we don't need to worry about someone else calling 967 * btrfs_sysfs_add_qgroups() after we unlock and getting an error because 968 * that function returns 0 (success) when the sysfs entries already exist. 969 */ 970 mutex_unlock(&fs_info->qgroup_ioctl_lock); 971 972 /* 973 * 1 for quota root item 974 * 1 for BTRFS_QGROUP_STATUS item 975 * 976 * Yet we also need 2*n items for a QGROUP_INFO/QGROUP_LIMIT items 977 * per subvolume. However those are not currently reserved since it 978 * would be a lot of overkill. 979 */ 980 trans = btrfs_start_transaction(tree_root, 2); 981 982 mutex_lock(&fs_info->qgroup_ioctl_lock); 983 if (IS_ERR(trans)) { 984 ret = PTR_ERR(trans); 985 trans = NULL; 986 goto out; 987 } 988 989 if (fs_info->quota_root) 990 goto out; 991 992 fs_info->qgroup_ulist = ulist; 993 ulist = NULL; 994 995 /* 996 * initially create the quota tree 997 */ 998 quota_root = btrfs_create_tree(trans, BTRFS_QUOTA_TREE_OBJECTID); 999 if (IS_ERR(quota_root)) { 1000 ret = PTR_ERR(quota_root); 1001 btrfs_abort_transaction(trans, ret); 1002 goto out; 1003 } 1004 1005 path = btrfs_alloc_path(); 1006 if (!path) { 1007 ret = -ENOMEM; 1008 btrfs_abort_transaction(trans, ret); 1009 goto out_free_root; 1010 } 1011 1012 key.objectid = 0; 1013 key.type = BTRFS_QGROUP_STATUS_KEY; 1014 key.offset = 0; 1015 1016 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 1017 sizeof(*ptr)); 1018 if (ret) { 1019 btrfs_abort_transaction(trans, ret); 1020 goto out_free_path; 1021 } 1022 1023 leaf = path->nodes[0]; 1024 ptr = btrfs_item_ptr(leaf, path->slots[0], 1025 struct btrfs_qgroup_status_item); 1026 btrfs_set_qgroup_status_generation(leaf, ptr, trans->transid); 1027 btrfs_set_qgroup_status_version(leaf, ptr, BTRFS_QGROUP_STATUS_VERSION); 1028 fs_info->qgroup_flags = BTRFS_QGROUP_STATUS_FLAG_ON | 1029 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1030 btrfs_set_qgroup_status_flags(leaf, ptr, fs_info->qgroup_flags); 1031 btrfs_set_qgroup_status_rescan(leaf, ptr, 0); 1032 1033 btrfs_mark_buffer_dirty(leaf); 1034 1035 key.objectid = 0; 1036 key.type = BTRFS_ROOT_REF_KEY; 1037 key.offset = 0; 1038 1039 btrfs_release_path(path); 1040 ret = btrfs_search_slot_for_read(tree_root, &key, path, 1, 0); 1041 if (ret > 0) 1042 goto out_add_root; 1043 if (ret < 0) { 1044 btrfs_abort_transaction(trans, ret); 1045 goto out_free_path; 1046 } 1047 1048 while (1) { 1049 slot = path->slots[0]; 1050 leaf = path->nodes[0]; 1051 btrfs_item_key_to_cpu(leaf, &found_key, slot); 1052 1053 if (found_key.type == BTRFS_ROOT_REF_KEY) { 1054 1055 /* Release locks on tree_root before we access quota_root */ 1056 btrfs_release_path(path); 1057 1058 ret = add_qgroup_item(trans, quota_root, 1059 found_key.offset); 1060 if (ret) { 1061 btrfs_abort_transaction(trans, ret); 1062 goto out_free_path; 1063 } 1064 1065 qgroup = add_qgroup_rb(fs_info, found_key.offset); 1066 if (IS_ERR(qgroup)) { 1067 ret = PTR_ERR(qgroup); 1068 btrfs_abort_transaction(trans, ret); 1069 goto out_free_path; 1070 } 1071 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup); 1072 if (ret < 0) { 1073 btrfs_abort_transaction(trans, ret); 1074 goto out_free_path; 1075 } 1076 ret = btrfs_search_slot_for_read(tree_root, &found_key, 1077 path, 1, 0); 1078 if (ret < 0) { 1079 btrfs_abort_transaction(trans, ret); 1080 goto out_free_path; 1081 } 1082 if (ret > 0) { 1083 /* 1084 * Shouldn't happen, but in case it does we 1085 * don't need to do the btrfs_next_item, just 1086 * continue. 1087 */ 1088 continue; 1089 } 1090 } 1091 ret = btrfs_next_item(tree_root, path); 1092 if (ret < 0) { 1093 btrfs_abort_transaction(trans, ret); 1094 goto out_free_path; 1095 } 1096 if (ret) 1097 break; 1098 } 1099 1100 out_add_root: 1101 btrfs_release_path(path); 1102 ret = add_qgroup_item(trans, quota_root, BTRFS_FS_TREE_OBJECTID); 1103 if (ret) { 1104 btrfs_abort_transaction(trans, ret); 1105 goto out_free_path; 1106 } 1107 1108 qgroup = add_qgroup_rb(fs_info, BTRFS_FS_TREE_OBJECTID); 1109 if (IS_ERR(qgroup)) { 1110 ret = PTR_ERR(qgroup); 1111 btrfs_abort_transaction(trans, ret); 1112 goto out_free_path; 1113 } 1114 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup); 1115 if (ret < 0) { 1116 btrfs_abort_transaction(trans, ret); 1117 goto out_free_path; 1118 } 1119 1120 ret = btrfs_commit_transaction(trans); 1121 trans = NULL; 1122 if (ret) 1123 goto out_free_path; 1124 1125 /* 1126 * Set quota enabled flag after committing the transaction, to avoid 1127 * deadlocks on fs_info->qgroup_ioctl_lock with concurrent snapshot 1128 * creation. 1129 */ 1130 spin_lock(&fs_info->qgroup_lock); 1131 fs_info->quota_root = quota_root; 1132 set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags); 1133 spin_unlock(&fs_info->qgroup_lock); 1134 1135 ret = qgroup_rescan_init(fs_info, 0, 1); 1136 if (!ret) { 1137 qgroup_rescan_zero_tracking(fs_info); 1138 fs_info->qgroup_rescan_running = true; 1139 btrfs_queue_work(fs_info->qgroup_rescan_workers, 1140 &fs_info->qgroup_rescan_work); 1141 } 1142 1143 out_free_path: 1144 btrfs_free_path(path); 1145 out_free_root: 1146 if (ret) 1147 btrfs_put_root(quota_root); 1148 out: 1149 if (ret) { 1150 ulist_free(fs_info->qgroup_ulist); 1151 fs_info->qgroup_ulist = NULL; 1152 btrfs_sysfs_del_qgroups(fs_info); 1153 } 1154 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1155 if (ret && trans) 1156 btrfs_end_transaction(trans); 1157 else if (trans) 1158 ret = btrfs_end_transaction(trans); 1159 ulist_free(ulist); 1160 return ret; 1161 } 1162 1163 int btrfs_quota_disable(struct btrfs_fs_info *fs_info) 1164 { 1165 struct btrfs_root *quota_root; 1166 struct btrfs_trans_handle *trans = NULL; 1167 int ret = 0; 1168 1169 mutex_lock(&fs_info->qgroup_ioctl_lock); 1170 if (!fs_info->quota_root) 1171 goto out; 1172 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1173 1174 /* 1175 * 1 For the root item 1176 * 1177 * We should also reserve enough items for the quota tree deletion in 1178 * btrfs_clean_quota_tree but this is not done. 1179 * 1180 * Also, we must always start a transaction without holding the mutex 1181 * qgroup_ioctl_lock, see btrfs_quota_enable(). 1182 */ 1183 trans = btrfs_start_transaction(fs_info->tree_root, 1); 1184 1185 mutex_lock(&fs_info->qgroup_ioctl_lock); 1186 if (IS_ERR(trans)) { 1187 ret = PTR_ERR(trans); 1188 trans = NULL; 1189 goto out; 1190 } 1191 1192 if (!fs_info->quota_root) 1193 goto out; 1194 1195 clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags); 1196 btrfs_qgroup_wait_for_completion(fs_info, false); 1197 spin_lock(&fs_info->qgroup_lock); 1198 quota_root = fs_info->quota_root; 1199 fs_info->quota_root = NULL; 1200 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON; 1201 spin_unlock(&fs_info->qgroup_lock); 1202 1203 btrfs_free_qgroup_config(fs_info); 1204 1205 ret = btrfs_clean_quota_tree(trans, quota_root); 1206 if (ret) { 1207 btrfs_abort_transaction(trans, ret); 1208 goto out; 1209 } 1210 1211 ret = btrfs_del_root(trans, "a_root->root_key); 1212 if (ret) { 1213 btrfs_abort_transaction(trans, ret); 1214 goto out; 1215 } 1216 1217 list_del("a_root->dirty_list); 1218 1219 btrfs_tree_lock(quota_root->node); 1220 btrfs_clean_tree_block(quota_root->node); 1221 btrfs_tree_unlock(quota_root->node); 1222 btrfs_free_tree_block(trans, quota_root, quota_root->node, 0, 1); 1223 1224 btrfs_put_root(quota_root); 1225 1226 out: 1227 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1228 if (ret && trans) 1229 btrfs_end_transaction(trans); 1230 else if (trans) 1231 ret = btrfs_end_transaction(trans); 1232 1233 return ret; 1234 } 1235 1236 static void qgroup_dirty(struct btrfs_fs_info *fs_info, 1237 struct btrfs_qgroup *qgroup) 1238 { 1239 if (list_empty(&qgroup->dirty)) 1240 list_add(&qgroup->dirty, &fs_info->dirty_qgroups); 1241 } 1242 1243 /* 1244 * The easy accounting, we're updating qgroup relationship whose child qgroup 1245 * only has exclusive extents. 1246 * 1247 * In this case, all exclusive extents will also be exclusive for parent, so 1248 * excl/rfer just get added/removed. 1249 * 1250 * So is qgroup reservation space, which should also be added/removed to 1251 * parent. 1252 * Or when child tries to release reservation space, parent will underflow its 1253 * reservation (for relationship adding case). 1254 * 1255 * Caller should hold fs_info->qgroup_lock. 1256 */ 1257 static int __qgroup_excl_accounting(struct btrfs_fs_info *fs_info, 1258 struct ulist *tmp, u64 ref_root, 1259 struct btrfs_qgroup *src, int sign) 1260 { 1261 struct btrfs_qgroup *qgroup; 1262 struct btrfs_qgroup_list *glist; 1263 struct ulist_node *unode; 1264 struct ulist_iterator uiter; 1265 u64 num_bytes = src->excl; 1266 int ret = 0; 1267 1268 qgroup = find_qgroup_rb(fs_info, ref_root); 1269 if (!qgroup) 1270 goto out; 1271 1272 qgroup->rfer += sign * num_bytes; 1273 qgroup->rfer_cmpr += sign * num_bytes; 1274 1275 WARN_ON(sign < 0 && qgroup->excl < num_bytes); 1276 qgroup->excl += sign * num_bytes; 1277 qgroup->excl_cmpr += sign * num_bytes; 1278 1279 if (sign > 0) 1280 qgroup_rsv_add_by_qgroup(fs_info, qgroup, src); 1281 else 1282 qgroup_rsv_release_by_qgroup(fs_info, qgroup, src); 1283 1284 qgroup_dirty(fs_info, qgroup); 1285 1286 /* Get all of the parent groups that contain this qgroup */ 1287 list_for_each_entry(glist, &qgroup->groups, next_group) { 1288 ret = ulist_add(tmp, glist->group->qgroupid, 1289 qgroup_to_aux(glist->group), GFP_ATOMIC); 1290 if (ret < 0) 1291 goto out; 1292 } 1293 1294 /* Iterate all of the parents and adjust their reference counts */ 1295 ULIST_ITER_INIT(&uiter); 1296 while ((unode = ulist_next(tmp, &uiter))) { 1297 qgroup = unode_aux_to_qgroup(unode); 1298 qgroup->rfer += sign * num_bytes; 1299 qgroup->rfer_cmpr += sign * num_bytes; 1300 WARN_ON(sign < 0 && qgroup->excl < num_bytes); 1301 qgroup->excl += sign * num_bytes; 1302 if (sign > 0) 1303 qgroup_rsv_add_by_qgroup(fs_info, qgroup, src); 1304 else 1305 qgroup_rsv_release_by_qgroup(fs_info, qgroup, src); 1306 qgroup->excl_cmpr += sign * num_bytes; 1307 qgroup_dirty(fs_info, qgroup); 1308 1309 /* Add any parents of the parents */ 1310 list_for_each_entry(glist, &qgroup->groups, next_group) { 1311 ret = ulist_add(tmp, glist->group->qgroupid, 1312 qgroup_to_aux(glist->group), GFP_ATOMIC); 1313 if (ret < 0) 1314 goto out; 1315 } 1316 } 1317 ret = 0; 1318 out: 1319 return ret; 1320 } 1321 1322 1323 /* 1324 * Quick path for updating qgroup with only excl refs. 1325 * 1326 * In that case, just update all parent will be enough. 1327 * Or we needs to do a full rescan. 1328 * Caller should also hold fs_info->qgroup_lock. 1329 * 1330 * Return 0 for quick update, return >0 for need to full rescan 1331 * and mark INCONSISTENT flag. 1332 * Return < 0 for other error. 1333 */ 1334 static int quick_update_accounting(struct btrfs_fs_info *fs_info, 1335 struct ulist *tmp, u64 src, u64 dst, 1336 int sign) 1337 { 1338 struct btrfs_qgroup *qgroup; 1339 int ret = 1; 1340 int err = 0; 1341 1342 qgroup = find_qgroup_rb(fs_info, src); 1343 if (!qgroup) 1344 goto out; 1345 if (qgroup->excl == qgroup->rfer) { 1346 ret = 0; 1347 err = __qgroup_excl_accounting(fs_info, tmp, dst, 1348 qgroup, sign); 1349 if (err < 0) { 1350 ret = err; 1351 goto out; 1352 } 1353 } 1354 out: 1355 if (ret) 1356 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1357 return ret; 1358 } 1359 1360 int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans, u64 src, 1361 u64 dst) 1362 { 1363 struct btrfs_fs_info *fs_info = trans->fs_info; 1364 struct btrfs_qgroup *parent; 1365 struct btrfs_qgroup *member; 1366 struct btrfs_qgroup_list *list; 1367 struct ulist *tmp; 1368 unsigned int nofs_flag; 1369 int ret = 0; 1370 1371 /* Check the level of src and dst first */ 1372 if (btrfs_qgroup_level(src) >= btrfs_qgroup_level(dst)) 1373 return -EINVAL; 1374 1375 /* We hold a transaction handle open, must do a NOFS allocation. */ 1376 nofs_flag = memalloc_nofs_save(); 1377 tmp = ulist_alloc(GFP_KERNEL); 1378 memalloc_nofs_restore(nofs_flag); 1379 if (!tmp) 1380 return -ENOMEM; 1381 1382 mutex_lock(&fs_info->qgroup_ioctl_lock); 1383 if (!fs_info->quota_root) { 1384 ret = -ENOTCONN; 1385 goto out; 1386 } 1387 member = find_qgroup_rb(fs_info, src); 1388 parent = find_qgroup_rb(fs_info, dst); 1389 if (!member || !parent) { 1390 ret = -EINVAL; 1391 goto out; 1392 } 1393 1394 /* check if such qgroup relation exist firstly */ 1395 list_for_each_entry(list, &member->groups, next_group) { 1396 if (list->group == parent) { 1397 ret = -EEXIST; 1398 goto out; 1399 } 1400 } 1401 1402 ret = add_qgroup_relation_item(trans, src, dst); 1403 if (ret) 1404 goto out; 1405 1406 ret = add_qgroup_relation_item(trans, dst, src); 1407 if (ret) { 1408 del_qgroup_relation_item(trans, src, dst); 1409 goto out; 1410 } 1411 1412 spin_lock(&fs_info->qgroup_lock); 1413 ret = add_relation_rb(fs_info, src, dst); 1414 if (ret < 0) { 1415 spin_unlock(&fs_info->qgroup_lock); 1416 goto out; 1417 } 1418 ret = quick_update_accounting(fs_info, tmp, src, dst, 1); 1419 spin_unlock(&fs_info->qgroup_lock); 1420 out: 1421 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1422 ulist_free(tmp); 1423 return ret; 1424 } 1425 1426 static int __del_qgroup_relation(struct btrfs_trans_handle *trans, u64 src, 1427 u64 dst) 1428 { 1429 struct btrfs_fs_info *fs_info = trans->fs_info; 1430 struct btrfs_qgroup *parent; 1431 struct btrfs_qgroup *member; 1432 struct btrfs_qgroup_list *list; 1433 struct ulist *tmp; 1434 bool found = false; 1435 unsigned int nofs_flag; 1436 int ret = 0; 1437 int ret2; 1438 1439 /* We hold a transaction handle open, must do a NOFS allocation. */ 1440 nofs_flag = memalloc_nofs_save(); 1441 tmp = ulist_alloc(GFP_KERNEL); 1442 memalloc_nofs_restore(nofs_flag); 1443 if (!tmp) 1444 return -ENOMEM; 1445 1446 if (!fs_info->quota_root) { 1447 ret = -ENOTCONN; 1448 goto out; 1449 } 1450 1451 member = find_qgroup_rb(fs_info, src); 1452 parent = find_qgroup_rb(fs_info, dst); 1453 /* 1454 * The parent/member pair doesn't exist, then try to delete the dead 1455 * relation items only. 1456 */ 1457 if (!member || !parent) 1458 goto delete_item; 1459 1460 /* check if such qgroup relation exist firstly */ 1461 list_for_each_entry(list, &member->groups, next_group) { 1462 if (list->group == parent) { 1463 found = true; 1464 break; 1465 } 1466 } 1467 1468 delete_item: 1469 ret = del_qgroup_relation_item(trans, src, dst); 1470 if (ret < 0 && ret != -ENOENT) 1471 goto out; 1472 ret2 = del_qgroup_relation_item(trans, dst, src); 1473 if (ret2 < 0 && ret2 != -ENOENT) 1474 goto out; 1475 1476 /* At least one deletion succeeded, return 0 */ 1477 if (!ret || !ret2) 1478 ret = 0; 1479 1480 if (found) { 1481 spin_lock(&fs_info->qgroup_lock); 1482 del_relation_rb(fs_info, src, dst); 1483 ret = quick_update_accounting(fs_info, tmp, src, dst, -1); 1484 spin_unlock(&fs_info->qgroup_lock); 1485 } 1486 out: 1487 ulist_free(tmp); 1488 return ret; 1489 } 1490 1491 int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans, u64 src, 1492 u64 dst) 1493 { 1494 struct btrfs_fs_info *fs_info = trans->fs_info; 1495 int ret = 0; 1496 1497 mutex_lock(&fs_info->qgroup_ioctl_lock); 1498 ret = __del_qgroup_relation(trans, src, dst); 1499 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1500 1501 return ret; 1502 } 1503 1504 int btrfs_create_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid) 1505 { 1506 struct btrfs_fs_info *fs_info = trans->fs_info; 1507 struct btrfs_root *quota_root; 1508 struct btrfs_qgroup *qgroup; 1509 int ret = 0; 1510 1511 mutex_lock(&fs_info->qgroup_ioctl_lock); 1512 if (!fs_info->quota_root) { 1513 ret = -ENOTCONN; 1514 goto out; 1515 } 1516 quota_root = fs_info->quota_root; 1517 qgroup = find_qgroup_rb(fs_info, qgroupid); 1518 if (qgroup) { 1519 ret = -EEXIST; 1520 goto out; 1521 } 1522 1523 ret = add_qgroup_item(trans, quota_root, qgroupid); 1524 if (ret) 1525 goto out; 1526 1527 spin_lock(&fs_info->qgroup_lock); 1528 qgroup = add_qgroup_rb(fs_info, qgroupid); 1529 spin_unlock(&fs_info->qgroup_lock); 1530 1531 if (IS_ERR(qgroup)) { 1532 ret = PTR_ERR(qgroup); 1533 goto out; 1534 } 1535 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup); 1536 out: 1537 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1538 return ret; 1539 } 1540 1541 int btrfs_remove_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid) 1542 { 1543 struct btrfs_fs_info *fs_info = trans->fs_info; 1544 struct btrfs_qgroup *qgroup; 1545 struct btrfs_qgroup_list *list; 1546 int ret = 0; 1547 1548 mutex_lock(&fs_info->qgroup_ioctl_lock); 1549 if (!fs_info->quota_root) { 1550 ret = -ENOTCONN; 1551 goto out; 1552 } 1553 1554 qgroup = find_qgroup_rb(fs_info, qgroupid); 1555 if (!qgroup) { 1556 ret = -ENOENT; 1557 goto out; 1558 } 1559 1560 /* Check if there are no children of this qgroup */ 1561 if (!list_empty(&qgroup->members)) { 1562 ret = -EBUSY; 1563 goto out; 1564 } 1565 1566 ret = del_qgroup_item(trans, qgroupid); 1567 if (ret && ret != -ENOENT) 1568 goto out; 1569 1570 while (!list_empty(&qgroup->groups)) { 1571 list = list_first_entry(&qgroup->groups, 1572 struct btrfs_qgroup_list, next_group); 1573 ret = __del_qgroup_relation(trans, qgroupid, 1574 list->group->qgroupid); 1575 if (ret) 1576 goto out; 1577 } 1578 1579 spin_lock(&fs_info->qgroup_lock); 1580 del_qgroup_rb(fs_info, qgroupid); 1581 spin_unlock(&fs_info->qgroup_lock); 1582 1583 /* 1584 * Remove the qgroup from sysfs now without holding the qgroup_lock 1585 * spinlock, since the sysfs_remove_group() function needs to take 1586 * the mutex kernfs_mutex through kernfs_remove_by_name_ns(). 1587 */ 1588 btrfs_sysfs_del_one_qgroup(fs_info, qgroup); 1589 kfree(qgroup); 1590 out: 1591 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1592 return ret; 1593 } 1594 1595 int btrfs_limit_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid, 1596 struct btrfs_qgroup_limit *limit) 1597 { 1598 struct btrfs_fs_info *fs_info = trans->fs_info; 1599 struct btrfs_qgroup *qgroup; 1600 int ret = 0; 1601 /* Sometimes we would want to clear the limit on this qgroup. 1602 * To meet this requirement, we treat the -1 as a special value 1603 * which tell kernel to clear the limit on this qgroup. 1604 */ 1605 const u64 CLEAR_VALUE = -1; 1606 1607 mutex_lock(&fs_info->qgroup_ioctl_lock); 1608 if (!fs_info->quota_root) { 1609 ret = -ENOTCONN; 1610 goto out; 1611 } 1612 1613 qgroup = find_qgroup_rb(fs_info, qgroupid); 1614 if (!qgroup) { 1615 ret = -ENOENT; 1616 goto out; 1617 } 1618 1619 spin_lock(&fs_info->qgroup_lock); 1620 if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_RFER) { 1621 if (limit->max_rfer == CLEAR_VALUE) { 1622 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER; 1623 limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER; 1624 qgroup->max_rfer = 0; 1625 } else { 1626 qgroup->max_rfer = limit->max_rfer; 1627 } 1628 } 1629 if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) { 1630 if (limit->max_excl == CLEAR_VALUE) { 1631 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL; 1632 limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL; 1633 qgroup->max_excl = 0; 1634 } else { 1635 qgroup->max_excl = limit->max_excl; 1636 } 1637 } 1638 if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_RFER) { 1639 if (limit->rsv_rfer == CLEAR_VALUE) { 1640 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER; 1641 limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER; 1642 qgroup->rsv_rfer = 0; 1643 } else { 1644 qgroup->rsv_rfer = limit->rsv_rfer; 1645 } 1646 } 1647 if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_EXCL) { 1648 if (limit->rsv_excl == CLEAR_VALUE) { 1649 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL; 1650 limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL; 1651 qgroup->rsv_excl = 0; 1652 } else { 1653 qgroup->rsv_excl = limit->rsv_excl; 1654 } 1655 } 1656 qgroup->lim_flags |= limit->flags; 1657 1658 spin_unlock(&fs_info->qgroup_lock); 1659 1660 ret = update_qgroup_limit_item(trans, qgroup); 1661 if (ret) { 1662 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1663 btrfs_info(fs_info, "unable to update quota limit for %llu", 1664 qgroupid); 1665 } 1666 1667 out: 1668 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1669 return ret; 1670 } 1671 1672 int btrfs_qgroup_trace_extent_nolock(struct btrfs_fs_info *fs_info, 1673 struct btrfs_delayed_ref_root *delayed_refs, 1674 struct btrfs_qgroup_extent_record *record) 1675 { 1676 struct rb_node **p = &delayed_refs->dirty_extent_root.rb_node; 1677 struct rb_node *parent_node = NULL; 1678 struct btrfs_qgroup_extent_record *entry; 1679 u64 bytenr = record->bytenr; 1680 1681 lockdep_assert_held(&delayed_refs->lock); 1682 trace_btrfs_qgroup_trace_extent(fs_info, record); 1683 1684 while (*p) { 1685 parent_node = *p; 1686 entry = rb_entry(parent_node, struct btrfs_qgroup_extent_record, 1687 node); 1688 if (bytenr < entry->bytenr) { 1689 p = &(*p)->rb_left; 1690 } else if (bytenr > entry->bytenr) { 1691 p = &(*p)->rb_right; 1692 } else { 1693 if (record->data_rsv && !entry->data_rsv) { 1694 entry->data_rsv = record->data_rsv; 1695 entry->data_rsv_refroot = 1696 record->data_rsv_refroot; 1697 } 1698 return 1; 1699 } 1700 } 1701 1702 rb_link_node(&record->node, parent_node, p); 1703 rb_insert_color(&record->node, &delayed_refs->dirty_extent_root); 1704 return 0; 1705 } 1706 1707 int btrfs_qgroup_trace_extent_post(struct btrfs_fs_info *fs_info, 1708 struct btrfs_qgroup_extent_record *qrecord) 1709 { 1710 struct ulist *old_root; 1711 u64 bytenr = qrecord->bytenr; 1712 int ret; 1713 1714 ret = btrfs_find_all_roots(NULL, fs_info, bytenr, 0, &old_root, false); 1715 if (ret < 0) { 1716 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1717 btrfs_warn(fs_info, 1718 "error accounting new delayed refs extent (err code: %d), quota inconsistent", 1719 ret); 1720 return 0; 1721 } 1722 1723 /* 1724 * Here we don't need to get the lock of 1725 * trans->transaction->delayed_refs, since inserted qrecord won't 1726 * be deleted, only qrecord->node may be modified (new qrecord insert) 1727 * 1728 * So modifying qrecord->old_roots is safe here 1729 */ 1730 qrecord->old_roots = old_root; 1731 return 0; 1732 } 1733 1734 int btrfs_qgroup_trace_extent(struct btrfs_trans_handle *trans, u64 bytenr, 1735 u64 num_bytes, gfp_t gfp_flag) 1736 { 1737 struct btrfs_fs_info *fs_info = trans->fs_info; 1738 struct btrfs_qgroup_extent_record *record; 1739 struct btrfs_delayed_ref_root *delayed_refs; 1740 int ret; 1741 1742 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) 1743 || bytenr == 0 || num_bytes == 0) 1744 return 0; 1745 record = kzalloc(sizeof(*record), gfp_flag); 1746 if (!record) 1747 return -ENOMEM; 1748 1749 delayed_refs = &trans->transaction->delayed_refs; 1750 record->bytenr = bytenr; 1751 record->num_bytes = num_bytes; 1752 record->old_roots = NULL; 1753 1754 spin_lock(&delayed_refs->lock); 1755 ret = btrfs_qgroup_trace_extent_nolock(fs_info, delayed_refs, record); 1756 spin_unlock(&delayed_refs->lock); 1757 if (ret > 0) { 1758 kfree(record); 1759 return 0; 1760 } 1761 return btrfs_qgroup_trace_extent_post(fs_info, record); 1762 } 1763 1764 int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle *trans, 1765 struct extent_buffer *eb) 1766 { 1767 struct btrfs_fs_info *fs_info = trans->fs_info; 1768 int nr = btrfs_header_nritems(eb); 1769 int i, extent_type, ret; 1770 struct btrfs_key key; 1771 struct btrfs_file_extent_item *fi; 1772 u64 bytenr, num_bytes; 1773 1774 /* We can be called directly from walk_up_proc() */ 1775 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 1776 return 0; 1777 1778 for (i = 0; i < nr; i++) { 1779 btrfs_item_key_to_cpu(eb, &key, i); 1780 1781 if (key.type != BTRFS_EXTENT_DATA_KEY) 1782 continue; 1783 1784 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item); 1785 /* filter out non qgroup-accountable extents */ 1786 extent_type = btrfs_file_extent_type(eb, fi); 1787 1788 if (extent_type == BTRFS_FILE_EXTENT_INLINE) 1789 continue; 1790 1791 bytenr = btrfs_file_extent_disk_bytenr(eb, fi); 1792 if (!bytenr) 1793 continue; 1794 1795 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi); 1796 1797 ret = btrfs_qgroup_trace_extent(trans, bytenr, num_bytes, 1798 GFP_NOFS); 1799 if (ret) 1800 return ret; 1801 } 1802 cond_resched(); 1803 return 0; 1804 } 1805 1806 /* 1807 * Walk up the tree from the bottom, freeing leaves and any interior 1808 * nodes which have had all slots visited. If a node (leaf or 1809 * interior) is freed, the node above it will have it's slot 1810 * incremented. The root node will never be freed. 1811 * 1812 * At the end of this function, we should have a path which has all 1813 * slots incremented to the next position for a search. If we need to 1814 * read a new node it will be NULL and the node above it will have the 1815 * correct slot selected for a later read. 1816 * 1817 * If we increment the root nodes slot counter past the number of 1818 * elements, 1 is returned to signal completion of the search. 1819 */ 1820 static int adjust_slots_upwards(struct btrfs_path *path, int root_level) 1821 { 1822 int level = 0; 1823 int nr, slot; 1824 struct extent_buffer *eb; 1825 1826 if (root_level == 0) 1827 return 1; 1828 1829 while (level <= root_level) { 1830 eb = path->nodes[level]; 1831 nr = btrfs_header_nritems(eb); 1832 path->slots[level]++; 1833 slot = path->slots[level]; 1834 if (slot >= nr || level == 0) { 1835 /* 1836 * Don't free the root - we will detect this 1837 * condition after our loop and return a 1838 * positive value for caller to stop walking the tree. 1839 */ 1840 if (level != root_level) { 1841 btrfs_tree_unlock_rw(eb, path->locks[level]); 1842 path->locks[level] = 0; 1843 1844 free_extent_buffer(eb); 1845 path->nodes[level] = NULL; 1846 path->slots[level] = 0; 1847 } 1848 } else { 1849 /* 1850 * We have a valid slot to walk back down 1851 * from. Stop here so caller can process these 1852 * new nodes. 1853 */ 1854 break; 1855 } 1856 1857 level++; 1858 } 1859 1860 eb = path->nodes[root_level]; 1861 if (path->slots[root_level] >= btrfs_header_nritems(eb)) 1862 return 1; 1863 1864 return 0; 1865 } 1866 1867 /* 1868 * Helper function to trace a subtree tree block swap. 1869 * 1870 * The swap will happen in highest tree block, but there may be a lot of 1871 * tree blocks involved. 1872 * 1873 * For example: 1874 * OO = Old tree blocks 1875 * NN = New tree blocks allocated during balance 1876 * 1877 * File tree (257) Reloc tree for 257 1878 * L2 OO NN 1879 * / \ / \ 1880 * L1 OO OO (a) OO NN (a) 1881 * / \ / \ / \ / \ 1882 * L0 OO OO OO OO OO OO NN NN 1883 * (b) (c) (b) (c) 1884 * 1885 * When calling qgroup_trace_extent_swap(), we will pass: 1886 * @src_eb = OO(a) 1887 * @dst_path = [ nodes[1] = NN(a), nodes[0] = NN(c) ] 1888 * @dst_level = 0 1889 * @root_level = 1 1890 * 1891 * In that case, qgroup_trace_extent_swap() will search from OO(a) to 1892 * reach OO(c), then mark both OO(c) and NN(c) as qgroup dirty. 1893 * 1894 * The main work of qgroup_trace_extent_swap() can be split into 3 parts: 1895 * 1896 * 1) Tree search from @src_eb 1897 * It should acts as a simplified btrfs_search_slot(). 1898 * The key for search can be extracted from @dst_path->nodes[dst_level] 1899 * (first key). 1900 * 1901 * 2) Mark the final tree blocks in @src_path and @dst_path qgroup dirty 1902 * NOTE: In above case, OO(a) and NN(a) won't be marked qgroup dirty. 1903 * They should be marked during previous (@dst_level = 1) iteration. 1904 * 1905 * 3) Mark file extents in leaves dirty 1906 * We don't have good way to pick out new file extents only. 1907 * So we still follow the old method by scanning all file extents in 1908 * the leave. 1909 * 1910 * This function can free us from keeping two paths, thus later we only need 1911 * to care about how to iterate all new tree blocks in reloc tree. 1912 */ 1913 static int qgroup_trace_extent_swap(struct btrfs_trans_handle* trans, 1914 struct extent_buffer *src_eb, 1915 struct btrfs_path *dst_path, 1916 int dst_level, int root_level, 1917 bool trace_leaf) 1918 { 1919 struct btrfs_key key; 1920 struct btrfs_path *src_path; 1921 struct btrfs_fs_info *fs_info = trans->fs_info; 1922 u32 nodesize = fs_info->nodesize; 1923 int cur_level = root_level; 1924 int ret; 1925 1926 BUG_ON(dst_level > root_level); 1927 /* Level mismatch */ 1928 if (btrfs_header_level(src_eb) != root_level) 1929 return -EINVAL; 1930 1931 src_path = btrfs_alloc_path(); 1932 if (!src_path) { 1933 ret = -ENOMEM; 1934 goto out; 1935 } 1936 1937 if (dst_level) 1938 btrfs_node_key_to_cpu(dst_path->nodes[dst_level], &key, 0); 1939 else 1940 btrfs_item_key_to_cpu(dst_path->nodes[dst_level], &key, 0); 1941 1942 /* For src_path */ 1943 atomic_inc(&src_eb->refs); 1944 src_path->nodes[root_level] = src_eb; 1945 src_path->slots[root_level] = dst_path->slots[root_level]; 1946 src_path->locks[root_level] = 0; 1947 1948 /* A simplified version of btrfs_search_slot() */ 1949 while (cur_level >= dst_level) { 1950 struct btrfs_key src_key; 1951 struct btrfs_key dst_key; 1952 1953 if (src_path->nodes[cur_level] == NULL) { 1954 struct extent_buffer *eb; 1955 int parent_slot; 1956 1957 eb = src_path->nodes[cur_level + 1]; 1958 parent_slot = src_path->slots[cur_level + 1]; 1959 1960 eb = btrfs_read_node_slot(eb, parent_slot); 1961 if (IS_ERR(eb)) { 1962 ret = PTR_ERR(eb); 1963 goto out; 1964 } 1965 1966 src_path->nodes[cur_level] = eb; 1967 1968 btrfs_tree_read_lock(eb); 1969 src_path->locks[cur_level] = BTRFS_READ_LOCK; 1970 } 1971 1972 src_path->slots[cur_level] = dst_path->slots[cur_level]; 1973 if (cur_level) { 1974 btrfs_node_key_to_cpu(dst_path->nodes[cur_level], 1975 &dst_key, dst_path->slots[cur_level]); 1976 btrfs_node_key_to_cpu(src_path->nodes[cur_level], 1977 &src_key, src_path->slots[cur_level]); 1978 } else { 1979 btrfs_item_key_to_cpu(dst_path->nodes[cur_level], 1980 &dst_key, dst_path->slots[cur_level]); 1981 btrfs_item_key_to_cpu(src_path->nodes[cur_level], 1982 &src_key, src_path->slots[cur_level]); 1983 } 1984 /* Content mismatch, something went wrong */ 1985 if (btrfs_comp_cpu_keys(&dst_key, &src_key)) { 1986 ret = -ENOENT; 1987 goto out; 1988 } 1989 cur_level--; 1990 } 1991 1992 /* 1993 * Now both @dst_path and @src_path have been populated, record the tree 1994 * blocks for qgroup accounting. 1995 */ 1996 ret = btrfs_qgroup_trace_extent(trans, src_path->nodes[dst_level]->start, 1997 nodesize, GFP_NOFS); 1998 if (ret < 0) 1999 goto out; 2000 ret = btrfs_qgroup_trace_extent(trans, 2001 dst_path->nodes[dst_level]->start, 2002 nodesize, GFP_NOFS); 2003 if (ret < 0) 2004 goto out; 2005 2006 /* Record leaf file extents */ 2007 if (dst_level == 0 && trace_leaf) { 2008 ret = btrfs_qgroup_trace_leaf_items(trans, src_path->nodes[0]); 2009 if (ret < 0) 2010 goto out; 2011 ret = btrfs_qgroup_trace_leaf_items(trans, dst_path->nodes[0]); 2012 } 2013 out: 2014 btrfs_free_path(src_path); 2015 return ret; 2016 } 2017 2018 /* 2019 * Helper function to do recursive generation-aware depth-first search, to 2020 * locate all new tree blocks in a subtree of reloc tree. 2021 * 2022 * E.g. (OO = Old tree blocks, NN = New tree blocks, whose gen == last_snapshot) 2023 * reloc tree 2024 * L2 NN (a) 2025 * / \ 2026 * L1 OO NN (b) 2027 * / \ / \ 2028 * L0 OO OO OO NN 2029 * (c) (d) 2030 * If we pass: 2031 * @dst_path = [ nodes[1] = NN(b), nodes[0] = NULL ], 2032 * @cur_level = 1 2033 * @root_level = 1 2034 * 2035 * We will iterate through tree blocks NN(b), NN(d) and info qgroup to trace 2036 * above tree blocks along with their counter parts in file tree. 2037 * While during search, old tree blocks OO(c) will be skipped as tree block swap 2038 * won't affect OO(c). 2039 */ 2040 static int qgroup_trace_new_subtree_blocks(struct btrfs_trans_handle* trans, 2041 struct extent_buffer *src_eb, 2042 struct btrfs_path *dst_path, 2043 int cur_level, int root_level, 2044 u64 last_snapshot, bool trace_leaf) 2045 { 2046 struct btrfs_fs_info *fs_info = trans->fs_info; 2047 struct extent_buffer *eb; 2048 bool need_cleanup = false; 2049 int ret = 0; 2050 int i; 2051 2052 /* Level sanity check */ 2053 if (cur_level < 0 || cur_level >= BTRFS_MAX_LEVEL - 1 || 2054 root_level < 0 || root_level >= BTRFS_MAX_LEVEL - 1 || 2055 root_level < cur_level) { 2056 btrfs_err_rl(fs_info, 2057 "%s: bad levels, cur_level=%d root_level=%d", 2058 __func__, cur_level, root_level); 2059 return -EUCLEAN; 2060 } 2061 2062 /* Read the tree block if needed */ 2063 if (dst_path->nodes[cur_level] == NULL) { 2064 int parent_slot; 2065 u64 child_gen; 2066 2067 /* 2068 * dst_path->nodes[root_level] must be initialized before 2069 * calling this function. 2070 */ 2071 if (cur_level == root_level) { 2072 btrfs_err_rl(fs_info, 2073 "%s: dst_path->nodes[%d] not initialized, root_level=%d cur_level=%d", 2074 __func__, root_level, root_level, cur_level); 2075 return -EUCLEAN; 2076 } 2077 2078 /* 2079 * We need to get child blockptr/gen from parent before we can 2080 * read it. 2081 */ 2082 eb = dst_path->nodes[cur_level + 1]; 2083 parent_slot = dst_path->slots[cur_level + 1]; 2084 child_gen = btrfs_node_ptr_generation(eb, parent_slot); 2085 2086 /* This node is old, no need to trace */ 2087 if (child_gen < last_snapshot) 2088 goto out; 2089 2090 eb = btrfs_read_node_slot(eb, parent_slot); 2091 if (IS_ERR(eb)) { 2092 ret = PTR_ERR(eb); 2093 goto out; 2094 } 2095 2096 dst_path->nodes[cur_level] = eb; 2097 dst_path->slots[cur_level] = 0; 2098 2099 btrfs_tree_read_lock(eb); 2100 dst_path->locks[cur_level] = BTRFS_READ_LOCK; 2101 need_cleanup = true; 2102 } 2103 2104 /* Now record this tree block and its counter part for qgroups */ 2105 ret = qgroup_trace_extent_swap(trans, src_eb, dst_path, cur_level, 2106 root_level, trace_leaf); 2107 if (ret < 0) 2108 goto cleanup; 2109 2110 eb = dst_path->nodes[cur_level]; 2111 2112 if (cur_level > 0) { 2113 /* Iterate all child tree blocks */ 2114 for (i = 0; i < btrfs_header_nritems(eb); i++) { 2115 /* Skip old tree blocks as they won't be swapped */ 2116 if (btrfs_node_ptr_generation(eb, i) < last_snapshot) 2117 continue; 2118 dst_path->slots[cur_level] = i; 2119 2120 /* Recursive call (at most 7 times) */ 2121 ret = qgroup_trace_new_subtree_blocks(trans, src_eb, 2122 dst_path, cur_level - 1, root_level, 2123 last_snapshot, trace_leaf); 2124 if (ret < 0) 2125 goto cleanup; 2126 } 2127 } 2128 2129 cleanup: 2130 if (need_cleanup) { 2131 /* Clean up */ 2132 btrfs_tree_unlock_rw(dst_path->nodes[cur_level], 2133 dst_path->locks[cur_level]); 2134 free_extent_buffer(dst_path->nodes[cur_level]); 2135 dst_path->nodes[cur_level] = NULL; 2136 dst_path->slots[cur_level] = 0; 2137 dst_path->locks[cur_level] = 0; 2138 } 2139 out: 2140 return ret; 2141 } 2142 2143 static int qgroup_trace_subtree_swap(struct btrfs_trans_handle *trans, 2144 struct extent_buffer *src_eb, 2145 struct extent_buffer *dst_eb, 2146 u64 last_snapshot, bool trace_leaf) 2147 { 2148 struct btrfs_fs_info *fs_info = trans->fs_info; 2149 struct btrfs_path *dst_path = NULL; 2150 int level; 2151 int ret; 2152 2153 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 2154 return 0; 2155 2156 /* Wrong parameter order */ 2157 if (btrfs_header_generation(src_eb) > btrfs_header_generation(dst_eb)) { 2158 btrfs_err_rl(fs_info, 2159 "%s: bad parameter order, src_gen=%llu dst_gen=%llu", __func__, 2160 btrfs_header_generation(src_eb), 2161 btrfs_header_generation(dst_eb)); 2162 return -EUCLEAN; 2163 } 2164 2165 if (!extent_buffer_uptodate(src_eb) || !extent_buffer_uptodate(dst_eb)) { 2166 ret = -EIO; 2167 goto out; 2168 } 2169 2170 level = btrfs_header_level(dst_eb); 2171 dst_path = btrfs_alloc_path(); 2172 if (!dst_path) { 2173 ret = -ENOMEM; 2174 goto out; 2175 } 2176 /* For dst_path */ 2177 atomic_inc(&dst_eb->refs); 2178 dst_path->nodes[level] = dst_eb; 2179 dst_path->slots[level] = 0; 2180 dst_path->locks[level] = 0; 2181 2182 /* Do the generation aware breadth-first search */ 2183 ret = qgroup_trace_new_subtree_blocks(trans, src_eb, dst_path, level, 2184 level, last_snapshot, trace_leaf); 2185 if (ret < 0) 2186 goto out; 2187 ret = 0; 2188 2189 out: 2190 btrfs_free_path(dst_path); 2191 if (ret < 0) 2192 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2193 return ret; 2194 } 2195 2196 int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans, 2197 struct extent_buffer *root_eb, 2198 u64 root_gen, int root_level) 2199 { 2200 struct btrfs_fs_info *fs_info = trans->fs_info; 2201 int ret = 0; 2202 int level; 2203 struct extent_buffer *eb = root_eb; 2204 struct btrfs_path *path = NULL; 2205 2206 BUG_ON(root_level < 0 || root_level >= BTRFS_MAX_LEVEL); 2207 BUG_ON(root_eb == NULL); 2208 2209 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 2210 return 0; 2211 2212 if (!extent_buffer_uptodate(root_eb)) { 2213 ret = btrfs_read_buffer(root_eb, root_gen, root_level, NULL); 2214 if (ret) 2215 goto out; 2216 } 2217 2218 if (root_level == 0) { 2219 ret = btrfs_qgroup_trace_leaf_items(trans, root_eb); 2220 goto out; 2221 } 2222 2223 path = btrfs_alloc_path(); 2224 if (!path) 2225 return -ENOMEM; 2226 2227 /* 2228 * Walk down the tree. Missing extent blocks are filled in as 2229 * we go. Metadata is accounted every time we read a new 2230 * extent block. 2231 * 2232 * When we reach a leaf, we account for file extent items in it, 2233 * walk back up the tree (adjusting slot pointers as we go) 2234 * and restart the search process. 2235 */ 2236 atomic_inc(&root_eb->refs); /* For path */ 2237 path->nodes[root_level] = root_eb; 2238 path->slots[root_level] = 0; 2239 path->locks[root_level] = 0; /* so release_path doesn't try to unlock */ 2240 walk_down: 2241 level = root_level; 2242 while (level >= 0) { 2243 if (path->nodes[level] == NULL) { 2244 int parent_slot; 2245 u64 child_bytenr; 2246 2247 /* 2248 * We need to get child blockptr from parent before we 2249 * can read it. 2250 */ 2251 eb = path->nodes[level + 1]; 2252 parent_slot = path->slots[level + 1]; 2253 child_bytenr = btrfs_node_blockptr(eb, parent_slot); 2254 2255 eb = btrfs_read_node_slot(eb, parent_slot); 2256 if (IS_ERR(eb)) { 2257 ret = PTR_ERR(eb); 2258 goto out; 2259 } 2260 2261 path->nodes[level] = eb; 2262 path->slots[level] = 0; 2263 2264 btrfs_tree_read_lock(eb); 2265 path->locks[level] = BTRFS_READ_LOCK; 2266 2267 ret = btrfs_qgroup_trace_extent(trans, child_bytenr, 2268 fs_info->nodesize, 2269 GFP_NOFS); 2270 if (ret) 2271 goto out; 2272 } 2273 2274 if (level == 0) { 2275 ret = btrfs_qgroup_trace_leaf_items(trans, 2276 path->nodes[level]); 2277 if (ret) 2278 goto out; 2279 2280 /* Nonzero return here means we completed our search */ 2281 ret = adjust_slots_upwards(path, root_level); 2282 if (ret) 2283 break; 2284 2285 /* Restart search with new slots */ 2286 goto walk_down; 2287 } 2288 2289 level--; 2290 } 2291 2292 ret = 0; 2293 out: 2294 btrfs_free_path(path); 2295 2296 return ret; 2297 } 2298 2299 #define UPDATE_NEW 0 2300 #define UPDATE_OLD 1 2301 /* 2302 * Walk all of the roots that points to the bytenr and adjust their refcnts. 2303 */ 2304 static int qgroup_update_refcnt(struct btrfs_fs_info *fs_info, 2305 struct ulist *roots, struct ulist *tmp, 2306 struct ulist *qgroups, u64 seq, int update_old) 2307 { 2308 struct ulist_node *unode; 2309 struct ulist_iterator uiter; 2310 struct ulist_node *tmp_unode; 2311 struct ulist_iterator tmp_uiter; 2312 struct btrfs_qgroup *qg; 2313 int ret = 0; 2314 2315 if (!roots) 2316 return 0; 2317 ULIST_ITER_INIT(&uiter); 2318 while ((unode = ulist_next(roots, &uiter))) { 2319 qg = find_qgroup_rb(fs_info, unode->val); 2320 if (!qg) 2321 continue; 2322 2323 ulist_reinit(tmp); 2324 ret = ulist_add(qgroups, qg->qgroupid, qgroup_to_aux(qg), 2325 GFP_ATOMIC); 2326 if (ret < 0) 2327 return ret; 2328 ret = ulist_add(tmp, qg->qgroupid, qgroup_to_aux(qg), GFP_ATOMIC); 2329 if (ret < 0) 2330 return ret; 2331 ULIST_ITER_INIT(&tmp_uiter); 2332 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) { 2333 struct btrfs_qgroup_list *glist; 2334 2335 qg = unode_aux_to_qgroup(tmp_unode); 2336 if (update_old) 2337 btrfs_qgroup_update_old_refcnt(qg, seq, 1); 2338 else 2339 btrfs_qgroup_update_new_refcnt(qg, seq, 1); 2340 list_for_each_entry(glist, &qg->groups, next_group) { 2341 ret = ulist_add(qgroups, glist->group->qgroupid, 2342 qgroup_to_aux(glist->group), 2343 GFP_ATOMIC); 2344 if (ret < 0) 2345 return ret; 2346 ret = ulist_add(tmp, glist->group->qgroupid, 2347 qgroup_to_aux(glist->group), 2348 GFP_ATOMIC); 2349 if (ret < 0) 2350 return ret; 2351 } 2352 } 2353 } 2354 return 0; 2355 } 2356 2357 /* 2358 * Update qgroup rfer/excl counters. 2359 * Rfer update is easy, codes can explain themselves. 2360 * 2361 * Excl update is tricky, the update is split into 2 parts. 2362 * Part 1: Possible exclusive <-> sharing detect: 2363 * | A | !A | 2364 * ------------------------------------- 2365 * B | * | - | 2366 * ------------------------------------- 2367 * !B | + | ** | 2368 * ------------------------------------- 2369 * 2370 * Conditions: 2371 * A: cur_old_roots < nr_old_roots (not exclusive before) 2372 * !A: cur_old_roots == nr_old_roots (possible exclusive before) 2373 * B: cur_new_roots < nr_new_roots (not exclusive now) 2374 * !B: cur_new_roots == nr_new_roots (possible exclusive now) 2375 * 2376 * Results: 2377 * +: Possible sharing -> exclusive -: Possible exclusive -> sharing 2378 * *: Definitely not changed. **: Possible unchanged. 2379 * 2380 * For !A and !B condition, the exception is cur_old/new_roots == 0 case. 2381 * 2382 * To make the logic clear, we first use condition A and B to split 2383 * combination into 4 results. 2384 * 2385 * Then, for result "+" and "-", check old/new_roots == 0 case, as in them 2386 * only on variant maybe 0. 2387 * 2388 * Lastly, check result **, since there are 2 variants maybe 0, split them 2389 * again(2x2). 2390 * But this time we don't need to consider other things, the codes and logic 2391 * is easy to understand now. 2392 */ 2393 static int qgroup_update_counters(struct btrfs_fs_info *fs_info, 2394 struct ulist *qgroups, 2395 u64 nr_old_roots, 2396 u64 nr_new_roots, 2397 u64 num_bytes, u64 seq) 2398 { 2399 struct ulist_node *unode; 2400 struct ulist_iterator uiter; 2401 struct btrfs_qgroup *qg; 2402 u64 cur_new_count, cur_old_count; 2403 2404 ULIST_ITER_INIT(&uiter); 2405 while ((unode = ulist_next(qgroups, &uiter))) { 2406 bool dirty = false; 2407 2408 qg = unode_aux_to_qgroup(unode); 2409 cur_old_count = btrfs_qgroup_get_old_refcnt(qg, seq); 2410 cur_new_count = btrfs_qgroup_get_new_refcnt(qg, seq); 2411 2412 trace_qgroup_update_counters(fs_info, qg, cur_old_count, 2413 cur_new_count); 2414 2415 /* Rfer update part */ 2416 if (cur_old_count == 0 && cur_new_count > 0) { 2417 qg->rfer += num_bytes; 2418 qg->rfer_cmpr += num_bytes; 2419 dirty = true; 2420 } 2421 if (cur_old_count > 0 && cur_new_count == 0) { 2422 qg->rfer -= num_bytes; 2423 qg->rfer_cmpr -= num_bytes; 2424 dirty = true; 2425 } 2426 2427 /* Excl update part */ 2428 /* Exclusive/none -> shared case */ 2429 if (cur_old_count == nr_old_roots && 2430 cur_new_count < nr_new_roots) { 2431 /* Exclusive -> shared */ 2432 if (cur_old_count != 0) { 2433 qg->excl -= num_bytes; 2434 qg->excl_cmpr -= num_bytes; 2435 dirty = true; 2436 } 2437 } 2438 2439 /* Shared -> exclusive/none case */ 2440 if (cur_old_count < nr_old_roots && 2441 cur_new_count == nr_new_roots) { 2442 /* Shared->exclusive */ 2443 if (cur_new_count != 0) { 2444 qg->excl += num_bytes; 2445 qg->excl_cmpr += num_bytes; 2446 dirty = true; 2447 } 2448 } 2449 2450 /* Exclusive/none -> exclusive/none case */ 2451 if (cur_old_count == nr_old_roots && 2452 cur_new_count == nr_new_roots) { 2453 if (cur_old_count == 0) { 2454 /* None -> exclusive/none */ 2455 2456 if (cur_new_count != 0) { 2457 /* None -> exclusive */ 2458 qg->excl += num_bytes; 2459 qg->excl_cmpr += num_bytes; 2460 dirty = true; 2461 } 2462 /* None -> none, nothing changed */ 2463 } else { 2464 /* Exclusive -> exclusive/none */ 2465 2466 if (cur_new_count == 0) { 2467 /* Exclusive -> none */ 2468 qg->excl -= num_bytes; 2469 qg->excl_cmpr -= num_bytes; 2470 dirty = true; 2471 } 2472 /* Exclusive -> exclusive, nothing changed */ 2473 } 2474 } 2475 2476 if (dirty) 2477 qgroup_dirty(fs_info, qg); 2478 } 2479 return 0; 2480 } 2481 2482 /* 2483 * Check if the @roots potentially is a list of fs tree roots 2484 * 2485 * Return 0 for definitely not a fs/subvol tree roots ulist 2486 * Return 1 for possible fs/subvol tree roots in the list (considering an empty 2487 * one as well) 2488 */ 2489 static int maybe_fs_roots(struct ulist *roots) 2490 { 2491 struct ulist_node *unode; 2492 struct ulist_iterator uiter; 2493 2494 /* Empty one, still possible for fs roots */ 2495 if (!roots || roots->nnodes == 0) 2496 return 1; 2497 2498 ULIST_ITER_INIT(&uiter); 2499 unode = ulist_next(roots, &uiter); 2500 if (!unode) 2501 return 1; 2502 2503 /* 2504 * If it contains fs tree roots, then it must belong to fs/subvol 2505 * trees. 2506 * If it contains a non-fs tree, it won't be shared with fs/subvol trees. 2507 */ 2508 return is_fstree(unode->val); 2509 } 2510 2511 int btrfs_qgroup_account_extent(struct btrfs_trans_handle *trans, u64 bytenr, 2512 u64 num_bytes, struct ulist *old_roots, 2513 struct ulist *new_roots) 2514 { 2515 struct btrfs_fs_info *fs_info = trans->fs_info; 2516 struct ulist *qgroups = NULL; 2517 struct ulist *tmp = NULL; 2518 u64 seq; 2519 u64 nr_new_roots = 0; 2520 u64 nr_old_roots = 0; 2521 int ret = 0; 2522 2523 /* 2524 * If quotas get disabled meanwhile, the resources need to be freed and 2525 * we can't just exit here. 2526 */ 2527 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 2528 goto out_free; 2529 2530 if (new_roots) { 2531 if (!maybe_fs_roots(new_roots)) 2532 goto out_free; 2533 nr_new_roots = new_roots->nnodes; 2534 } 2535 if (old_roots) { 2536 if (!maybe_fs_roots(old_roots)) 2537 goto out_free; 2538 nr_old_roots = old_roots->nnodes; 2539 } 2540 2541 /* Quick exit, either not fs tree roots, or won't affect any qgroup */ 2542 if (nr_old_roots == 0 && nr_new_roots == 0) 2543 goto out_free; 2544 2545 BUG_ON(!fs_info->quota_root); 2546 2547 trace_btrfs_qgroup_account_extent(fs_info, trans->transid, bytenr, 2548 num_bytes, nr_old_roots, nr_new_roots); 2549 2550 qgroups = ulist_alloc(GFP_NOFS); 2551 if (!qgroups) { 2552 ret = -ENOMEM; 2553 goto out_free; 2554 } 2555 tmp = ulist_alloc(GFP_NOFS); 2556 if (!tmp) { 2557 ret = -ENOMEM; 2558 goto out_free; 2559 } 2560 2561 mutex_lock(&fs_info->qgroup_rescan_lock); 2562 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) { 2563 if (fs_info->qgroup_rescan_progress.objectid <= bytenr) { 2564 mutex_unlock(&fs_info->qgroup_rescan_lock); 2565 ret = 0; 2566 goto out_free; 2567 } 2568 } 2569 mutex_unlock(&fs_info->qgroup_rescan_lock); 2570 2571 spin_lock(&fs_info->qgroup_lock); 2572 seq = fs_info->qgroup_seq; 2573 2574 /* Update old refcnts using old_roots */ 2575 ret = qgroup_update_refcnt(fs_info, old_roots, tmp, qgroups, seq, 2576 UPDATE_OLD); 2577 if (ret < 0) 2578 goto out; 2579 2580 /* Update new refcnts using new_roots */ 2581 ret = qgroup_update_refcnt(fs_info, new_roots, tmp, qgroups, seq, 2582 UPDATE_NEW); 2583 if (ret < 0) 2584 goto out; 2585 2586 qgroup_update_counters(fs_info, qgroups, nr_old_roots, nr_new_roots, 2587 num_bytes, seq); 2588 2589 /* 2590 * Bump qgroup_seq to avoid seq overlap 2591 */ 2592 fs_info->qgroup_seq += max(nr_old_roots, nr_new_roots) + 1; 2593 out: 2594 spin_unlock(&fs_info->qgroup_lock); 2595 out_free: 2596 ulist_free(tmp); 2597 ulist_free(qgroups); 2598 ulist_free(old_roots); 2599 ulist_free(new_roots); 2600 return ret; 2601 } 2602 2603 int btrfs_qgroup_account_extents(struct btrfs_trans_handle *trans) 2604 { 2605 struct btrfs_fs_info *fs_info = trans->fs_info; 2606 struct btrfs_qgroup_extent_record *record; 2607 struct btrfs_delayed_ref_root *delayed_refs; 2608 struct ulist *new_roots = NULL; 2609 struct rb_node *node; 2610 u64 num_dirty_extents = 0; 2611 u64 qgroup_to_skip; 2612 int ret = 0; 2613 2614 delayed_refs = &trans->transaction->delayed_refs; 2615 qgroup_to_skip = delayed_refs->qgroup_to_skip; 2616 while ((node = rb_first(&delayed_refs->dirty_extent_root))) { 2617 record = rb_entry(node, struct btrfs_qgroup_extent_record, 2618 node); 2619 2620 num_dirty_extents++; 2621 trace_btrfs_qgroup_account_extents(fs_info, record); 2622 2623 if (!ret) { 2624 /* 2625 * Old roots should be searched when inserting qgroup 2626 * extent record 2627 */ 2628 if (WARN_ON(!record->old_roots)) { 2629 /* Search commit root to find old_roots */ 2630 ret = btrfs_find_all_roots(NULL, fs_info, 2631 record->bytenr, 0, 2632 &record->old_roots, false); 2633 if (ret < 0) 2634 goto cleanup; 2635 } 2636 2637 /* Free the reserved data space */ 2638 btrfs_qgroup_free_refroot(fs_info, 2639 record->data_rsv_refroot, 2640 record->data_rsv, 2641 BTRFS_QGROUP_RSV_DATA); 2642 /* 2643 * Use BTRFS_SEQ_LAST as time_seq to do special search, 2644 * which doesn't lock tree or delayed_refs and search 2645 * current root. It's safe inside commit_transaction(). 2646 */ 2647 ret = btrfs_find_all_roots(trans, fs_info, 2648 record->bytenr, BTRFS_SEQ_LAST, &new_roots, false); 2649 if (ret < 0) 2650 goto cleanup; 2651 if (qgroup_to_skip) { 2652 ulist_del(new_roots, qgroup_to_skip, 0); 2653 ulist_del(record->old_roots, qgroup_to_skip, 2654 0); 2655 } 2656 ret = btrfs_qgroup_account_extent(trans, record->bytenr, 2657 record->num_bytes, 2658 record->old_roots, 2659 new_roots); 2660 record->old_roots = NULL; 2661 new_roots = NULL; 2662 } 2663 cleanup: 2664 ulist_free(record->old_roots); 2665 ulist_free(new_roots); 2666 new_roots = NULL; 2667 rb_erase(node, &delayed_refs->dirty_extent_root); 2668 kfree(record); 2669 2670 } 2671 trace_qgroup_num_dirty_extents(fs_info, trans->transid, 2672 num_dirty_extents); 2673 return ret; 2674 } 2675 2676 /* 2677 * called from commit_transaction. Writes all changed qgroups to disk. 2678 */ 2679 int btrfs_run_qgroups(struct btrfs_trans_handle *trans) 2680 { 2681 struct btrfs_fs_info *fs_info = trans->fs_info; 2682 int ret = 0; 2683 2684 if (!fs_info->quota_root) 2685 return ret; 2686 2687 spin_lock(&fs_info->qgroup_lock); 2688 while (!list_empty(&fs_info->dirty_qgroups)) { 2689 struct btrfs_qgroup *qgroup; 2690 qgroup = list_first_entry(&fs_info->dirty_qgroups, 2691 struct btrfs_qgroup, dirty); 2692 list_del_init(&qgroup->dirty); 2693 spin_unlock(&fs_info->qgroup_lock); 2694 ret = update_qgroup_info_item(trans, qgroup); 2695 if (ret) 2696 fs_info->qgroup_flags |= 2697 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2698 ret = update_qgroup_limit_item(trans, qgroup); 2699 if (ret) 2700 fs_info->qgroup_flags |= 2701 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2702 spin_lock(&fs_info->qgroup_lock); 2703 } 2704 if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 2705 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_ON; 2706 else 2707 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON; 2708 spin_unlock(&fs_info->qgroup_lock); 2709 2710 ret = update_qgroup_status_item(trans); 2711 if (ret) 2712 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2713 2714 return ret; 2715 } 2716 2717 /* 2718 * Copy the accounting information between qgroups. This is necessary 2719 * when a snapshot or a subvolume is created. Throwing an error will 2720 * cause a transaction abort so we take extra care here to only error 2721 * when a readonly fs is a reasonable outcome. 2722 */ 2723 int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans, u64 srcid, 2724 u64 objectid, struct btrfs_qgroup_inherit *inherit) 2725 { 2726 int ret = 0; 2727 int i; 2728 u64 *i_qgroups; 2729 bool committing = false; 2730 struct btrfs_fs_info *fs_info = trans->fs_info; 2731 struct btrfs_root *quota_root; 2732 struct btrfs_qgroup *srcgroup; 2733 struct btrfs_qgroup *dstgroup; 2734 bool need_rescan = false; 2735 u32 level_size = 0; 2736 u64 nums; 2737 2738 /* 2739 * There are only two callers of this function. 2740 * 2741 * One in create_subvol() in the ioctl context, which needs to hold 2742 * the qgroup_ioctl_lock. 2743 * 2744 * The other one in create_pending_snapshot() where no other qgroup 2745 * code can modify the fs as they all need to either start a new trans 2746 * or hold a trans handler, thus we don't need to hold 2747 * qgroup_ioctl_lock. 2748 * This would avoid long and complex lock chain and make lockdep happy. 2749 */ 2750 spin_lock(&fs_info->trans_lock); 2751 if (trans->transaction->state == TRANS_STATE_COMMIT_DOING) 2752 committing = true; 2753 spin_unlock(&fs_info->trans_lock); 2754 2755 if (!committing) 2756 mutex_lock(&fs_info->qgroup_ioctl_lock); 2757 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 2758 goto out; 2759 2760 quota_root = fs_info->quota_root; 2761 if (!quota_root) { 2762 ret = -EINVAL; 2763 goto out; 2764 } 2765 2766 if (inherit) { 2767 i_qgroups = (u64 *)(inherit + 1); 2768 nums = inherit->num_qgroups + 2 * inherit->num_ref_copies + 2769 2 * inherit->num_excl_copies; 2770 for (i = 0; i < nums; ++i) { 2771 srcgroup = find_qgroup_rb(fs_info, *i_qgroups); 2772 2773 /* 2774 * Zero out invalid groups so we can ignore 2775 * them later. 2776 */ 2777 if (!srcgroup || 2778 ((srcgroup->qgroupid >> 48) <= (objectid >> 48))) 2779 *i_qgroups = 0ULL; 2780 2781 ++i_qgroups; 2782 } 2783 } 2784 2785 /* 2786 * create a tracking group for the subvol itself 2787 */ 2788 ret = add_qgroup_item(trans, quota_root, objectid); 2789 if (ret) 2790 goto out; 2791 2792 /* 2793 * add qgroup to all inherited groups 2794 */ 2795 if (inherit) { 2796 i_qgroups = (u64 *)(inherit + 1); 2797 for (i = 0; i < inherit->num_qgroups; ++i, ++i_qgroups) { 2798 if (*i_qgroups == 0) 2799 continue; 2800 ret = add_qgroup_relation_item(trans, objectid, 2801 *i_qgroups); 2802 if (ret && ret != -EEXIST) 2803 goto out; 2804 ret = add_qgroup_relation_item(trans, *i_qgroups, 2805 objectid); 2806 if (ret && ret != -EEXIST) 2807 goto out; 2808 } 2809 ret = 0; 2810 } 2811 2812 2813 spin_lock(&fs_info->qgroup_lock); 2814 2815 dstgroup = add_qgroup_rb(fs_info, objectid); 2816 if (IS_ERR(dstgroup)) { 2817 ret = PTR_ERR(dstgroup); 2818 goto unlock; 2819 } 2820 2821 if (inherit && inherit->flags & BTRFS_QGROUP_INHERIT_SET_LIMITS) { 2822 dstgroup->lim_flags = inherit->lim.flags; 2823 dstgroup->max_rfer = inherit->lim.max_rfer; 2824 dstgroup->max_excl = inherit->lim.max_excl; 2825 dstgroup->rsv_rfer = inherit->lim.rsv_rfer; 2826 dstgroup->rsv_excl = inherit->lim.rsv_excl; 2827 2828 ret = update_qgroup_limit_item(trans, dstgroup); 2829 if (ret) { 2830 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2831 btrfs_info(fs_info, 2832 "unable to update quota limit for %llu", 2833 dstgroup->qgroupid); 2834 goto unlock; 2835 } 2836 } 2837 2838 if (srcid) { 2839 srcgroup = find_qgroup_rb(fs_info, srcid); 2840 if (!srcgroup) 2841 goto unlock; 2842 2843 /* 2844 * We call inherit after we clone the root in order to make sure 2845 * our counts don't go crazy, so at this point the only 2846 * difference between the two roots should be the root node. 2847 */ 2848 level_size = fs_info->nodesize; 2849 dstgroup->rfer = srcgroup->rfer; 2850 dstgroup->rfer_cmpr = srcgroup->rfer_cmpr; 2851 dstgroup->excl = level_size; 2852 dstgroup->excl_cmpr = level_size; 2853 srcgroup->excl = level_size; 2854 srcgroup->excl_cmpr = level_size; 2855 2856 /* inherit the limit info */ 2857 dstgroup->lim_flags = srcgroup->lim_flags; 2858 dstgroup->max_rfer = srcgroup->max_rfer; 2859 dstgroup->max_excl = srcgroup->max_excl; 2860 dstgroup->rsv_rfer = srcgroup->rsv_rfer; 2861 dstgroup->rsv_excl = srcgroup->rsv_excl; 2862 2863 qgroup_dirty(fs_info, dstgroup); 2864 qgroup_dirty(fs_info, srcgroup); 2865 } 2866 2867 if (!inherit) 2868 goto unlock; 2869 2870 i_qgroups = (u64 *)(inherit + 1); 2871 for (i = 0; i < inherit->num_qgroups; ++i) { 2872 if (*i_qgroups) { 2873 ret = add_relation_rb(fs_info, objectid, *i_qgroups); 2874 if (ret) 2875 goto unlock; 2876 } 2877 ++i_qgroups; 2878 2879 /* 2880 * If we're doing a snapshot, and adding the snapshot to a new 2881 * qgroup, the numbers are guaranteed to be incorrect. 2882 */ 2883 if (srcid) 2884 need_rescan = true; 2885 } 2886 2887 for (i = 0; i < inherit->num_ref_copies; ++i, i_qgroups += 2) { 2888 struct btrfs_qgroup *src; 2889 struct btrfs_qgroup *dst; 2890 2891 if (!i_qgroups[0] || !i_qgroups[1]) 2892 continue; 2893 2894 src = find_qgroup_rb(fs_info, i_qgroups[0]); 2895 dst = find_qgroup_rb(fs_info, i_qgroups[1]); 2896 2897 if (!src || !dst) { 2898 ret = -EINVAL; 2899 goto unlock; 2900 } 2901 2902 dst->rfer = src->rfer - level_size; 2903 dst->rfer_cmpr = src->rfer_cmpr - level_size; 2904 2905 /* Manually tweaking numbers certainly needs a rescan */ 2906 need_rescan = true; 2907 } 2908 for (i = 0; i < inherit->num_excl_copies; ++i, i_qgroups += 2) { 2909 struct btrfs_qgroup *src; 2910 struct btrfs_qgroup *dst; 2911 2912 if (!i_qgroups[0] || !i_qgroups[1]) 2913 continue; 2914 2915 src = find_qgroup_rb(fs_info, i_qgroups[0]); 2916 dst = find_qgroup_rb(fs_info, i_qgroups[1]); 2917 2918 if (!src || !dst) { 2919 ret = -EINVAL; 2920 goto unlock; 2921 } 2922 2923 dst->excl = src->excl + level_size; 2924 dst->excl_cmpr = src->excl_cmpr + level_size; 2925 need_rescan = true; 2926 } 2927 2928 unlock: 2929 spin_unlock(&fs_info->qgroup_lock); 2930 if (!ret) 2931 ret = btrfs_sysfs_add_one_qgroup(fs_info, dstgroup); 2932 out: 2933 if (!committing) 2934 mutex_unlock(&fs_info->qgroup_ioctl_lock); 2935 if (need_rescan) 2936 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2937 return ret; 2938 } 2939 2940 static bool qgroup_check_limits(const struct btrfs_qgroup *qg, u64 num_bytes) 2941 { 2942 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_RFER) && 2943 qgroup_rsv_total(qg) + (s64)qg->rfer + num_bytes > qg->max_rfer) 2944 return false; 2945 2946 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) && 2947 qgroup_rsv_total(qg) + (s64)qg->excl + num_bytes > qg->max_excl) 2948 return false; 2949 2950 return true; 2951 } 2952 2953 static int qgroup_reserve(struct btrfs_root *root, u64 num_bytes, bool enforce, 2954 enum btrfs_qgroup_rsv_type type) 2955 { 2956 struct btrfs_qgroup *qgroup; 2957 struct btrfs_fs_info *fs_info = root->fs_info; 2958 u64 ref_root = root->root_key.objectid; 2959 int ret = 0; 2960 struct ulist_node *unode; 2961 struct ulist_iterator uiter; 2962 2963 if (!is_fstree(ref_root)) 2964 return 0; 2965 2966 if (num_bytes == 0) 2967 return 0; 2968 2969 if (test_bit(BTRFS_FS_QUOTA_OVERRIDE, &fs_info->flags) && 2970 capable(CAP_SYS_RESOURCE)) 2971 enforce = false; 2972 2973 spin_lock(&fs_info->qgroup_lock); 2974 if (!fs_info->quota_root) 2975 goto out; 2976 2977 qgroup = find_qgroup_rb(fs_info, ref_root); 2978 if (!qgroup) 2979 goto out; 2980 2981 /* 2982 * in a first step, we check all affected qgroups if any limits would 2983 * be exceeded 2984 */ 2985 ulist_reinit(fs_info->qgroup_ulist); 2986 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid, 2987 qgroup_to_aux(qgroup), GFP_ATOMIC); 2988 if (ret < 0) 2989 goto out; 2990 ULIST_ITER_INIT(&uiter); 2991 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) { 2992 struct btrfs_qgroup *qg; 2993 struct btrfs_qgroup_list *glist; 2994 2995 qg = unode_aux_to_qgroup(unode); 2996 2997 if (enforce && !qgroup_check_limits(qg, num_bytes)) { 2998 ret = -EDQUOT; 2999 goto out; 3000 } 3001 3002 list_for_each_entry(glist, &qg->groups, next_group) { 3003 ret = ulist_add(fs_info->qgroup_ulist, 3004 glist->group->qgroupid, 3005 qgroup_to_aux(glist->group), GFP_ATOMIC); 3006 if (ret < 0) 3007 goto out; 3008 } 3009 } 3010 ret = 0; 3011 /* 3012 * no limits exceeded, now record the reservation into all qgroups 3013 */ 3014 ULIST_ITER_INIT(&uiter); 3015 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) { 3016 struct btrfs_qgroup *qg; 3017 3018 qg = unode_aux_to_qgroup(unode); 3019 3020 qgroup_rsv_add(fs_info, qg, num_bytes, type); 3021 } 3022 3023 out: 3024 spin_unlock(&fs_info->qgroup_lock); 3025 return ret; 3026 } 3027 3028 /* 3029 * Free @num_bytes of reserved space with @type for qgroup. (Normally level 0 3030 * qgroup). 3031 * 3032 * Will handle all higher level qgroup too. 3033 * 3034 * NOTE: If @num_bytes is (u64)-1, this means to free all bytes of this qgroup. 3035 * This special case is only used for META_PERTRANS type. 3036 */ 3037 void btrfs_qgroup_free_refroot(struct btrfs_fs_info *fs_info, 3038 u64 ref_root, u64 num_bytes, 3039 enum btrfs_qgroup_rsv_type type) 3040 { 3041 struct btrfs_qgroup *qgroup; 3042 struct ulist_node *unode; 3043 struct ulist_iterator uiter; 3044 int ret = 0; 3045 3046 if (!is_fstree(ref_root)) 3047 return; 3048 3049 if (num_bytes == 0) 3050 return; 3051 3052 if (num_bytes == (u64)-1 && type != BTRFS_QGROUP_RSV_META_PERTRANS) { 3053 WARN(1, "%s: Invalid type to free", __func__); 3054 return; 3055 } 3056 spin_lock(&fs_info->qgroup_lock); 3057 3058 if (!fs_info->quota_root) 3059 goto out; 3060 3061 qgroup = find_qgroup_rb(fs_info, ref_root); 3062 if (!qgroup) 3063 goto out; 3064 3065 if (num_bytes == (u64)-1) 3066 /* 3067 * We're freeing all pertrans rsv, get reserved value from 3068 * level 0 qgroup as real num_bytes to free. 3069 */ 3070 num_bytes = qgroup->rsv.values[type]; 3071 3072 ulist_reinit(fs_info->qgroup_ulist); 3073 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid, 3074 qgroup_to_aux(qgroup), GFP_ATOMIC); 3075 if (ret < 0) 3076 goto out; 3077 ULIST_ITER_INIT(&uiter); 3078 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) { 3079 struct btrfs_qgroup *qg; 3080 struct btrfs_qgroup_list *glist; 3081 3082 qg = unode_aux_to_qgroup(unode); 3083 3084 qgroup_rsv_release(fs_info, qg, num_bytes, type); 3085 3086 list_for_each_entry(glist, &qg->groups, next_group) { 3087 ret = ulist_add(fs_info->qgroup_ulist, 3088 glist->group->qgroupid, 3089 qgroup_to_aux(glist->group), GFP_ATOMIC); 3090 if (ret < 0) 3091 goto out; 3092 } 3093 } 3094 3095 out: 3096 spin_unlock(&fs_info->qgroup_lock); 3097 } 3098 3099 /* 3100 * Check if the leaf is the last leaf. Which means all node pointers 3101 * are at their last position. 3102 */ 3103 static bool is_last_leaf(struct btrfs_path *path) 3104 { 3105 int i; 3106 3107 for (i = 1; i < BTRFS_MAX_LEVEL && path->nodes[i]; i++) { 3108 if (path->slots[i] != btrfs_header_nritems(path->nodes[i]) - 1) 3109 return false; 3110 } 3111 return true; 3112 } 3113 3114 /* 3115 * returns < 0 on error, 0 when more leafs are to be scanned. 3116 * returns 1 when done. 3117 */ 3118 static int qgroup_rescan_leaf(struct btrfs_trans_handle *trans, 3119 struct btrfs_path *path) 3120 { 3121 struct btrfs_fs_info *fs_info = trans->fs_info; 3122 struct btrfs_key found; 3123 struct extent_buffer *scratch_leaf = NULL; 3124 struct ulist *roots = NULL; 3125 u64 num_bytes; 3126 bool done; 3127 int slot; 3128 int ret; 3129 3130 mutex_lock(&fs_info->qgroup_rescan_lock); 3131 ret = btrfs_search_slot_for_read(fs_info->extent_root, 3132 &fs_info->qgroup_rescan_progress, 3133 path, 1, 0); 3134 3135 btrfs_debug(fs_info, 3136 "current progress key (%llu %u %llu), search_slot ret %d", 3137 fs_info->qgroup_rescan_progress.objectid, 3138 fs_info->qgroup_rescan_progress.type, 3139 fs_info->qgroup_rescan_progress.offset, ret); 3140 3141 if (ret) { 3142 /* 3143 * The rescan is about to end, we will not be scanning any 3144 * further blocks. We cannot unset the RESCAN flag here, because 3145 * we want to commit the transaction if everything went well. 3146 * To make the live accounting work in this phase, we set our 3147 * scan progress pointer such that every real extent objectid 3148 * will be smaller. 3149 */ 3150 fs_info->qgroup_rescan_progress.objectid = (u64)-1; 3151 btrfs_release_path(path); 3152 mutex_unlock(&fs_info->qgroup_rescan_lock); 3153 return ret; 3154 } 3155 done = is_last_leaf(path); 3156 3157 btrfs_item_key_to_cpu(path->nodes[0], &found, 3158 btrfs_header_nritems(path->nodes[0]) - 1); 3159 fs_info->qgroup_rescan_progress.objectid = found.objectid + 1; 3160 3161 scratch_leaf = btrfs_clone_extent_buffer(path->nodes[0]); 3162 if (!scratch_leaf) { 3163 ret = -ENOMEM; 3164 mutex_unlock(&fs_info->qgroup_rescan_lock); 3165 goto out; 3166 } 3167 slot = path->slots[0]; 3168 btrfs_release_path(path); 3169 mutex_unlock(&fs_info->qgroup_rescan_lock); 3170 3171 for (; slot < btrfs_header_nritems(scratch_leaf); ++slot) { 3172 btrfs_item_key_to_cpu(scratch_leaf, &found, slot); 3173 if (found.type != BTRFS_EXTENT_ITEM_KEY && 3174 found.type != BTRFS_METADATA_ITEM_KEY) 3175 continue; 3176 if (found.type == BTRFS_METADATA_ITEM_KEY) 3177 num_bytes = fs_info->nodesize; 3178 else 3179 num_bytes = found.offset; 3180 3181 ret = btrfs_find_all_roots(NULL, fs_info, found.objectid, 0, 3182 &roots, false); 3183 if (ret < 0) 3184 goto out; 3185 /* For rescan, just pass old_roots as NULL */ 3186 ret = btrfs_qgroup_account_extent(trans, found.objectid, 3187 num_bytes, NULL, roots); 3188 if (ret < 0) 3189 goto out; 3190 } 3191 out: 3192 if (scratch_leaf) 3193 free_extent_buffer(scratch_leaf); 3194 3195 if (done && !ret) { 3196 ret = 1; 3197 fs_info->qgroup_rescan_progress.objectid = (u64)-1; 3198 } 3199 return ret; 3200 } 3201 3202 static bool rescan_should_stop(struct btrfs_fs_info *fs_info) 3203 { 3204 return btrfs_fs_closing(fs_info) || 3205 test_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state); 3206 } 3207 3208 static void btrfs_qgroup_rescan_worker(struct btrfs_work *work) 3209 { 3210 struct btrfs_fs_info *fs_info = container_of(work, struct btrfs_fs_info, 3211 qgroup_rescan_work); 3212 struct btrfs_path *path; 3213 struct btrfs_trans_handle *trans = NULL; 3214 int err = -ENOMEM; 3215 int ret = 0; 3216 bool stopped = false; 3217 3218 path = btrfs_alloc_path(); 3219 if (!path) 3220 goto out; 3221 /* 3222 * Rescan should only search for commit root, and any later difference 3223 * should be recorded by qgroup 3224 */ 3225 path->search_commit_root = 1; 3226 path->skip_locking = 1; 3227 3228 err = 0; 3229 while (!err && !(stopped = rescan_should_stop(fs_info))) { 3230 trans = btrfs_start_transaction(fs_info->fs_root, 0); 3231 if (IS_ERR(trans)) { 3232 err = PTR_ERR(trans); 3233 break; 3234 } 3235 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) { 3236 err = -EINTR; 3237 } else { 3238 err = qgroup_rescan_leaf(trans, path); 3239 } 3240 if (err > 0) 3241 btrfs_commit_transaction(trans); 3242 else 3243 btrfs_end_transaction(trans); 3244 } 3245 3246 out: 3247 btrfs_free_path(path); 3248 3249 mutex_lock(&fs_info->qgroup_rescan_lock); 3250 if (err > 0 && 3251 fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) { 3252 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 3253 } else if (err < 0) { 3254 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 3255 } 3256 mutex_unlock(&fs_info->qgroup_rescan_lock); 3257 3258 /* 3259 * only update status, since the previous part has already updated the 3260 * qgroup info. 3261 */ 3262 trans = btrfs_start_transaction(fs_info->quota_root, 1); 3263 if (IS_ERR(trans)) { 3264 err = PTR_ERR(trans); 3265 trans = NULL; 3266 btrfs_err(fs_info, 3267 "fail to start transaction for status update: %d", 3268 err); 3269 } 3270 3271 mutex_lock(&fs_info->qgroup_rescan_lock); 3272 if (!stopped) 3273 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 3274 if (trans) { 3275 ret = update_qgroup_status_item(trans); 3276 if (ret < 0) { 3277 err = ret; 3278 btrfs_err(fs_info, "fail to update qgroup status: %d", 3279 err); 3280 } 3281 } 3282 fs_info->qgroup_rescan_running = false; 3283 complete_all(&fs_info->qgroup_rescan_completion); 3284 mutex_unlock(&fs_info->qgroup_rescan_lock); 3285 3286 if (!trans) 3287 return; 3288 3289 btrfs_end_transaction(trans); 3290 3291 if (stopped) { 3292 btrfs_info(fs_info, "qgroup scan paused"); 3293 } else if (err >= 0) { 3294 btrfs_info(fs_info, "qgroup scan completed%s", 3295 err > 0 ? " (inconsistency flag cleared)" : ""); 3296 } else { 3297 btrfs_err(fs_info, "qgroup scan failed with %d", err); 3298 } 3299 } 3300 3301 /* 3302 * Checks that (a) no rescan is running and (b) quota is enabled. Allocates all 3303 * memory required for the rescan context. 3304 */ 3305 static int 3306 qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid, 3307 int init_flags) 3308 { 3309 int ret = 0; 3310 3311 if (!init_flags) { 3312 /* we're resuming qgroup rescan at mount time */ 3313 if (!(fs_info->qgroup_flags & 3314 BTRFS_QGROUP_STATUS_FLAG_RESCAN)) { 3315 btrfs_warn(fs_info, 3316 "qgroup rescan init failed, qgroup rescan is not queued"); 3317 ret = -EINVAL; 3318 } else if (!(fs_info->qgroup_flags & 3319 BTRFS_QGROUP_STATUS_FLAG_ON)) { 3320 btrfs_warn(fs_info, 3321 "qgroup rescan init failed, qgroup is not enabled"); 3322 ret = -EINVAL; 3323 } 3324 3325 if (ret) 3326 return ret; 3327 } 3328 3329 mutex_lock(&fs_info->qgroup_rescan_lock); 3330 3331 if (init_flags) { 3332 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) { 3333 btrfs_warn(fs_info, 3334 "qgroup rescan is already in progress"); 3335 ret = -EINPROGRESS; 3336 } else if (!(fs_info->qgroup_flags & 3337 BTRFS_QGROUP_STATUS_FLAG_ON)) { 3338 btrfs_warn(fs_info, 3339 "qgroup rescan init failed, qgroup is not enabled"); 3340 ret = -EINVAL; 3341 } 3342 3343 if (ret) { 3344 mutex_unlock(&fs_info->qgroup_rescan_lock); 3345 return ret; 3346 } 3347 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN; 3348 } 3349 3350 memset(&fs_info->qgroup_rescan_progress, 0, 3351 sizeof(fs_info->qgroup_rescan_progress)); 3352 fs_info->qgroup_rescan_progress.objectid = progress_objectid; 3353 init_completion(&fs_info->qgroup_rescan_completion); 3354 mutex_unlock(&fs_info->qgroup_rescan_lock); 3355 3356 btrfs_init_work(&fs_info->qgroup_rescan_work, 3357 btrfs_qgroup_rescan_worker, NULL, NULL); 3358 return 0; 3359 } 3360 3361 static void 3362 qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info) 3363 { 3364 struct rb_node *n; 3365 struct btrfs_qgroup *qgroup; 3366 3367 spin_lock(&fs_info->qgroup_lock); 3368 /* clear all current qgroup tracking information */ 3369 for (n = rb_first(&fs_info->qgroup_tree); n; n = rb_next(n)) { 3370 qgroup = rb_entry(n, struct btrfs_qgroup, node); 3371 qgroup->rfer = 0; 3372 qgroup->rfer_cmpr = 0; 3373 qgroup->excl = 0; 3374 qgroup->excl_cmpr = 0; 3375 qgroup_dirty(fs_info, qgroup); 3376 } 3377 spin_unlock(&fs_info->qgroup_lock); 3378 } 3379 3380 int 3381 btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info) 3382 { 3383 int ret = 0; 3384 struct btrfs_trans_handle *trans; 3385 3386 ret = qgroup_rescan_init(fs_info, 0, 1); 3387 if (ret) 3388 return ret; 3389 3390 /* 3391 * We have set the rescan_progress to 0, which means no more 3392 * delayed refs will be accounted by btrfs_qgroup_account_ref. 3393 * However, btrfs_qgroup_account_ref may be right after its call 3394 * to btrfs_find_all_roots, in which case it would still do the 3395 * accounting. 3396 * To solve this, we're committing the transaction, which will 3397 * ensure we run all delayed refs and only after that, we are 3398 * going to clear all tracking information for a clean start. 3399 */ 3400 3401 trans = btrfs_join_transaction(fs_info->fs_root); 3402 if (IS_ERR(trans)) { 3403 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 3404 return PTR_ERR(trans); 3405 } 3406 ret = btrfs_commit_transaction(trans); 3407 if (ret) { 3408 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 3409 return ret; 3410 } 3411 3412 qgroup_rescan_zero_tracking(fs_info); 3413 3414 mutex_lock(&fs_info->qgroup_rescan_lock); 3415 fs_info->qgroup_rescan_running = true; 3416 btrfs_queue_work(fs_info->qgroup_rescan_workers, 3417 &fs_info->qgroup_rescan_work); 3418 mutex_unlock(&fs_info->qgroup_rescan_lock); 3419 3420 return 0; 3421 } 3422 3423 int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info, 3424 bool interruptible) 3425 { 3426 int running; 3427 int ret = 0; 3428 3429 mutex_lock(&fs_info->qgroup_rescan_lock); 3430 running = fs_info->qgroup_rescan_running; 3431 mutex_unlock(&fs_info->qgroup_rescan_lock); 3432 3433 if (!running) 3434 return 0; 3435 3436 if (interruptible) 3437 ret = wait_for_completion_interruptible( 3438 &fs_info->qgroup_rescan_completion); 3439 else 3440 wait_for_completion(&fs_info->qgroup_rescan_completion); 3441 3442 return ret; 3443 } 3444 3445 /* 3446 * this is only called from open_ctree where we're still single threaded, thus 3447 * locking is omitted here. 3448 */ 3449 void 3450 btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info) 3451 { 3452 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) { 3453 mutex_lock(&fs_info->qgroup_rescan_lock); 3454 fs_info->qgroup_rescan_running = true; 3455 btrfs_queue_work(fs_info->qgroup_rescan_workers, 3456 &fs_info->qgroup_rescan_work); 3457 mutex_unlock(&fs_info->qgroup_rescan_lock); 3458 } 3459 } 3460 3461 #define rbtree_iterate_from_safe(node, next, start) \ 3462 for (node = start; node && ({ next = rb_next(node); 1;}); node = next) 3463 3464 static int qgroup_unreserve_range(struct btrfs_inode *inode, 3465 struct extent_changeset *reserved, u64 start, 3466 u64 len) 3467 { 3468 struct rb_node *node; 3469 struct rb_node *next; 3470 struct ulist_node *entry; 3471 int ret = 0; 3472 3473 node = reserved->range_changed.root.rb_node; 3474 if (!node) 3475 return 0; 3476 while (node) { 3477 entry = rb_entry(node, struct ulist_node, rb_node); 3478 if (entry->val < start) 3479 node = node->rb_right; 3480 else 3481 node = node->rb_left; 3482 } 3483 3484 if (entry->val > start && rb_prev(&entry->rb_node)) 3485 entry = rb_entry(rb_prev(&entry->rb_node), struct ulist_node, 3486 rb_node); 3487 3488 rbtree_iterate_from_safe(node, next, &entry->rb_node) { 3489 u64 entry_start; 3490 u64 entry_end; 3491 u64 entry_len; 3492 int clear_ret; 3493 3494 entry = rb_entry(node, struct ulist_node, rb_node); 3495 entry_start = entry->val; 3496 entry_end = entry->aux; 3497 entry_len = entry_end - entry_start + 1; 3498 3499 if (entry_start >= start + len) 3500 break; 3501 if (entry_start + entry_len <= start) 3502 continue; 3503 /* 3504 * Now the entry is in [start, start + len), revert the 3505 * EXTENT_QGROUP_RESERVED bit. 3506 */ 3507 clear_ret = clear_extent_bits(&inode->io_tree, entry_start, 3508 entry_end, EXTENT_QGROUP_RESERVED); 3509 if (!ret && clear_ret < 0) 3510 ret = clear_ret; 3511 3512 ulist_del(&reserved->range_changed, entry->val, entry->aux); 3513 if (likely(reserved->bytes_changed >= entry_len)) { 3514 reserved->bytes_changed -= entry_len; 3515 } else { 3516 WARN_ON(1); 3517 reserved->bytes_changed = 0; 3518 } 3519 } 3520 3521 return ret; 3522 } 3523 3524 /* 3525 * Try to free some space for qgroup. 3526 * 3527 * For qgroup, there are only 3 ways to free qgroup space: 3528 * - Flush nodatacow write 3529 * Any nodatacow write will free its reserved data space at run_delalloc_range(). 3530 * In theory, we should only flush nodatacow inodes, but it's not yet 3531 * possible, so we need to flush the whole root. 3532 * 3533 * - Wait for ordered extents 3534 * When ordered extents are finished, their reserved metadata is finally 3535 * converted to per_trans status, which can be freed by later commit 3536 * transaction. 3537 * 3538 * - Commit transaction 3539 * This would free the meta_per_trans space. 3540 * In theory this shouldn't provide much space, but any more qgroup space 3541 * is needed. 3542 */ 3543 static int try_flush_qgroup(struct btrfs_root *root) 3544 { 3545 struct btrfs_trans_handle *trans; 3546 int ret; 3547 3548 /* Can't hold an open transaction or we run the risk of deadlocking. */ 3549 ASSERT(current->journal_info == NULL); 3550 if (WARN_ON(current->journal_info)) 3551 return 0; 3552 3553 /* 3554 * We don't want to run flush again and again, so if there is a running 3555 * one, we won't try to start a new flush, but exit directly. 3556 */ 3557 if (test_and_set_bit(BTRFS_ROOT_QGROUP_FLUSHING, &root->state)) { 3558 wait_event(root->qgroup_flush_wait, 3559 !test_bit(BTRFS_ROOT_QGROUP_FLUSHING, &root->state)); 3560 return 0; 3561 } 3562 3563 ret = btrfs_start_delalloc_snapshot(root, true); 3564 if (ret < 0) 3565 goto out; 3566 btrfs_wait_ordered_extents(root, U64_MAX, 0, (u64)-1); 3567 3568 trans = btrfs_join_transaction(root); 3569 if (IS_ERR(trans)) { 3570 ret = PTR_ERR(trans); 3571 goto out; 3572 } 3573 3574 ret = btrfs_commit_transaction(trans); 3575 out: 3576 clear_bit(BTRFS_ROOT_QGROUP_FLUSHING, &root->state); 3577 wake_up(&root->qgroup_flush_wait); 3578 return ret; 3579 } 3580 3581 static int qgroup_reserve_data(struct btrfs_inode *inode, 3582 struct extent_changeset **reserved_ret, u64 start, 3583 u64 len) 3584 { 3585 struct btrfs_root *root = inode->root; 3586 struct extent_changeset *reserved; 3587 bool new_reserved = false; 3588 u64 orig_reserved; 3589 u64 to_reserve; 3590 int ret; 3591 3592 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &root->fs_info->flags) || 3593 !is_fstree(root->root_key.objectid) || len == 0) 3594 return 0; 3595 3596 /* @reserved parameter is mandatory for qgroup */ 3597 if (WARN_ON(!reserved_ret)) 3598 return -EINVAL; 3599 if (!*reserved_ret) { 3600 new_reserved = true; 3601 *reserved_ret = extent_changeset_alloc(); 3602 if (!*reserved_ret) 3603 return -ENOMEM; 3604 } 3605 reserved = *reserved_ret; 3606 /* Record already reserved space */ 3607 orig_reserved = reserved->bytes_changed; 3608 ret = set_record_extent_bits(&inode->io_tree, start, 3609 start + len -1, EXTENT_QGROUP_RESERVED, reserved); 3610 3611 /* Newly reserved space */ 3612 to_reserve = reserved->bytes_changed - orig_reserved; 3613 trace_btrfs_qgroup_reserve_data(&inode->vfs_inode, start, len, 3614 to_reserve, QGROUP_RESERVE); 3615 if (ret < 0) 3616 goto out; 3617 ret = qgroup_reserve(root, to_reserve, true, BTRFS_QGROUP_RSV_DATA); 3618 if (ret < 0) 3619 goto cleanup; 3620 3621 return ret; 3622 3623 cleanup: 3624 qgroup_unreserve_range(inode, reserved, start, len); 3625 out: 3626 if (new_reserved) { 3627 extent_changeset_free(reserved); 3628 *reserved_ret = NULL; 3629 } 3630 return ret; 3631 } 3632 3633 /* 3634 * Reserve qgroup space for range [start, start + len). 3635 * 3636 * This function will either reserve space from related qgroups or do nothing 3637 * if the range is already reserved. 3638 * 3639 * Return 0 for successful reservation 3640 * Return <0 for error (including -EQUOT) 3641 * 3642 * NOTE: This function may sleep for memory allocation, dirty page flushing and 3643 * commit transaction. So caller should not hold any dirty page locked. 3644 */ 3645 int btrfs_qgroup_reserve_data(struct btrfs_inode *inode, 3646 struct extent_changeset **reserved_ret, u64 start, 3647 u64 len) 3648 { 3649 int ret; 3650 3651 ret = qgroup_reserve_data(inode, reserved_ret, start, len); 3652 if (ret <= 0 && ret != -EDQUOT) 3653 return ret; 3654 3655 ret = try_flush_qgroup(inode->root); 3656 if (ret < 0) 3657 return ret; 3658 return qgroup_reserve_data(inode, reserved_ret, start, len); 3659 } 3660 3661 /* Free ranges specified by @reserved, normally in error path */ 3662 static int qgroup_free_reserved_data(struct btrfs_inode *inode, 3663 struct extent_changeset *reserved, u64 start, u64 len) 3664 { 3665 struct btrfs_root *root = inode->root; 3666 struct ulist_node *unode; 3667 struct ulist_iterator uiter; 3668 struct extent_changeset changeset; 3669 int freed = 0; 3670 int ret; 3671 3672 extent_changeset_init(&changeset); 3673 len = round_up(start + len, root->fs_info->sectorsize); 3674 start = round_down(start, root->fs_info->sectorsize); 3675 3676 ULIST_ITER_INIT(&uiter); 3677 while ((unode = ulist_next(&reserved->range_changed, &uiter))) { 3678 u64 range_start = unode->val; 3679 /* unode->aux is the inclusive end */ 3680 u64 range_len = unode->aux - range_start + 1; 3681 u64 free_start; 3682 u64 free_len; 3683 3684 extent_changeset_release(&changeset); 3685 3686 /* Only free range in range [start, start + len) */ 3687 if (range_start >= start + len || 3688 range_start + range_len <= start) 3689 continue; 3690 free_start = max(range_start, start); 3691 free_len = min(start + len, range_start + range_len) - 3692 free_start; 3693 /* 3694 * TODO: To also modify reserved->ranges_reserved to reflect 3695 * the modification. 3696 * 3697 * However as long as we free qgroup reserved according to 3698 * EXTENT_QGROUP_RESERVED, we won't double free. 3699 * So not need to rush. 3700 */ 3701 ret = clear_record_extent_bits(&inode->io_tree, free_start, 3702 free_start + free_len - 1, 3703 EXTENT_QGROUP_RESERVED, &changeset); 3704 if (ret < 0) 3705 goto out; 3706 freed += changeset.bytes_changed; 3707 } 3708 btrfs_qgroup_free_refroot(root->fs_info, root->root_key.objectid, freed, 3709 BTRFS_QGROUP_RSV_DATA); 3710 ret = freed; 3711 out: 3712 extent_changeset_release(&changeset); 3713 return ret; 3714 } 3715 3716 static int __btrfs_qgroup_release_data(struct btrfs_inode *inode, 3717 struct extent_changeset *reserved, u64 start, u64 len, 3718 int free) 3719 { 3720 struct extent_changeset changeset; 3721 int trace_op = QGROUP_RELEASE; 3722 int ret; 3723 3724 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &inode->root->fs_info->flags)) 3725 return 0; 3726 3727 /* In release case, we shouldn't have @reserved */ 3728 WARN_ON(!free && reserved); 3729 if (free && reserved) 3730 return qgroup_free_reserved_data(inode, reserved, start, len); 3731 extent_changeset_init(&changeset); 3732 ret = clear_record_extent_bits(&inode->io_tree, start, start + len -1, 3733 EXTENT_QGROUP_RESERVED, &changeset); 3734 if (ret < 0) 3735 goto out; 3736 3737 if (free) 3738 trace_op = QGROUP_FREE; 3739 trace_btrfs_qgroup_release_data(&inode->vfs_inode, start, len, 3740 changeset.bytes_changed, trace_op); 3741 if (free) 3742 btrfs_qgroup_free_refroot(inode->root->fs_info, 3743 inode->root->root_key.objectid, 3744 changeset.bytes_changed, BTRFS_QGROUP_RSV_DATA); 3745 ret = changeset.bytes_changed; 3746 out: 3747 extent_changeset_release(&changeset); 3748 return ret; 3749 } 3750 3751 /* 3752 * Free a reserved space range from io_tree and related qgroups 3753 * 3754 * Should be called when a range of pages get invalidated before reaching disk. 3755 * Or for error cleanup case. 3756 * if @reserved is given, only reserved range in [@start, @start + @len) will 3757 * be freed. 3758 * 3759 * For data written to disk, use btrfs_qgroup_release_data(). 3760 * 3761 * NOTE: This function may sleep for memory allocation. 3762 */ 3763 int btrfs_qgroup_free_data(struct btrfs_inode *inode, 3764 struct extent_changeset *reserved, u64 start, u64 len) 3765 { 3766 return __btrfs_qgroup_release_data(inode, reserved, start, len, 1); 3767 } 3768 3769 /* 3770 * Release a reserved space range from io_tree only. 3771 * 3772 * Should be called when a range of pages get written to disk and corresponding 3773 * FILE_EXTENT is inserted into corresponding root. 3774 * 3775 * Since new qgroup accounting framework will only update qgroup numbers at 3776 * commit_transaction() time, its reserved space shouldn't be freed from 3777 * related qgroups. 3778 * 3779 * But we should release the range from io_tree, to allow further write to be 3780 * COWed. 3781 * 3782 * NOTE: This function may sleep for memory allocation. 3783 */ 3784 int btrfs_qgroup_release_data(struct btrfs_inode *inode, u64 start, u64 len) 3785 { 3786 return __btrfs_qgroup_release_data(inode, NULL, start, len, 0); 3787 } 3788 3789 static void add_root_meta_rsv(struct btrfs_root *root, int num_bytes, 3790 enum btrfs_qgroup_rsv_type type) 3791 { 3792 if (type != BTRFS_QGROUP_RSV_META_PREALLOC && 3793 type != BTRFS_QGROUP_RSV_META_PERTRANS) 3794 return; 3795 if (num_bytes == 0) 3796 return; 3797 3798 spin_lock(&root->qgroup_meta_rsv_lock); 3799 if (type == BTRFS_QGROUP_RSV_META_PREALLOC) 3800 root->qgroup_meta_rsv_prealloc += num_bytes; 3801 else 3802 root->qgroup_meta_rsv_pertrans += num_bytes; 3803 spin_unlock(&root->qgroup_meta_rsv_lock); 3804 } 3805 3806 static int sub_root_meta_rsv(struct btrfs_root *root, int num_bytes, 3807 enum btrfs_qgroup_rsv_type type) 3808 { 3809 if (type != BTRFS_QGROUP_RSV_META_PREALLOC && 3810 type != BTRFS_QGROUP_RSV_META_PERTRANS) 3811 return 0; 3812 if (num_bytes == 0) 3813 return 0; 3814 3815 spin_lock(&root->qgroup_meta_rsv_lock); 3816 if (type == BTRFS_QGROUP_RSV_META_PREALLOC) { 3817 num_bytes = min_t(u64, root->qgroup_meta_rsv_prealloc, 3818 num_bytes); 3819 root->qgroup_meta_rsv_prealloc -= num_bytes; 3820 } else { 3821 num_bytes = min_t(u64, root->qgroup_meta_rsv_pertrans, 3822 num_bytes); 3823 root->qgroup_meta_rsv_pertrans -= num_bytes; 3824 } 3825 spin_unlock(&root->qgroup_meta_rsv_lock); 3826 return num_bytes; 3827 } 3828 3829 int btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes, 3830 enum btrfs_qgroup_rsv_type type, bool enforce) 3831 { 3832 struct btrfs_fs_info *fs_info = root->fs_info; 3833 int ret; 3834 3835 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) || 3836 !is_fstree(root->root_key.objectid) || num_bytes == 0) 3837 return 0; 3838 3839 BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize)); 3840 trace_qgroup_meta_reserve(root, (s64)num_bytes, type); 3841 ret = qgroup_reserve(root, num_bytes, enforce, type); 3842 if (ret < 0) 3843 return ret; 3844 /* 3845 * Record what we have reserved into root. 3846 * 3847 * To avoid quota disabled->enabled underflow. 3848 * In that case, we may try to free space we haven't reserved 3849 * (since quota was disabled), so record what we reserved into root. 3850 * And ensure later release won't underflow this number. 3851 */ 3852 add_root_meta_rsv(root, num_bytes, type); 3853 return ret; 3854 } 3855 3856 int __btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes, 3857 enum btrfs_qgroup_rsv_type type, bool enforce) 3858 { 3859 int ret; 3860 3861 ret = btrfs_qgroup_reserve_meta(root, num_bytes, type, enforce); 3862 if (ret <= 0 && ret != -EDQUOT) 3863 return ret; 3864 3865 ret = try_flush_qgroup(root); 3866 if (ret < 0) 3867 return ret; 3868 return btrfs_qgroup_reserve_meta(root, num_bytes, type, enforce); 3869 } 3870 3871 void btrfs_qgroup_free_meta_all_pertrans(struct btrfs_root *root) 3872 { 3873 struct btrfs_fs_info *fs_info = root->fs_info; 3874 3875 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) || 3876 !is_fstree(root->root_key.objectid)) 3877 return; 3878 3879 /* TODO: Update trace point to handle such free */ 3880 trace_qgroup_meta_free_all_pertrans(root); 3881 /* Special value -1 means to free all reserved space */ 3882 btrfs_qgroup_free_refroot(fs_info, root->root_key.objectid, (u64)-1, 3883 BTRFS_QGROUP_RSV_META_PERTRANS); 3884 } 3885 3886 void __btrfs_qgroup_free_meta(struct btrfs_root *root, int num_bytes, 3887 enum btrfs_qgroup_rsv_type type) 3888 { 3889 struct btrfs_fs_info *fs_info = root->fs_info; 3890 3891 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) || 3892 !is_fstree(root->root_key.objectid)) 3893 return; 3894 3895 /* 3896 * reservation for META_PREALLOC can happen before quota is enabled, 3897 * which can lead to underflow. 3898 * Here ensure we will only free what we really have reserved. 3899 */ 3900 num_bytes = sub_root_meta_rsv(root, num_bytes, type); 3901 BUG_ON(num_bytes != round_down(num_bytes, fs_info->nodesize)); 3902 trace_qgroup_meta_reserve(root, -(s64)num_bytes, type); 3903 btrfs_qgroup_free_refroot(fs_info, root->root_key.objectid, 3904 num_bytes, type); 3905 } 3906 3907 static void qgroup_convert_meta(struct btrfs_fs_info *fs_info, u64 ref_root, 3908 int num_bytes) 3909 { 3910 struct btrfs_qgroup *qgroup; 3911 struct ulist_node *unode; 3912 struct ulist_iterator uiter; 3913 int ret = 0; 3914 3915 if (num_bytes == 0) 3916 return; 3917 if (!fs_info->quota_root) 3918 return; 3919 3920 spin_lock(&fs_info->qgroup_lock); 3921 qgroup = find_qgroup_rb(fs_info, ref_root); 3922 if (!qgroup) 3923 goto out; 3924 ulist_reinit(fs_info->qgroup_ulist); 3925 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid, 3926 qgroup_to_aux(qgroup), GFP_ATOMIC); 3927 if (ret < 0) 3928 goto out; 3929 ULIST_ITER_INIT(&uiter); 3930 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) { 3931 struct btrfs_qgroup *qg; 3932 struct btrfs_qgroup_list *glist; 3933 3934 qg = unode_aux_to_qgroup(unode); 3935 3936 qgroup_rsv_release(fs_info, qg, num_bytes, 3937 BTRFS_QGROUP_RSV_META_PREALLOC); 3938 qgroup_rsv_add(fs_info, qg, num_bytes, 3939 BTRFS_QGROUP_RSV_META_PERTRANS); 3940 list_for_each_entry(glist, &qg->groups, next_group) { 3941 ret = ulist_add(fs_info->qgroup_ulist, 3942 glist->group->qgroupid, 3943 qgroup_to_aux(glist->group), GFP_ATOMIC); 3944 if (ret < 0) 3945 goto out; 3946 } 3947 } 3948 out: 3949 spin_unlock(&fs_info->qgroup_lock); 3950 } 3951 3952 void btrfs_qgroup_convert_reserved_meta(struct btrfs_root *root, int num_bytes) 3953 { 3954 struct btrfs_fs_info *fs_info = root->fs_info; 3955 3956 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) || 3957 !is_fstree(root->root_key.objectid)) 3958 return; 3959 /* Same as btrfs_qgroup_free_meta_prealloc() */ 3960 num_bytes = sub_root_meta_rsv(root, num_bytes, 3961 BTRFS_QGROUP_RSV_META_PREALLOC); 3962 trace_qgroup_meta_convert(root, num_bytes); 3963 qgroup_convert_meta(fs_info, root->root_key.objectid, num_bytes); 3964 } 3965 3966 /* 3967 * Check qgroup reserved space leaking, normally at destroy inode 3968 * time 3969 */ 3970 void btrfs_qgroup_check_reserved_leak(struct btrfs_inode *inode) 3971 { 3972 struct extent_changeset changeset; 3973 struct ulist_node *unode; 3974 struct ulist_iterator iter; 3975 int ret; 3976 3977 extent_changeset_init(&changeset); 3978 ret = clear_record_extent_bits(&inode->io_tree, 0, (u64)-1, 3979 EXTENT_QGROUP_RESERVED, &changeset); 3980 3981 WARN_ON(ret < 0); 3982 if (WARN_ON(changeset.bytes_changed)) { 3983 ULIST_ITER_INIT(&iter); 3984 while ((unode = ulist_next(&changeset.range_changed, &iter))) { 3985 btrfs_warn(inode->root->fs_info, 3986 "leaking qgroup reserved space, ino: %llu, start: %llu, end: %llu", 3987 btrfs_ino(inode), unode->val, unode->aux); 3988 } 3989 btrfs_qgroup_free_refroot(inode->root->fs_info, 3990 inode->root->root_key.objectid, 3991 changeset.bytes_changed, BTRFS_QGROUP_RSV_DATA); 3992 3993 } 3994 extent_changeset_release(&changeset); 3995 } 3996 3997 void btrfs_qgroup_init_swapped_blocks( 3998 struct btrfs_qgroup_swapped_blocks *swapped_blocks) 3999 { 4000 int i; 4001 4002 spin_lock_init(&swapped_blocks->lock); 4003 for (i = 0; i < BTRFS_MAX_LEVEL; i++) 4004 swapped_blocks->blocks[i] = RB_ROOT; 4005 swapped_blocks->swapped = false; 4006 } 4007 4008 /* 4009 * Delete all swapped blocks record of @root. 4010 * Every record here means we skipped a full subtree scan for qgroup. 4011 * 4012 * Gets called when committing one transaction. 4013 */ 4014 void btrfs_qgroup_clean_swapped_blocks(struct btrfs_root *root) 4015 { 4016 struct btrfs_qgroup_swapped_blocks *swapped_blocks; 4017 int i; 4018 4019 swapped_blocks = &root->swapped_blocks; 4020 4021 spin_lock(&swapped_blocks->lock); 4022 if (!swapped_blocks->swapped) 4023 goto out; 4024 for (i = 0; i < BTRFS_MAX_LEVEL; i++) { 4025 struct rb_root *cur_root = &swapped_blocks->blocks[i]; 4026 struct btrfs_qgroup_swapped_block *entry; 4027 struct btrfs_qgroup_swapped_block *next; 4028 4029 rbtree_postorder_for_each_entry_safe(entry, next, cur_root, 4030 node) 4031 kfree(entry); 4032 swapped_blocks->blocks[i] = RB_ROOT; 4033 } 4034 swapped_blocks->swapped = false; 4035 out: 4036 spin_unlock(&swapped_blocks->lock); 4037 } 4038 4039 /* 4040 * Add subtree roots record into @subvol_root. 4041 * 4042 * @subvol_root: tree root of the subvolume tree get swapped 4043 * @bg: block group under balance 4044 * @subvol_parent/slot: pointer to the subtree root in subvolume tree 4045 * @reloc_parent/slot: pointer to the subtree root in reloc tree 4046 * BOTH POINTERS ARE BEFORE TREE SWAP 4047 * @last_snapshot: last snapshot generation of the subvolume tree 4048 */ 4049 int btrfs_qgroup_add_swapped_blocks(struct btrfs_trans_handle *trans, 4050 struct btrfs_root *subvol_root, 4051 struct btrfs_block_group *bg, 4052 struct extent_buffer *subvol_parent, int subvol_slot, 4053 struct extent_buffer *reloc_parent, int reloc_slot, 4054 u64 last_snapshot) 4055 { 4056 struct btrfs_fs_info *fs_info = subvol_root->fs_info; 4057 struct btrfs_qgroup_swapped_blocks *blocks = &subvol_root->swapped_blocks; 4058 struct btrfs_qgroup_swapped_block *block; 4059 struct rb_node **cur; 4060 struct rb_node *parent = NULL; 4061 int level = btrfs_header_level(subvol_parent) - 1; 4062 int ret = 0; 4063 4064 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 4065 return 0; 4066 4067 if (btrfs_node_ptr_generation(subvol_parent, subvol_slot) > 4068 btrfs_node_ptr_generation(reloc_parent, reloc_slot)) { 4069 btrfs_err_rl(fs_info, 4070 "%s: bad parameter order, subvol_gen=%llu reloc_gen=%llu", 4071 __func__, 4072 btrfs_node_ptr_generation(subvol_parent, subvol_slot), 4073 btrfs_node_ptr_generation(reloc_parent, reloc_slot)); 4074 return -EUCLEAN; 4075 } 4076 4077 block = kmalloc(sizeof(*block), GFP_NOFS); 4078 if (!block) { 4079 ret = -ENOMEM; 4080 goto out; 4081 } 4082 4083 /* 4084 * @reloc_parent/slot is still before swap, while @block is going to 4085 * record the bytenr after swap, so we do the swap here. 4086 */ 4087 block->subvol_bytenr = btrfs_node_blockptr(reloc_parent, reloc_slot); 4088 block->subvol_generation = btrfs_node_ptr_generation(reloc_parent, 4089 reloc_slot); 4090 block->reloc_bytenr = btrfs_node_blockptr(subvol_parent, subvol_slot); 4091 block->reloc_generation = btrfs_node_ptr_generation(subvol_parent, 4092 subvol_slot); 4093 block->last_snapshot = last_snapshot; 4094 block->level = level; 4095 4096 /* 4097 * If we have bg == NULL, we're called from btrfs_recover_relocation(), 4098 * no one else can modify tree blocks thus we qgroup will not change 4099 * no matter the value of trace_leaf. 4100 */ 4101 if (bg && bg->flags & BTRFS_BLOCK_GROUP_DATA) 4102 block->trace_leaf = true; 4103 else 4104 block->trace_leaf = false; 4105 btrfs_node_key_to_cpu(reloc_parent, &block->first_key, reloc_slot); 4106 4107 /* Insert @block into @blocks */ 4108 spin_lock(&blocks->lock); 4109 cur = &blocks->blocks[level].rb_node; 4110 while (*cur) { 4111 struct btrfs_qgroup_swapped_block *entry; 4112 4113 parent = *cur; 4114 entry = rb_entry(parent, struct btrfs_qgroup_swapped_block, 4115 node); 4116 4117 if (entry->subvol_bytenr < block->subvol_bytenr) { 4118 cur = &(*cur)->rb_left; 4119 } else if (entry->subvol_bytenr > block->subvol_bytenr) { 4120 cur = &(*cur)->rb_right; 4121 } else { 4122 if (entry->subvol_generation != 4123 block->subvol_generation || 4124 entry->reloc_bytenr != block->reloc_bytenr || 4125 entry->reloc_generation != 4126 block->reloc_generation) { 4127 /* 4128 * Duplicated but mismatch entry found. 4129 * Shouldn't happen. 4130 * 4131 * Marking qgroup inconsistent should be enough 4132 * for end users. 4133 */ 4134 WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG)); 4135 ret = -EEXIST; 4136 } 4137 kfree(block); 4138 goto out_unlock; 4139 } 4140 } 4141 rb_link_node(&block->node, parent, cur); 4142 rb_insert_color(&block->node, &blocks->blocks[level]); 4143 blocks->swapped = true; 4144 out_unlock: 4145 spin_unlock(&blocks->lock); 4146 out: 4147 if (ret < 0) 4148 fs_info->qgroup_flags |= 4149 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 4150 return ret; 4151 } 4152 4153 /* 4154 * Check if the tree block is a subtree root, and if so do the needed 4155 * delayed subtree trace for qgroup. 4156 * 4157 * This is called during btrfs_cow_block(). 4158 */ 4159 int btrfs_qgroup_trace_subtree_after_cow(struct btrfs_trans_handle *trans, 4160 struct btrfs_root *root, 4161 struct extent_buffer *subvol_eb) 4162 { 4163 struct btrfs_fs_info *fs_info = root->fs_info; 4164 struct btrfs_qgroup_swapped_blocks *blocks = &root->swapped_blocks; 4165 struct btrfs_qgroup_swapped_block *block; 4166 struct extent_buffer *reloc_eb = NULL; 4167 struct rb_node *node; 4168 bool found = false; 4169 bool swapped = false; 4170 int level = btrfs_header_level(subvol_eb); 4171 int ret = 0; 4172 int i; 4173 4174 if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 4175 return 0; 4176 if (!is_fstree(root->root_key.objectid) || !root->reloc_root) 4177 return 0; 4178 4179 spin_lock(&blocks->lock); 4180 if (!blocks->swapped) { 4181 spin_unlock(&blocks->lock); 4182 return 0; 4183 } 4184 node = blocks->blocks[level].rb_node; 4185 4186 while (node) { 4187 block = rb_entry(node, struct btrfs_qgroup_swapped_block, node); 4188 if (block->subvol_bytenr < subvol_eb->start) { 4189 node = node->rb_left; 4190 } else if (block->subvol_bytenr > subvol_eb->start) { 4191 node = node->rb_right; 4192 } else { 4193 found = true; 4194 break; 4195 } 4196 } 4197 if (!found) { 4198 spin_unlock(&blocks->lock); 4199 goto out; 4200 } 4201 /* Found one, remove it from @blocks first and update blocks->swapped */ 4202 rb_erase(&block->node, &blocks->blocks[level]); 4203 for (i = 0; i < BTRFS_MAX_LEVEL; i++) { 4204 if (RB_EMPTY_ROOT(&blocks->blocks[i])) { 4205 swapped = true; 4206 break; 4207 } 4208 } 4209 blocks->swapped = swapped; 4210 spin_unlock(&blocks->lock); 4211 4212 /* Read out reloc subtree root */ 4213 reloc_eb = read_tree_block(fs_info, block->reloc_bytenr, 0, 4214 block->reloc_generation, block->level, 4215 &block->first_key); 4216 if (IS_ERR(reloc_eb)) { 4217 ret = PTR_ERR(reloc_eb); 4218 reloc_eb = NULL; 4219 goto free_out; 4220 } 4221 if (!extent_buffer_uptodate(reloc_eb)) { 4222 ret = -EIO; 4223 goto free_out; 4224 } 4225 4226 ret = qgroup_trace_subtree_swap(trans, reloc_eb, subvol_eb, 4227 block->last_snapshot, block->trace_leaf); 4228 free_out: 4229 kfree(block); 4230 free_extent_buffer(reloc_eb); 4231 out: 4232 if (ret < 0) { 4233 btrfs_err_rl(fs_info, 4234 "failed to account subtree at bytenr %llu: %d", 4235 subvol_eb->start, ret); 4236 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 4237 } 4238 return ret; 4239 } 4240 4241 void btrfs_qgroup_destroy_extent_records(struct btrfs_transaction *trans) 4242 { 4243 struct btrfs_qgroup_extent_record *entry; 4244 struct btrfs_qgroup_extent_record *next; 4245 struct rb_root *root; 4246 4247 root = &trans->delayed_refs.dirty_extent_root; 4248 rbtree_postorder_for_each_entry_safe(entry, next, root, node) { 4249 ulist_free(entry->old_roots); 4250 kfree(entry); 4251 } 4252 } 4253