1 /* 2 * Copyright (C) 2011 STRATO. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/sched.h> 20 #include <linux/pagemap.h> 21 #include <linux/writeback.h> 22 #include <linux/blkdev.h> 23 #include <linux/rbtree.h> 24 #include <linux/slab.h> 25 #include <linux/workqueue.h> 26 #include <linux/btrfs.h> 27 28 #include "ctree.h" 29 #include "transaction.h" 30 #include "disk-io.h" 31 #include "locking.h" 32 #include "ulist.h" 33 #include "backref.h" 34 #include "extent_io.h" 35 #include "qgroup.h" 36 37 38 /* TODO XXX FIXME 39 * - subvol delete -> delete when ref goes to 0? delete limits also? 40 * - reorganize keys 41 * - compressed 42 * - sync 43 * - copy also limits on subvol creation 44 * - limit 45 * - caches fuer ulists 46 * - performance benchmarks 47 * - check all ioctl parameters 48 */ 49 50 /* 51 * one struct for each qgroup, organized in fs_info->qgroup_tree. 52 */ 53 struct btrfs_qgroup { 54 u64 qgroupid; 55 56 /* 57 * state 58 */ 59 u64 rfer; /* referenced */ 60 u64 rfer_cmpr; /* referenced compressed */ 61 u64 excl; /* exclusive */ 62 u64 excl_cmpr; /* exclusive compressed */ 63 64 /* 65 * limits 66 */ 67 u64 lim_flags; /* which limits are set */ 68 u64 max_rfer; 69 u64 max_excl; 70 u64 rsv_rfer; 71 u64 rsv_excl; 72 73 /* 74 * reservation tracking 75 */ 76 u64 reserved; 77 78 /* 79 * lists 80 */ 81 struct list_head groups; /* groups this group is member of */ 82 struct list_head members; /* groups that are members of this group */ 83 struct list_head dirty; /* dirty groups */ 84 struct rb_node node; /* tree of qgroups */ 85 86 /* 87 * temp variables for accounting operations 88 * Refer to qgroup_shared_accounting() for details. 89 */ 90 u64 old_refcnt; 91 u64 new_refcnt; 92 }; 93 94 static void btrfs_qgroup_update_old_refcnt(struct btrfs_qgroup *qg, u64 seq, 95 int mod) 96 { 97 if (qg->old_refcnt < seq) 98 qg->old_refcnt = seq; 99 qg->old_refcnt += mod; 100 } 101 102 static void btrfs_qgroup_update_new_refcnt(struct btrfs_qgroup *qg, u64 seq, 103 int mod) 104 { 105 if (qg->new_refcnt < seq) 106 qg->new_refcnt = seq; 107 qg->new_refcnt += mod; 108 } 109 110 static inline u64 btrfs_qgroup_get_old_refcnt(struct btrfs_qgroup *qg, u64 seq) 111 { 112 if (qg->old_refcnt < seq) 113 return 0; 114 return qg->old_refcnt - seq; 115 } 116 117 static inline u64 btrfs_qgroup_get_new_refcnt(struct btrfs_qgroup *qg, u64 seq) 118 { 119 if (qg->new_refcnt < seq) 120 return 0; 121 return qg->new_refcnt - seq; 122 } 123 124 /* 125 * glue structure to represent the relations between qgroups. 126 */ 127 struct btrfs_qgroup_list { 128 struct list_head next_group; 129 struct list_head next_member; 130 struct btrfs_qgroup *group; 131 struct btrfs_qgroup *member; 132 }; 133 134 #define ptr_to_u64(x) ((u64)(uintptr_t)x) 135 #define u64_to_ptr(x) ((struct btrfs_qgroup *)(uintptr_t)x) 136 137 static int 138 qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid, 139 int init_flags); 140 static void qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info); 141 142 /* must be called with qgroup_ioctl_lock held */ 143 static struct btrfs_qgroup *find_qgroup_rb(struct btrfs_fs_info *fs_info, 144 u64 qgroupid) 145 { 146 struct rb_node *n = fs_info->qgroup_tree.rb_node; 147 struct btrfs_qgroup *qgroup; 148 149 while (n) { 150 qgroup = rb_entry(n, struct btrfs_qgroup, node); 151 if (qgroup->qgroupid < qgroupid) 152 n = n->rb_left; 153 else if (qgroup->qgroupid > qgroupid) 154 n = n->rb_right; 155 else 156 return qgroup; 157 } 158 return NULL; 159 } 160 161 /* must be called with qgroup_lock held */ 162 static struct btrfs_qgroup *add_qgroup_rb(struct btrfs_fs_info *fs_info, 163 u64 qgroupid) 164 { 165 struct rb_node **p = &fs_info->qgroup_tree.rb_node; 166 struct rb_node *parent = NULL; 167 struct btrfs_qgroup *qgroup; 168 169 while (*p) { 170 parent = *p; 171 qgroup = rb_entry(parent, struct btrfs_qgroup, node); 172 173 if (qgroup->qgroupid < qgroupid) 174 p = &(*p)->rb_left; 175 else if (qgroup->qgroupid > qgroupid) 176 p = &(*p)->rb_right; 177 else 178 return qgroup; 179 } 180 181 qgroup = kzalloc(sizeof(*qgroup), GFP_ATOMIC); 182 if (!qgroup) 183 return ERR_PTR(-ENOMEM); 184 185 qgroup->qgroupid = qgroupid; 186 INIT_LIST_HEAD(&qgroup->groups); 187 INIT_LIST_HEAD(&qgroup->members); 188 INIT_LIST_HEAD(&qgroup->dirty); 189 190 rb_link_node(&qgroup->node, parent, p); 191 rb_insert_color(&qgroup->node, &fs_info->qgroup_tree); 192 193 return qgroup; 194 } 195 196 static void __del_qgroup_rb(struct btrfs_qgroup *qgroup) 197 { 198 struct btrfs_qgroup_list *list; 199 200 list_del(&qgroup->dirty); 201 while (!list_empty(&qgroup->groups)) { 202 list = list_first_entry(&qgroup->groups, 203 struct btrfs_qgroup_list, next_group); 204 list_del(&list->next_group); 205 list_del(&list->next_member); 206 kfree(list); 207 } 208 209 while (!list_empty(&qgroup->members)) { 210 list = list_first_entry(&qgroup->members, 211 struct btrfs_qgroup_list, next_member); 212 list_del(&list->next_group); 213 list_del(&list->next_member); 214 kfree(list); 215 } 216 kfree(qgroup); 217 } 218 219 /* must be called with qgroup_lock held */ 220 static int del_qgroup_rb(struct btrfs_fs_info *fs_info, u64 qgroupid) 221 { 222 struct btrfs_qgroup *qgroup = find_qgroup_rb(fs_info, qgroupid); 223 224 if (!qgroup) 225 return -ENOENT; 226 227 rb_erase(&qgroup->node, &fs_info->qgroup_tree); 228 __del_qgroup_rb(qgroup); 229 return 0; 230 } 231 232 /* must be called with qgroup_lock held */ 233 static int add_relation_rb(struct btrfs_fs_info *fs_info, 234 u64 memberid, u64 parentid) 235 { 236 struct btrfs_qgroup *member; 237 struct btrfs_qgroup *parent; 238 struct btrfs_qgroup_list *list; 239 240 member = find_qgroup_rb(fs_info, memberid); 241 parent = find_qgroup_rb(fs_info, parentid); 242 if (!member || !parent) 243 return -ENOENT; 244 245 list = kzalloc(sizeof(*list), GFP_ATOMIC); 246 if (!list) 247 return -ENOMEM; 248 249 list->group = parent; 250 list->member = member; 251 list_add_tail(&list->next_group, &member->groups); 252 list_add_tail(&list->next_member, &parent->members); 253 254 return 0; 255 } 256 257 /* must be called with qgroup_lock held */ 258 static int del_relation_rb(struct btrfs_fs_info *fs_info, 259 u64 memberid, u64 parentid) 260 { 261 struct btrfs_qgroup *member; 262 struct btrfs_qgroup *parent; 263 struct btrfs_qgroup_list *list; 264 265 member = find_qgroup_rb(fs_info, memberid); 266 parent = find_qgroup_rb(fs_info, parentid); 267 if (!member || !parent) 268 return -ENOENT; 269 270 list_for_each_entry(list, &member->groups, next_group) { 271 if (list->group == parent) { 272 list_del(&list->next_group); 273 list_del(&list->next_member); 274 kfree(list); 275 return 0; 276 } 277 } 278 return -ENOENT; 279 } 280 281 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS 282 int btrfs_verify_qgroup_counts(struct btrfs_fs_info *fs_info, u64 qgroupid, 283 u64 rfer, u64 excl) 284 { 285 struct btrfs_qgroup *qgroup; 286 287 qgroup = find_qgroup_rb(fs_info, qgroupid); 288 if (!qgroup) 289 return -EINVAL; 290 if (qgroup->rfer != rfer || qgroup->excl != excl) 291 return -EINVAL; 292 return 0; 293 } 294 #endif 295 296 /* 297 * The full config is read in one go, only called from open_ctree() 298 * It doesn't use any locking, as at this point we're still single-threaded 299 */ 300 int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info) 301 { 302 struct btrfs_key key; 303 struct btrfs_key found_key; 304 struct btrfs_root *quota_root = fs_info->quota_root; 305 struct btrfs_path *path = NULL; 306 struct extent_buffer *l; 307 int slot; 308 int ret = 0; 309 u64 flags = 0; 310 u64 rescan_progress = 0; 311 312 if (!fs_info->quota_enabled) 313 return 0; 314 315 fs_info->qgroup_ulist = ulist_alloc(GFP_NOFS); 316 if (!fs_info->qgroup_ulist) { 317 ret = -ENOMEM; 318 goto out; 319 } 320 321 path = btrfs_alloc_path(); 322 if (!path) { 323 ret = -ENOMEM; 324 goto out; 325 } 326 327 /* default this to quota off, in case no status key is found */ 328 fs_info->qgroup_flags = 0; 329 330 /* 331 * pass 1: read status, all qgroup infos and limits 332 */ 333 key.objectid = 0; 334 key.type = 0; 335 key.offset = 0; 336 ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 1); 337 if (ret) 338 goto out; 339 340 while (1) { 341 struct btrfs_qgroup *qgroup; 342 343 slot = path->slots[0]; 344 l = path->nodes[0]; 345 btrfs_item_key_to_cpu(l, &found_key, slot); 346 347 if (found_key.type == BTRFS_QGROUP_STATUS_KEY) { 348 struct btrfs_qgroup_status_item *ptr; 349 350 ptr = btrfs_item_ptr(l, slot, 351 struct btrfs_qgroup_status_item); 352 353 if (btrfs_qgroup_status_version(l, ptr) != 354 BTRFS_QGROUP_STATUS_VERSION) { 355 btrfs_err(fs_info, 356 "old qgroup version, quota disabled"); 357 goto out; 358 } 359 if (btrfs_qgroup_status_generation(l, ptr) != 360 fs_info->generation) { 361 flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 362 btrfs_err(fs_info, 363 "qgroup generation mismatch, " 364 "marked as inconsistent"); 365 } 366 fs_info->qgroup_flags = btrfs_qgroup_status_flags(l, 367 ptr); 368 rescan_progress = btrfs_qgroup_status_rescan(l, ptr); 369 goto next1; 370 } 371 372 if (found_key.type != BTRFS_QGROUP_INFO_KEY && 373 found_key.type != BTRFS_QGROUP_LIMIT_KEY) 374 goto next1; 375 376 qgroup = find_qgroup_rb(fs_info, found_key.offset); 377 if ((qgroup && found_key.type == BTRFS_QGROUP_INFO_KEY) || 378 (!qgroup && found_key.type == BTRFS_QGROUP_LIMIT_KEY)) { 379 btrfs_err(fs_info, "inconsistent qgroup config"); 380 flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 381 } 382 if (!qgroup) { 383 qgroup = add_qgroup_rb(fs_info, found_key.offset); 384 if (IS_ERR(qgroup)) { 385 ret = PTR_ERR(qgroup); 386 goto out; 387 } 388 } 389 switch (found_key.type) { 390 case BTRFS_QGROUP_INFO_KEY: { 391 struct btrfs_qgroup_info_item *ptr; 392 393 ptr = btrfs_item_ptr(l, slot, 394 struct btrfs_qgroup_info_item); 395 qgroup->rfer = btrfs_qgroup_info_rfer(l, ptr); 396 qgroup->rfer_cmpr = btrfs_qgroup_info_rfer_cmpr(l, ptr); 397 qgroup->excl = btrfs_qgroup_info_excl(l, ptr); 398 qgroup->excl_cmpr = btrfs_qgroup_info_excl_cmpr(l, ptr); 399 /* generation currently unused */ 400 break; 401 } 402 case BTRFS_QGROUP_LIMIT_KEY: { 403 struct btrfs_qgroup_limit_item *ptr; 404 405 ptr = btrfs_item_ptr(l, slot, 406 struct btrfs_qgroup_limit_item); 407 qgroup->lim_flags = btrfs_qgroup_limit_flags(l, ptr); 408 qgroup->max_rfer = btrfs_qgroup_limit_max_rfer(l, ptr); 409 qgroup->max_excl = btrfs_qgroup_limit_max_excl(l, ptr); 410 qgroup->rsv_rfer = btrfs_qgroup_limit_rsv_rfer(l, ptr); 411 qgroup->rsv_excl = btrfs_qgroup_limit_rsv_excl(l, ptr); 412 break; 413 } 414 } 415 next1: 416 ret = btrfs_next_item(quota_root, path); 417 if (ret < 0) 418 goto out; 419 if (ret) 420 break; 421 } 422 btrfs_release_path(path); 423 424 /* 425 * pass 2: read all qgroup relations 426 */ 427 key.objectid = 0; 428 key.type = BTRFS_QGROUP_RELATION_KEY; 429 key.offset = 0; 430 ret = btrfs_search_slot_for_read(quota_root, &key, path, 1, 0); 431 if (ret) 432 goto out; 433 while (1) { 434 slot = path->slots[0]; 435 l = path->nodes[0]; 436 btrfs_item_key_to_cpu(l, &found_key, slot); 437 438 if (found_key.type != BTRFS_QGROUP_RELATION_KEY) 439 goto next2; 440 441 if (found_key.objectid > found_key.offset) { 442 /* parent <- member, not needed to build config */ 443 /* FIXME should we omit the key completely? */ 444 goto next2; 445 } 446 447 ret = add_relation_rb(fs_info, found_key.objectid, 448 found_key.offset); 449 if (ret == -ENOENT) { 450 btrfs_warn(fs_info, 451 "orphan qgroup relation 0x%llx->0x%llx", 452 found_key.objectid, found_key.offset); 453 ret = 0; /* ignore the error */ 454 } 455 if (ret) 456 goto out; 457 next2: 458 ret = btrfs_next_item(quota_root, path); 459 if (ret < 0) 460 goto out; 461 if (ret) 462 break; 463 } 464 out: 465 fs_info->qgroup_flags |= flags; 466 if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)) { 467 fs_info->quota_enabled = 0; 468 fs_info->pending_quota_state = 0; 469 } else if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN && 470 ret >= 0) { 471 ret = qgroup_rescan_init(fs_info, rescan_progress, 0); 472 } 473 btrfs_free_path(path); 474 475 if (ret < 0) { 476 ulist_free(fs_info->qgroup_ulist); 477 fs_info->qgroup_ulist = NULL; 478 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 479 } 480 481 return ret < 0 ? ret : 0; 482 } 483 484 /* 485 * This is called from close_ctree() or open_ctree() or btrfs_quota_disable(), 486 * first two are in single-threaded paths.And for the third one, we have set 487 * quota_root to be null with qgroup_lock held before, so it is safe to clean 488 * up the in-memory structures without qgroup_lock held. 489 */ 490 void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info) 491 { 492 struct rb_node *n; 493 struct btrfs_qgroup *qgroup; 494 495 while ((n = rb_first(&fs_info->qgroup_tree))) { 496 qgroup = rb_entry(n, struct btrfs_qgroup, node); 497 rb_erase(n, &fs_info->qgroup_tree); 498 __del_qgroup_rb(qgroup); 499 } 500 /* 501 * we call btrfs_free_qgroup_config() when umounting 502 * filesystem and disabling quota, so we set qgroup_ulist 503 * to be null here to avoid double free. 504 */ 505 ulist_free(fs_info->qgroup_ulist); 506 fs_info->qgroup_ulist = NULL; 507 } 508 509 static int add_qgroup_relation_item(struct btrfs_trans_handle *trans, 510 struct btrfs_root *quota_root, 511 u64 src, u64 dst) 512 { 513 int ret; 514 struct btrfs_path *path; 515 struct btrfs_key key; 516 517 path = btrfs_alloc_path(); 518 if (!path) 519 return -ENOMEM; 520 521 key.objectid = src; 522 key.type = BTRFS_QGROUP_RELATION_KEY; 523 key.offset = dst; 524 525 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 0); 526 527 btrfs_mark_buffer_dirty(path->nodes[0]); 528 529 btrfs_free_path(path); 530 return ret; 531 } 532 533 static int del_qgroup_relation_item(struct btrfs_trans_handle *trans, 534 struct btrfs_root *quota_root, 535 u64 src, u64 dst) 536 { 537 int ret; 538 struct btrfs_path *path; 539 struct btrfs_key key; 540 541 path = btrfs_alloc_path(); 542 if (!path) 543 return -ENOMEM; 544 545 key.objectid = src; 546 key.type = BTRFS_QGROUP_RELATION_KEY; 547 key.offset = dst; 548 549 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1); 550 if (ret < 0) 551 goto out; 552 553 if (ret > 0) { 554 ret = -ENOENT; 555 goto out; 556 } 557 558 ret = btrfs_del_item(trans, quota_root, path); 559 out: 560 btrfs_free_path(path); 561 return ret; 562 } 563 564 static int add_qgroup_item(struct btrfs_trans_handle *trans, 565 struct btrfs_root *quota_root, u64 qgroupid) 566 { 567 int ret; 568 struct btrfs_path *path; 569 struct btrfs_qgroup_info_item *qgroup_info; 570 struct btrfs_qgroup_limit_item *qgroup_limit; 571 struct extent_buffer *leaf; 572 struct btrfs_key key; 573 574 if (btrfs_is_testing(quota_root->fs_info)) 575 return 0; 576 577 path = btrfs_alloc_path(); 578 if (!path) 579 return -ENOMEM; 580 581 key.objectid = 0; 582 key.type = BTRFS_QGROUP_INFO_KEY; 583 key.offset = qgroupid; 584 585 /* 586 * Avoid a transaction abort by catching -EEXIST here. In that 587 * case, we proceed by re-initializing the existing structure 588 * on disk. 589 */ 590 591 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 592 sizeof(*qgroup_info)); 593 if (ret && ret != -EEXIST) 594 goto out; 595 596 leaf = path->nodes[0]; 597 qgroup_info = btrfs_item_ptr(leaf, path->slots[0], 598 struct btrfs_qgroup_info_item); 599 btrfs_set_qgroup_info_generation(leaf, qgroup_info, trans->transid); 600 btrfs_set_qgroup_info_rfer(leaf, qgroup_info, 0); 601 btrfs_set_qgroup_info_rfer_cmpr(leaf, qgroup_info, 0); 602 btrfs_set_qgroup_info_excl(leaf, qgroup_info, 0); 603 btrfs_set_qgroup_info_excl_cmpr(leaf, qgroup_info, 0); 604 605 btrfs_mark_buffer_dirty(leaf); 606 607 btrfs_release_path(path); 608 609 key.type = BTRFS_QGROUP_LIMIT_KEY; 610 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 611 sizeof(*qgroup_limit)); 612 if (ret && ret != -EEXIST) 613 goto out; 614 615 leaf = path->nodes[0]; 616 qgroup_limit = btrfs_item_ptr(leaf, path->slots[0], 617 struct btrfs_qgroup_limit_item); 618 btrfs_set_qgroup_limit_flags(leaf, qgroup_limit, 0); 619 btrfs_set_qgroup_limit_max_rfer(leaf, qgroup_limit, 0); 620 btrfs_set_qgroup_limit_max_excl(leaf, qgroup_limit, 0); 621 btrfs_set_qgroup_limit_rsv_rfer(leaf, qgroup_limit, 0); 622 btrfs_set_qgroup_limit_rsv_excl(leaf, qgroup_limit, 0); 623 624 btrfs_mark_buffer_dirty(leaf); 625 626 ret = 0; 627 out: 628 btrfs_free_path(path); 629 return ret; 630 } 631 632 static int del_qgroup_item(struct btrfs_trans_handle *trans, 633 struct btrfs_root *quota_root, u64 qgroupid) 634 { 635 int ret; 636 struct btrfs_path *path; 637 struct btrfs_key key; 638 639 path = btrfs_alloc_path(); 640 if (!path) 641 return -ENOMEM; 642 643 key.objectid = 0; 644 key.type = BTRFS_QGROUP_INFO_KEY; 645 key.offset = qgroupid; 646 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1); 647 if (ret < 0) 648 goto out; 649 650 if (ret > 0) { 651 ret = -ENOENT; 652 goto out; 653 } 654 655 ret = btrfs_del_item(trans, quota_root, path); 656 if (ret) 657 goto out; 658 659 btrfs_release_path(path); 660 661 key.type = BTRFS_QGROUP_LIMIT_KEY; 662 ret = btrfs_search_slot(trans, quota_root, &key, path, -1, 1); 663 if (ret < 0) 664 goto out; 665 666 if (ret > 0) { 667 ret = -ENOENT; 668 goto out; 669 } 670 671 ret = btrfs_del_item(trans, quota_root, path); 672 673 out: 674 btrfs_free_path(path); 675 return ret; 676 } 677 678 static int update_qgroup_limit_item(struct btrfs_trans_handle *trans, 679 struct btrfs_root *root, 680 struct btrfs_qgroup *qgroup) 681 { 682 struct btrfs_path *path; 683 struct btrfs_key key; 684 struct extent_buffer *l; 685 struct btrfs_qgroup_limit_item *qgroup_limit; 686 int ret; 687 int slot; 688 689 key.objectid = 0; 690 key.type = BTRFS_QGROUP_LIMIT_KEY; 691 key.offset = qgroup->qgroupid; 692 693 path = btrfs_alloc_path(); 694 if (!path) 695 return -ENOMEM; 696 697 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 698 if (ret > 0) 699 ret = -ENOENT; 700 701 if (ret) 702 goto out; 703 704 l = path->nodes[0]; 705 slot = path->slots[0]; 706 qgroup_limit = btrfs_item_ptr(l, slot, struct btrfs_qgroup_limit_item); 707 btrfs_set_qgroup_limit_flags(l, qgroup_limit, qgroup->lim_flags); 708 btrfs_set_qgroup_limit_max_rfer(l, qgroup_limit, qgroup->max_rfer); 709 btrfs_set_qgroup_limit_max_excl(l, qgroup_limit, qgroup->max_excl); 710 btrfs_set_qgroup_limit_rsv_rfer(l, qgroup_limit, qgroup->rsv_rfer); 711 btrfs_set_qgroup_limit_rsv_excl(l, qgroup_limit, qgroup->rsv_excl); 712 713 btrfs_mark_buffer_dirty(l); 714 715 out: 716 btrfs_free_path(path); 717 return ret; 718 } 719 720 static int update_qgroup_info_item(struct btrfs_trans_handle *trans, 721 struct btrfs_root *root, 722 struct btrfs_qgroup *qgroup) 723 { 724 struct btrfs_path *path; 725 struct btrfs_key key; 726 struct extent_buffer *l; 727 struct btrfs_qgroup_info_item *qgroup_info; 728 int ret; 729 int slot; 730 731 if (btrfs_is_testing(root->fs_info)) 732 return 0; 733 734 key.objectid = 0; 735 key.type = BTRFS_QGROUP_INFO_KEY; 736 key.offset = qgroup->qgroupid; 737 738 path = btrfs_alloc_path(); 739 if (!path) 740 return -ENOMEM; 741 742 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 743 if (ret > 0) 744 ret = -ENOENT; 745 746 if (ret) 747 goto out; 748 749 l = path->nodes[0]; 750 slot = path->slots[0]; 751 qgroup_info = btrfs_item_ptr(l, slot, struct btrfs_qgroup_info_item); 752 btrfs_set_qgroup_info_generation(l, qgroup_info, trans->transid); 753 btrfs_set_qgroup_info_rfer(l, qgroup_info, qgroup->rfer); 754 btrfs_set_qgroup_info_rfer_cmpr(l, qgroup_info, qgroup->rfer_cmpr); 755 btrfs_set_qgroup_info_excl(l, qgroup_info, qgroup->excl); 756 btrfs_set_qgroup_info_excl_cmpr(l, qgroup_info, qgroup->excl_cmpr); 757 758 btrfs_mark_buffer_dirty(l); 759 760 out: 761 btrfs_free_path(path); 762 return ret; 763 } 764 765 static int update_qgroup_status_item(struct btrfs_trans_handle *trans, 766 struct btrfs_fs_info *fs_info, 767 struct btrfs_root *root) 768 { 769 struct btrfs_path *path; 770 struct btrfs_key key; 771 struct extent_buffer *l; 772 struct btrfs_qgroup_status_item *ptr; 773 int ret; 774 int slot; 775 776 key.objectid = 0; 777 key.type = BTRFS_QGROUP_STATUS_KEY; 778 key.offset = 0; 779 780 path = btrfs_alloc_path(); 781 if (!path) 782 return -ENOMEM; 783 784 ret = btrfs_search_slot(trans, root, &key, path, 0, 1); 785 if (ret > 0) 786 ret = -ENOENT; 787 788 if (ret) 789 goto out; 790 791 l = path->nodes[0]; 792 slot = path->slots[0]; 793 ptr = btrfs_item_ptr(l, slot, struct btrfs_qgroup_status_item); 794 btrfs_set_qgroup_status_flags(l, ptr, fs_info->qgroup_flags); 795 btrfs_set_qgroup_status_generation(l, ptr, trans->transid); 796 btrfs_set_qgroup_status_rescan(l, ptr, 797 fs_info->qgroup_rescan_progress.objectid); 798 799 btrfs_mark_buffer_dirty(l); 800 801 out: 802 btrfs_free_path(path); 803 return ret; 804 } 805 806 /* 807 * called with qgroup_lock held 808 */ 809 static int btrfs_clean_quota_tree(struct btrfs_trans_handle *trans, 810 struct btrfs_root *root) 811 { 812 struct btrfs_path *path; 813 struct btrfs_key key; 814 struct extent_buffer *leaf = NULL; 815 int ret; 816 int nr = 0; 817 818 path = btrfs_alloc_path(); 819 if (!path) 820 return -ENOMEM; 821 822 path->leave_spinning = 1; 823 824 key.objectid = 0; 825 key.offset = 0; 826 key.type = 0; 827 828 while (1) { 829 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 830 if (ret < 0) 831 goto out; 832 leaf = path->nodes[0]; 833 nr = btrfs_header_nritems(leaf); 834 if (!nr) 835 break; 836 /* 837 * delete the leaf one by one 838 * since the whole tree is going 839 * to be deleted. 840 */ 841 path->slots[0] = 0; 842 ret = btrfs_del_items(trans, root, path, 0, nr); 843 if (ret) 844 goto out; 845 846 btrfs_release_path(path); 847 } 848 ret = 0; 849 out: 850 root->fs_info->pending_quota_state = 0; 851 btrfs_free_path(path); 852 return ret; 853 } 854 855 int btrfs_quota_enable(struct btrfs_trans_handle *trans, 856 struct btrfs_fs_info *fs_info) 857 { 858 struct btrfs_root *quota_root; 859 struct btrfs_root *tree_root = fs_info->tree_root; 860 struct btrfs_path *path = NULL; 861 struct btrfs_qgroup_status_item *ptr; 862 struct extent_buffer *leaf; 863 struct btrfs_key key; 864 struct btrfs_key found_key; 865 struct btrfs_qgroup *qgroup = NULL; 866 int ret = 0; 867 int slot; 868 869 mutex_lock(&fs_info->qgroup_ioctl_lock); 870 if (fs_info->quota_root) { 871 fs_info->pending_quota_state = 1; 872 goto out; 873 } 874 875 fs_info->qgroup_ulist = ulist_alloc(GFP_NOFS); 876 if (!fs_info->qgroup_ulist) { 877 ret = -ENOMEM; 878 goto out; 879 } 880 881 /* 882 * initially create the quota tree 883 */ 884 quota_root = btrfs_create_tree(trans, fs_info, 885 BTRFS_QUOTA_TREE_OBJECTID); 886 if (IS_ERR(quota_root)) { 887 ret = PTR_ERR(quota_root); 888 goto out; 889 } 890 891 path = btrfs_alloc_path(); 892 if (!path) { 893 ret = -ENOMEM; 894 goto out_free_root; 895 } 896 897 key.objectid = 0; 898 key.type = BTRFS_QGROUP_STATUS_KEY; 899 key.offset = 0; 900 901 ret = btrfs_insert_empty_item(trans, quota_root, path, &key, 902 sizeof(*ptr)); 903 if (ret) 904 goto out_free_path; 905 906 leaf = path->nodes[0]; 907 ptr = btrfs_item_ptr(leaf, path->slots[0], 908 struct btrfs_qgroup_status_item); 909 btrfs_set_qgroup_status_generation(leaf, ptr, trans->transid); 910 btrfs_set_qgroup_status_version(leaf, ptr, BTRFS_QGROUP_STATUS_VERSION); 911 fs_info->qgroup_flags = BTRFS_QGROUP_STATUS_FLAG_ON | 912 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 913 btrfs_set_qgroup_status_flags(leaf, ptr, fs_info->qgroup_flags); 914 btrfs_set_qgroup_status_rescan(leaf, ptr, 0); 915 916 btrfs_mark_buffer_dirty(leaf); 917 918 key.objectid = 0; 919 key.type = BTRFS_ROOT_REF_KEY; 920 key.offset = 0; 921 922 btrfs_release_path(path); 923 ret = btrfs_search_slot_for_read(tree_root, &key, path, 1, 0); 924 if (ret > 0) 925 goto out_add_root; 926 if (ret < 0) 927 goto out_free_path; 928 929 930 while (1) { 931 slot = path->slots[0]; 932 leaf = path->nodes[0]; 933 btrfs_item_key_to_cpu(leaf, &found_key, slot); 934 935 if (found_key.type == BTRFS_ROOT_REF_KEY) { 936 ret = add_qgroup_item(trans, quota_root, 937 found_key.offset); 938 if (ret) 939 goto out_free_path; 940 941 qgroup = add_qgroup_rb(fs_info, found_key.offset); 942 if (IS_ERR(qgroup)) { 943 ret = PTR_ERR(qgroup); 944 goto out_free_path; 945 } 946 } 947 ret = btrfs_next_item(tree_root, path); 948 if (ret < 0) 949 goto out_free_path; 950 if (ret) 951 break; 952 } 953 954 out_add_root: 955 btrfs_release_path(path); 956 ret = add_qgroup_item(trans, quota_root, BTRFS_FS_TREE_OBJECTID); 957 if (ret) 958 goto out_free_path; 959 960 qgroup = add_qgroup_rb(fs_info, BTRFS_FS_TREE_OBJECTID); 961 if (IS_ERR(qgroup)) { 962 ret = PTR_ERR(qgroup); 963 goto out_free_path; 964 } 965 spin_lock(&fs_info->qgroup_lock); 966 fs_info->quota_root = quota_root; 967 fs_info->pending_quota_state = 1; 968 spin_unlock(&fs_info->qgroup_lock); 969 out_free_path: 970 btrfs_free_path(path); 971 out_free_root: 972 if (ret) { 973 free_extent_buffer(quota_root->node); 974 free_extent_buffer(quota_root->commit_root); 975 kfree(quota_root); 976 } 977 out: 978 if (ret) { 979 ulist_free(fs_info->qgroup_ulist); 980 fs_info->qgroup_ulist = NULL; 981 } 982 mutex_unlock(&fs_info->qgroup_ioctl_lock); 983 return ret; 984 } 985 986 int btrfs_quota_disable(struct btrfs_trans_handle *trans, 987 struct btrfs_fs_info *fs_info) 988 { 989 struct btrfs_root *tree_root = fs_info->tree_root; 990 struct btrfs_root *quota_root; 991 int ret = 0; 992 993 mutex_lock(&fs_info->qgroup_ioctl_lock); 994 if (!fs_info->quota_root) 995 goto out; 996 fs_info->quota_enabled = 0; 997 fs_info->pending_quota_state = 0; 998 btrfs_qgroup_wait_for_completion(fs_info, false); 999 spin_lock(&fs_info->qgroup_lock); 1000 quota_root = fs_info->quota_root; 1001 fs_info->quota_root = NULL; 1002 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON; 1003 spin_unlock(&fs_info->qgroup_lock); 1004 1005 btrfs_free_qgroup_config(fs_info); 1006 1007 ret = btrfs_clean_quota_tree(trans, quota_root); 1008 if (ret) 1009 goto out; 1010 1011 ret = btrfs_del_root(trans, tree_root, "a_root->root_key); 1012 if (ret) 1013 goto out; 1014 1015 list_del("a_root->dirty_list); 1016 1017 btrfs_tree_lock(quota_root->node); 1018 clean_tree_block(trans, tree_root->fs_info, quota_root->node); 1019 btrfs_tree_unlock(quota_root->node); 1020 btrfs_free_tree_block(trans, quota_root, quota_root->node, 0, 1); 1021 1022 free_extent_buffer(quota_root->node); 1023 free_extent_buffer(quota_root->commit_root); 1024 kfree(quota_root); 1025 out: 1026 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1027 return ret; 1028 } 1029 1030 static void qgroup_dirty(struct btrfs_fs_info *fs_info, 1031 struct btrfs_qgroup *qgroup) 1032 { 1033 if (list_empty(&qgroup->dirty)) 1034 list_add(&qgroup->dirty, &fs_info->dirty_qgroups); 1035 } 1036 1037 /* 1038 * The easy accounting, if we are adding/removing the only ref for an extent 1039 * then this qgroup and all of the parent qgroups get their reference and 1040 * exclusive counts adjusted. 1041 * 1042 * Caller should hold fs_info->qgroup_lock. 1043 */ 1044 static int __qgroup_excl_accounting(struct btrfs_fs_info *fs_info, 1045 struct ulist *tmp, u64 ref_root, 1046 u64 num_bytes, int sign) 1047 { 1048 struct btrfs_qgroup *qgroup; 1049 struct btrfs_qgroup_list *glist; 1050 struct ulist_node *unode; 1051 struct ulist_iterator uiter; 1052 int ret = 0; 1053 1054 qgroup = find_qgroup_rb(fs_info, ref_root); 1055 if (!qgroup) 1056 goto out; 1057 1058 qgroup->rfer += sign * num_bytes; 1059 qgroup->rfer_cmpr += sign * num_bytes; 1060 1061 WARN_ON(sign < 0 && qgroup->excl < num_bytes); 1062 qgroup->excl += sign * num_bytes; 1063 qgroup->excl_cmpr += sign * num_bytes; 1064 if (sign > 0) 1065 qgroup->reserved -= num_bytes; 1066 1067 qgroup_dirty(fs_info, qgroup); 1068 1069 /* Get all of the parent groups that contain this qgroup */ 1070 list_for_each_entry(glist, &qgroup->groups, next_group) { 1071 ret = ulist_add(tmp, glist->group->qgroupid, 1072 ptr_to_u64(glist->group), GFP_ATOMIC); 1073 if (ret < 0) 1074 goto out; 1075 } 1076 1077 /* Iterate all of the parents and adjust their reference counts */ 1078 ULIST_ITER_INIT(&uiter); 1079 while ((unode = ulist_next(tmp, &uiter))) { 1080 qgroup = u64_to_ptr(unode->aux); 1081 qgroup->rfer += sign * num_bytes; 1082 qgroup->rfer_cmpr += sign * num_bytes; 1083 WARN_ON(sign < 0 && qgroup->excl < num_bytes); 1084 qgroup->excl += sign * num_bytes; 1085 if (sign > 0) 1086 qgroup->reserved -= num_bytes; 1087 qgroup->excl_cmpr += sign * num_bytes; 1088 qgroup_dirty(fs_info, qgroup); 1089 1090 /* Add any parents of the parents */ 1091 list_for_each_entry(glist, &qgroup->groups, next_group) { 1092 ret = ulist_add(tmp, glist->group->qgroupid, 1093 ptr_to_u64(glist->group), GFP_ATOMIC); 1094 if (ret < 0) 1095 goto out; 1096 } 1097 } 1098 ret = 0; 1099 out: 1100 return ret; 1101 } 1102 1103 1104 /* 1105 * Quick path for updating qgroup with only excl refs. 1106 * 1107 * In that case, just update all parent will be enough. 1108 * Or we needs to do a full rescan. 1109 * Caller should also hold fs_info->qgroup_lock. 1110 * 1111 * Return 0 for quick update, return >0 for need to full rescan 1112 * and mark INCONSISTENT flag. 1113 * Return < 0 for other error. 1114 */ 1115 static int quick_update_accounting(struct btrfs_fs_info *fs_info, 1116 struct ulist *tmp, u64 src, u64 dst, 1117 int sign) 1118 { 1119 struct btrfs_qgroup *qgroup; 1120 int ret = 1; 1121 int err = 0; 1122 1123 qgroup = find_qgroup_rb(fs_info, src); 1124 if (!qgroup) 1125 goto out; 1126 if (qgroup->excl == qgroup->rfer) { 1127 ret = 0; 1128 err = __qgroup_excl_accounting(fs_info, tmp, dst, 1129 qgroup->excl, sign); 1130 if (err < 0) { 1131 ret = err; 1132 goto out; 1133 } 1134 } 1135 out: 1136 if (ret) 1137 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1138 return ret; 1139 } 1140 1141 int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans, 1142 struct btrfs_fs_info *fs_info, u64 src, u64 dst) 1143 { 1144 struct btrfs_root *quota_root; 1145 struct btrfs_qgroup *parent; 1146 struct btrfs_qgroup *member; 1147 struct btrfs_qgroup_list *list; 1148 struct ulist *tmp; 1149 int ret = 0; 1150 1151 /* Check the level of src and dst first */ 1152 if (btrfs_qgroup_level(src) >= btrfs_qgroup_level(dst)) 1153 return -EINVAL; 1154 1155 tmp = ulist_alloc(GFP_NOFS); 1156 if (!tmp) 1157 return -ENOMEM; 1158 1159 mutex_lock(&fs_info->qgroup_ioctl_lock); 1160 quota_root = fs_info->quota_root; 1161 if (!quota_root) { 1162 ret = -EINVAL; 1163 goto out; 1164 } 1165 member = find_qgroup_rb(fs_info, src); 1166 parent = find_qgroup_rb(fs_info, dst); 1167 if (!member || !parent) { 1168 ret = -EINVAL; 1169 goto out; 1170 } 1171 1172 /* check if such qgroup relation exist firstly */ 1173 list_for_each_entry(list, &member->groups, next_group) { 1174 if (list->group == parent) { 1175 ret = -EEXIST; 1176 goto out; 1177 } 1178 } 1179 1180 ret = add_qgroup_relation_item(trans, quota_root, src, dst); 1181 if (ret) 1182 goto out; 1183 1184 ret = add_qgroup_relation_item(trans, quota_root, dst, src); 1185 if (ret) { 1186 del_qgroup_relation_item(trans, quota_root, src, dst); 1187 goto out; 1188 } 1189 1190 spin_lock(&fs_info->qgroup_lock); 1191 ret = add_relation_rb(quota_root->fs_info, src, dst); 1192 if (ret < 0) { 1193 spin_unlock(&fs_info->qgroup_lock); 1194 goto out; 1195 } 1196 ret = quick_update_accounting(fs_info, tmp, src, dst, 1); 1197 spin_unlock(&fs_info->qgroup_lock); 1198 out: 1199 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1200 ulist_free(tmp); 1201 return ret; 1202 } 1203 1204 int __del_qgroup_relation(struct btrfs_trans_handle *trans, 1205 struct btrfs_fs_info *fs_info, u64 src, u64 dst) 1206 { 1207 struct btrfs_root *quota_root; 1208 struct btrfs_qgroup *parent; 1209 struct btrfs_qgroup *member; 1210 struct btrfs_qgroup_list *list; 1211 struct ulist *tmp; 1212 int ret = 0; 1213 int err; 1214 1215 tmp = ulist_alloc(GFP_NOFS); 1216 if (!tmp) 1217 return -ENOMEM; 1218 1219 quota_root = fs_info->quota_root; 1220 if (!quota_root) { 1221 ret = -EINVAL; 1222 goto out; 1223 } 1224 1225 member = find_qgroup_rb(fs_info, src); 1226 parent = find_qgroup_rb(fs_info, dst); 1227 if (!member || !parent) { 1228 ret = -EINVAL; 1229 goto out; 1230 } 1231 1232 /* check if such qgroup relation exist firstly */ 1233 list_for_each_entry(list, &member->groups, next_group) { 1234 if (list->group == parent) 1235 goto exist; 1236 } 1237 ret = -ENOENT; 1238 goto out; 1239 exist: 1240 ret = del_qgroup_relation_item(trans, quota_root, src, dst); 1241 err = del_qgroup_relation_item(trans, quota_root, dst, src); 1242 if (err && !ret) 1243 ret = err; 1244 1245 spin_lock(&fs_info->qgroup_lock); 1246 del_relation_rb(fs_info, src, dst); 1247 ret = quick_update_accounting(fs_info, tmp, src, dst, -1); 1248 spin_unlock(&fs_info->qgroup_lock); 1249 out: 1250 ulist_free(tmp); 1251 return ret; 1252 } 1253 1254 int btrfs_del_qgroup_relation(struct btrfs_trans_handle *trans, 1255 struct btrfs_fs_info *fs_info, u64 src, u64 dst) 1256 { 1257 int ret = 0; 1258 1259 mutex_lock(&fs_info->qgroup_ioctl_lock); 1260 ret = __del_qgroup_relation(trans, fs_info, src, dst); 1261 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1262 1263 return ret; 1264 } 1265 1266 int btrfs_create_qgroup(struct btrfs_trans_handle *trans, 1267 struct btrfs_fs_info *fs_info, u64 qgroupid) 1268 { 1269 struct btrfs_root *quota_root; 1270 struct btrfs_qgroup *qgroup; 1271 int ret = 0; 1272 1273 mutex_lock(&fs_info->qgroup_ioctl_lock); 1274 quota_root = fs_info->quota_root; 1275 if (!quota_root) { 1276 ret = -EINVAL; 1277 goto out; 1278 } 1279 qgroup = find_qgroup_rb(fs_info, qgroupid); 1280 if (qgroup) { 1281 ret = -EEXIST; 1282 goto out; 1283 } 1284 1285 ret = add_qgroup_item(trans, quota_root, qgroupid); 1286 if (ret) 1287 goto out; 1288 1289 spin_lock(&fs_info->qgroup_lock); 1290 qgroup = add_qgroup_rb(fs_info, qgroupid); 1291 spin_unlock(&fs_info->qgroup_lock); 1292 1293 if (IS_ERR(qgroup)) 1294 ret = PTR_ERR(qgroup); 1295 out: 1296 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1297 return ret; 1298 } 1299 1300 int btrfs_remove_qgroup(struct btrfs_trans_handle *trans, 1301 struct btrfs_fs_info *fs_info, u64 qgroupid) 1302 { 1303 struct btrfs_root *quota_root; 1304 struct btrfs_qgroup *qgroup; 1305 struct btrfs_qgroup_list *list; 1306 int ret = 0; 1307 1308 mutex_lock(&fs_info->qgroup_ioctl_lock); 1309 quota_root = fs_info->quota_root; 1310 if (!quota_root) { 1311 ret = -EINVAL; 1312 goto out; 1313 } 1314 1315 qgroup = find_qgroup_rb(fs_info, qgroupid); 1316 if (!qgroup) { 1317 ret = -ENOENT; 1318 goto out; 1319 } else { 1320 /* check if there are no children of this qgroup */ 1321 if (!list_empty(&qgroup->members)) { 1322 ret = -EBUSY; 1323 goto out; 1324 } 1325 } 1326 ret = del_qgroup_item(trans, quota_root, qgroupid); 1327 1328 while (!list_empty(&qgroup->groups)) { 1329 list = list_first_entry(&qgroup->groups, 1330 struct btrfs_qgroup_list, next_group); 1331 ret = __del_qgroup_relation(trans, fs_info, 1332 qgroupid, 1333 list->group->qgroupid); 1334 if (ret) 1335 goto out; 1336 } 1337 1338 spin_lock(&fs_info->qgroup_lock); 1339 del_qgroup_rb(quota_root->fs_info, qgroupid); 1340 spin_unlock(&fs_info->qgroup_lock); 1341 out: 1342 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1343 return ret; 1344 } 1345 1346 int btrfs_limit_qgroup(struct btrfs_trans_handle *trans, 1347 struct btrfs_fs_info *fs_info, u64 qgroupid, 1348 struct btrfs_qgroup_limit *limit) 1349 { 1350 struct btrfs_root *quota_root; 1351 struct btrfs_qgroup *qgroup; 1352 int ret = 0; 1353 /* Sometimes we would want to clear the limit on this qgroup. 1354 * To meet this requirement, we treat the -1 as a special value 1355 * which tell kernel to clear the limit on this qgroup. 1356 */ 1357 const u64 CLEAR_VALUE = -1; 1358 1359 mutex_lock(&fs_info->qgroup_ioctl_lock); 1360 quota_root = fs_info->quota_root; 1361 if (!quota_root) { 1362 ret = -EINVAL; 1363 goto out; 1364 } 1365 1366 qgroup = find_qgroup_rb(fs_info, qgroupid); 1367 if (!qgroup) { 1368 ret = -ENOENT; 1369 goto out; 1370 } 1371 1372 spin_lock(&fs_info->qgroup_lock); 1373 if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_RFER) { 1374 if (limit->max_rfer == CLEAR_VALUE) { 1375 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER; 1376 limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER; 1377 qgroup->max_rfer = 0; 1378 } else { 1379 qgroup->max_rfer = limit->max_rfer; 1380 } 1381 } 1382 if (limit->flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) { 1383 if (limit->max_excl == CLEAR_VALUE) { 1384 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL; 1385 limit->flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL; 1386 qgroup->max_excl = 0; 1387 } else { 1388 qgroup->max_excl = limit->max_excl; 1389 } 1390 } 1391 if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_RFER) { 1392 if (limit->rsv_rfer == CLEAR_VALUE) { 1393 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER; 1394 limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER; 1395 qgroup->rsv_rfer = 0; 1396 } else { 1397 qgroup->rsv_rfer = limit->rsv_rfer; 1398 } 1399 } 1400 if (limit->flags & BTRFS_QGROUP_LIMIT_RSV_EXCL) { 1401 if (limit->rsv_excl == CLEAR_VALUE) { 1402 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL; 1403 limit->flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL; 1404 qgroup->rsv_excl = 0; 1405 } else { 1406 qgroup->rsv_excl = limit->rsv_excl; 1407 } 1408 } 1409 qgroup->lim_flags |= limit->flags; 1410 1411 spin_unlock(&fs_info->qgroup_lock); 1412 1413 ret = update_qgroup_limit_item(trans, quota_root, qgroup); 1414 if (ret) { 1415 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1416 btrfs_info(fs_info, "unable to update quota limit for %llu", 1417 qgroupid); 1418 } 1419 1420 out: 1421 mutex_unlock(&fs_info->qgroup_ioctl_lock); 1422 return ret; 1423 } 1424 1425 int btrfs_qgroup_prepare_account_extents(struct btrfs_trans_handle *trans, 1426 struct btrfs_fs_info *fs_info) 1427 { 1428 struct btrfs_qgroup_extent_record *record; 1429 struct btrfs_delayed_ref_root *delayed_refs; 1430 struct rb_node *node; 1431 u64 qgroup_to_skip; 1432 int ret = 0; 1433 1434 delayed_refs = &trans->transaction->delayed_refs; 1435 qgroup_to_skip = delayed_refs->qgroup_to_skip; 1436 1437 /* 1438 * No need to do lock, since this function will only be called in 1439 * btrfs_commit_transaction(). 1440 */ 1441 node = rb_first(&delayed_refs->dirty_extent_root); 1442 while (node) { 1443 record = rb_entry(node, struct btrfs_qgroup_extent_record, 1444 node); 1445 ret = btrfs_find_all_roots(NULL, fs_info, record->bytenr, 0, 1446 &record->old_roots); 1447 if (ret < 0) 1448 break; 1449 if (qgroup_to_skip) 1450 ulist_del(record->old_roots, qgroup_to_skip, 0); 1451 node = rb_next(node); 1452 } 1453 return ret; 1454 } 1455 1456 int btrfs_qgroup_insert_dirty_extent_nolock(struct btrfs_fs_info *fs_info, 1457 struct btrfs_delayed_ref_root *delayed_refs, 1458 struct btrfs_qgroup_extent_record *record) 1459 { 1460 struct rb_node **p = &delayed_refs->dirty_extent_root.rb_node; 1461 struct rb_node *parent_node = NULL; 1462 struct btrfs_qgroup_extent_record *entry; 1463 u64 bytenr = record->bytenr; 1464 1465 assert_spin_locked(&delayed_refs->lock); 1466 trace_btrfs_qgroup_insert_dirty_extent(fs_info, record); 1467 1468 while (*p) { 1469 parent_node = *p; 1470 entry = rb_entry(parent_node, struct btrfs_qgroup_extent_record, 1471 node); 1472 if (bytenr < entry->bytenr) 1473 p = &(*p)->rb_left; 1474 else if (bytenr > entry->bytenr) 1475 p = &(*p)->rb_right; 1476 else 1477 return 1; 1478 } 1479 1480 rb_link_node(&record->node, parent_node, p); 1481 rb_insert_color(&record->node, &delayed_refs->dirty_extent_root); 1482 return 0; 1483 } 1484 1485 int btrfs_qgroup_insert_dirty_extent(struct btrfs_trans_handle *trans, 1486 struct btrfs_fs_info *fs_info, u64 bytenr, u64 num_bytes, 1487 gfp_t gfp_flag) 1488 { 1489 struct btrfs_qgroup_extent_record *record; 1490 struct btrfs_delayed_ref_root *delayed_refs; 1491 int ret; 1492 1493 if (!fs_info->quota_enabled || bytenr == 0 || num_bytes == 0) 1494 return 0; 1495 if (WARN_ON(trans == NULL)) 1496 return -EINVAL; 1497 record = kmalloc(sizeof(*record), gfp_flag); 1498 if (!record) 1499 return -ENOMEM; 1500 1501 delayed_refs = &trans->transaction->delayed_refs; 1502 record->bytenr = bytenr; 1503 record->num_bytes = num_bytes; 1504 record->old_roots = NULL; 1505 1506 spin_lock(&delayed_refs->lock); 1507 ret = btrfs_qgroup_insert_dirty_extent_nolock(fs_info, delayed_refs, 1508 record); 1509 spin_unlock(&delayed_refs->lock); 1510 if (ret > 0) 1511 kfree(record); 1512 return 0; 1513 } 1514 1515 #define UPDATE_NEW 0 1516 #define UPDATE_OLD 1 1517 /* 1518 * Walk all of the roots that points to the bytenr and adjust their refcnts. 1519 */ 1520 static int qgroup_update_refcnt(struct btrfs_fs_info *fs_info, 1521 struct ulist *roots, struct ulist *tmp, 1522 struct ulist *qgroups, u64 seq, int update_old) 1523 { 1524 struct ulist_node *unode; 1525 struct ulist_iterator uiter; 1526 struct ulist_node *tmp_unode; 1527 struct ulist_iterator tmp_uiter; 1528 struct btrfs_qgroup *qg; 1529 int ret = 0; 1530 1531 if (!roots) 1532 return 0; 1533 ULIST_ITER_INIT(&uiter); 1534 while ((unode = ulist_next(roots, &uiter))) { 1535 qg = find_qgroup_rb(fs_info, unode->val); 1536 if (!qg) 1537 continue; 1538 1539 ulist_reinit(tmp); 1540 ret = ulist_add(qgroups, qg->qgroupid, ptr_to_u64(qg), 1541 GFP_ATOMIC); 1542 if (ret < 0) 1543 return ret; 1544 ret = ulist_add(tmp, qg->qgroupid, ptr_to_u64(qg), GFP_ATOMIC); 1545 if (ret < 0) 1546 return ret; 1547 ULIST_ITER_INIT(&tmp_uiter); 1548 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) { 1549 struct btrfs_qgroup_list *glist; 1550 1551 qg = u64_to_ptr(tmp_unode->aux); 1552 if (update_old) 1553 btrfs_qgroup_update_old_refcnt(qg, seq, 1); 1554 else 1555 btrfs_qgroup_update_new_refcnt(qg, seq, 1); 1556 list_for_each_entry(glist, &qg->groups, next_group) { 1557 ret = ulist_add(qgroups, glist->group->qgroupid, 1558 ptr_to_u64(glist->group), 1559 GFP_ATOMIC); 1560 if (ret < 0) 1561 return ret; 1562 ret = ulist_add(tmp, glist->group->qgroupid, 1563 ptr_to_u64(glist->group), 1564 GFP_ATOMIC); 1565 if (ret < 0) 1566 return ret; 1567 } 1568 } 1569 } 1570 return 0; 1571 } 1572 1573 /* 1574 * Update qgroup rfer/excl counters. 1575 * Rfer update is easy, codes can explain themselves. 1576 * 1577 * Excl update is tricky, the update is split into 2 part. 1578 * Part 1: Possible exclusive <-> sharing detect: 1579 * | A | !A | 1580 * ------------------------------------- 1581 * B | * | - | 1582 * ------------------------------------- 1583 * !B | + | ** | 1584 * ------------------------------------- 1585 * 1586 * Conditions: 1587 * A: cur_old_roots < nr_old_roots (not exclusive before) 1588 * !A: cur_old_roots == nr_old_roots (possible exclusive before) 1589 * B: cur_new_roots < nr_new_roots (not exclusive now) 1590 * !B: cur_new_roots == nr_new_roots (possible exclusive now) 1591 * 1592 * Results: 1593 * +: Possible sharing -> exclusive -: Possible exclusive -> sharing 1594 * *: Definitely not changed. **: Possible unchanged. 1595 * 1596 * For !A and !B condition, the exception is cur_old/new_roots == 0 case. 1597 * 1598 * To make the logic clear, we first use condition A and B to split 1599 * combination into 4 results. 1600 * 1601 * Then, for result "+" and "-", check old/new_roots == 0 case, as in them 1602 * only on variant maybe 0. 1603 * 1604 * Lastly, check result **, since there are 2 variants maybe 0, split them 1605 * again(2x2). 1606 * But this time we don't need to consider other things, the codes and logic 1607 * is easy to understand now. 1608 */ 1609 static int qgroup_update_counters(struct btrfs_fs_info *fs_info, 1610 struct ulist *qgroups, 1611 u64 nr_old_roots, 1612 u64 nr_new_roots, 1613 u64 num_bytes, u64 seq) 1614 { 1615 struct ulist_node *unode; 1616 struct ulist_iterator uiter; 1617 struct btrfs_qgroup *qg; 1618 u64 cur_new_count, cur_old_count; 1619 1620 ULIST_ITER_INIT(&uiter); 1621 while ((unode = ulist_next(qgroups, &uiter))) { 1622 bool dirty = false; 1623 1624 qg = u64_to_ptr(unode->aux); 1625 cur_old_count = btrfs_qgroup_get_old_refcnt(qg, seq); 1626 cur_new_count = btrfs_qgroup_get_new_refcnt(qg, seq); 1627 1628 trace_qgroup_update_counters(fs_info, qg->qgroupid, 1629 cur_old_count, cur_new_count); 1630 1631 /* Rfer update part */ 1632 if (cur_old_count == 0 && cur_new_count > 0) { 1633 qg->rfer += num_bytes; 1634 qg->rfer_cmpr += num_bytes; 1635 dirty = true; 1636 } 1637 if (cur_old_count > 0 && cur_new_count == 0) { 1638 qg->rfer -= num_bytes; 1639 qg->rfer_cmpr -= num_bytes; 1640 dirty = true; 1641 } 1642 1643 /* Excl update part */ 1644 /* Exclusive/none -> shared case */ 1645 if (cur_old_count == nr_old_roots && 1646 cur_new_count < nr_new_roots) { 1647 /* Exclusive -> shared */ 1648 if (cur_old_count != 0) { 1649 qg->excl -= num_bytes; 1650 qg->excl_cmpr -= num_bytes; 1651 dirty = true; 1652 } 1653 } 1654 1655 /* Shared -> exclusive/none case */ 1656 if (cur_old_count < nr_old_roots && 1657 cur_new_count == nr_new_roots) { 1658 /* Shared->exclusive */ 1659 if (cur_new_count != 0) { 1660 qg->excl += num_bytes; 1661 qg->excl_cmpr += num_bytes; 1662 dirty = true; 1663 } 1664 } 1665 1666 /* Exclusive/none -> exclusive/none case */ 1667 if (cur_old_count == nr_old_roots && 1668 cur_new_count == nr_new_roots) { 1669 if (cur_old_count == 0) { 1670 /* None -> exclusive/none */ 1671 1672 if (cur_new_count != 0) { 1673 /* None -> exclusive */ 1674 qg->excl += num_bytes; 1675 qg->excl_cmpr += num_bytes; 1676 dirty = true; 1677 } 1678 /* None -> none, nothing changed */ 1679 } else { 1680 /* Exclusive -> exclusive/none */ 1681 1682 if (cur_new_count == 0) { 1683 /* Exclusive -> none */ 1684 qg->excl -= num_bytes; 1685 qg->excl_cmpr -= num_bytes; 1686 dirty = true; 1687 } 1688 /* Exclusive -> exclusive, nothing changed */ 1689 } 1690 } 1691 1692 if (dirty) 1693 qgroup_dirty(fs_info, qg); 1694 } 1695 return 0; 1696 } 1697 1698 int 1699 btrfs_qgroup_account_extent(struct btrfs_trans_handle *trans, 1700 struct btrfs_fs_info *fs_info, 1701 u64 bytenr, u64 num_bytes, 1702 struct ulist *old_roots, struct ulist *new_roots) 1703 { 1704 struct ulist *qgroups = NULL; 1705 struct ulist *tmp = NULL; 1706 u64 seq; 1707 u64 nr_new_roots = 0; 1708 u64 nr_old_roots = 0; 1709 int ret = 0; 1710 1711 if (new_roots) 1712 nr_new_roots = new_roots->nnodes; 1713 if (old_roots) 1714 nr_old_roots = old_roots->nnodes; 1715 1716 if (!fs_info->quota_enabled) 1717 goto out_free; 1718 BUG_ON(!fs_info->quota_root); 1719 1720 trace_btrfs_qgroup_account_extent(fs_info, bytenr, num_bytes, 1721 nr_old_roots, nr_new_roots); 1722 1723 qgroups = ulist_alloc(GFP_NOFS); 1724 if (!qgroups) { 1725 ret = -ENOMEM; 1726 goto out_free; 1727 } 1728 tmp = ulist_alloc(GFP_NOFS); 1729 if (!tmp) { 1730 ret = -ENOMEM; 1731 goto out_free; 1732 } 1733 1734 mutex_lock(&fs_info->qgroup_rescan_lock); 1735 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) { 1736 if (fs_info->qgroup_rescan_progress.objectid <= bytenr) { 1737 mutex_unlock(&fs_info->qgroup_rescan_lock); 1738 ret = 0; 1739 goto out_free; 1740 } 1741 } 1742 mutex_unlock(&fs_info->qgroup_rescan_lock); 1743 1744 spin_lock(&fs_info->qgroup_lock); 1745 seq = fs_info->qgroup_seq; 1746 1747 /* Update old refcnts using old_roots */ 1748 ret = qgroup_update_refcnt(fs_info, old_roots, tmp, qgroups, seq, 1749 UPDATE_OLD); 1750 if (ret < 0) 1751 goto out; 1752 1753 /* Update new refcnts using new_roots */ 1754 ret = qgroup_update_refcnt(fs_info, new_roots, tmp, qgroups, seq, 1755 UPDATE_NEW); 1756 if (ret < 0) 1757 goto out; 1758 1759 qgroup_update_counters(fs_info, qgroups, nr_old_roots, nr_new_roots, 1760 num_bytes, seq); 1761 1762 /* 1763 * Bump qgroup_seq to avoid seq overlap 1764 */ 1765 fs_info->qgroup_seq += max(nr_old_roots, nr_new_roots) + 1; 1766 out: 1767 spin_unlock(&fs_info->qgroup_lock); 1768 out_free: 1769 ulist_free(tmp); 1770 ulist_free(qgroups); 1771 ulist_free(old_roots); 1772 ulist_free(new_roots); 1773 return ret; 1774 } 1775 1776 int btrfs_qgroup_account_extents(struct btrfs_trans_handle *trans, 1777 struct btrfs_fs_info *fs_info) 1778 { 1779 struct btrfs_qgroup_extent_record *record; 1780 struct btrfs_delayed_ref_root *delayed_refs; 1781 struct ulist *new_roots = NULL; 1782 struct rb_node *node; 1783 u64 qgroup_to_skip; 1784 int ret = 0; 1785 1786 delayed_refs = &trans->transaction->delayed_refs; 1787 qgroup_to_skip = delayed_refs->qgroup_to_skip; 1788 while ((node = rb_first(&delayed_refs->dirty_extent_root))) { 1789 record = rb_entry(node, struct btrfs_qgroup_extent_record, 1790 node); 1791 1792 trace_btrfs_qgroup_account_extents(fs_info, record); 1793 1794 if (!ret) { 1795 /* 1796 * Use (u64)-1 as time_seq to do special search, which 1797 * doesn't lock tree or delayed_refs and search current 1798 * root. It's safe inside commit_transaction(). 1799 */ 1800 ret = btrfs_find_all_roots(trans, fs_info, 1801 record->bytenr, (u64)-1, &new_roots); 1802 if (ret < 0) 1803 goto cleanup; 1804 if (qgroup_to_skip) 1805 ulist_del(new_roots, qgroup_to_skip, 0); 1806 ret = btrfs_qgroup_account_extent(trans, fs_info, 1807 record->bytenr, record->num_bytes, 1808 record->old_roots, new_roots); 1809 record->old_roots = NULL; 1810 new_roots = NULL; 1811 } 1812 cleanup: 1813 ulist_free(record->old_roots); 1814 ulist_free(new_roots); 1815 new_roots = NULL; 1816 rb_erase(node, &delayed_refs->dirty_extent_root); 1817 kfree(record); 1818 1819 } 1820 return ret; 1821 } 1822 1823 /* 1824 * called from commit_transaction. Writes all changed qgroups to disk. 1825 */ 1826 int btrfs_run_qgroups(struct btrfs_trans_handle *trans, 1827 struct btrfs_fs_info *fs_info) 1828 { 1829 struct btrfs_root *quota_root = fs_info->quota_root; 1830 int ret = 0; 1831 int start_rescan_worker = 0; 1832 1833 if (!quota_root) 1834 goto out; 1835 1836 if (!fs_info->quota_enabled && fs_info->pending_quota_state) 1837 start_rescan_worker = 1; 1838 1839 fs_info->quota_enabled = fs_info->pending_quota_state; 1840 1841 spin_lock(&fs_info->qgroup_lock); 1842 while (!list_empty(&fs_info->dirty_qgroups)) { 1843 struct btrfs_qgroup *qgroup; 1844 qgroup = list_first_entry(&fs_info->dirty_qgroups, 1845 struct btrfs_qgroup, dirty); 1846 list_del_init(&qgroup->dirty); 1847 spin_unlock(&fs_info->qgroup_lock); 1848 ret = update_qgroup_info_item(trans, quota_root, qgroup); 1849 if (ret) 1850 fs_info->qgroup_flags |= 1851 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1852 ret = update_qgroup_limit_item(trans, quota_root, qgroup); 1853 if (ret) 1854 fs_info->qgroup_flags |= 1855 BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1856 spin_lock(&fs_info->qgroup_lock); 1857 } 1858 if (fs_info->quota_enabled) 1859 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_ON; 1860 else 1861 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_ON; 1862 spin_unlock(&fs_info->qgroup_lock); 1863 1864 ret = update_qgroup_status_item(trans, fs_info, quota_root); 1865 if (ret) 1866 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1867 1868 if (!ret && start_rescan_worker) { 1869 ret = qgroup_rescan_init(fs_info, 0, 1); 1870 if (!ret) { 1871 qgroup_rescan_zero_tracking(fs_info); 1872 btrfs_queue_work(fs_info->qgroup_rescan_workers, 1873 &fs_info->qgroup_rescan_work); 1874 } 1875 ret = 0; 1876 } 1877 1878 out: 1879 1880 return ret; 1881 } 1882 1883 /* 1884 * Copy the accounting information between qgroups. This is necessary 1885 * when a snapshot or a subvolume is created. Throwing an error will 1886 * cause a transaction abort so we take extra care here to only error 1887 * when a readonly fs is a reasonable outcome. 1888 */ 1889 int btrfs_qgroup_inherit(struct btrfs_trans_handle *trans, 1890 struct btrfs_fs_info *fs_info, u64 srcid, u64 objectid, 1891 struct btrfs_qgroup_inherit *inherit) 1892 { 1893 int ret = 0; 1894 int i; 1895 u64 *i_qgroups; 1896 struct btrfs_root *quota_root = fs_info->quota_root; 1897 struct btrfs_qgroup *srcgroup; 1898 struct btrfs_qgroup *dstgroup; 1899 u32 level_size = 0; 1900 u64 nums; 1901 1902 mutex_lock(&fs_info->qgroup_ioctl_lock); 1903 if (!fs_info->quota_enabled) 1904 goto out; 1905 1906 if (!quota_root) { 1907 ret = -EINVAL; 1908 goto out; 1909 } 1910 1911 if (inherit) { 1912 i_qgroups = (u64 *)(inherit + 1); 1913 nums = inherit->num_qgroups + 2 * inherit->num_ref_copies + 1914 2 * inherit->num_excl_copies; 1915 for (i = 0; i < nums; ++i) { 1916 srcgroup = find_qgroup_rb(fs_info, *i_qgroups); 1917 1918 /* 1919 * Zero out invalid groups so we can ignore 1920 * them later. 1921 */ 1922 if (!srcgroup || 1923 ((srcgroup->qgroupid >> 48) <= (objectid >> 48))) 1924 *i_qgroups = 0ULL; 1925 1926 ++i_qgroups; 1927 } 1928 } 1929 1930 /* 1931 * create a tracking group for the subvol itself 1932 */ 1933 ret = add_qgroup_item(trans, quota_root, objectid); 1934 if (ret) 1935 goto out; 1936 1937 if (srcid) { 1938 struct btrfs_root *srcroot; 1939 struct btrfs_key srckey; 1940 1941 srckey.objectid = srcid; 1942 srckey.type = BTRFS_ROOT_ITEM_KEY; 1943 srckey.offset = (u64)-1; 1944 srcroot = btrfs_read_fs_root_no_name(fs_info, &srckey); 1945 if (IS_ERR(srcroot)) { 1946 ret = PTR_ERR(srcroot); 1947 goto out; 1948 } 1949 1950 rcu_read_lock(); 1951 level_size = srcroot->nodesize; 1952 rcu_read_unlock(); 1953 } 1954 1955 /* 1956 * add qgroup to all inherited groups 1957 */ 1958 if (inherit) { 1959 i_qgroups = (u64 *)(inherit + 1); 1960 for (i = 0; i < inherit->num_qgroups; ++i, ++i_qgroups) { 1961 if (*i_qgroups == 0) 1962 continue; 1963 ret = add_qgroup_relation_item(trans, quota_root, 1964 objectid, *i_qgroups); 1965 if (ret && ret != -EEXIST) 1966 goto out; 1967 ret = add_qgroup_relation_item(trans, quota_root, 1968 *i_qgroups, objectid); 1969 if (ret && ret != -EEXIST) 1970 goto out; 1971 } 1972 ret = 0; 1973 } 1974 1975 1976 spin_lock(&fs_info->qgroup_lock); 1977 1978 dstgroup = add_qgroup_rb(fs_info, objectid); 1979 if (IS_ERR(dstgroup)) { 1980 ret = PTR_ERR(dstgroup); 1981 goto unlock; 1982 } 1983 1984 if (inherit && inherit->flags & BTRFS_QGROUP_INHERIT_SET_LIMITS) { 1985 dstgroup->lim_flags = inherit->lim.flags; 1986 dstgroup->max_rfer = inherit->lim.max_rfer; 1987 dstgroup->max_excl = inherit->lim.max_excl; 1988 dstgroup->rsv_rfer = inherit->lim.rsv_rfer; 1989 dstgroup->rsv_excl = inherit->lim.rsv_excl; 1990 1991 ret = update_qgroup_limit_item(trans, quota_root, dstgroup); 1992 if (ret) { 1993 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 1994 btrfs_info(fs_info, "unable to update quota limit for %llu", 1995 dstgroup->qgroupid); 1996 goto unlock; 1997 } 1998 } 1999 2000 if (srcid) { 2001 srcgroup = find_qgroup_rb(fs_info, srcid); 2002 if (!srcgroup) 2003 goto unlock; 2004 2005 /* 2006 * We call inherit after we clone the root in order to make sure 2007 * our counts don't go crazy, so at this point the only 2008 * difference between the two roots should be the root node. 2009 */ 2010 dstgroup->rfer = srcgroup->rfer; 2011 dstgroup->rfer_cmpr = srcgroup->rfer_cmpr; 2012 dstgroup->excl = level_size; 2013 dstgroup->excl_cmpr = level_size; 2014 srcgroup->excl = level_size; 2015 srcgroup->excl_cmpr = level_size; 2016 2017 /* inherit the limit info */ 2018 dstgroup->lim_flags = srcgroup->lim_flags; 2019 dstgroup->max_rfer = srcgroup->max_rfer; 2020 dstgroup->max_excl = srcgroup->max_excl; 2021 dstgroup->rsv_rfer = srcgroup->rsv_rfer; 2022 dstgroup->rsv_excl = srcgroup->rsv_excl; 2023 2024 qgroup_dirty(fs_info, dstgroup); 2025 qgroup_dirty(fs_info, srcgroup); 2026 } 2027 2028 if (!inherit) 2029 goto unlock; 2030 2031 i_qgroups = (u64 *)(inherit + 1); 2032 for (i = 0; i < inherit->num_qgroups; ++i) { 2033 if (*i_qgroups) { 2034 ret = add_relation_rb(quota_root->fs_info, objectid, 2035 *i_qgroups); 2036 if (ret) 2037 goto unlock; 2038 } 2039 ++i_qgroups; 2040 } 2041 2042 for (i = 0; i < inherit->num_ref_copies; ++i, i_qgroups += 2) { 2043 struct btrfs_qgroup *src; 2044 struct btrfs_qgroup *dst; 2045 2046 if (!i_qgroups[0] || !i_qgroups[1]) 2047 continue; 2048 2049 src = find_qgroup_rb(fs_info, i_qgroups[0]); 2050 dst = find_qgroup_rb(fs_info, i_qgroups[1]); 2051 2052 if (!src || !dst) { 2053 ret = -EINVAL; 2054 goto unlock; 2055 } 2056 2057 dst->rfer = src->rfer - level_size; 2058 dst->rfer_cmpr = src->rfer_cmpr - level_size; 2059 } 2060 for (i = 0; i < inherit->num_excl_copies; ++i, i_qgroups += 2) { 2061 struct btrfs_qgroup *src; 2062 struct btrfs_qgroup *dst; 2063 2064 if (!i_qgroups[0] || !i_qgroups[1]) 2065 continue; 2066 2067 src = find_qgroup_rb(fs_info, i_qgroups[0]); 2068 dst = find_qgroup_rb(fs_info, i_qgroups[1]); 2069 2070 if (!src || !dst) { 2071 ret = -EINVAL; 2072 goto unlock; 2073 } 2074 2075 dst->excl = src->excl + level_size; 2076 dst->excl_cmpr = src->excl_cmpr + level_size; 2077 } 2078 2079 unlock: 2080 spin_unlock(&fs_info->qgroup_lock); 2081 out: 2082 mutex_unlock(&fs_info->qgroup_ioctl_lock); 2083 return ret; 2084 } 2085 2086 static int qgroup_reserve(struct btrfs_root *root, u64 num_bytes) 2087 { 2088 struct btrfs_root *quota_root; 2089 struct btrfs_qgroup *qgroup; 2090 struct btrfs_fs_info *fs_info = root->fs_info; 2091 u64 ref_root = root->root_key.objectid; 2092 int ret = 0; 2093 struct ulist_node *unode; 2094 struct ulist_iterator uiter; 2095 2096 if (!is_fstree(ref_root)) 2097 return 0; 2098 2099 if (num_bytes == 0) 2100 return 0; 2101 2102 spin_lock(&fs_info->qgroup_lock); 2103 quota_root = fs_info->quota_root; 2104 if (!quota_root) 2105 goto out; 2106 2107 qgroup = find_qgroup_rb(fs_info, ref_root); 2108 if (!qgroup) 2109 goto out; 2110 2111 /* 2112 * in a first step, we check all affected qgroups if any limits would 2113 * be exceeded 2114 */ 2115 ulist_reinit(fs_info->qgroup_ulist); 2116 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid, 2117 (uintptr_t)qgroup, GFP_ATOMIC); 2118 if (ret < 0) 2119 goto out; 2120 ULIST_ITER_INIT(&uiter); 2121 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) { 2122 struct btrfs_qgroup *qg; 2123 struct btrfs_qgroup_list *glist; 2124 2125 qg = u64_to_ptr(unode->aux); 2126 2127 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_RFER) && 2128 qg->reserved + (s64)qg->rfer + num_bytes > 2129 qg->max_rfer) { 2130 ret = -EDQUOT; 2131 goto out; 2132 } 2133 2134 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_EXCL) && 2135 qg->reserved + (s64)qg->excl + num_bytes > 2136 qg->max_excl) { 2137 ret = -EDQUOT; 2138 goto out; 2139 } 2140 2141 list_for_each_entry(glist, &qg->groups, next_group) { 2142 ret = ulist_add(fs_info->qgroup_ulist, 2143 glist->group->qgroupid, 2144 (uintptr_t)glist->group, GFP_ATOMIC); 2145 if (ret < 0) 2146 goto out; 2147 } 2148 } 2149 ret = 0; 2150 /* 2151 * no limits exceeded, now record the reservation into all qgroups 2152 */ 2153 ULIST_ITER_INIT(&uiter); 2154 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) { 2155 struct btrfs_qgroup *qg; 2156 2157 qg = u64_to_ptr(unode->aux); 2158 2159 qg->reserved += num_bytes; 2160 } 2161 2162 out: 2163 spin_unlock(&fs_info->qgroup_lock); 2164 return ret; 2165 } 2166 2167 void btrfs_qgroup_free_refroot(struct btrfs_fs_info *fs_info, 2168 u64 ref_root, u64 num_bytes) 2169 { 2170 struct btrfs_root *quota_root; 2171 struct btrfs_qgroup *qgroup; 2172 struct ulist_node *unode; 2173 struct ulist_iterator uiter; 2174 int ret = 0; 2175 2176 if (!is_fstree(ref_root)) 2177 return; 2178 2179 if (num_bytes == 0) 2180 return; 2181 2182 spin_lock(&fs_info->qgroup_lock); 2183 2184 quota_root = fs_info->quota_root; 2185 if (!quota_root) 2186 goto out; 2187 2188 qgroup = find_qgroup_rb(fs_info, ref_root); 2189 if (!qgroup) 2190 goto out; 2191 2192 ulist_reinit(fs_info->qgroup_ulist); 2193 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid, 2194 (uintptr_t)qgroup, GFP_ATOMIC); 2195 if (ret < 0) 2196 goto out; 2197 ULIST_ITER_INIT(&uiter); 2198 while ((unode = ulist_next(fs_info->qgroup_ulist, &uiter))) { 2199 struct btrfs_qgroup *qg; 2200 struct btrfs_qgroup_list *glist; 2201 2202 qg = u64_to_ptr(unode->aux); 2203 2204 qg->reserved -= num_bytes; 2205 2206 list_for_each_entry(glist, &qg->groups, next_group) { 2207 ret = ulist_add(fs_info->qgroup_ulist, 2208 glist->group->qgroupid, 2209 (uintptr_t)glist->group, GFP_ATOMIC); 2210 if (ret < 0) 2211 goto out; 2212 } 2213 } 2214 2215 out: 2216 spin_unlock(&fs_info->qgroup_lock); 2217 } 2218 2219 static inline void qgroup_free(struct btrfs_root *root, u64 num_bytes) 2220 { 2221 return btrfs_qgroup_free_refroot(root->fs_info, root->objectid, 2222 num_bytes); 2223 } 2224 void assert_qgroups_uptodate(struct btrfs_trans_handle *trans) 2225 { 2226 if (list_empty(&trans->qgroup_ref_list) && !trans->delayed_ref_elem.seq) 2227 return; 2228 btrfs_err(trans->fs_info, 2229 "qgroups not uptodate in trans handle %p: list is%s empty, " 2230 "seq is %#x.%x", 2231 trans, list_empty(&trans->qgroup_ref_list) ? "" : " not", 2232 (u32)(trans->delayed_ref_elem.seq >> 32), 2233 (u32)trans->delayed_ref_elem.seq); 2234 BUG(); 2235 } 2236 2237 /* 2238 * returns < 0 on error, 0 when more leafs are to be scanned. 2239 * returns 1 when done. 2240 */ 2241 static int 2242 qgroup_rescan_leaf(struct btrfs_fs_info *fs_info, struct btrfs_path *path, 2243 struct btrfs_trans_handle *trans) 2244 { 2245 struct btrfs_key found; 2246 struct extent_buffer *scratch_leaf = NULL; 2247 struct ulist *roots = NULL; 2248 struct seq_list tree_mod_seq_elem = SEQ_LIST_INIT(tree_mod_seq_elem); 2249 u64 num_bytes; 2250 int slot; 2251 int ret; 2252 2253 mutex_lock(&fs_info->qgroup_rescan_lock); 2254 ret = btrfs_search_slot_for_read(fs_info->extent_root, 2255 &fs_info->qgroup_rescan_progress, 2256 path, 1, 0); 2257 2258 pr_debug("current progress key (%llu %u %llu), search_slot ret %d\n", 2259 fs_info->qgroup_rescan_progress.objectid, 2260 fs_info->qgroup_rescan_progress.type, 2261 fs_info->qgroup_rescan_progress.offset, ret); 2262 2263 if (ret) { 2264 /* 2265 * The rescan is about to end, we will not be scanning any 2266 * further blocks. We cannot unset the RESCAN flag here, because 2267 * we want to commit the transaction if everything went well. 2268 * To make the live accounting work in this phase, we set our 2269 * scan progress pointer such that every real extent objectid 2270 * will be smaller. 2271 */ 2272 fs_info->qgroup_rescan_progress.objectid = (u64)-1; 2273 btrfs_release_path(path); 2274 mutex_unlock(&fs_info->qgroup_rescan_lock); 2275 return ret; 2276 } 2277 2278 btrfs_item_key_to_cpu(path->nodes[0], &found, 2279 btrfs_header_nritems(path->nodes[0]) - 1); 2280 fs_info->qgroup_rescan_progress.objectid = found.objectid + 1; 2281 2282 btrfs_get_tree_mod_seq(fs_info, &tree_mod_seq_elem); 2283 scratch_leaf = btrfs_clone_extent_buffer(path->nodes[0]); 2284 if (!scratch_leaf) { 2285 ret = -ENOMEM; 2286 mutex_unlock(&fs_info->qgroup_rescan_lock); 2287 goto out; 2288 } 2289 extent_buffer_get(scratch_leaf); 2290 btrfs_tree_read_lock(scratch_leaf); 2291 btrfs_set_lock_blocking_rw(scratch_leaf, BTRFS_READ_LOCK); 2292 slot = path->slots[0]; 2293 btrfs_release_path(path); 2294 mutex_unlock(&fs_info->qgroup_rescan_lock); 2295 2296 for (; slot < btrfs_header_nritems(scratch_leaf); ++slot) { 2297 btrfs_item_key_to_cpu(scratch_leaf, &found, slot); 2298 if (found.type != BTRFS_EXTENT_ITEM_KEY && 2299 found.type != BTRFS_METADATA_ITEM_KEY) 2300 continue; 2301 if (found.type == BTRFS_METADATA_ITEM_KEY) 2302 num_bytes = fs_info->extent_root->nodesize; 2303 else 2304 num_bytes = found.offset; 2305 2306 ret = btrfs_find_all_roots(NULL, fs_info, found.objectid, 0, 2307 &roots); 2308 if (ret < 0) 2309 goto out; 2310 /* For rescan, just pass old_roots as NULL */ 2311 ret = btrfs_qgroup_account_extent(trans, fs_info, 2312 found.objectid, num_bytes, NULL, roots); 2313 if (ret < 0) 2314 goto out; 2315 } 2316 out: 2317 if (scratch_leaf) { 2318 btrfs_tree_read_unlock_blocking(scratch_leaf); 2319 free_extent_buffer(scratch_leaf); 2320 } 2321 btrfs_put_tree_mod_seq(fs_info, &tree_mod_seq_elem); 2322 2323 return ret; 2324 } 2325 2326 static void btrfs_qgroup_rescan_worker(struct btrfs_work *work) 2327 { 2328 struct btrfs_fs_info *fs_info = container_of(work, struct btrfs_fs_info, 2329 qgroup_rescan_work); 2330 struct btrfs_path *path; 2331 struct btrfs_trans_handle *trans = NULL; 2332 int err = -ENOMEM; 2333 int ret = 0; 2334 2335 mutex_lock(&fs_info->qgroup_rescan_lock); 2336 fs_info->qgroup_rescan_running = true; 2337 mutex_unlock(&fs_info->qgroup_rescan_lock); 2338 2339 path = btrfs_alloc_path(); 2340 if (!path) 2341 goto out; 2342 2343 err = 0; 2344 while (!err && !btrfs_fs_closing(fs_info)) { 2345 trans = btrfs_start_transaction(fs_info->fs_root, 0); 2346 if (IS_ERR(trans)) { 2347 err = PTR_ERR(trans); 2348 break; 2349 } 2350 if (!fs_info->quota_enabled) { 2351 err = -EINTR; 2352 } else { 2353 err = qgroup_rescan_leaf(fs_info, path, trans); 2354 } 2355 if (err > 0) 2356 btrfs_commit_transaction(trans, fs_info->fs_root); 2357 else 2358 btrfs_end_transaction(trans, fs_info->fs_root); 2359 } 2360 2361 out: 2362 btrfs_free_path(path); 2363 2364 mutex_lock(&fs_info->qgroup_rescan_lock); 2365 if (!btrfs_fs_closing(fs_info)) 2366 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 2367 2368 if (err > 0 && 2369 fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT) { 2370 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2371 } else if (err < 0) { 2372 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT; 2373 } 2374 mutex_unlock(&fs_info->qgroup_rescan_lock); 2375 2376 /* 2377 * only update status, since the previous part has already updated the 2378 * qgroup info. 2379 */ 2380 trans = btrfs_start_transaction(fs_info->quota_root, 1); 2381 if (IS_ERR(trans)) { 2382 err = PTR_ERR(trans); 2383 btrfs_err(fs_info, 2384 "fail to start transaction for status update: %d\n", 2385 err); 2386 goto done; 2387 } 2388 ret = update_qgroup_status_item(trans, fs_info, fs_info->quota_root); 2389 if (ret < 0) { 2390 err = ret; 2391 btrfs_err(fs_info, "fail to update qgroup status: %d\n", err); 2392 } 2393 btrfs_end_transaction(trans, fs_info->quota_root); 2394 2395 if (btrfs_fs_closing(fs_info)) { 2396 btrfs_info(fs_info, "qgroup scan paused"); 2397 } else if (err >= 0) { 2398 btrfs_info(fs_info, "qgroup scan completed%s", 2399 err > 0 ? " (inconsistency flag cleared)" : ""); 2400 } else { 2401 btrfs_err(fs_info, "qgroup scan failed with %d", err); 2402 } 2403 2404 done: 2405 mutex_lock(&fs_info->qgroup_rescan_lock); 2406 fs_info->qgroup_rescan_running = false; 2407 mutex_unlock(&fs_info->qgroup_rescan_lock); 2408 complete_all(&fs_info->qgroup_rescan_completion); 2409 } 2410 2411 /* 2412 * Checks that (a) no rescan is running and (b) quota is enabled. Allocates all 2413 * memory required for the rescan context. 2414 */ 2415 static int 2416 qgroup_rescan_init(struct btrfs_fs_info *fs_info, u64 progress_objectid, 2417 int init_flags) 2418 { 2419 int ret = 0; 2420 2421 if (!init_flags && 2422 (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) || 2423 !(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON))) { 2424 ret = -EINVAL; 2425 goto err; 2426 } 2427 2428 mutex_lock(&fs_info->qgroup_rescan_lock); 2429 spin_lock(&fs_info->qgroup_lock); 2430 2431 if (init_flags) { 2432 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) 2433 ret = -EINPROGRESS; 2434 else if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)) 2435 ret = -EINVAL; 2436 2437 if (ret) { 2438 spin_unlock(&fs_info->qgroup_lock); 2439 mutex_unlock(&fs_info->qgroup_rescan_lock); 2440 goto err; 2441 } 2442 fs_info->qgroup_flags |= BTRFS_QGROUP_STATUS_FLAG_RESCAN; 2443 } 2444 2445 memset(&fs_info->qgroup_rescan_progress, 0, 2446 sizeof(fs_info->qgroup_rescan_progress)); 2447 fs_info->qgroup_rescan_progress.objectid = progress_objectid; 2448 init_completion(&fs_info->qgroup_rescan_completion); 2449 2450 spin_unlock(&fs_info->qgroup_lock); 2451 mutex_unlock(&fs_info->qgroup_rescan_lock); 2452 2453 memset(&fs_info->qgroup_rescan_work, 0, 2454 sizeof(fs_info->qgroup_rescan_work)); 2455 btrfs_init_work(&fs_info->qgroup_rescan_work, 2456 btrfs_qgroup_rescan_helper, 2457 btrfs_qgroup_rescan_worker, NULL, NULL); 2458 2459 if (ret) { 2460 err: 2461 btrfs_info(fs_info, "qgroup_rescan_init failed with %d", ret); 2462 return ret; 2463 } 2464 2465 return 0; 2466 } 2467 2468 static void 2469 qgroup_rescan_zero_tracking(struct btrfs_fs_info *fs_info) 2470 { 2471 struct rb_node *n; 2472 struct btrfs_qgroup *qgroup; 2473 2474 spin_lock(&fs_info->qgroup_lock); 2475 /* clear all current qgroup tracking information */ 2476 for (n = rb_first(&fs_info->qgroup_tree); n; n = rb_next(n)) { 2477 qgroup = rb_entry(n, struct btrfs_qgroup, node); 2478 qgroup->rfer = 0; 2479 qgroup->rfer_cmpr = 0; 2480 qgroup->excl = 0; 2481 qgroup->excl_cmpr = 0; 2482 } 2483 spin_unlock(&fs_info->qgroup_lock); 2484 } 2485 2486 int 2487 btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info) 2488 { 2489 int ret = 0; 2490 struct btrfs_trans_handle *trans; 2491 2492 ret = qgroup_rescan_init(fs_info, 0, 1); 2493 if (ret) 2494 return ret; 2495 2496 /* 2497 * We have set the rescan_progress to 0, which means no more 2498 * delayed refs will be accounted by btrfs_qgroup_account_ref. 2499 * However, btrfs_qgroup_account_ref may be right after its call 2500 * to btrfs_find_all_roots, in which case it would still do the 2501 * accounting. 2502 * To solve this, we're committing the transaction, which will 2503 * ensure we run all delayed refs and only after that, we are 2504 * going to clear all tracking information for a clean start. 2505 */ 2506 2507 trans = btrfs_join_transaction(fs_info->fs_root); 2508 if (IS_ERR(trans)) { 2509 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 2510 return PTR_ERR(trans); 2511 } 2512 ret = btrfs_commit_transaction(trans, fs_info->fs_root); 2513 if (ret) { 2514 fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN; 2515 return ret; 2516 } 2517 2518 qgroup_rescan_zero_tracking(fs_info); 2519 2520 btrfs_queue_work(fs_info->qgroup_rescan_workers, 2521 &fs_info->qgroup_rescan_work); 2522 2523 return 0; 2524 } 2525 2526 int btrfs_qgroup_wait_for_completion(struct btrfs_fs_info *fs_info, 2527 bool interruptible) 2528 { 2529 int running; 2530 int ret = 0; 2531 2532 mutex_lock(&fs_info->qgroup_rescan_lock); 2533 spin_lock(&fs_info->qgroup_lock); 2534 running = fs_info->qgroup_rescan_running; 2535 spin_unlock(&fs_info->qgroup_lock); 2536 mutex_unlock(&fs_info->qgroup_rescan_lock); 2537 2538 if (!running) 2539 return 0; 2540 2541 if (interruptible) 2542 ret = wait_for_completion_interruptible( 2543 &fs_info->qgroup_rescan_completion); 2544 else 2545 wait_for_completion(&fs_info->qgroup_rescan_completion); 2546 2547 return ret; 2548 } 2549 2550 /* 2551 * this is only called from open_ctree where we're still single threaded, thus 2552 * locking is omitted here. 2553 */ 2554 void 2555 btrfs_qgroup_rescan_resume(struct btrfs_fs_info *fs_info) 2556 { 2557 if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN) 2558 btrfs_queue_work(fs_info->qgroup_rescan_workers, 2559 &fs_info->qgroup_rescan_work); 2560 } 2561 2562 /* 2563 * Reserve qgroup space for range [start, start + len). 2564 * 2565 * This function will either reserve space from related qgroups or doing 2566 * nothing if the range is already reserved. 2567 * 2568 * Return 0 for successful reserve 2569 * Return <0 for error (including -EQUOT) 2570 * 2571 * NOTE: this function may sleep for memory allocation. 2572 */ 2573 int btrfs_qgroup_reserve_data(struct inode *inode, u64 start, u64 len) 2574 { 2575 struct btrfs_root *root = BTRFS_I(inode)->root; 2576 struct extent_changeset changeset; 2577 struct ulist_node *unode; 2578 struct ulist_iterator uiter; 2579 int ret; 2580 2581 if (!root->fs_info->quota_enabled || !is_fstree(root->objectid) || 2582 len == 0) 2583 return 0; 2584 2585 changeset.bytes_changed = 0; 2586 changeset.range_changed = ulist_alloc(GFP_NOFS); 2587 ret = set_record_extent_bits(&BTRFS_I(inode)->io_tree, start, 2588 start + len -1, EXTENT_QGROUP_RESERVED, &changeset); 2589 trace_btrfs_qgroup_reserve_data(inode, start, len, 2590 changeset.bytes_changed, 2591 QGROUP_RESERVE); 2592 if (ret < 0) 2593 goto cleanup; 2594 ret = qgroup_reserve(root, changeset.bytes_changed); 2595 if (ret < 0) 2596 goto cleanup; 2597 2598 ulist_free(changeset.range_changed); 2599 return ret; 2600 2601 cleanup: 2602 /* cleanup already reserved ranges */ 2603 ULIST_ITER_INIT(&uiter); 2604 while ((unode = ulist_next(changeset.range_changed, &uiter))) 2605 clear_extent_bit(&BTRFS_I(inode)->io_tree, unode->val, 2606 unode->aux, EXTENT_QGROUP_RESERVED, 0, 0, NULL, 2607 GFP_NOFS); 2608 ulist_free(changeset.range_changed); 2609 return ret; 2610 } 2611 2612 static int __btrfs_qgroup_release_data(struct inode *inode, u64 start, u64 len, 2613 int free) 2614 { 2615 struct extent_changeset changeset; 2616 int trace_op = QGROUP_RELEASE; 2617 int ret; 2618 2619 changeset.bytes_changed = 0; 2620 changeset.range_changed = ulist_alloc(GFP_NOFS); 2621 if (!changeset.range_changed) 2622 return -ENOMEM; 2623 2624 ret = clear_record_extent_bits(&BTRFS_I(inode)->io_tree, start, 2625 start + len -1, EXTENT_QGROUP_RESERVED, &changeset); 2626 if (ret < 0) 2627 goto out; 2628 2629 if (free) { 2630 qgroup_free(BTRFS_I(inode)->root, changeset.bytes_changed); 2631 trace_op = QGROUP_FREE; 2632 } 2633 trace_btrfs_qgroup_release_data(inode, start, len, 2634 changeset.bytes_changed, trace_op); 2635 out: 2636 ulist_free(changeset.range_changed); 2637 return ret; 2638 } 2639 2640 /* 2641 * Free a reserved space range from io_tree and related qgroups 2642 * 2643 * Should be called when a range of pages get invalidated before reaching disk. 2644 * Or for error cleanup case. 2645 * 2646 * For data written to disk, use btrfs_qgroup_release_data(). 2647 * 2648 * NOTE: This function may sleep for memory allocation. 2649 */ 2650 int btrfs_qgroup_free_data(struct inode *inode, u64 start, u64 len) 2651 { 2652 return __btrfs_qgroup_release_data(inode, start, len, 1); 2653 } 2654 2655 /* 2656 * Release a reserved space range from io_tree only. 2657 * 2658 * Should be called when a range of pages get written to disk and corresponding 2659 * FILE_EXTENT is inserted into corresponding root. 2660 * 2661 * Since new qgroup accounting framework will only update qgroup numbers at 2662 * commit_transaction() time, its reserved space shouldn't be freed from 2663 * related qgroups. 2664 * 2665 * But we should release the range from io_tree, to allow further write to be 2666 * COWed. 2667 * 2668 * NOTE: This function may sleep for memory allocation. 2669 */ 2670 int btrfs_qgroup_release_data(struct inode *inode, u64 start, u64 len) 2671 { 2672 return __btrfs_qgroup_release_data(inode, start, len, 0); 2673 } 2674 2675 int btrfs_qgroup_reserve_meta(struct btrfs_root *root, int num_bytes) 2676 { 2677 int ret; 2678 2679 if (!root->fs_info->quota_enabled || !is_fstree(root->objectid) || 2680 num_bytes == 0) 2681 return 0; 2682 2683 BUG_ON(num_bytes != round_down(num_bytes, root->nodesize)); 2684 ret = qgroup_reserve(root, num_bytes); 2685 if (ret < 0) 2686 return ret; 2687 atomic_add(num_bytes, &root->qgroup_meta_rsv); 2688 return ret; 2689 } 2690 2691 void btrfs_qgroup_free_meta_all(struct btrfs_root *root) 2692 { 2693 int reserved; 2694 2695 if (!root->fs_info->quota_enabled || !is_fstree(root->objectid)) 2696 return; 2697 2698 reserved = atomic_xchg(&root->qgroup_meta_rsv, 0); 2699 if (reserved == 0) 2700 return; 2701 qgroup_free(root, reserved); 2702 } 2703 2704 void btrfs_qgroup_free_meta(struct btrfs_root *root, int num_bytes) 2705 { 2706 if (!root->fs_info->quota_enabled || !is_fstree(root->objectid)) 2707 return; 2708 2709 BUG_ON(num_bytes != round_down(num_bytes, root->nodesize)); 2710 WARN_ON(atomic_read(&root->qgroup_meta_rsv) < num_bytes); 2711 atomic_sub(num_bytes, &root->qgroup_meta_rsv); 2712 qgroup_free(root, num_bytes); 2713 } 2714 2715 /* 2716 * Check qgroup reserved space leaking, normally at destroy inode 2717 * time 2718 */ 2719 void btrfs_qgroup_check_reserved_leak(struct inode *inode) 2720 { 2721 struct extent_changeset changeset; 2722 struct ulist_node *unode; 2723 struct ulist_iterator iter; 2724 int ret; 2725 2726 changeset.bytes_changed = 0; 2727 changeset.range_changed = ulist_alloc(GFP_NOFS); 2728 if (WARN_ON(!changeset.range_changed)) 2729 return; 2730 2731 ret = clear_record_extent_bits(&BTRFS_I(inode)->io_tree, 0, (u64)-1, 2732 EXTENT_QGROUP_RESERVED, &changeset); 2733 2734 WARN_ON(ret < 0); 2735 if (WARN_ON(changeset.bytes_changed)) { 2736 ULIST_ITER_INIT(&iter); 2737 while ((unode = ulist_next(changeset.range_changed, &iter))) { 2738 btrfs_warn(BTRFS_I(inode)->root->fs_info, 2739 "leaking qgroup reserved space, ino: %lu, start: %llu, end: %llu", 2740 inode->i_ino, unode->val, unode->aux); 2741 } 2742 qgroup_free(BTRFS_I(inode)->root, changeset.bytes_changed); 2743 } 2744 ulist_free(changeset.range_changed); 2745 } 2746