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