blob: e06dd75ad13f98999682c00128ae852e0a886e14 [file] [log] [blame]
Chris Mason56bec292009-03-13 10:10:06 -04001/*
2 * Copyright (C) 2009 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Chris Mason56bec292009-03-13 10:10:06 -040021#include <linux/sort.h>
Chris Mason56bec292009-03-13 10:10:06 -040022#include "ctree.h"
23#include "delayed-ref.h"
24#include "transaction.h"
Qu Wenruo3368d002015-04-16 14:34:17 +080025#include "qgroup.h"
Chris Mason56bec292009-03-13 10:10:06 -040026
Miao Xie78a61842012-11-21 02:21:28 +000027struct kmem_cache *btrfs_delayed_ref_head_cachep;
28struct kmem_cache *btrfs_delayed_tree_ref_cachep;
29struct kmem_cache *btrfs_delayed_data_ref_cachep;
30struct kmem_cache *btrfs_delayed_extent_op_cachep;
Chris Mason56bec292009-03-13 10:10:06 -040031/*
32 * delayed back reference update tracking. For subvolume trees
33 * we queue up extent allocations and backref maintenance for
34 * delayed processing. This avoids deep call chains where we
35 * add extents in the middle of btrfs_search_slot, and it allows
36 * us to buffer up frequently modified backrefs in an rb tree instead
37 * of hammering updates on the extent allocation tree.
Chris Mason56bec292009-03-13 10:10:06 -040038 */
39
40/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -040041 * compare two delayed tree backrefs with same bytenr and type
Chris Mason56bec292009-03-13 10:10:06 -040042 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -040043static int comp_tree_refs(struct btrfs_delayed_tree_ref *ref2,
Josef Bacik41b0fc42013-04-01 20:36:28 -040044 struct btrfs_delayed_tree_ref *ref1, int type)
Chris Mason56bec292009-03-13 10:10:06 -040045{
Josef Bacik41b0fc42013-04-01 20:36:28 -040046 if (type == BTRFS_TREE_BLOCK_REF_KEY) {
47 if (ref1->root < ref2->root)
48 return -1;
49 if (ref1->root > ref2->root)
50 return 1;
51 } else {
52 if (ref1->parent < ref2->parent)
53 return -1;
54 if (ref1->parent > ref2->parent)
55 return 1;
56 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -040057 return 0;
58}
59
60/*
61 * compare two delayed data backrefs with same bytenr and type
62 */
63static int comp_data_refs(struct btrfs_delayed_data_ref *ref2,
64 struct btrfs_delayed_data_ref *ref1)
65{
66 if (ref1->node.type == BTRFS_EXTENT_DATA_REF_KEY) {
67 if (ref1->root < ref2->root)
68 return -1;
69 if (ref1->root > ref2->root)
70 return 1;
71 if (ref1->objectid < ref2->objectid)
72 return -1;
73 if (ref1->objectid > ref2->objectid)
74 return 1;
75 if (ref1->offset < ref2->offset)
76 return -1;
77 if (ref1->offset > ref2->offset)
78 return 1;
79 } else {
80 if (ref1->parent < ref2->parent)
81 return -1;
82 if (ref1->parent > ref2->parent)
83 return 1;
84 }
85 return 0;
86}
87
Liu Boc46effa2013-10-14 12:59:45 +080088/* insert a new ref to head ref rbtree */
89static struct btrfs_delayed_ref_head *htree_insert(struct rb_root *root,
90 struct rb_node *node)
91{
92 struct rb_node **p = &root->rb_node;
93 struct rb_node *parent_node = NULL;
94 struct btrfs_delayed_ref_head *entry;
95 struct btrfs_delayed_ref_head *ins;
96 u64 bytenr;
97
98 ins = rb_entry(node, struct btrfs_delayed_ref_head, href_node);
99 bytenr = ins->node.bytenr;
100 while (*p) {
101 parent_node = *p;
102 entry = rb_entry(parent_node, struct btrfs_delayed_ref_head,
103 href_node);
104
105 if (bytenr < entry->node.bytenr)
106 p = &(*p)->rb_left;
107 else if (bytenr > entry->node.bytenr)
108 p = &(*p)->rb_right;
109 else
110 return entry;
111 }
112
113 rb_link_node(node, parent_node, p);
114 rb_insert_color(node, root);
115 return NULL;
116}
117
Chris Mason56bec292009-03-13 10:10:06 -0400118/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400119 * find an head entry based on bytenr. This returns the delayed ref
Arne Jansend1270cd2011-09-13 15:16:43 +0200120 * head if it was able to find one, or NULL if nothing was in that spot.
121 * If return_bigger is given, the next bigger entry is returned if no exact
122 * match is found.
Chris Mason56bec292009-03-13 10:10:06 -0400123 */
Liu Boc46effa2013-10-14 12:59:45 +0800124static struct btrfs_delayed_ref_head *
125find_ref_head(struct rb_root *root, u64 bytenr,
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000126 int return_bigger)
Chris Mason56bec292009-03-13 10:10:06 -0400127{
Arne Jansend1270cd2011-09-13 15:16:43 +0200128 struct rb_node *n;
Liu Boc46effa2013-10-14 12:59:45 +0800129 struct btrfs_delayed_ref_head *entry;
Chris Mason56bec292009-03-13 10:10:06 -0400130
Arne Jansend1270cd2011-09-13 15:16:43 +0200131 n = root->rb_node;
132 entry = NULL;
Chris Mason56bec292009-03-13 10:10:06 -0400133 while (n) {
Liu Boc46effa2013-10-14 12:59:45 +0800134 entry = rb_entry(n, struct btrfs_delayed_ref_head, href_node);
Chris Mason56bec292009-03-13 10:10:06 -0400135
Liu Boc46effa2013-10-14 12:59:45 +0800136 if (bytenr < entry->node.bytenr)
Chris Mason56bec292009-03-13 10:10:06 -0400137 n = n->rb_left;
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000138 else if (bytenr > entry->node.bytenr)
Chris Mason56bec292009-03-13 10:10:06 -0400139 n = n->rb_right;
140 else
141 return entry;
142 }
Arne Jansend1270cd2011-09-13 15:16:43 +0200143 if (entry && return_bigger) {
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000144 if (bytenr > entry->node.bytenr) {
Liu Boc46effa2013-10-14 12:59:45 +0800145 n = rb_next(&entry->href_node);
Arne Jansend1270cd2011-09-13 15:16:43 +0200146 if (!n)
147 n = rb_first(root);
Liu Boc46effa2013-10-14 12:59:45 +0800148 entry = rb_entry(n, struct btrfs_delayed_ref_head,
149 href_node);
Filipe Manana6103fb42014-02-12 15:07:52 +0000150 return entry;
Arne Jansend1270cd2011-09-13 15:16:43 +0200151 }
152 return entry;
153 }
Chris Mason56bec292009-03-13 10:10:06 -0400154 return NULL;
155}
156
Chris Masonc3e69d52009-03-13 10:17:05 -0400157int btrfs_delayed_ref_lock(struct btrfs_trans_handle *trans,
158 struct btrfs_delayed_ref_head *head)
Chris Mason56bec292009-03-13 10:10:06 -0400159{
Chris Masonc3e69d52009-03-13 10:17:05 -0400160 struct btrfs_delayed_ref_root *delayed_refs;
Chris Mason56bec292009-03-13 10:10:06 -0400161
Chris Masonc3e69d52009-03-13 10:17:05 -0400162 delayed_refs = &trans->transaction->delayed_refs;
163 assert_spin_locked(&delayed_refs->lock);
164 if (mutex_trylock(&head->mutex))
165 return 0;
166
167 atomic_inc(&head->node.refs);
168 spin_unlock(&delayed_refs->lock);
169
170 mutex_lock(&head->mutex);
171 spin_lock(&delayed_refs->lock);
172 if (!head->node.in_tree) {
173 mutex_unlock(&head->mutex);
174 btrfs_put_delayed_ref(&head->node);
175 return -EAGAIN;
176 }
177 btrfs_put_delayed_ref(&head->node);
178 return 0;
179}
180
Stefan Behrens35a36212013-08-14 18:12:25 +0200181static inline void drop_delayed_ref(struct btrfs_trans_handle *trans,
Josef Bacikae1e2062012-08-07 16:00:32 -0400182 struct btrfs_delayed_ref_root *delayed_refs,
Josef Bacikd7df2c72014-01-23 09:21:38 -0500183 struct btrfs_delayed_ref_head *head,
Josef Bacikae1e2062012-08-07 16:00:32 -0400184 struct btrfs_delayed_ref_node *ref)
185{
Liu Boc46effa2013-10-14 12:59:45 +0800186 if (btrfs_delayed_ref_is_head(ref)) {
Liu Boc46effa2013-10-14 12:59:45 +0800187 head = btrfs_delayed_node_to_head(ref);
188 rb_erase(&head->href_node, &delayed_refs->href_root);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500189 } else {
190 assert_spin_locked(&head->lock);
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800191 list_del(&ref->list);
Liu Boc46effa2013-10-14 12:59:45 +0800192 }
Josef Bacikae1e2062012-08-07 16:00:32 -0400193 ref->in_tree = 0;
194 btrfs_put_delayed_ref(ref);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500195 atomic_dec(&delayed_refs->num_entries);
Josef Bacikae1e2062012-08-07 16:00:32 -0400196 if (trans->delayed_ref_updates)
197 trans->delayed_ref_updates--;
198}
199
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100200static bool merge_ref(struct btrfs_trans_handle *trans,
201 struct btrfs_delayed_ref_root *delayed_refs,
202 struct btrfs_delayed_ref_head *head,
203 struct btrfs_delayed_ref_node *ref,
204 u64 seq)
205{
206 struct btrfs_delayed_ref_node *next;
207 bool done = false;
208
209 next = list_first_entry(&head->ref_list, struct btrfs_delayed_ref_node,
210 list);
211 while (!done && &next->list != &head->ref_list) {
212 int mod;
213 struct btrfs_delayed_ref_node *next2;
214
215 next2 = list_next_entry(next, list);
216
217 if (next == ref)
218 goto next;
219
220 if (seq && next->seq >= seq)
221 goto next;
222
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100223 if (next->type != ref->type)
Filipe Manana2c3cf7d2015-10-22 09:47:34 +0100224 goto next;
225
226 if ((ref->type == BTRFS_TREE_BLOCK_REF_KEY ||
227 ref->type == BTRFS_SHARED_BLOCK_REF_KEY) &&
228 comp_tree_refs(btrfs_delayed_node_to_tree_ref(ref),
229 btrfs_delayed_node_to_tree_ref(next),
230 ref->type))
231 goto next;
232 if ((ref->type == BTRFS_EXTENT_DATA_REF_KEY ||
233 ref->type == BTRFS_SHARED_DATA_REF_KEY) &&
234 comp_data_refs(btrfs_delayed_node_to_data_ref(ref),
235 btrfs_delayed_node_to_data_ref(next)))
236 goto next;
237
238 if (ref->action == next->action) {
239 mod = next->ref_mod;
240 } else {
241 if (ref->ref_mod < next->ref_mod) {
242 swap(ref, next);
243 done = true;
244 }
245 mod = -next->ref_mod;
246 }
247
248 drop_delayed_ref(trans, delayed_refs, head, next);
249 ref->ref_mod += mod;
250 if (ref->ref_mod == 0) {
251 drop_delayed_ref(trans, delayed_refs, head, ref);
252 done = true;
253 } else {
254 /*
255 * Can't have multiples of the same ref on a tree block.
256 */
257 WARN_ON(ref->type == BTRFS_TREE_BLOCK_REF_KEY ||
258 ref->type == BTRFS_SHARED_BLOCK_REF_KEY);
259 }
260next:
261 next = next2;
262 }
263
264 return done;
265}
266
267void btrfs_merge_delayed_refs(struct btrfs_trans_handle *trans,
268 struct btrfs_fs_info *fs_info,
269 struct btrfs_delayed_ref_root *delayed_refs,
270 struct btrfs_delayed_ref_head *head)
271{
272 struct btrfs_delayed_ref_node *ref;
273 u64 seq = 0;
274
275 assert_spin_locked(&head->lock);
276
277 if (list_empty(&head->ref_list))
278 return;
279
280 /* We don't have too many refs to merge for data. */
281 if (head->is_data)
282 return;
283
284 spin_lock(&fs_info->tree_mod_seq_lock);
285 if (!list_empty(&fs_info->tree_mod_seq_list)) {
286 struct seq_list *elem;
287
288 elem = list_first_entry(&fs_info->tree_mod_seq_list,
289 struct seq_list, list);
290 seq = elem->seq;
291 }
292 spin_unlock(&fs_info->tree_mod_seq_lock);
293
294 ref = list_first_entry(&head->ref_list, struct btrfs_delayed_ref_node,
295 list);
296 while (&ref->list != &head->ref_list) {
297 if (seq && ref->seq >= seq)
298 goto next;
299
300 if (merge_ref(trans, delayed_refs, head, ref, seq)) {
301 if (list_empty(&head->ref_list))
302 break;
303 ref = list_first_entry(&head->ref_list,
304 struct btrfs_delayed_ref_node,
305 list);
306 continue;
307 }
308next:
309 ref = list_next_entry(ref, list);
310 }
311}
312
Jan Schmidt097b8a72012-06-21 11:08:04 +0200313int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info,
314 struct btrfs_delayed_ref_root *delayed_refs,
Arne Jansen00f04b82011-09-14 12:37:00 +0200315 u64 seq)
316{
317 struct seq_list *elem;
Jan Schmidt097b8a72012-06-21 11:08:04 +0200318 int ret = 0;
Arne Jansen00f04b82011-09-14 12:37:00 +0200319
Jan Schmidt097b8a72012-06-21 11:08:04 +0200320 spin_lock(&fs_info->tree_mod_seq_lock);
321 if (!list_empty(&fs_info->tree_mod_seq_list)) {
322 elem = list_first_entry(&fs_info->tree_mod_seq_list,
323 struct seq_list, list);
324 if (seq >= elem->seq) {
Jan Schmidtfc36ed7e2013-04-24 16:57:33 +0000325 pr_debug("holding back delayed_ref %#x.%x, lowest is %#x.%x (%p)\n",
326 (u32)(seq >> 32), (u32)seq,
327 (u32)(elem->seq >> 32), (u32)elem->seq,
328 delayed_refs);
Jan Schmidt097b8a72012-06-21 11:08:04 +0200329 ret = 1;
330 }
Arne Jansen00f04b82011-09-14 12:37:00 +0200331 }
Jan Schmidt097b8a72012-06-21 11:08:04 +0200332
333 spin_unlock(&fs_info->tree_mod_seq_lock);
334 return ret;
Arne Jansen00f04b82011-09-14 12:37:00 +0200335}
336
Josef Bacikd7df2c72014-01-23 09:21:38 -0500337struct btrfs_delayed_ref_head *
338btrfs_select_ref_head(struct btrfs_trans_handle *trans)
Chris Masonc3e69d52009-03-13 10:17:05 -0400339{
Chris Masonc3e69d52009-03-13 10:17:05 -0400340 struct btrfs_delayed_ref_root *delayed_refs;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500341 struct btrfs_delayed_ref_head *head;
342 u64 start;
343 bool loop = false;
Chris Masonc3e69d52009-03-13 10:17:05 -0400344
345 delayed_refs = &trans->transaction->delayed_refs;
Liu Boc46effa2013-10-14 12:59:45 +0800346
Chris Masonc3e69d52009-03-13 10:17:05 -0400347again:
Josef Bacikd7df2c72014-01-23 09:21:38 -0500348 start = delayed_refs->run_delayed_start;
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000349 head = find_ref_head(&delayed_refs->href_root, start, 1);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500350 if (!head && !loop) {
351 delayed_refs->run_delayed_start = 0;
Chris Masonc3e69d52009-03-13 10:17:05 -0400352 start = 0;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500353 loop = true;
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000354 head = find_ref_head(&delayed_refs->href_root, start, 1);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500355 if (!head)
356 return NULL;
357 } else if (!head && loop) {
358 return NULL;
Chris Masonc3e69d52009-03-13 10:17:05 -0400359 }
Chris Mason56bec292009-03-13 10:10:06 -0400360
Josef Bacikd7df2c72014-01-23 09:21:38 -0500361 while (head->processing) {
362 struct rb_node *node;
Miao Xie093486c2012-12-19 08:10:10 +0000363
Josef Bacikd7df2c72014-01-23 09:21:38 -0500364 node = rb_next(&head->href_node);
365 if (!node) {
366 if (loop)
367 return NULL;
368 delayed_refs->run_delayed_start = 0;
369 start = 0;
370 loop = true;
371 goto again;
372 }
373 head = rb_entry(node, struct btrfs_delayed_ref_head,
374 href_node);
375 }
376
377 head->processing = 1;
378 WARN_ON(delayed_refs->num_heads_ready == 0);
379 delayed_refs->num_heads_ready--;
380 delayed_refs->run_delayed_start = head->node.bytenr +
381 head->node.num_bytes;
382 return head;
Miao Xie093486c2012-12-19 08:10:10 +0000383}
384
Chris Mason56bec292009-03-13 10:10:06 -0400385/*
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800386 * Helper to insert the ref_node to the tail or merge with tail.
387 *
388 * Return 0 for insert.
389 * Return >0 for merge.
390 */
391static int
392add_delayed_ref_tail_merge(struct btrfs_trans_handle *trans,
393 struct btrfs_delayed_ref_root *root,
394 struct btrfs_delayed_ref_head *href,
395 struct btrfs_delayed_ref_node *ref)
396{
397 struct btrfs_delayed_ref_node *exist;
398 int mod;
399 int ret = 0;
400
401 spin_lock(&href->lock);
402 /* Check whether we can merge the tail node with ref */
403 if (list_empty(&href->ref_list))
404 goto add_tail;
405 exist = list_entry(href->ref_list.prev, struct btrfs_delayed_ref_node,
406 list);
407 /* No need to compare bytenr nor is_head */
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100408 if (exist->type != ref->type || exist->seq != ref->seq)
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800409 goto add_tail;
410
411 if ((exist->type == BTRFS_TREE_BLOCK_REF_KEY ||
412 exist->type == BTRFS_SHARED_BLOCK_REF_KEY) &&
413 comp_tree_refs(btrfs_delayed_node_to_tree_ref(exist),
414 btrfs_delayed_node_to_tree_ref(ref),
415 ref->type))
416 goto add_tail;
417 if ((exist->type == BTRFS_EXTENT_DATA_REF_KEY ||
418 exist->type == BTRFS_SHARED_DATA_REF_KEY) &&
419 comp_data_refs(btrfs_delayed_node_to_data_ref(exist),
420 btrfs_delayed_node_to_data_ref(ref)))
421 goto add_tail;
422
423 /* Now we are sure we can merge */
424 ret = 1;
425 if (exist->action == ref->action) {
426 mod = ref->ref_mod;
427 } else {
428 /* Need to change action */
429 if (exist->ref_mod < ref->ref_mod) {
430 exist->action = ref->action;
431 mod = -exist->ref_mod;
432 exist->ref_mod = ref->ref_mod;
433 } else
434 mod = -ref->ref_mod;
435 }
436 exist->ref_mod += mod;
437
438 /* remove existing tail if its ref_mod is zero */
439 if (exist->ref_mod == 0)
440 drop_delayed_ref(trans, root, href, exist);
441 spin_unlock(&href->lock);
442 return ret;
443
444add_tail:
445 list_add_tail(&ref->list, &href->ref_list);
446 atomic_inc(&root->num_entries);
447 trans->delayed_ref_updates++;
448 spin_unlock(&href->lock);
449 return ret;
450}
451
452/*
Chris Mason56bec292009-03-13 10:10:06 -0400453 * helper function to update the accounting in the head ref
454 * existing and update must have the same bytenr
455 */
456static noinline void
Josef Bacik12621332015-02-03 07:50:16 -0800457update_existing_head_ref(struct btrfs_delayed_ref_root *delayed_refs,
458 struct btrfs_delayed_ref_node *existing,
Chris Mason56bec292009-03-13 10:10:06 -0400459 struct btrfs_delayed_ref_node *update)
460{
461 struct btrfs_delayed_ref_head *existing_ref;
462 struct btrfs_delayed_ref_head *ref;
Josef Bacik12621332015-02-03 07:50:16 -0800463 int old_ref_mod;
Chris Mason56bec292009-03-13 10:10:06 -0400464
465 existing_ref = btrfs_delayed_node_to_head(existing);
466 ref = btrfs_delayed_node_to_head(update);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400467 BUG_ON(existing_ref->is_data != ref->is_data);
Chris Mason56bec292009-03-13 10:10:06 -0400468
Filipe Manana21543ba2014-03-14 20:55:01 +0000469 spin_lock(&existing_ref->lock);
Chris Mason56bec292009-03-13 10:10:06 -0400470 if (ref->must_insert_reserved) {
471 /* if the extent was freed and then
472 * reallocated before the delayed ref
473 * entries were processed, we can end up
474 * with an existing head ref without
475 * the must_insert_reserved flag set.
476 * Set it again here
477 */
478 existing_ref->must_insert_reserved = ref->must_insert_reserved;
479
480 /*
481 * update the num_bytes so we make sure the accounting
482 * is done correctly
483 */
484 existing->num_bytes = update->num_bytes;
485
486 }
487
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400488 if (ref->extent_op) {
489 if (!existing_ref->extent_op) {
490 existing_ref->extent_op = ref->extent_op;
491 } else {
492 if (ref->extent_op->update_key) {
493 memcpy(&existing_ref->extent_op->key,
494 &ref->extent_op->key,
495 sizeof(ref->extent_op->key));
496 existing_ref->extent_op->update_key = 1;
497 }
498 if (ref->extent_op->update_flags) {
499 existing_ref->extent_op->flags_to_set |=
500 ref->extent_op->flags_to_set;
501 existing_ref->extent_op->update_flags = 1;
502 }
Miao Xie78a61842012-11-21 02:21:28 +0000503 btrfs_free_delayed_extent_op(ref->extent_op);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400504 }
505 }
Chris Mason56bec292009-03-13 10:10:06 -0400506 /*
Josef Bacikd7df2c72014-01-23 09:21:38 -0500507 * update the reference mod on the head to reflect this new operation,
508 * only need the lock for this case cause we could be processing it
509 * currently, for refs we just added we know we're a-ok.
Chris Mason56bec292009-03-13 10:10:06 -0400510 */
Josef Bacik12621332015-02-03 07:50:16 -0800511 old_ref_mod = existing_ref->total_ref_mod;
Chris Mason56bec292009-03-13 10:10:06 -0400512 existing->ref_mod += update->ref_mod;
Josef Bacik12621332015-02-03 07:50:16 -0800513 existing_ref->total_ref_mod += update->ref_mod;
514
515 /*
516 * If we are going to from a positive ref mod to a negative or vice
517 * versa we need to make sure to adjust pending_csums accordingly.
518 */
519 if (existing_ref->is_data) {
520 if (existing_ref->total_ref_mod >= 0 && old_ref_mod < 0)
521 delayed_refs->pending_csums -= existing->num_bytes;
522 if (existing_ref->total_ref_mod < 0 && old_ref_mod >= 0)
523 delayed_refs->pending_csums += existing->num_bytes;
524 }
Josef Bacikd7df2c72014-01-23 09:21:38 -0500525 spin_unlock(&existing_ref->lock);
Chris Mason56bec292009-03-13 10:10:06 -0400526}
527
528/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400529 * helper function to actually insert a head node into the rbtree.
Chris Mason56bec292009-03-13 10:10:06 -0400530 * this does all the dirty work in terms of maintaining the correct
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400531 * overall modification count.
Chris Mason56bec292009-03-13 10:10:06 -0400532 */
Josef Bacikd7df2c72014-01-23 09:21:38 -0500533static noinline struct btrfs_delayed_ref_head *
534add_delayed_ref_head(struct btrfs_fs_info *fs_info,
535 struct btrfs_trans_handle *trans,
Qu Wenruo3368d002015-04-16 14:34:17 +0800536 struct btrfs_delayed_ref_node *ref,
537 struct btrfs_qgroup_extent_record *qrecord,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800538 u64 bytenr, u64 num_bytes, u64 ref_root, u64 reserved,
539 int action, int is_data)
Chris Mason56bec292009-03-13 10:10:06 -0400540{
Josef Bacikd7df2c72014-01-23 09:21:38 -0500541 struct btrfs_delayed_ref_head *existing;
Chris Masonc3e69d52009-03-13 10:17:05 -0400542 struct btrfs_delayed_ref_head *head_ref = NULL;
Chris Mason56bec292009-03-13 10:10:06 -0400543 struct btrfs_delayed_ref_root *delayed_refs;
Qu Wenruo3368d002015-04-16 14:34:17 +0800544 struct btrfs_qgroup_extent_record *qexisting;
Chris Mason56bec292009-03-13 10:10:06 -0400545 int count_mod = 1;
546 int must_insert_reserved = 0;
547
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800548 /* If reserved is provided, it must be a data extent. */
549 BUG_ON(!is_data && reserved);
550
Chris Mason56bec292009-03-13 10:10:06 -0400551 /*
552 * the head node stores the sum of all the mods, so dropping a ref
553 * should drop the sum in the head node by one.
554 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400555 if (action == BTRFS_UPDATE_DELAYED_HEAD)
556 count_mod = 0;
557 else if (action == BTRFS_DROP_DELAYED_REF)
558 count_mod = -1;
Chris Mason56bec292009-03-13 10:10:06 -0400559
560 /*
561 * BTRFS_ADD_DELAYED_EXTENT means that we need to update
562 * the reserved accounting when the extent is finally added, or
563 * if a later modification deletes the delayed ref without ever
564 * inserting the extent into the extent allocation tree.
565 * ref->must_insert_reserved is the flag used to record
566 * that accounting mods are required.
567 *
568 * Once we record must_insert_reserved, switch the action to
569 * BTRFS_ADD_DELAYED_REF because other special casing is not required.
570 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400571 if (action == BTRFS_ADD_DELAYED_EXTENT)
Chris Mason56bec292009-03-13 10:10:06 -0400572 must_insert_reserved = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400573 else
Chris Mason56bec292009-03-13 10:10:06 -0400574 must_insert_reserved = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400575
576 delayed_refs = &trans->transaction->delayed_refs;
577
578 /* first set the basic ref node struct up */
579 atomic_set(&ref->refs, 1);
580 ref->bytenr = bytenr;
Chris Mason56bec292009-03-13 10:10:06 -0400581 ref->num_bytes = num_bytes;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400582 ref->ref_mod = count_mod;
583 ref->type = 0;
584 ref->action = 0;
585 ref->is_head = 1;
586 ref->in_tree = 1;
Arne Jansen00f04b82011-09-14 12:37:00 +0200587 ref->seq = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400588
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400589 head_ref = btrfs_delayed_node_to_head(ref);
590 head_ref->must_insert_reserved = must_insert_reserved;
591 head_ref->is_data = is_data;
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800592 INIT_LIST_HEAD(&head_ref->ref_list);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500593 head_ref->processing = 0;
Josef Bacik12621332015-02-03 07:50:16 -0800594 head_ref->total_ref_mod = count_mod;
Qu Wenruof64d5ca2015-09-08 17:08:36 +0800595 head_ref->qgroup_reserved = 0;
596 head_ref->qgroup_ref_root = 0;
Chris Mason56bec292009-03-13 10:10:06 -0400597
Qu Wenruo3368d002015-04-16 14:34:17 +0800598 /* Record qgroup extent info if provided */
599 if (qrecord) {
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800600 if (ref_root && reserved) {
601 head_ref->qgroup_ref_root = ref_root;
602 head_ref->qgroup_reserved = reserved;
603 }
604
Qu Wenruo3368d002015-04-16 14:34:17 +0800605 qrecord->bytenr = bytenr;
606 qrecord->num_bytes = num_bytes;
607 qrecord->old_roots = NULL;
608
609 qexisting = btrfs_qgroup_insert_dirty_extent(delayed_refs,
610 qrecord);
611 if (qexisting)
612 kfree(qrecord);
613 }
614
Josef Bacikd7df2c72014-01-23 09:21:38 -0500615 spin_lock_init(&head_ref->lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400616 mutex_init(&head_ref->mutex);
617
Liu Bo599c75e2013-07-16 19:03:36 +0800618 trace_add_delayed_ref_head(ref, head_ref, action);
liubo1abe9b82011-03-24 11:18:59 +0000619
Josef Bacikd7df2c72014-01-23 09:21:38 -0500620 existing = htree_insert(&delayed_refs->href_root,
621 &head_ref->href_node);
Chris Mason56bec292009-03-13 10:10:06 -0400622 if (existing) {
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800623 WARN_ON(ref_root && reserved && existing->qgroup_ref_root
624 && existing->qgroup_reserved);
Josef Bacik12621332015-02-03 07:50:16 -0800625 update_existing_head_ref(delayed_refs, &existing->node, ref);
Chris Mason56bec292009-03-13 10:10:06 -0400626 /*
627 * we've updated the existing ref, free the newly
628 * allocated ref
629 */
Miao Xie78a61842012-11-21 02:21:28 +0000630 kmem_cache_free(btrfs_delayed_ref_head_cachep, head_ref);
Josef Bacikd7df2c72014-01-23 09:21:38 -0500631 head_ref = existing;
Chris Mason56bec292009-03-13 10:10:06 -0400632 } else {
Josef Bacik12621332015-02-03 07:50:16 -0800633 if (is_data && count_mod < 0)
634 delayed_refs->pending_csums += num_bytes;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400635 delayed_refs->num_heads++;
636 delayed_refs->num_heads_ready++;
Josef Bacikd7df2c72014-01-23 09:21:38 -0500637 atomic_inc(&delayed_refs->num_entries);
Chris Mason56bec292009-03-13 10:10:06 -0400638 trans->delayed_ref_updates++;
639 }
Josef Bacikd7df2c72014-01-23 09:21:38 -0500640 return head_ref;
Chris Mason56bec292009-03-13 10:10:06 -0400641}
642
643/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400644 * helper to insert a delayed tree ref into the rbtree.
645 */
Josef Bacikd7df2c72014-01-23 09:21:38 -0500646static noinline void
647add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
648 struct btrfs_trans_handle *trans,
649 struct btrfs_delayed_ref_head *head_ref,
650 struct btrfs_delayed_ref_node *ref, u64 bytenr,
651 u64 num_bytes, u64 parent, u64 ref_root, int level,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100652 int action)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400653{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400654 struct btrfs_delayed_tree_ref *full_ref;
655 struct btrfs_delayed_ref_root *delayed_refs;
Arne Jansen00f04b82011-09-14 12:37:00 +0200656 u64 seq = 0;
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800657 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400658
659 if (action == BTRFS_ADD_DELAYED_EXTENT)
660 action = BTRFS_ADD_DELAYED_REF;
661
Josef Bacikfcebe452014-05-13 17:30:47 -0700662 if (is_fstree(ref_root))
663 seq = atomic64_read(&fs_info->tree_mod_seq);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400664 delayed_refs = &trans->transaction->delayed_refs;
665
666 /* first set the basic ref node struct up */
667 atomic_set(&ref->refs, 1);
668 ref->bytenr = bytenr;
669 ref->num_bytes = num_bytes;
670 ref->ref_mod = 1;
671 ref->action = action;
672 ref->is_head = 0;
673 ref->in_tree = 1;
Arne Jansen00f04b82011-09-14 12:37:00 +0200674 ref->seq = seq;
675
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400676 full_ref = btrfs_delayed_node_to_tree_ref(ref);
Arne Janseneebe0632011-09-14 14:01:24 +0200677 full_ref->parent = parent;
678 full_ref->root = ref_root;
679 if (parent)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400680 ref->type = BTRFS_SHARED_BLOCK_REF_KEY;
Arne Janseneebe0632011-09-14 14:01:24 +0200681 else
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400682 ref->type = BTRFS_TREE_BLOCK_REF_KEY;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400683 full_ref->level = level;
684
Liu Bo599c75e2013-07-16 19:03:36 +0800685 trace_add_delayed_tree_ref(ref, full_ref, action);
liubo1abe9b82011-03-24 11:18:59 +0000686
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800687 ret = add_delayed_ref_tail_merge(trans, delayed_refs, head_ref, ref);
688
689 /*
690 * XXX: memory should be freed at the same level allocated.
691 * But bad practice is anywhere... Follow it now. Need cleanup.
692 */
693 if (ret > 0)
Miao Xie78a61842012-11-21 02:21:28 +0000694 kmem_cache_free(btrfs_delayed_tree_ref_cachep, full_ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400695}
696
697/*
698 * helper to insert a delayed data ref into the rbtree.
699 */
Josef Bacikd7df2c72014-01-23 09:21:38 -0500700static noinline void
701add_delayed_data_ref(struct btrfs_fs_info *fs_info,
702 struct btrfs_trans_handle *trans,
703 struct btrfs_delayed_ref_head *head_ref,
704 struct btrfs_delayed_ref_node *ref, u64 bytenr,
705 u64 num_bytes, u64 parent, u64 ref_root, u64 owner,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100706 u64 offset, int action)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400707{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400708 struct btrfs_delayed_data_ref *full_ref;
709 struct btrfs_delayed_ref_root *delayed_refs;
Arne Jansen00f04b82011-09-14 12:37:00 +0200710 u64 seq = 0;
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800711 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400712
713 if (action == BTRFS_ADD_DELAYED_EXTENT)
714 action = BTRFS_ADD_DELAYED_REF;
715
716 delayed_refs = &trans->transaction->delayed_refs;
717
Josef Bacikfcebe452014-05-13 17:30:47 -0700718 if (is_fstree(ref_root))
719 seq = atomic64_read(&fs_info->tree_mod_seq);
720
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400721 /* first set the basic ref node struct up */
722 atomic_set(&ref->refs, 1);
723 ref->bytenr = bytenr;
724 ref->num_bytes = num_bytes;
725 ref->ref_mod = 1;
726 ref->action = action;
727 ref->is_head = 0;
728 ref->in_tree = 1;
Arne Jansen00f04b82011-09-14 12:37:00 +0200729 ref->seq = seq;
730
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400731 full_ref = btrfs_delayed_node_to_data_ref(ref);
Arne Janseneebe0632011-09-14 14:01:24 +0200732 full_ref->parent = parent;
733 full_ref->root = ref_root;
734 if (parent)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400735 ref->type = BTRFS_SHARED_DATA_REF_KEY;
Arne Janseneebe0632011-09-14 14:01:24 +0200736 else
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400737 ref->type = BTRFS_EXTENT_DATA_REF_KEY;
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200738
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400739 full_ref->objectid = owner;
740 full_ref->offset = offset;
741
Liu Bo599c75e2013-07-16 19:03:36 +0800742 trace_add_delayed_data_ref(ref, full_ref, action);
liubo1abe9b82011-03-24 11:18:59 +0000743
Qu Wenruoc6fc2452015-03-30 17:03:00 +0800744 ret = add_delayed_ref_tail_merge(trans, delayed_refs, head_ref, ref);
745
746 if (ret > 0)
Miao Xie78a61842012-11-21 02:21:28 +0000747 kmem_cache_free(btrfs_delayed_data_ref_cachep, full_ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400748}
749
750/*
751 * add a delayed tree ref. This does all of the accounting required
Chris Mason56bec292009-03-13 10:10:06 -0400752 * to make sure the delayed ref is eventually processed before this
753 * transaction commits.
754 */
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200755int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info,
756 struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400757 u64 bytenr, u64 num_bytes, u64 parent,
758 u64 ref_root, int level, int action,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100759 struct btrfs_delayed_extent_op *extent_op)
Chris Mason56bec292009-03-13 10:10:06 -0400760{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400761 struct btrfs_delayed_tree_ref *ref;
Chris Mason56bec292009-03-13 10:10:06 -0400762 struct btrfs_delayed_ref_head *head_ref;
763 struct btrfs_delayed_ref_root *delayed_refs;
Qu Wenruo3368d002015-04-16 14:34:17 +0800764 struct btrfs_qgroup_extent_record *record = NULL;
Chris Mason56bec292009-03-13 10:10:06 -0400765
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400766 BUG_ON(extent_op && extent_op->is_data);
Miao Xie78a61842012-11-21 02:21:28 +0000767 ref = kmem_cache_alloc(btrfs_delayed_tree_ref_cachep, GFP_NOFS);
Chris Mason56bec292009-03-13 10:10:06 -0400768 if (!ref)
769 return -ENOMEM;
770
Miao Xie78a61842012-11-21 02:21:28 +0000771 head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
Dan Carpenter5a5003df2015-06-24 17:32:33 +0300772 if (!head_ref)
773 goto free_ref;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400774
Qu Wenruo3368d002015-04-16 14:34:17 +0800775 if (fs_info->quota_enabled && is_fstree(ref_root)) {
776 record = kmalloc(sizeof(*record), GFP_NOFS);
Dan Carpenter5a5003df2015-06-24 17:32:33 +0300777 if (!record)
778 goto free_head_ref;
Qu Wenruo3368d002015-04-16 14:34:17 +0800779 }
780
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400781 head_ref->extent_op = extent_op;
782
Chris Mason56bec292009-03-13 10:10:06 -0400783 delayed_refs = &trans->transaction->delayed_refs;
784 spin_lock(&delayed_refs->lock);
785
786 /*
787 * insert both the head node and the new ref without dropping
788 * the spin lock
789 */
Qu Wenruo3368d002015-04-16 14:34:17 +0800790 head_ref = add_delayed_ref_head(fs_info, trans, &head_ref->node, record,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800791 bytenr, num_bytes, 0, 0, action, 0);
Chris Mason56bec292009-03-13 10:10:06 -0400792
Josef Bacikd7df2c72014-01-23 09:21:38 -0500793 add_delayed_tree_ref(fs_info, trans, head_ref, &ref->node, bytenr,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100794 num_bytes, parent, ref_root, level, action);
Chris Mason56bec292009-03-13 10:10:06 -0400795 spin_unlock(&delayed_refs->lock);
Jan Schmidt95a06072012-05-29 17:06:54 +0200796
Chris Mason56bec292009-03-13 10:10:06 -0400797 return 0;
Dan Carpenter5a5003df2015-06-24 17:32:33 +0300798
799free_head_ref:
800 kmem_cache_free(btrfs_delayed_ref_head_cachep, head_ref);
801free_ref:
802 kmem_cache_free(btrfs_delayed_tree_ref_cachep, ref);
803
804 return -ENOMEM;
Chris Mason56bec292009-03-13 10:10:06 -0400805}
806
807/*
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400808 * add a delayed data ref. it's similar to btrfs_add_delayed_tree_ref.
809 */
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200810int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info,
811 struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400812 u64 bytenr, u64 num_bytes,
813 u64 parent, u64 ref_root,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800814 u64 owner, u64 offset, u64 reserved, int action,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100815 struct btrfs_delayed_extent_op *extent_op)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400816{
817 struct btrfs_delayed_data_ref *ref;
818 struct btrfs_delayed_ref_head *head_ref;
819 struct btrfs_delayed_ref_root *delayed_refs;
Qu Wenruo3368d002015-04-16 14:34:17 +0800820 struct btrfs_qgroup_extent_record *record = NULL;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400821
822 BUG_ON(extent_op && !extent_op->is_data);
Miao Xie78a61842012-11-21 02:21:28 +0000823 ref = kmem_cache_alloc(btrfs_delayed_data_ref_cachep, GFP_NOFS);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400824 if (!ref)
825 return -ENOMEM;
826
Miao Xie78a61842012-11-21 02:21:28 +0000827 head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400828 if (!head_ref) {
Miao Xie78a61842012-11-21 02:21:28 +0000829 kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400830 return -ENOMEM;
831 }
832
Qu Wenruo3368d002015-04-16 14:34:17 +0800833 if (fs_info->quota_enabled && is_fstree(ref_root)) {
834 record = kmalloc(sizeof(*record), GFP_NOFS);
835 if (!record) {
836 kmem_cache_free(btrfs_delayed_data_ref_cachep, ref);
837 kmem_cache_free(btrfs_delayed_ref_head_cachep,
838 head_ref);
839 return -ENOMEM;
840 }
841 }
842
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400843 head_ref->extent_op = extent_op;
844
845 delayed_refs = &trans->transaction->delayed_refs;
846 spin_lock(&delayed_refs->lock);
847
848 /*
849 * insert both the head node and the new ref without dropping
850 * the spin lock
851 */
Qu Wenruo3368d002015-04-16 14:34:17 +0800852 head_ref = add_delayed_ref_head(fs_info, trans, &head_ref->node, record,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800853 bytenr, num_bytes, ref_root, reserved,
854 action, 1);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400855
Josef Bacikd7df2c72014-01-23 09:21:38 -0500856 add_delayed_data_ref(fs_info, trans, head_ref, &ref->node, bytenr,
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200857 num_bytes, parent, ref_root, owner, offset,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100858 action);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400859 spin_unlock(&delayed_refs->lock);
Jan Schmidt95a06072012-05-29 17:06:54 +0200860
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400861 return 0;
862}
863
Qu Wenruof64d5ca2015-09-08 17:08:36 +0800864int btrfs_add_delayed_qgroup_reserve(struct btrfs_fs_info *fs_info,
865 struct btrfs_trans_handle *trans,
866 u64 ref_root, u64 bytenr, u64 num_bytes)
867{
868 struct btrfs_delayed_ref_root *delayed_refs;
869 struct btrfs_delayed_ref_head *ref_head;
870 int ret = 0;
871
872 if (!fs_info->quota_enabled || !is_fstree(ref_root))
873 return 0;
874
875 delayed_refs = &trans->transaction->delayed_refs;
876
877 spin_lock(&delayed_refs->lock);
878 ref_head = find_ref_head(&delayed_refs->href_root, bytenr, 0);
879 if (!ref_head) {
880 ret = -ENOENT;
881 goto out;
882 }
883 WARN_ON(ref_head->qgroup_reserved || ref_head->qgroup_ref_root);
884 ref_head->qgroup_ref_root = ref_root;
885 ref_head->qgroup_reserved = num_bytes;
886out:
887 spin_unlock(&delayed_refs->lock);
888 return ret;
889}
890
Arne Jansen66d7e7f2011-09-12 15:26:38 +0200891int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info,
892 struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400893 u64 bytenr, u64 num_bytes,
894 struct btrfs_delayed_extent_op *extent_op)
895{
896 struct btrfs_delayed_ref_head *head_ref;
897 struct btrfs_delayed_ref_root *delayed_refs;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400898
Miao Xie78a61842012-11-21 02:21:28 +0000899 head_ref = kmem_cache_alloc(btrfs_delayed_ref_head_cachep, GFP_NOFS);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400900 if (!head_ref)
901 return -ENOMEM;
902
903 head_ref->extent_op = extent_op;
904
905 delayed_refs = &trans->transaction->delayed_refs;
906 spin_lock(&delayed_refs->lock);
907
Qu Wenruo3368d002015-04-16 14:34:17 +0800908 add_delayed_ref_head(fs_info, trans, &head_ref->node, NULL, bytenr,
Qu Wenruo5846a3c2015-10-26 14:11:18 +0800909 num_bytes, 0, 0, BTRFS_UPDATE_DELAYED_HEAD,
Qu Wenruo3368d002015-04-16 14:34:17 +0800910 extent_op->is_data);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400911
912 spin_unlock(&delayed_refs->lock);
913 return 0;
914}
915
916/*
Chris Mason1887be62009-03-13 10:11:24 -0400917 * this does a simple search for the head node for a given extent.
918 * It must be called with the delayed ref spinlock held, and it returns
919 * the head node if any where found, or NULL if not.
920 */
921struct btrfs_delayed_ref_head *
922btrfs_find_delayed_ref_head(struct btrfs_trans_handle *trans, u64 bytenr)
923{
Chris Mason1887be62009-03-13 10:11:24 -0400924 struct btrfs_delayed_ref_root *delayed_refs;
925
926 delayed_refs = &trans->transaction->delayed_refs;
Filipe Manana85fdfdf2014-02-12 15:07:53 +0000927 return find_ref_head(&delayed_refs->href_root, bytenr, 0);
Chris Mason1887be62009-03-13 10:11:24 -0400928}
Miao Xie78a61842012-11-21 02:21:28 +0000929
930void btrfs_delayed_ref_exit(void)
931{
932 if (btrfs_delayed_ref_head_cachep)
933 kmem_cache_destroy(btrfs_delayed_ref_head_cachep);
934 if (btrfs_delayed_tree_ref_cachep)
935 kmem_cache_destroy(btrfs_delayed_tree_ref_cachep);
936 if (btrfs_delayed_data_ref_cachep)
937 kmem_cache_destroy(btrfs_delayed_data_ref_cachep);
938 if (btrfs_delayed_extent_op_cachep)
939 kmem_cache_destroy(btrfs_delayed_extent_op_cachep);
940}
941
942int btrfs_delayed_ref_init(void)
943{
944 btrfs_delayed_ref_head_cachep = kmem_cache_create(
945 "btrfs_delayed_ref_head",
946 sizeof(struct btrfs_delayed_ref_head), 0,
947 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
948 if (!btrfs_delayed_ref_head_cachep)
949 goto fail;
950
951 btrfs_delayed_tree_ref_cachep = kmem_cache_create(
952 "btrfs_delayed_tree_ref",
953 sizeof(struct btrfs_delayed_tree_ref), 0,
954 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
955 if (!btrfs_delayed_tree_ref_cachep)
956 goto fail;
957
958 btrfs_delayed_data_ref_cachep = kmem_cache_create(
959 "btrfs_delayed_data_ref",
960 sizeof(struct btrfs_delayed_data_ref), 0,
961 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
962 if (!btrfs_delayed_data_ref_cachep)
963 goto fail;
964
965 btrfs_delayed_extent_op_cachep = kmem_cache_create(
966 "btrfs_delayed_extent_op",
967 sizeof(struct btrfs_delayed_extent_op), 0,
968 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
969 if (!btrfs_delayed_extent_op_cachep)
970 goto fail;
971
972 return 0;
973fail:
974 btrfs_delayed_ref_exit();
975 return -ENOMEM;
976}