blob: e1b0651686f7c4e988766d927c669306560c468d [file] [log] [blame]
David Sterbac1d7c512018-04-03 19:23:33 +02001// SPDX-License-Identifier: GPL-2.0
Chris Mason56bec292009-03-13 10:10:06 -04002/*
3 * Copyright (C) 2009 Oracle. All rights reserved.
Chris Mason56bec292009-03-13 10:10:06 -04004 */
5
6#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09007#include <linux/slab.h>
Chris Mason56bec292009-03-13 10:10:06 -04008#include <linux/sort.h>
Chris Mason56bec292009-03-13 10:10:06 -04009#include "ctree.h"
10#include "delayed-ref.h"
11#include "transaction.h"
Qu Wenruo3368d002015-04-16 14:34:17 +080012#include "qgroup.h"
Chris Mason56bec292009-03-13 10:10:06 -040013
Miao Xie78a61842012-11-21 02:21:28 +000014struct kmem_cache *btrfs_delayed_ref_head_cachep;
15struct kmem_cache *btrfs_delayed_tree_ref_cachep;
16struct kmem_cache *btrfs_delayed_data_ref_cachep;
17struct kmem_cache *btrfs_delayed_extent_op_cachep;
Chris Mason56bec292009-03-13 10:10:06 -040018/*
19 * delayed back reference update tracking. For subvolume trees
20 * we queue up extent allocations and backref maintenance for
21 * delayed processing. This avoids deep call chains where we
22 * add extents in the middle of btrfs_search_slot, and it allows
23 * us to buffer up frequently modified backrefs in an rb tree instead
24 * of hammering updates on the extent allocation tree.
Chris Mason56bec292009-03-13 10:10:06 -040025 */
26
27/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -040028 * compare two delayed tree backrefs with same bytenr and type
Chris Mason56bec292009-03-13 10:10:06 -040029 */
Josef Bacikc7ad7c82017-10-19 14:15:58 -040030static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref1,
31 struct btrfs_delayed_tree_ref *ref2)
Chris Mason56bec292009-03-13 10:10:06 -040032{
Josef Bacik3b60d432017-09-29 15:43:58 -040033 if (ref1->node.type == BTRFS_TREE_BLOCK_REF_KEY) {
Josef Bacik41b0fc42013-04-01 20:36:28 -040034 if (ref1->root < ref2->root)
35 return -1;
36 if (ref1->root > ref2->root)
37 return 1;
38 } else {
39 if (ref1->parent < ref2->parent)
40 return -1;
41 if (ref1->parent > ref2->parent)
42 return 1;
43 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -040044 return 0;
45}
46
47/*
48 * compare two delayed data backrefs with same bytenr and type
49 */
Josef Bacikc7ad7c82017-10-19 14:15:58 -040050static int comp_data_refs(struct btrfs_delayed_data_ref *ref1,
51 struct btrfs_delayed_data_ref *ref2)
Yan Zheng5d4f98a2009-06-10 10:45:14 -040052{
53 if (ref1->node.type == BTRFS_EXTENT_DATA_REF_KEY) {
54 if (ref1->root < ref2->root)
55 return -1;
56 if (ref1->root > ref2->root)
57 return 1;
58 if (ref1->objectid < ref2->objectid)
59 return -1;
60 if (ref1->objectid > ref2->objectid)
61 return 1;
62 if (ref1->offset < ref2->offset)
63 return -1;
64 if (ref1->offset > ref2->offset)
65 return 1;
66 } else {
67 if (ref1->parent < ref2->parent)
68 return -1;
69 if (ref1->parent > ref2->parent)
70 return 1;
71 }
72 return 0;
73}
74
Josef Bacik1d148e52017-10-19 14:15:59 -040075static int comp_refs(struct btrfs_delayed_ref_node *ref1,
76 struct btrfs_delayed_ref_node *ref2,
77 bool check_seq)
78{
79 int ret = 0;
80
81 if (ref1->type < ref2->type)
82 return -1;
83 if (ref1->type > ref2->type)
84 return 1;
85 if (ref1->type == BTRFS_TREE_BLOCK_REF_KEY ||
86 ref1->type == BTRFS_SHARED_BLOCK_REF_KEY)
87 ret = comp_tree_refs(btrfs_delayed_node_to_tree_ref(ref1),
88 btrfs_delayed_node_to_tree_ref(ref2));
89 else
90 ret = comp_data_refs(btrfs_delayed_node_to_data_ref(ref1),
91 btrfs_delayed_node_to_data_ref(ref2));
92 if (ret)
93 return ret;
94 if (check_seq) {
95 if (ref1->seq < ref2->seq)
96 return -1;
97 if (ref1->seq > ref2->seq)
98 return 1;
99 }
100 return 0;
101}
102
Liu Boc46effa2013-10-14 12:59:45 +0800103/* insert a new ref to head ref rbtree */
104static struct btrfs_delayed_ref_head *htree_insert(struct rb_root *root,
105 struct rb_node *node)
106{
107 struct rb_node **p = &root->rb_node;
108 struct rb_node *parent_node = NULL;
109 struct btrfs_delayed_ref_head *entry;
110 struct btrfs_delayed_ref_head *ins;
111 u64 bytenr;
112
113 ins = rb_entry(node, struct btrfs_delayed_ref_head, href_node);
Josef Bacikd2788502017-09-29 15:43:57 -0400114 bytenr = ins->bytenr;
Liu Boc46effa2013-10-14 12:59:45 +0800115 while (*p) {
116 parent_node = *p;
117 entry = rb_entry(parent_node, struct btrfs_delayed_ref_head,
118 href_node);
119
Josef Bacikd2788502017-09-29 15:43:57 -0400120 if (bytenr < entry->bytenr)
Liu Boc46effa2013-10-14 12:59:45 +0800121 p = &(*p)->rb_left;
Josef Bacikd2788502017-09-29 15:43:57 -0400122 else if (bytenr > entry->bytenr)
Liu Boc46effa2013-10-14 12:59:45 +0800123 p = &(*p)->rb_right;
124 else
125 return entry;
126 }
127
128 rb_link_node(node, parent_node, p);
129 rb_insert_color(node, root);
130 return NULL;
131}
132
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400133static struct btrfs_delayed_ref_node* tree_insert(struct rb_root *root,
134 struct btrfs_delayed_ref_node *ins)
135{
136 struct rb_node **p = &root->rb_node;
137 struct rb_node *node = &ins->ref_node;
138 struct rb_node *parent_node = NULL;
139 struct btrfs_delayed_ref_node *entry;
140
141 while (*p) {
142 int comp;
143
144 parent_node = *p;
145 entry = rb_entry(parent_node, struct btrfs_delayed_ref_node,
146 ref_node);
147 comp = comp_refs(ins, entry, true);
148 if (comp < 0)
149 p = &(*p)->rb_left;
150 else if (comp > 0)
151 p = &(*p)->rb_right;
152 else
153 return entry;
154 }
155
156 rb_link_node(node, parent_node, p);
157 rb_insert_color(node, root);
158 return NULL;
159}
160
Chris Mason56bec292009-03-13 10:10:06 -0400161/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400162 * find an head entry based on bytenr. This returns the delayed ref
Arne Jansend1270cd2011-09-13 15:16:43 +0200163 * head if it was able to find one, or NULL if nothing was in that spot.
164 * If return_bigger is given, the next bigger entry is returned if no exact
165 * match is found.
Chris Mason56bec292009-03-13 10:10:06 -0400166 */
Liu Boc46effa2013-10-14 12:59:45 +0800167static struct btrfs_delayed_ref_head *
168find_ref_head(struct rb_root *root, u64 bytenr,
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000169 int return_bigger)
Chris Mason56bec292009-03-13 10:10:06 -0400170{
Arne Jansend1270cd2011-09-13 15:16:43 +0200171 struct rb_node *n;
Liu Boc46effa2013-10-14 12:59:45 +0800172 struct btrfs_delayed_ref_head *entry;
Chris Mason56bec292009-03-13 10:10:06 -0400173
Arne Jansend1270cd2011-09-13 15:16:43 +0200174 n = root->rb_node;
175 entry = NULL;
Chris Mason56bec292009-03-13 10:10:06 -0400176 while (n) {
Liu Boc46effa2013-10-14 12:59:45 +0800177 entry = rb_entry(n, struct btrfs_delayed_ref_head, href_node);
Chris Mason56bec292009-03-13 10:10:06 -0400178
Josef Bacikd2788502017-09-29 15:43:57 -0400179 if (bytenr < entry->bytenr)
Chris Mason56bec292009-03-13 10:10:06 -0400180 n = n->rb_left;
Josef Bacikd2788502017-09-29 15:43:57 -0400181 else if (bytenr > entry->bytenr)
Chris Mason56bec292009-03-13 10:10:06 -0400182 n = n->rb_right;
183 else
184 return entry;
185 }
Arne Jansend1270cd2011-09-13 15:16:43 +0200186 if (entry && return_bigger) {
Josef Bacikd2788502017-09-29 15:43:57 -0400187 if (bytenr > entry->bytenr) {
Liu Boc46effa2013-10-14 12:59:45 +0800188 n = rb_next(&entry->href_node);
Arne Jansend1270cd2011-09-13 15:16:43 +0200189 if (!n)
190 n = rb_first(root);
Liu Boc46effa2013-10-14 12:59:45 +0800191 entry = rb_entry(n, struct btrfs_delayed_ref_head,
192 href_node);
Filipe Manana6103fb42014-02-12 15:07:52 +0000193 return entry;
Arne Jansend1270cd2011-09-13 15:16:43 +0200194 }
195 return entry;
196 }
Chris Mason56bec292009-03-13 10:10:06 -0400197 return NULL;
198}
199
Chris Masonc3e69d52009-03-13 10:17:05 -0400200int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans,
201 struct btrfs_delayed_ref_head *head)
Chris Mason56bec292009-03-13 10:10:06 -0400202{
Chris Masonc3e69d52009-03-13 10:17:05 -0400203 struct btrfs_delayed_ref_root *delayed_refs;
Chris Mason56bec292009-03-13 10:10:06 -0400204
Chris Masonc3e69d52009-03-13 10:17:05 -0400205 delayed_refs = &trans->transaction->delayed_refs;
David Sterbaa4666e62018-03-16 02:21:22 +0100206 lockdep_assert_held(&delayed_refs->lock);
Chris Masonc3e69d52009-03-13 10:17:05 -0400207 if (mutex_trylock(&head->mutex))
208 return 0;
209
Josef Bacikd2788502017-09-29 15:43:57 -0400210 refcount_inc(&head->refs);
Chris Masonc3e69d52009-03-13 10:17:05 -0400211 spin_unlock(&delayed_refs->lock);
212
213 mutex_lock(&head->mutex);
214 spin_lock(&delayed_refs->lock);
Josef Bacikd2788502017-09-29 15:43:57 -0400215 if (RB_EMPTY_NODE(&head->href_node)) {
Chris Masonc3e69d52009-03-13 10:17:05 -0400216 mutex_unlock(&head->mutex);
Josef Bacikd2788502017-09-29 15:43:57 -0400217 btrfs_put_delayed_ref_head(head);
Chris Masonc3e69d52009-03-13 10:17:05 -0400218 return -EAGAIN;
219 }
Josef Bacikd2788502017-09-29 15:43:57 -0400220 btrfs_put_delayed_ref_head(head);
Chris Masonc3e69d52009-03-13 10:17:05 -0400221 return 0;
222}
223
Stefan Behrens35a36212013-08-14 18:12:25 +0200224static inline void drop_delayed_ref(struct btrfs_trans_handle *trans,
Josef Bacikae1e2062012-08-07 16:00:32 -0400225 struct btrfs_delayed_ref_root *delayed_refs,
Josef Bacikd7df2c72014-01-23 09:21:38 -0500226 struct btrfs_delayed_ref_head *head,
Josef Bacikae1e2062012-08-07 16:00:32 -0400227 struct btrfs_delayed_ref_node *ref)
228{
David Sterbaa4666e62018-03-16 02:21:22 +0100229 lockdep_assert_held(&head->lock);
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400230 rb_erase(&ref->ref_node, &head->ref_tree);
231 RB_CLEAR_NODE(&ref->ref_node);
Josef Bacikd2788502017-09-29 15:43:57 -0400232 if (!list_empty(&ref->add_list))
233 list_del(&ref->add_list);
Josef Bacikae1e2062012-08-07 16:00:32 -0400234 ref->in_tree = 0;
235 btrfs_put_delayed_ref(ref);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500236 atomic_dec(&delayed_refs->num_entries);
Josef Bacikae1e2062012-08-07 16:00:32 -0400237 if (trans->delayed_ref_updates)
238 trans->delayed_ref_updates--;
239}
240
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100241static bool merge_ref(struct btrfs_trans_handle *trans,
242 struct btrfs_delayed_ref_root *delayed_refs,
243 struct btrfs_delayed_ref_head *head,
244 struct btrfs_delayed_ref_node *ref,
245 u64 seq)
246{
247 struct btrfs_delayed_ref_node *next;
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400248 struct rb_node *node = rb_next(&ref->ref_node);
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100249 bool done = false;
250
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400251 while (!done && node) {
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100252 int mod;
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100253
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400254 next = rb_entry(node, struct btrfs_delayed_ref_node, ref_node);
255 node = rb_next(node);
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100256 if (seq && next->seq >= seq)
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400257 break;
Josef Bacik1d148e52017-10-19 14:15:59 -0400258 if (comp_refs(ref, next, false))
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400259 break;
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100260
261 if (ref->action == next->action) {
262 mod = next->ref_mod;
263 } else {
264 if (ref->ref_mod < next->ref_mod) {
265 swap(ref, next);
266 done = true;
267 }
268 mod = -next->ref_mod;
269 }
270
271 drop_delayed_ref(trans, delayed_refs, head, next);
272 ref->ref_mod += mod;
273 if (ref->ref_mod == 0) {
274 drop_delayed_ref(trans, delayed_refs, head, ref);
275 done = true;
276 } else {
277 /*
278 * Can't have multiples of the same ref on a tree block.
279 */
280 WARN_ON(ref->type == BTRFS_TREE_BLOCK_REF_KEY ||
281 ref->type == BTRFS_SHARED_BLOCK_REF_KEY);
282 }
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100283 }
284
285 return done;
286}
287
288void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans,
289 struct btrfs_fs_info *fs_info,
290 struct btrfs_delayed_ref_root *delayed_refs,
291 struct btrfs_delayed_ref_head *head)
292{
293 struct btrfs_delayed_ref_node *ref;
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400294 struct rb_node *node;
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100295 u64 seq = 0;
296
David Sterbaa4666e62018-03-16 02:21:22 +0100297 lockdep_assert_held(&head->lock);
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100298
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400299 if (RB_EMPTY_ROOT(&head->ref_tree))
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100300 return;
301
302 /* We don't have too many refs to merge for data. */
303 if (head->is_data)
304 return;
305
306 spin_lock(&fs_info->tree_mod_seq_lock);
307 if (!list_empty(&fs_info->tree_mod_seq_list)) {
308 struct seq_list *elem;
309
310 elem = list_first_entry(&fs_info->tree_mod_seq_list,
311 struct seq_list, list);
312 seq = elem->seq;
313 }
314 spin_unlock(&fs_info->tree_mod_seq_lock);
315
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400316again:
317 for (node = rb_first(&head->ref_tree); node; node = rb_next(node)) {
318 ref = rb_entry(node, struct btrfs_delayed_ref_node, ref_node);
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100319 if (seq && ref->seq >= seq)
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100320 continue;
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400321 if (merge_ref(trans, delayed_refs, head, ref, seq))
322 goto again;
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100323 }
324}
325
Jan Schmidt097b8a72012-06-21 11:08:04 +0200326int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info,
327 struct btrfs_delayed_ref_root *delayed_refs,
Arne Jansen00f04b82011-09-14 12:37:00 +0200328 u64 seq)
329{
330 struct seq_list *elem;
Jan Schmidt097b8a72012-06-21 11:08:04 +0200331 int ret = 0;
Arne Jansen00f04b82011-09-14 12:37:00 +0200332
Jan Schmidt097b8a72012-06-21 11:08:04 +0200333 spin_lock(&fs_info->tree_mod_seq_lock);
334 if (!list_empty(&fs_info->tree_mod_seq_list)) {
335 elem = list_first_entry(&fs_info->tree_mod_seq_list,
336 struct seq_list, list);
337 if (seq >= elem->seq) {
Jeff Mahoneyab8d0fc2016-09-20 10:05:02 -0400338 btrfs_debug(fs_info,
339 "holding back delayed_ref %#x.%x, lowest is %#x.%x (%p)",
340 (u32)(seq >> 32), (u32)seq,
341 (u32)(elem->seq >> 32), (u32)elem->seq,
342 delayed_refs);
Jan Schmidt097b8a72012-06-21 11:08:04 +0200343 ret = 1;
344 }
Arne Jansen00f04b82011-09-14 12:37:00 +0200345 }
Jan Schmidt097b8a72012-06-21 11:08:04 +0200346
347 spin_unlock(&fs_info->tree_mod_seq_lock);
348 return ret;
Arne Jansen00f04b82011-09-14 12:37:00 +0200349}
350
Josef Bacikd7df2c72014-01-23 09:21:38 -0500351struct btrfs_delayed_ref_head *
352btrfs_select_ref_head(struct btrfs_trans_handle *trans)
Chris Masonc3e69d52009-03-13 10:17:05 -0400353{
Chris Masonc3e69d52009-03-13 10:17:05 -0400354 struct btrfs_delayed_ref_root *delayed_refs;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500355 struct btrfs_delayed_ref_head *head;
356 u64 start;
357 bool loop = false;
Chris Masonc3e69d52009-03-13 10:17:05 -0400358
359 delayed_refs = &trans->transaction->delayed_refs;
Liu Boc46effa2013-10-14 12:59:45 +0800360
Chris Masonc3e69d52009-03-13 10:17:05 -0400361again:
Josef Bacikd7df2c72014-01-23 09:21:38 -0500362 start = delayed_refs->run_delayed_start;
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000363 head = find_ref_head(&delayed_refs->href_root, start, 1);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500364 if (!head && !loop) {
365 delayed_refs->run_delayed_start = 0;
Chris Masonc3e69d52009-03-13 10:17:05 -0400366 start = 0;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500367 loop = true;
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000368 head = find_ref_head(&delayed_refs->href_root, start, 1);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500369 if (!head)
370 return NULL;
371 } else if (!head && loop) {
372 return NULL;
Chris Masonc3e69d52009-03-13 10:17:05 -0400373 }
Chris Mason56bec292009-03-13 10:10:06 -0400374
Josef Bacikd7df2c72014-01-23 09:21:38 -0500375 while (head->processing) {
376 struct rb_node *node;
Miao Xie093486c2012-12-19 08:10:10 +0000377
Josef Bacikd7df2c72014-01-23 09:21:38 -0500378 node = rb_next(&head->href_node);
379 if (!node) {
380 if (loop)
381 return NULL;
382 delayed_refs->run_delayed_start = 0;
383 start = 0;
384 loop = true;
385 goto again;
386 }
387 head = rb_entry(node, struct btrfs_delayed_ref_head,
388 href_node);
389 }
390
391 head->processing = 1;
392 WARN_ON(delayed_refs->num_heads_ready == 0);
393 delayed_refs->num_heads_ready--;
Josef Bacikd2788502017-09-29 15:43:57 -0400394 delayed_refs->run_delayed_start = head->bytenr +
395 head->num_bytes;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500396 return head;
Miao Xie093486c2012-12-19 08:10:10 +0000397}
398
Chris Mason56bec292009-03-13 10:10:06 -0400399/*
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800400 * Helper to insert the ref_node to the tail or merge with tail.
401 *
402 * Return 0 for insert.
403 * Return >0 for merge.
404 */
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400405static int insert_delayed_ref(struct btrfs_trans_handle *trans,
406 struct btrfs_delayed_ref_root *root,
407 struct btrfs_delayed_ref_head *href,
408 struct btrfs_delayed_ref_node *ref)
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800409{
410 struct btrfs_delayed_ref_node *exist;
411 int mod;
412 int ret = 0;
413
414 spin_lock(&href->lock);
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400415 exist = tree_insert(&href->ref_tree, ref);
416 if (!exist)
417 goto inserted;
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800418
419 /* Now we are sure we can merge */
420 ret = 1;
421 if (exist->action == ref->action) {
422 mod = ref->ref_mod;
423 } else {
424 /* Need to change action */
425 if (exist->ref_mod < ref->ref_mod) {
426 exist->action = ref->action;
427 mod = -exist->ref_mod;
428 exist->ref_mod = ref->ref_mod;
Wang Xiaoguang1d57ee92016-10-26 18:07:33 +0800429 if (ref->action == BTRFS_ADD_DELAYED_REF)
430 list_add_tail(&exist->add_list,
431 &href->ref_add_list);
432 else if (ref->action == BTRFS_DROP_DELAYED_REF) {
433 ASSERT(!list_empty(&exist->add_list));
434 list_del(&exist->add_list);
435 } else {
436 ASSERT(0);
437 }
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800438 } else
439 mod = -ref->ref_mod;
440 }
441 exist->ref_mod += mod;
442
443 /* remove existing tail if its ref_mod is zero */
444 if (exist->ref_mod == 0)
445 drop_delayed_ref(trans, root, href, exist);
446 spin_unlock(&href->lock);
447 return ret;
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400448inserted:
Wang Xiaoguang1d57ee92016-10-26 18:07:33 +0800449 if (ref->action == BTRFS_ADD_DELAYED_REF)
450 list_add_tail(&ref->add_list, &href->ref_add_list);
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800451 atomic_inc(&root->num_entries);
452 trans->delayed_ref_updates++;
453 spin_unlock(&href->lock);
454 return ret;
455}
456
457/*
Chris Mason56bec292009-03-13 10:10:06 -0400458 * helper function to update the accounting in the head ref
459 * existing and update must have the same bytenr
460 */
461static noinline void
Josef Bacik12621332015-02-03 07:50:16 -0800462update_existing_head_ref(struct btrfs_delayed_ref_root *delayed_refs,
Josef Bacikd2788502017-09-29 15:43:57 -0400463 struct btrfs_delayed_ref_head *existing,
464 struct btrfs_delayed_ref_head *update,
Omar Sandoval7be07912017-06-06 16:45:30 -0700465 int *old_ref_mod_ret)
Chris Mason56bec292009-03-13 10:10:06 -0400466{
Josef Bacik12621332015-02-03 07:50:16 -0800467 int old_ref_mod;
Chris Mason56bec292009-03-13 10:10:06 -0400468
Josef Bacikd2788502017-09-29 15:43:57 -0400469 BUG_ON(existing->is_data != update->is_data);
Chris Mason56bec292009-03-13 10:10:06 -0400470
Josef Bacikd2788502017-09-29 15:43:57 -0400471 spin_lock(&existing->lock);
472 if (update->must_insert_reserved) {
Chris Mason56bec292009-03-13 10:10:06 -0400473 /* if the extent was freed and then
474 * reallocated before the delayed ref
475 * entries were processed, we can end up
476 * with an existing head ref without
477 * the must_insert_reserved flag set.
478 * Set it again here
479 */
Josef Bacikd2788502017-09-29 15:43:57 -0400480 existing->must_insert_reserved = update->must_insert_reserved;
Chris Mason56bec292009-03-13 10:10:06 -0400481
482 /*
483 * update the num_bytes so we make sure the accounting
484 * is done correctly
485 */
486 existing->num_bytes = update->num_bytes;
487
488 }
489
Josef Bacikd2788502017-09-29 15:43:57 -0400490 if (update->extent_op) {
491 if (!existing->extent_op) {
492 existing->extent_op = update->extent_op;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400493 } else {
Josef Bacikd2788502017-09-29 15:43:57 -0400494 if (update->extent_op->update_key) {
495 memcpy(&existing->extent_op->key,
496 &update->extent_op->key,
497 sizeof(update->extent_op->key));
498 existing->extent_op->update_key = true;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400499 }
Josef Bacikd2788502017-09-29 15:43:57 -0400500 if (update->extent_op->update_flags) {
501 existing->extent_op->flags_to_set |=
502 update->extent_op->flags_to_set;
503 existing->extent_op->update_flags = true;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400504 }
Josef Bacikd2788502017-09-29 15:43:57 -0400505 btrfs_free_delayed_extent_op(update->extent_op);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400506 }
507 }
Chris Mason56bec292009-03-13 10:10:06 -0400508 /*
Josef Bacikd7df2c72014-01-23 09:21:38 -0500509 * update the reference mod on the head to reflect this new operation,
510 * only need the lock for this case cause we could be processing it
511 * currently, for refs we just added we know we're a-ok.
Chris Mason56bec292009-03-13 10:10:06 -0400512 */
Josef Bacikd2788502017-09-29 15:43:57 -0400513 old_ref_mod = existing->total_ref_mod;
Omar Sandoval7be07912017-06-06 16:45:30 -0700514 if (old_ref_mod_ret)
515 *old_ref_mod_ret = old_ref_mod;
Chris Mason56bec292009-03-13 10:10:06 -0400516 existing->ref_mod += update->ref_mod;
Josef Bacikd2788502017-09-29 15:43:57 -0400517 existing->total_ref_mod += update->ref_mod;
Josef Bacik12621332015-02-03 07:50:16 -0800518
519 /*
520 * If we are going to from a positive ref mod to a negative or vice
521 * versa we need to make sure to adjust pending_csums accordingly.
522 */
Josef Bacikd2788502017-09-29 15:43:57 -0400523 if (existing->is_data) {
524 if (existing->total_ref_mod >= 0 && old_ref_mod < 0)
Josef Bacik12621332015-02-03 07:50:16 -0800525 delayed_refs->pending_csums -= existing->num_bytes;
Josef Bacikd2788502017-09-29 15:43:57 -0400526 if (existing->total_ref_mod < 0 && old_ref_mod >= 0)
Josef Bacik12621332015-02-03 07:50:16 -0800527 delayed_refs->pending_csums += existing->num_bytes;
528 }
Josef Bacikd2788502017-09-29 15:43:57 -0400529 spin_unlock(&existing->lock);
Chris Mason56bec292009-03-13 10:10:06 -0400530}
531
532/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400533 * helper function to actually insert a head node into the rbtree.
Chris Mason56bec292009-03-13 10:10:06 -0400534 * this does all the dirty work in terms of maintaining the correct
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400535 * overall modification count.
Chris Mason56bec292009-03-13 10:10:06 -0400536 */
Josef Bacikd7df2c72014-01-23 09:21:38 -0500537static noinline struct btrfs_delayed_ref_head *
538add_delayed_ref_head(struct btrfs_fs_info *fs_info,
539 struct btrfs_trans_handle *trans,
Josef Bacikd2788502017-09-29 15:43:57 -0400540 struct btrfs_delayed_ref_head *head_ref,
Qu Wenruo3368d002015-04-16 14:34:17 +0800541 struct btrfs_qgroup_extent_record *qrecord,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800542 u64 bytenr, u64 num_bytes, u64 ref_root, u64 reserved,
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300543 int action, int is_data, int is_system,
544 int *qrecord_inserted_ret,
Omar Sandoval7be07912017-06-06 16:45:30 -0700545 int *old_ref_mod, int *new_ref_mod)
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300546
Chris Mason56bec292009-03-13 10:10:06 -0400547{
Josef Bacikd7df2c72014-01-23 09:21:38 -0500548 struct btrfs_delayed_ref_head *existing;
Chris Mason56bec292009-03-13 10:10:06 -0400549 struct btrfs_delayed_ref_root *delayed_refs;
550 int count_mod = 1;
551 int must_insert_reserved = 0;
Qu Wenruofb235dc2017-02-15 10:43:03 +0800552 int qrecord_inserted = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400553
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800554 /* If reserved is provided, it must be a data extent. */
555 BUG_ON(!is_data && reserved);
556
Chris Mason56bec292009-03-13 10:10:06 -0400557 /*
558 * the head node stores the sum of all the mods, so dropping a ref
559 * should drop the sum in the head node by one.
560 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400561 if (action == BTRFS_UPDATE_DELAYED_HEAD)
562 count_mod = 0;
563 else if (action == BTRFS_DROP_DELAYED_REF)
564 count_mod = -1;
Chris Mason56bec292009-03-13 10:10:06 -0400565
566 /*
567 * BTRFS_ADD_DELAYED_EXTENT means that we need to update
568 * the reserved accounting when the extent is finally added, or
569 * if a later modification deletes the delayed ref without ever
570 * inserting the extent into the extent allocation tree.
571 * ref->must_insert_reserved is the flag used to record
572 * that accounting mods are required.
573 *
574 * Once we record must_insert_reserved, switch the action to
575 * BTRFS_ADD_DELAYED_REF because other special casing is not required.
576 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400577 if (action == BTRFS_ADD_DELAYED_EXTENT)
Chris Mason56bec292009-03-13 10:10:06 -0400578 must_insert_reserved = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400579 else
Chris Mason56bec292009-03-13 10:10:06 -0400580 must_insert_reserved = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400581
582 delayed_refs = &trans->transaction->delayed_refs;
583
Josef Bacikd2788502017-09-29 15:43:57 -0400584 refcount_set(&head_ref->refs, 1);
585 head_ref->bytenr = bytenr;
586 head_ref->num_bytes = num_bytes;
587 head_ref->ref_mod = count_mod;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400588 head_ref->must_insert_reserved = must_insert_reserved;
589 head_ref->is_data = is_data;
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300590 head_ref->is_system = is_system;
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400591 head_ref->ref_tree = RB_ROOT;
Wang Xiaoguang1d57ee92016-10-26 18:07:33 +0800592 INIT_LIST_HEAD(&head_ref->ref_add_list);
Josef Bacikd2788502017-09-29 15:43:57 -0400593 RB_CLEAR_NODE(&head_ref->href_node);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500594 head_ref->processing = 0;
Josef Bacik12621332015-02-03 07:50:16 -0800595 head_ref->total_ref_mod = count_mod;
Qu Wenruof64d5ca2015-09-08 17:08:36 +0800596 head_ref->qgroup_reserved = 0;
597 head_ref->qgroup_ref_root = 0;
Josef Bacikd2788502017-09-29 15:43:57 -0400598 spin_lock_init(&head_ref->lock);
599 mutex_init(&head_ref->mutex);
Chris Mason56bec292009-03-13 10:10:06 -0400600
Qu Wenruo3368d002015-04-16 14:34:17 +0800601 /* Record qgroup extent info if provided */
602 if (qrecord) {
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800603 if (ref_root && reserved) {
604 head_ref->qgroup_ref_root = ref_root;
605 head_ref->qgroup_reserved = reserved;
606 }
607
Qu Wenruo3368d002015-04-16 14:34:17 +0800608 qrecord->bytenr = bytenr;
609 qrecord->num_bytes = num_bytes;
610 qrecord->old_roots = NULL;
611
Qu Wenruo50b3e042016-10-18 09:31:27 +0800612 if(btrfs_qgroup_trace_extent_nolock(fs_info,
Qu Wenruocb93b522016-08-15 10:36:50 +0800613 delayed_refs, qrecord))
Qu Wenruo3368d002015-04-16 14:34:17 +0800614 kfree(qrecord);
Qu Wenruofb235dc2017-02-15 10:43:03 +0800615 else
616 qrecord_inserted = 1;
Qu Wenruo3368d002015-04-16 14:34:17 +0800617 }
618
Josef Bacikd2788502017-09-29 15:43:57 -0400619 trace_add_delayed_ref_head(fs_info, head_ref, action);
liubo1abe9b82011-03-24 11:18:59 +0000620
Josef Bacikd7df2c72014-01-23 09:21:38 -0500621 existing = htree_insert(&delayed_refs->href_root,
622 &head_ref->href_node);
Chris Mason56bec292009-03-13 10:10:06 -0400623 if (existing) {
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800624 WARN_ON(ref_root && reserved && existing->qgroup_ref_root
625 && existing->qgroup_reserved);
Josef Bacikd2788502017-09-29 15:43:57 -0400626 update_existing_head_ref(delayed_refs, existing, head_ref,
Omar Sandoval7be07912017-06-06 16:45:30 -0700627 old_ref_mod);
Chris Mason56bec292009-03-13 10:10:06 -0400628 /*
629 * we've updated the existing ref, free the newly
630 * allocated ref
631 */
Miao Xie78a61842012-11-21 02:21:28 +0000632 kmem_cache_free(btrfs_delayed_ref_head_cachep, head_ref);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500633 head_ref = existing;
Chris Mason56bec292009-03-13 10:10:06 -0400634 } else {
Omar Sandoval7be07912017-06-06 16:45:30 -0700635 if (old_ref_mod)
636 *old_ref_mod = 0;
Josef Bacik12621332015-02-03 07:50:16 -0800637 if (is_data && count_mod < 0)
638 delayed_refs->pending_csums += num_bytes;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400639 delayed_refs->num_heads++;
640 delayed_refs->num_heads_ready++;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500641 atomic_inc(&delayed_refs->num_entries);
Chris Mason56bec292009-03-13 10:10:06 -0400642 trans->delayed_ref_updates++;
643 }
Qu Wenruofb235dc2017-02-15 10:43:03 +0800644 if (qrecord_inserted_ret)
645 *qrecord_inserted_ret = qrecord_inserted;
Omar Sandoval7be07912017-06-06 16:45:30 -0700646 if (new_ref_mod)
647 *new_ref_mod = head_ref->total_ref_mod;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500648 return head_ref;
Chris Mason56bec292009-03-13 10:10:06 -0400649}
650
651/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400652 * helper to insert a delayed tree ref into the rbtree.
653 */
Josef Bacikd7df2c72014-01-23 09:21:38 -0500654static noinline void
655add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
656 struct btrfs_trans_handle *trans,
657 struct btrfs_delayed_ref_head *head_ref,
658 struct btrfs_delayed_ref_node *ref, u64 bytenr,
659 u64 num_bytes, u64 parent, u64 ref_root, int level,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100660 int action)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400661{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400662 struct btrfs_delayed_tree_ref *full_ref;
663 struct btrfs_delayed_ref_root *delayed_refs;
Arne Jansen00f04b82011-09-14 12:37:00 +0200664 u64 seq = 0;
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800665 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400666
667 if (action == BTRFS_ADD_DELAYED_EXTENT)
668 action = BTRFS_ADD_DELAYED_REF;
669
Josef Bacikfcebe452014-05-13 17:30:47 -0700670 if (is_fstree(ref_root))
671 seq = atomic64_read(&fs_info->tree_mod_seq);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400672 delayed_refs = &trans->transaction->delayed_refs;
673
674 /* first set the basic ref node struct up */
Elena Reshetova6df8cdf2017-03-03 10:55:15 +0200675 refcount_set(&ref->refs, 1);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400676 ref->bytenr = bytenr;
677 ref->num_bytes = num_bytes;
678 ref->ref_mod = 1;
679 ref->action = action;
680 ref->is_head = 0;
681 ref->in_tree = 1;
Arne Jansen00f04b82011-09-14 12:37:00 +0200682 ref->seq = seq;
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400683 RB_CLEAR_NODE(&ref->ref_node);
Wang Xiaoguang1d57ee92016-10-26 18:07:33 +0800684 INIT_LIST_HEAD(&ref->add_list);
Arne Jansen00f04b82011-09-14 12:37:00 +0200685
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400686 full_ref = btrfs_delayed_node_to_tree_ref(ref);
Arne Janseneebe0632011-09-14 14:01:24 +0200687 full_ref->parent = parent;
688 full_ref->root = ref_root;
689 if (parent)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400690 ref->type = BTRFS_SHARED_BLOCK_REF_KEY;
Arne Janseneebe0632011-09-14 14:01:24 +0200691 else
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400692 ref->type = BTRFS_TREE_BLOCK_REF_KEY;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400693 full_ref->level = level;
694
Jeff Mahoneybc074522016-06-09 17:27:55 -0400695 trace_add_delayed_tree_ref(fs_info, ref, full_ref, action);
liubo1abe9b82011-03-24 11:18:59 +0000696
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400697 ret = insert_delayed_ref(trans, delayed_refs, head_ref, ref);
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800698
699 /*
700 * XXX: memory should be freed at the same level allocated.
701 * But bad practice is anywhere... Follow it now. Need cleanup.
702 */
703 if (ret > 0)
Miao Xie78a61842012-11-21 02:21:28 +0000704 kmem_cache_free(btrfs_delayed_tree_ref_cachep, full_ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400705}
706
707/*
708 * helper to insert a delayed data ref into the rbtree.
709 */
Josef Bacikd7df2c72014-01-23 09:21:38 -0500710static noinline void
711add_delayed_data_ref(struct btrfs_fs_info *fs_info,
712 struct btrfs_trans_handle *trans,
713 struct btrfs_delayed_ref_head *head_ref,
714 struct btrfs_delayed_ref_node *ref, u64 bytenr,
715 u64 num_bytes, u64 parent, u64 ref_root, u64 owner,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100716 u64 offset, int action)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400717{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400718 struct btrfs_delayed_data_ref *full_ref;
719 struct btrfs_delayed_ref_root *delayed_refs;
Arne Jansen00f04b82011-09-14 12:37:00 +0200720 u64 seq = 0;
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800721 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400722
723 if (action == BTRFS_ADD_DELAYED_EXTENT)
724 action = BTRFS_ADD_DELAYED_REF;
725
726 delayed_refs = &trans->transaction->delayed_refs;
727
Josef Bacikfcebe452014-05-13 17:30:47 -0700728 if (is_fstree(ref_root))
729 seq = atomic64_read(&fs_info->tree_mod_seq);
730
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400731 /* first set the basic ref node struct up */
Elena Reshetova6df8cdf2017-03-03 10:55:15 +0200732 refcount_set(&ref->refs, 1);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400733 ref->bytenr = bytenr;
734 ref->num_bytes = num_bytes;
735 ref->ref_mod = 1;
736 ref->action = action;
737 ref->is_head = 0;
738 ref->in_tree = 1;
Arne Jansen00f04b82011-09-14 12:37:00 +0200739 ref->seq = seq;
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400740 RB_CLEAR_NODE(&ref->ref_node);
Wang Xiaoguang1d57ee92016-10-26 18:07:33 +0800741 INIT_LIST_HEAD(&ref->add_list);
Arne Jansen00f04b82011-09-14 12:37:00 +0200742
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400743 full_ref = btrfs_delayed_node_to_data_ref(ref);
Arne Janseneebe0632011-09-14 14:01:24 +0200744 full_ref->parent = parent;
745 full_ref->root = ref_root;
746 if (parent)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400747 ref->type = BTRFS_SHARED_DATA_REF_KEY;
Arne Janseneebe0632011-09-14 14:01:24 +0200748 else
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400749 ref->type = BTRFS_EXTENT_DATA_REF_KEY;
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200750
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400751 full_ref->objectid = owner;
752 full_ref->offset = offset;
753
Jeff Mahoneybc074522016-06-09 17:27:55 -0400754 trace_add_delayed_data_ref(fs_info, ref, full_ref, action);
liubo1abe9b82011-03-24 11:18:59 +0000755
Josef Bacik0e0adbc2017-10-19 14:16:00 -0400756 ret = insert_delayed_ref(trans, delayed_refs, head_ref, ref);
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800757 if (ret > 0)
Miao Xie78a61842012-11-21 02:21:28 +0000758 kmem_cache_free(btrfs_delayed_data_ref_cachep, full_ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400759}
760
761/*
762 * add a delayed tree ref. This does all of the accounting required
Chris Mason56bec292009-03-13 10:10:06 -0400763 * to make sure the delayed ref is eventually processed before this
764 * transaction commits.
765 */
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200766int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
767 struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400768 u64 bytenr, u64 num_bytes, u64 parent,
769 u64 ref_root, int level, int action,
Omar Sandoval7be07912017-06-06 16:45:30 -0700770 struct btrfs_delayed_extent_op *extent_op,
771 int *old_ref_mod, int *new_ref_mod)
Chris Mason56bec292009-03-13 10:10:06 -0400772{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400773 struct btrfs_delayed_tree_ref *ref;
Chris Mason56bec292009-03-13 10:10:06 -0400774 struct btrfs_delayed_ref_head *head_ref;
775 struct btrfs_delayed_ref_root *delayed_refs;
Qu Wenruo3368d002015-04-16 14:34:17 +0800776 struct btrfs_qgroup_extent_record *record = NULL;
Qu Wenruofb235dc2017-02-15 10:43:03 +0800777 int qrecord_inserted;
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300778 int is_system = (ref_root == BTRFS_CHUNK_TREE_OBJECTID);
Chris Mason56bec292009-03-13 10:10:06 -0400779
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400780 BUG_ON(extent_op && extent_op->is_data);
Miao Xie78a61842012-11-21 02:21:28 +0000781 ref = kmem_cache_alloc(btrfs_delayed_tree_ref_cachep, GFP_NOFS);
Chris Mason56bec292009-03-13 10:10:06 -0400782 if (!ref)
783 return -ENOMEM;
784
Miao Xie78a61842012-11-21 02:21:28 +0000785 head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
Dan Carpenter5a5003df2015-06-24 17:32:33 +0300786 if (!head_ref)
787 goto free_ref;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400788
Josef Bacikafcdd122016-09-02 15:40:02 -0400789 if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) &&
790 is_fstree(ref_root)) {
Qu Wenruo3368d002015-04-16 14:34:17 +0800791 record = kmalloc(sizeof(*record), GFP_NOFS);
Dan Carpenter5a5003df2015-06-24 17:32:33 +0300792 if (!record)
793 goto free_head_ref;
Qu Wenruo3368d002015-04-16 14:34:17 +0800794 }
795
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400796 head_ref->extent_op = extent_op;
797
Chris Mason56bec292009-03-13 10:10:06 -0400798 delayed_refs = &trans->transaction->delayed_refs;
799 spin_lock(&delayed_refs->lock);
800
801 /*
802 * insert both the head node and the new ref without dropping
803 * the spin lock
804 */
Josef Bacikd2788502017-09-29 15:43:57 -0400805 head_ref = add_delayed_ref_head(fs_info, trans, head_ref, record,
Qu Wenruofb235dc2017-02-15 10:43:03 +0800806 bytenr, num_bytes, 0, 0, action, 0,
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300807 is_system, &qrecord_inserted,
808 old_ref_mod, new_ref_mod);
Chris Mason56bec292009-03-13 10:10:06 -0400809
Josef Bacikd7df2c72014-01-23 09:21:38 -0500810 add_delayed_tree_ref(fs_info, trans, head_ref, &ref->node, bytenr,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100811 num_bytes, parent, ref_root, level, action);
Chris Mason56bec292009-03-13 10:10:06 -0400812 spin_unlock(&delayed_refs->lock);
Jan Schmidt95a06072012-05-29 17:06:54 +0200813
Qu Wenruofb235dc2017-02-15 10:43:03 +0800814 if (qrecord_inserted)
Nikolay Borisov952bd3db2018-01-29 15:53:01 +0200815 btrfs_qgroup_trace_extent_post(fs_info, record);
816
Chris Mason56bec292009-03-13 10:10:06 -0400817 return 0;
Dan Carpenter5a5003df2015-06-24 17:32:33 +0300818
819free_head_ref:
820 kmem_cache_free(btrfs_delayed_ref_head_cachep, head_ref);
821free_ref:
822 kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref);
823
824 return -ENOMEM;
Chris Mason56bec292009-03-13 10:10:06 -0400825}
826
827/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400828 * add a delayed data ref. it's similar to btrfs_add_delayed_tree_ref.
829 */
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200830int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info,
831 struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400832 u64 bytenr, u64 num_bytes,
833 u64 parent, u64 ref_root,
Omar Sandoval7be07912017-06-06 16:45:30 -0700834 u64 owner, u64 offset, u64 reserved, int action,
835 int *old_ref_mod, int *new_ref_mod)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400836{
837 struct btrfs_delayed_data_ref *ref;
838 struct btrfs_delayed_ref_head *head_ref;
839 struct btrfs_delayed_ref_root *delayed_refs;
Qu Wenruo3368d002015-04-16 14:34:17 +0800840 struct btrfs_qgroup_extent_record *record = NULL;
Qu Wenruofb235dc2017-02-15 10:43:03 +0800841 int qrecord_inserted;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400842
Miao Xie78a61842012-11-21 02:21:28 +0000843 ref = kmem_cache_alloc(btrfs_delayed_data_ref_cachep, GFP_NOFS);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400844 if (!ref)
845 return -ENOMEM;
846
Miao Xie78a61842012-11-21 02:21:28 +0000847 head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400848 if (!head_ref) {
Miao Xie78a61842012-11-21 02:21:28 +0000849 kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400850 return -ENOMEM;
851 }
852
Josef Bacikafcdd122016-09-02 15:40:02 -0400853 if (test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags) &&
854 is_fstree(ref_root)) {
Qu Wenruo3368d002015-04-16 14:34:17 +0800855 record = kmalloc(sizeof(*record), GFP_NOFS);
856 if (!record) {
857 kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
858 kmem_cache_free(btrfs_delayed_ref_head_cachep,
859 head_ref);
860 return -ENOMEM;
861 }
862 }
863
Jeff Mahoneyfef394f2016-12-13 14:39:34 -0500864 head_ref->extent_op = NULL;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400865
866 delayed_refs = &trans->transaction->delayed_refs;
867 spin_lock(&delayed_refs->lock);
868
869 /*
870 * insert both the head node and the new ref without dropping
871 * the spin lock
872 */
Josef Bacikd2788502017-09-29 15:43:57 -0400873 head_ref = add_delayed_ref_head(fs_info, trans, head_ref, record,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800874 bytenr, num_bytes, ref_root, reserved,
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300875 action, 1, 0, &qrecord_inserted,
Omar Sandoval7be07912017-06-06 16:45:30 -0700876 old_ref_mod, new_ref_mod);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400877
Josef Bacikd7df2c72014-01-23 09:21:38 -0500878 add_delayed_data_ref(fs_info, trans, head_ref, &ref->node, bytenr,
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200879 num_bytes, parent, ref_root, owner, offset,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100880 action);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400881 spin_unlock(&delayed_refs->lock);
Jan Schmidt95a06072012-05-29 17:06:54 +0200882
Qu Wenruofb235dc2017-02-15 10:43:03 +0800883 if (qrecord_inserted)
884 return btrfs_qgroup_trace_extent_post(fs_info, record);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400885 return 0;
886}
887
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200888int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info,
889 struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400890 u64 bytenr, u64 num_bytes,
891 struct btrfs_delayed_extent_op *extent_op)
892{
893 struct btrfs_delayed_ref_head *head_ref;
894 struct btrfs_delayed_ref_root *delayed_refs;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400895
Miao Xie78a61842012-11-21 02:21:28 +0000896 head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400897 if (!head_ref)
898 return -ENOMEM;
899
900 head_ref->extent_op = extent_op;
901
902 delayed_refs = &trans->transaction->delayed_refs;
903 spin_lock(&delayed_refs->lock);
904
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300905 /*
906 * extent_ops just modify the flags of an extent and they don't result
907 * in ref count changes, hence it's safe to pass false/0 for is_system
908 * argument
909 */
Josef Bacikd2788502017-09-29 15:43:57 -0400910 add_delayed_ref_head(fs_info, trans, head_ref, NULL, bytenr,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800911 num_bytes, 0, 0, BTRFS_UPDATE_DELAYED_HEAD,
Nikolay Borisov5e388e92018-04-18 09:41:54 +0300912 extent_op->is_data, 0, NULL, NULL, NULL);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400913
914 spin_unlock(&delayed_refs->lock);
915 return 0;
916}
917
918/*
Chris Mason1887be62009-03-13 10:11:24 -0400919 * this does a simple search for the head node for a given extent.
920 * It must be called with the delayed ref spinlock held, and it returns
921 * the head node if any where found, or NULL if not.
922 */
923struct btrfs_delayed_ref_head *
Liu Bof72ad18e2017-01-30 12:24:37 -0800924btrfs_find_delayed_ref_head(struct btrfs_delayed_ref_root *delayed_refs, u64 bytenr)
Chris Mason1887be62009-03-13 10:11:24 -0400925{
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000926 return find_ref_head(&delayed_refs->href_root, bytenr, 0);
Chris Mason1887be62009-03-13 10:11:24 -0400927}
Miao Xie78a61842012-11-21 02:21:28 +0000928
David Sterbae67c7182018-02-19 17:24:18 +0100929void __cold btrfs_delayed_ref_exit(void)
Miao Xie78a61842012-11-21 02:21:28 +0000930{
Kinglong Mee5598e902016-01-29 21:36:35 +0800931 kmem_cache_destroy(btrfs_delayed_ref_head_cachep);
932 kmem_cache_destroy(btrfs_delayed_tree_ref_cachep);
933 kmem_cache_destroy(btrfs_delayed_data_ref_cachep);
934 kmem_cache_destroy(btrfs_delayed_extent_op_cachep);
Miao Xie78a61842012-11-21 02:21:28 +0000935}
936
Liu Bof5c29bd2017-11-02 17:21:50 -0600937int __init btrfs_delayed_ref_init(void)
Miao Xie78a61842012-11-21 02:21:28 +0000938{
939 btrfs_delayed_ref_head_cachep = kmem_cache_create(
940 "btrfs_delayed_ref_head",
941 sizeof(struct btrfs_delayed_ref_head), 0,
Nikolay Borisovfba4b692016-06-23 21:17:08 +0300942 SLAB_MEM_SPREAD, NULL);
Miao Xie78a61842012-11-21 02:21:28 +0000943 if (!btrfs_delayed_ref_head_cachep)
944 goto fail;
945
946 btrfs_delayed_tree_ref_cachep = kmem_cache_create(
947 "btrfs_delayed_tree_ref",
948 sizeof(struct btrfs_delayed_tree_ref), 0,
Nikolay Borisovfba4b692016-06-23 21:17:08 +0300949 SLAB_MEM_SPREAD, NULL);
Miao Xie78a61842012-11-21 02:21:28 +0000950 if (!btrfs_delayed_tree_ref_cachep)
951 goto fail;
952
953 btrfs_delayed_data_ref_cachep = kmem_cache_create(
954 "btrfs_delayed_data_ref",
955 sizeof(struct btrfs_delayed_data_ref), 0,
Nikolay Borisovfba4b692016-06-23 21:17:08 +0300956 SLAB_MEM_SPREAD, NULL);
Miao Xie78a61842012-11-21 02:21:28 +0000957 if (!btrfs_delayed_data_ref_cachep)
958 goto fail;
959
960 btrfs_delayed_extent_op_cachep = kmem_cache_create(
961 "btrfs_delayed_extent_op",
962 sizeof(struct btrfs_delayed_extent_op), 0,
Nikolay Borisovfba4b692016-06-23 21:17:08 +0300963 SLAB_MEM_SPREAD, NULL);
Miao Xie78a61842012-11-21 02:21:28 +0000964 if (!btrfs_delayed_extent_op_cachep)
965 goto fail;
966
967 return 0;
968fail:
969 btrfs_delayed_ref_exit();
970 return -ENOMEM;
971}