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