Lines Matching defs:qgroup
23 #include "qgroup.h"
40 * Helpers to access qgroup reservation
45 static u64 qgroup_rsv_total(const struct btrfs_qgroup *qgroup)
51 ret += qgroup->rsv.values[i];
70 struct btrfs_qgroup *qgroup, u64 num_bytes,
73 trace_qgroup_update_reserve(fs_info, qgroup, num_bytes, type);
74 qgroup->rsv.values[type] += num_bytes;
78 struct btrfs_qgroup *qgroup, u64 num_bytes,
81 trace_qgroup_update_reserve(fs_info, qgroup, -(s64)num_bytes, type);
82 if (qgroup->rsv.values[type] >= num_bytes) {
83 qgroup->rsv.values[type] -= num_bytes;
88 "qgroup %llu %s reserved space underflow, have %llu to free %llu",
89 qgroup->qgroupid, qgroup_rsv_type_str(type),
90 qgroup->rsv.values[type], num_bytes);
92 qgroup->rsv.values[type] = 0;
175 struct btrfs_qgroup *qgroup;
178 qgroup = rb_entry(n, struct btrfs_qgroup, node);
179 if (qgroup->qgroupid < qgroupid)
181 else if (qgroup->qgroupid > qgroupid)
184 return qgroup;
195 struct btrfs_qgroup *qgroup;
199 qgroup = rb_entry(parent, struct btrfs_qgroup, node);
201 if (qgroup->qgroupid < qgroupid)
203 else if (qgroup->qgroupid > qgroupid)
206 return qgroup;
209 qgroup = kzalloc(sizeof(*qgroup), GFP_ATOMIC);
210 if (!qgroup)
213 qgroup->qgroupid = qgroupid;
214 INIT_LIST_HEAD(&qgroup->groups);
215 INIT_LIST_HEAD(&qgroup->members);
216 INIT_LIST_HEAD(&qgroup->dirty);
218 rb_link_node(&qgroup->node, parent, p);
219 rb_insert_color(&qgroup->node, &fs_info->qgroup_tree);
221 return qgroup;
225 struct btrfs_qgroup *qgroup)
229 list_del(&qgroup->dirty);
230 while (!list_empty(&qgroup->groups)) {
231 list = list_first_entry(&qgroup->groups,
238 while (!list_empty(&qgroup->members)) {
239 list = list_first_entry(&qgroup->members,
250 struct btrfs_qgroup *qgroup = find_qgroup_rb(fs_info, qgroupid);
252 if (!qgroup)
255 rb_erase(&qgroup->node, &fs_info->qgroup_tree);
256 __del_qgroup_rb(fs_info, qgroup);
313 struct btrfs_qgroup *qgroup;
315 qgroup = find_qgroup_rb(fs_info, qgroupid);
316 if (!qgroup)
318 if (qgroup->rfer != rfer || qgroup->excl != excl)
362 * pass 1: read status, all qgroup infos and limits
372 struct btrfs_qgroup *qgroup;
387 "old qgroup version, quota disabled");
394 "qgroup generation mismatch, marked as inconsistent");
406 qgroup = find_qgroup_rb(fs_info, found_key.offset);
407 if ((qgroup && found_key.type == BTRFS_QGROUP_INFO_KEY) ||
408 (!qgroup && found_key.type == BTRFS_QGROUP_LIMIT_KEY)) {
409 btrfs_err(fs_info, "inconsistent qgroup config");
412 if (!qgroup) {
413 qgroup = add_qgroup_rb(fs_info, found_key.offset);
414 if (IS_ERR(qgroup)) {
415 ret = PTR_ERR(qgroup);
419 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
429 qgroup->rfer = btrfs_qgroup_info_rfer(l, ptr);
430 qgroup->rfer_cmpr = btrfs_qgroup_info_rfer_cmpr(l, ptr);
431 qgroup->excl = btrfs_qgroup_info_excl(l, ptr);
432 qgroup->excl_cmpr = btrfs_qgroup_info_excl_cmpr(l, ptr);
441 qgroup->lim_flags = btrfs_qgroup_limit_flags(l, ptr);
442 qgroup->max_rfer = btrfs_qgroup_limit_max_rfer(l, ptr);
443 qgroup->max_excl = btrfs_qgroup_limit_max_excl(l, ptr);
444 qgroup->rsv_rfer = btrfs_qgroup_limit_rsv_rfer(l, ptr);
445 qgroup->rsv_excl = btrfs_qgroup_limit_rsv_excl(l, ptr);
459 * pass 2: read all qgroup relations
485 "orphan qgroup relation 0x%llx->0x%llx",
532 * Since we're unmounting, there is no race and no need to grab qgroup
537 struct btrfs_qgroup *qgroup;
540 qgroup = rb_entry(node, struct btrfs_qgroup, node);
542 if (qgroup->rsv.values[i]) {
545 "qgroup %hu/%llu has unreleased space, type %d rsv %llu",
546 btrfs_qgroup_level(qgroup->qgroupid),
547 btrfs_qgroup_subvolid(qgroup->qgroupid),
548 i, qgroup->rsv.values[i]);
564 struct btrfs_qgroup *qgroup;
567 qgroup = rb_entry(n, struct btrfs_qgroup, node);
569 __del_qgroup_rb(fs_info, qgroup);
570 btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
571 kfree(qgroup);
753 struct btrfs_qgroup *qgroup)
765 key.offset = qgroup->qgroupid;
781 btrfs_set_qgroup_limit_flags(l, qgroup_limit, qgroup->lim_flags);
782 btrfs_set_qgroup_limit_max_rfer(l, qgroup_limit, qgroup->max_rfer);
783 btrfs_set_qgroup_limit_max_excl(l, qgroup_limit, qgroup->max_excl);
784 btrfs_set_qgroup_limit_rsv_rfer(l, qgroup_limit, qgroup->rsv_rfer);
785 btrfs_set_qgroup_limit_rsv_excl(l, qgroup_limit, qgroup->rsv_excl);
795 struct btrfs_qgroup *qgroup)
811 key.offset = qgroup->qgroupid;
828 btrfs_set_qgroup_info_rfer(l, qgroup_info, qgroup->rfer);
829 btrfs_set_qgroup_info_rfer_cmpr(l, qgroup_info, qgroup->rfer_cmpr);
830 btrfs_set_qgroup_info_excl(l, qgroup_info, qgroup->excl);
831 btrfs_set_qgroup_info_excl_cmpr(l, qgroup_info, qgroup->excl_cmpr);
938 struct btrfs_qgroup *qgroup = NULL;
1074 qgroup = add_qgroup_rb(fs_info, found_key.offset);
1075 if (IS_ERR(qgroup)) {
1076 ret = PTR_ERR(qgroup);
1080 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
1117 qgroup = add_qgroup_rb(fs_info, BTRFS_FS_TREE_OBJECTID);
1118 if (IS_ERR(qgroup)) {
1119 ret = PTR_ERR(qgroup);
1123 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
1132 * a deadlock with tasks concurrently doing other qgroup operations, such
1133 * adding/removing qgroups or adding/deleting qgroup relations for example,
1134 * because all qgroup operations first start or join a transaction and then
1235 * Request qgroup rescan worker to complete and wait for it. This wait
1237 * deadlock with transaction by the qgroup rescan worker.
1307 struct btrfs_qgroup *qgroup)
1309 if (list_empty(&qgroup->dirty))
1310 list_add(&qgroup->dirty, &fs_info->dirty_qgroups);
1314 * The easy accounting, we're updating qgroup relationship whose child qgroup
1320 * So is qgroup reservation space, which should also be added/removed to
1331 struct btrfs_qgroup *qgroup;
1338 qgroup = find_qgroup_rb(fs_info, ref_root);
1339 if (!qgroup)
1342 qgroup->rfer += sign * num_bytes;
1343 qgroup->rfer_cmpr += sign * num_bytes;
1345 WARN_ON(sign < 0 && qgroup->excl < num_bytes);
1346 qgroup->excl += sign * num_bytes;
1347 qgroup->excl_cmpr += sign * num_bytes;
1350 qgroup_rsv_add_by_qgroup(fs_info, qgroup, src);
1352 qgroup_rsv_release_by_qgroup(fs_info, qgroup, src);
1354 qgroup_dirty(fs_info, qgroup);
1356 /* Get all of the parent groups that contain this qgroup */
1357 list_for_each_entry(glist, &qgroup->groups, next_group) {
1367 qgroup = unode_aux_to_qgroup(unode);
1368 qgroup->rfer += sign * num_bytes;
1369 qgroup->rfer_cmpr += sign * num_bytes;
1370 WARN_ON(sign < 0 && qgroup->excl < num_bytes);
1371 qgroup->excl += sign * num_bytes;
1373 qgroup_rsv_add_by_qgroup(fs_info, qgroup, src);
1375 qgroup_rsv_release_by_qgroup(fs_info, qgroup, src);
1376 qgroup->excl_cmpr += sign * num_bytes;
1377 qgroup_dirty(fs_info, qgroup);
1380 list_for_each_entry(glist, &qgroup->groups, next_group) {
1394 * Quick path for updating qgroup with only excl refs.
1408 struct btrfs_qgroup *qgroup;
1412 qgroup = find_qgroup_rb(fs_info, src);
1413 if (!qgroup)
1415 if (qgroup->excl == qgroup->rfer) {
1418 qgroup, sign);
1464 /* check if such qgroup relation exist firstly */
1530 /* check if such qgroup relation exist firstly */
1578 struct btrfs_qgroup *qgroup;
1587 qgroup = find_qgroup_rb(fs_info, qgroupid);
1588 if (qgroup) {
1598 qgroup = add_qgroup_rb(fs_info, qgroupid);
1601 if (IS_ERR(qgroup)) {
1602 ret = PTR_ERR(qgroup);
1605 ret = btrfs_sysfs_add_one_qgroup(fs_info, qgroup);
1611 static bool qgroup_has_usage(struct btrfs_qgroup *qgroup)
1613 return (qgroup->rfer > 0 || qgroup->rfer_cmpr > 0 ||
1614 qgroup->excl > 0 || qgroup->excl_cmpr > 0 ||
1615 qgroup->rsv.values[BTRFS_QGROUP_RSV_DATA] > 0 ||
1616 qgroup->rsv.values[BTRFS_QGROUP_RSV_META_PREALLOC] > 0 ||
1617 qgroup->rsv.values[BTRFS_QGROUP_RSV_META_PERTRANS] > 0);
1623 struct btrfs_qgroup *qgroup;
1633 qgroup = find_qgroup_rb(fs_info, qgroupid);
1634 if (!qgroup) {
1639 if (is_fstree(qgroupid) && qgroup_has_usage(qgroup)) {
1644 /* Check if there are no children of this qgroup */
1645 if (!list_empty(&qgroup->members)) {
1654 while (!list_empty(&qgroup->groups)) {
1655 list = list_first_entry(&qgroup->groups,
1668 * Remove the qgroup from sysfs now without holding the qgroup_lock
1672 btrfs_sysfs_del_one_qgroup(fs_info, qgroup);
1673 kfree(qgroup);
1683 struct btrfs_qgroup *qgroup;
1685 /* Sometimes we would want to clear the limit on this qgroup.
1687 * which tell kernel to clear the limit on this qgroup.
1697 qgroup = find_qgroup_rb(fs_info, qgroupid);
1698 if (!qgroup) {
1706 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_RFER;
1708 qgroup->max_rfer = 0;
1710 qgroup->max_rfer = limit->max_rfer;
1715 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_MAX_EXCL;
1717 qgroup->max_excl = 0;
1719 qgroup->max_excl = limit->max_excl;
1724 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_RFER;
1726 qgroup->rsv_rfer = 0;
1728 qgroup->rsv_rfer = limit->rsv_rfer;
1733 qgroup->lim_flags &= ~BTRFS_QGROUP_LIMIT_RSV_EXCL;
1735 qgroup->rsv_excl = 0;
1737 qgroup->rsv_excl = limit->rsv_excl;
1740 qgroup->lim_flags |= limit->flags;
1744 ret = update_qgroup_limit_item(trans, qgroup);
1869 /* filter out non qgroup-accountable extents */
1976 * reach OO(c), then mark both OO(c) and NN(c) as qgroup dirty.
1985 * 2) Mark the final tree blocks in @src_path and @dst_path qgroup dirty
1986 * NOTE: In above case, OO(a) and NN(a) won't be marked qgroup dirty.
2090 * blocks for qgroup accounting.
2131 * We will iterate through tree blocks NN(b), NN(d) and info qgroup to trace
2474 * Update qgroup rfer/excl counters.
2657 /* Quick exit, either not fs tree roots, or won't affect any qgroup */
2741 * Old roots should be searched when inserting qgroup
2794 * Called by the transaction commit path and the qgroup assign ioctl.
2802 * In case we are called from the qgroup assign ioctl, assert that we
2814 struct btrfs_qgroup *qgroup;
2815 qgroup = list_first_entry(&fs_info->dirty_qgroups,
2817 list_del_init(&qgroup->dirty);
2819 ret = update_qgroup_info_item(trans, qgroup);
2823 ret = update_qgroup_limit_item(trans, qgroup);
2869 * The other one in create_pending_snapshot() where no other qgroup
2918 * add qgroup to all inherited groups
2999 * qgroup, the numbers are guaranteed to be incorrect.
3074 struct btrfs_qgroup *qgroup;
3095 qgroup = find_qgroup_rb(fs_info, ref_root);
3096 if (!qgroup)
3104 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid,
3105 qgroup_to_aux(qgroup), GFP_ATOMIC);
3147 * Free @num_bytes of reserved space with @type for qgroup. (Normally level 0
3148 * qgroup).
3150 * Will handle all higher level qgroup too.
3152 * NOTE: If @num_bytes is (u64)-1, this means to free all bytes of this qgroup.
3159 struct btrfs_qgroup *qgroup;
3179 qgroup = find_qgroup_rb(fs_info, ref_root);
3180 if (!qgroup)
3186 * level 0 qgroup as real num_bytes to free.
3188 num_bytes = qgroup->rsv.values[type];
3191 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid,
3192 qgroup_to_aux(qgroup), GFP_ATOMIC);
3343 * should be recorded by qgroup
3379 * qgroup info, and only if we did any actual work. This also prevents
3404 btrfs_err(fs_info, "fail to update qgroup status: %d",
3418 btrfs_info(fs_info, "qgroup scan paused");
3420 btrfs_info(fs_info, "qgroup scan completed%s",
3423 btrfs_err(fs_info, "qgroup scan failed with %d", err);
3438 /* we're resuming qgroup rescan at mount time */
3442 "qgroup rescan init failed, qgroup rescan is not queued");
3447 "qgroup rescan init failed, qgroup is not enabled");
3460 "qgroup rescan is already in progress");
3465 "qgroup rescan init failed, qgroup is not enabled");
3494 struct btrfs_qgroup *qgroup;
3497 /* clear all current qgroup tracking information */
3499 qgroup = rb_entry(n, struct btrfs_qgroup, node);
3500 qgroup->rfer = 0;
3501 qgroup->rfer_cmpr = 0;
3502 qgroup->excl = 0;
3503 qgroup->excl_cmpr = 0;
3504 qgroup_dirty(fs_info, qgroup);
3654 * Try to free some space for qgroup.
3656 * For qgroup, there are only 3 ways to free qgroup space:
3669 * In theory this shouldn't provide much space, but any more qgroup space
3748 /* @reserved parameter is mandatory for qgroup */
3787 * Reserve qgroup space for range [start, start + len).
3850 * However as long as we free qgroup reserved according to
3928 * Since new qgroup accounting framework will only update qgroup numbers at
4063 struct btrfs_qgroup *qgroup;
4074 qgroup = find_qgroup_rb(fs_info, ref_root);
4075 if (!qgroup)
4078 ret = ulist_add(fs_info->qgroup_ulist, qgroup->qgroupid,
4079 qgroup_to_aux(qgroup), GFP_ATOMIC);
4120 * Check qgroup reserved space leaking, normally at destroy inode
4139 "leaking qgroup reserved space, ino: %llu, start: %llu, end: %llu",
4163 * Every record here means we skipped a full subtree scan for qgroup.
4251 * no one else can modify tree blocks thus we qgroup will not change
4284 * Marking qgroup inconsistent should be enough
4308 * delayed subtree trace for qgroup.