blob: c669f250d4a0e27a839ed91f0c0dcd59a18dbaa4 [file] [log] [blame]
David Sterbac1d7c512018-04-03 19:23:33 +02001// SPDX-License-Identifier: GPL-2.0
Miao Xie16cdcec2011-04-22 18:12:22 +08002/*
3 * Copyright (C) 2011 Fujitsu. All rights reserved.
4 * Written by Miao Xie <miaox@cn.fujitsu.com>
Miao Xie16cdcec2011-04-22 18:12:22 +08005 */
6
7#include <linux/slab.h>
Jeff Laytonc7f88c42017-12-11 06:35:12 -05008#include <linux/iversion.h>
Miao Xie16cdcec2011-04-22 18:12:22 +08009#include "delayed-inode.h"
10#include "disk-io.h"
11#include "transaction.h"
Qu Wenruo3cae2102013-07-16 11:19:18 +080012#include "ctree.h"
Qu Wenruo4f5427c2017-12-12 15:34:33 +080013#include "qgroup.h"
Miao Xie16cdcec2011-04-22 18:12:22 +080014
Chris Masonde3cb942013-03-04 17:13:31 -050015#define BTRFS_DELAYED_WRITEBACK 512
16#define BTRFS_DELAYED_BACKGROUND 128
17#define BTRFS_DELAYED_BATCH 16
Miao Xie16cdcec2011-04-22 18:12:22 +080018
19static struct kmem_cache *delayed_node_cache;
20
21int __init btrfs_delayed_inode_init(void)
22{
David Sterba837e1972012-09-07 03:00:48 -060023 delayed_node_cache = kmem_cache_create("btrfs_delayed_node",
Miao Xie16cdcec2011-04-22 18:12:22 +080024 sizeof(struct btrfs_delayed_node),
25 0,
Nikolay Borisovfba4b692016-06-23 21:17:08 +030026 SLAB_MEM_SPREAD,
Miao Xie16cdcec2011-04-22 18:12:22 +080027 NULL);
28 if (!delayed_node_cache)
29 return -ENOMEM;
30 return 0;
31}
32
David Sterbae67c7182018-02-19 17:24:18 +010033void __cold btrfs_delayed_inode_exit(void)
Miao Xie16cdcec2011-04-22 18:12:22 +080034{
Kinglong Mee5598e902016-01-29 21:36:35 +080035 kmem_cache_destroy(delayed_node_cache);
Miao Xie16cdcec2011-04-22 18:12:22 +080036}
37
38static inline void btrfs_init_delayed_node(
39 struct btrfs_delayed_node *delayed_node,
40 struct btrfs_root *root, u64 inode_id)
41{
42 delayed_node->root = root;
43 delayed_node->inode_id = inode_id;
Elena Reshetova6de5f182017-03-03 10:55:16 +020044 refcount_set(&delayed_node->refs, 0);
Liu Bo03a1d4c2018-08-23 03:51:51 +080045 delayed_node->ins_root = RB_ROOT_CACHED;
46 delayed_node->del_root = RB_ROOT_CACHED;
Miao Xie16cdcec2011-04-22 18:12:22 +080047 mutex_init(&delayed_node->mutex);
Miao Xie16cdcec2011-04-22 18:12:22 +080048 INIT_LIST_HEAD(&delayed_node->n_list);
49 INIT_LIST_HEAD(&delayed_node->p_list);
Miao Xie16cdcec2011-04-22 18:12:22 +080050}
51
52static inline int btrfs_is_continuous_delayed_item(
53 struct btrfs_delayed_item *item1,
54 struct btrfs_delayed_item *item2)
55{
56 if (item1->key.type == BTRFS_DIR_INDEX_KEY &&
57 item1->key.objectid == item2->key.objectid &&
58 item1->key.type == item2->key.type &&
59 item1->key.offset + 1 == item2->key.offset)
60 return 1;
61 return 0;
62}
63
David Sterbaf85b7372017-01-20 14:54:07 +010064static struct btrfs_delayed_node *btrfs_get_delayed_node(
65 struct btrfs_inode *btrfs_inode)
Miao Xie2f7e33d2011-06-23 07:27:13 +000066{
Miao Xie2f7e33d2011-06-23 07:27:13 +000067 struct btrfs_root *root = btrfs_inode->root;
Nikolay Borisov4a0cc7c2017-01-10 20:35:31 +020068 u64 ino = btrfs_ino(btrfs_inode);
Miao Xie2f7e33d2011-06-23 07:27:13 +000069 struct btrfs_delayed_node *node;
70
Seraphime Kirkovski20c7bce2016-12-15 14:38:16 +010071 node = READ_ONCE(btrfs_inode->delayed_node);
Miao Xie2f7e33d2011-06-23 07:27:13 +000072 if (node) {
Elena Reshetova6de5f182017-03-03 10:55:16 +020073 refcount_inc(&node->refs);
Miao Xie2f7e33d2011-06-23 07:27:13 +000074 return node;
75 }
76
77 spin_lock(&root->inode_lock);
78 node = radix_tree_lookup(&root->delayed_nodes_tree, ino);
Chris Masonec35e482017-12-15 11:58:27 -080079
Miao Xie2f7e33d2011-06-23 07:27:13 +000080 if (node) {
81 if (btrfs_inode->delayed_node) {
Elena Reshetova6de5f182017-03-03 10:55:16 +020082 refcount_inc(&node->refs); /* can be accessed */
Miao Xie2f7e33d2011-06-23 07:27:13 +000083 BUG_ON(btrfs_inode->delayed_node != node);
84 spin_unlock(&root->inode_lock);
85 return node;
86 }
Chris Masonec35e482017-12-15 11:58:27 -080087
88 /*
89 * It's possible that we're racing into the middle of removing
90 * this node from the radix tree. In this case, the refcount
91 * was zero and it should never go back to one. Just return
92 * NULL like it was never in the radix at all; our release
93 * function is in the process of removing it.
94 *
95 * Some implementations of refcount_inc refuse to bump the
96 * refcount once it has hit zero. If we don't do this dance
97 * here, refcount_inc() may decide to just WARN_ONCE() instead
98 * of actually bumping the refcount.
99 *
100 * If this node is properly in the radix, we want to bump the
101 * refcount twice, once for the inode and once for this get
102 * operation.
103 */
104 if (refcount_inc_not_zero(&node->refs)) {
105 refcount_inc(&node->refs);
106 btrfs_inode->delayed_node = node;
107 } else {
108 node = NULL;
109 }
110
Miao Xie2f7e33d2011-06-23 07:27:13 +0000111 spin_unlock(&root->inode_lock);
112 return node;
113 }
114 spin_unlock(&root->inode_lock);
115
116 return NULL;
117}
118
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100119/* Will return either the node or PTR_ERR(-ENOMEM) */
Miao Xie16cdcec2011-04-22 18:12:22 +0800120static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node(
David Sterbaf85b7372017-01-20 14:54:07 +0100121 struct btrfs_inode *btrfs_inode)
Miao Xie16cdcec2011-04-22 18:12:22 +0800122{
123 struct btrfs_delayed_node *node;
Miao Xie16cdcec2011-04-22 18:12:22 +0800124 struct btrfs_root *root = btrfs_inode->root;
Nikolay Borisov4a0cc7c2017-01-10 20:35:31 +0200125 u64 ino = btrfs_ino(btrfs_inode);
Miao Xie16cdcec2011-04-22 18:12:22 +0800126 int ret;
127
128again:
Nikolay Borisov340c6ca2017-01-10 20:35:32 +0200129 node = btrfs_get_delayed_node(btrfs_inode);
Miao Xie2f7e33d2011-06-23 07:27:13 +0000130 if (node)
Miao Xie16cdcec2011-04-22 18:12:22 +0800131 return node;
Miao Xie16cdcec2011-04-22 18:12:22 +0800132
Alexandru Moise352dd9c2015-10-25 20:15:06 +0000133 node = kmem_cache_zalloc(delayed_node_cache, GFP_NOFS);
Miao Xie16cdcec2011-04-22 18:12:22 +0800134 if (!node)
135 return ERR_PTR(-ENOMEM);
Chris Mason0d0ca302011-05-22 07:11:22 -0400136 btrfs_init_delayed_node(node, root, ino);
Miao Xie16cdcec2011-04-22 18:12:22 +0800137
Rashika95e94d12013-10-31 03:12:42 +0530138 /* cached in the btrfs inode and can be accessed */
Elena Reshetova6de5f182017-03-03 10:55:16 +0200139 refcount_set(&node->refs, 2);
Miao Xie16cdcec2011-04-22 18:12:22 +0800140
David Sterbae1860a72016-05-09 14:11:38 +0200141 ret = radix_tree_preload(GFP_NOFS);
Miao Xie16cdcec2011-04-22 18:12:22 +0800142 if (ret) {
143 kmem_cache_free(delayed_node_cache, node);
144 return ERR_PTR(ret);
145 }
146
147 spin_lock(&root->inode_lock);
Chris Mason0d0ca302011-05-22 07:11:22 -0400148 ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node);
Miao Xie16cdcec2011-04-22 18:12:22 +0800149 if (ret == -EEXIST) {
Miao Xie16cdcec2011-04-22 18:12:22 +0800150 spin_unlock(&root->inode_lock);
Jeff Mahoney96493032014-05-27 13:53:20 -0400151 kmem_cache_free(delayed_node_cache, node);
Miao Xie16cdcec2011-04-22 18:12:22 +0800152 radix_tree_preload_end();
153 goto again;
154 }
155 btrfs_inode->delayed_node = node;
156 spin_unlock(&root->inode_lock);
157 radix_tree_preload_end();
158
159 return node;
160}
161
162/*
163 * Call it when holding delayed_node->mutex
164 *
165 * If mod = 1, add this node into the prepared list.
166 */
167static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root,
168 struct btrfs_delayed_node *node,
169 int mod)
170{
171 spin_lock(&root->lock);
Miao Xie7cf35d92013-12-26 13:07:05 +0800172 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {
Miao Xie16cdcec2011-04-22 18:12:22 +0800173 if (!list_empty(&node->p_list))
174 list_move_tail(&node->p_list, &root->prepare_list);
175 else if (mod)
176 list_add_tail(&node->p_list, &root->prepare_list);
177 } else {
178 list_add_tail(&node->n_list, &root->node_list);
179 list_add_tail(&node->p_list, &root->prepare_list);
Elena Reshetova6de5f182017-03-03 10:55:16 +0200180 refcount_inc(&node->refs); /* inserted into list */
Miao Xie16cdcec2011-04-22 18:12:22 +0800181 root->nodes++;
Miao Xie7cf35d92013-12-26 13:07:05 +0800182 set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags);
Miao Xie16cdcec2011-04-22 18:12:22 +0800183 }
184 spin_unlock(&root->lock);
185}
186
187/* Call it when holding delayed_node->mutex */
188static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root,
189 struct btrfs_delayed_node *node)
190{
191 spin_lock(&root->lock);
Miao Xie7cf35d92013-12-26 13:07:05 +0800192 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {
Miao Xie16cdcec2011-04-22 18:12:22 +0800193 root->nodes--;
Elena Reshetova6de5f182017-03-03 10:55:16 +0200194 refcount_dec(&node->refs); /* not in the list */
Miao Xie16cdcec2011-04-22 18:12:22 +0800195 list_del_init(&node->n_list);
196 if (!list_empty(&node->p_list))
197 list_del_init(&node->p_list);
Miao Xie7cf35d92013-12-26 13:07:05 +0800198 clear_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags);
Miao Xie16cdcec2011-04-22 18:12:22 +0800199 }
200 spin_unlock(&root->lock);
201}
202
Eric Sandeen48a3b632013-04-25 20:41:01 +0000203static struct btrfs_delayed_node *btrfs_first_delayed_node(
Miao Xie16cdcec2011-04-22 18:12:22 +0800204 struct btrfs_delayed_root *delayed_root)
205{
206 struct list_head *p;
207 struct btrfs_delayed_node *node = NULL;
208
209 spin_lock(&delayed_root->lock);
210 if (list_empty(&delayed_root->node_list))
211 goto out;
212
213 p = delayed_root->node_list.next;
214 node = list_entry(p, struct btrfs_delayed_node, n_list);
Elena Reshetova6de5f182017-03-03 10:55:16 +0200215 refcount_inc(&node->refs);
Miao Xie16cdcec2011-04-22 18:12:22 +0800216out:
217 spin_unlock(&delayed_root->lock);
218
219 return node;
220}
221
Eric Sandeen48a3b632013-04-25 20:41:01 +0000222static struct btrfs_delayed_node *btrfs_next_delayed_node(
Miao Xie16cdcec2011-04-22 18:12:22 +0800223 struct btrfs_delayed_node *node)
224{
225 struct btrfs_delayed_root *delayed_root;
226 struct list_head *p;
227 struct btrfs_delayed_node *next = NULL;
228
229 delayed_root = node->root->fs_info->delayed_root;
230 spin_lock(&delayed_root->lock);
Miao Xie7cf35d92013-12-26 13:07:05 +0800231 if (!test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {
232 /* not in the list */
Miao Xie16cdcec2011-04-22 18:12:22 +0800233 if (list_empty(&delayed_root->node_list))
234 goto out;
235 p = delayed_root->node_list.next;
236 } else if (list_is_last(&node->n_list, &delayed_root->node_list))
237 goto out;
238 else
239 p = node->n_list.next;
240
241 next = list_entry(p, struct btrfs_delayed_node, n_list);
Elena Reshetova6de5f182017-03-03 10:55:16 +0200242 refcount_inc(&next->refs);
Miao Xie16cdcec2011-04-22 18:12:22 +0800243out:
244 spin_unlock(&delayed_root->lock);
245
246 return next;
247}
248
249static void __btrfs_release_delayed_node(
250 struct btrfs_delayed_node *delayed_node,
251 int mod)
252{
253 struct btrfs_delayed_root *delayed_root;
254
255 if (!delayed_node)
256 return;
257
258 delayed_root = delayed_node->root->fs_info->delayed_root;
259
260 mutex_lock(&delayed_node->mutex);
261 if (delayed_node->count)
262 btrfs_queue_delayed_node(delayed_root, delayed_node, mod);
263 else
264 btrfs_dequeue_delayed_node(delayed_root, delayed_node);
265 mutex_unlock(&delayed_node->mutex);
266
Elena Reshetova6de5f182017-03-03 10:55:16 +0200267 if (refcount_dec_and_test(&delayed_node->refs)) {
Miao Xie16cdcec2011-04-22 18:12:22 +0800268 struct btrfs_root *root = delayed_node->root;
Chris Masonec35e482017-12-15 11:58:27 -0800269
Miao Xie16cdcec2011-04-22 18:12:22 +0800270 spin_lock(&root->inode_lock);
Chris Masonec35e482017-12-15 11:58:27 -0800271 /*
272 * Once our refcount goes to zero, nobody is allowed to bump it
273 * back up. We can delete it now.
274 */
275 ASSERT(refcount_read(&delayed_node->refs) == 0);
276 radix_tree_delete(&root->delayed_nodes_tree,
277 delayed_node->inode_id);
Miao Xie16cdcec2011-04-22 18:12:22 +0800278 spin_unlock(&root->inode_lock);
Chris Masonec35e482017-12-15 11:58:27 -0800279 kmem_cache_free(delayed_node_cache, delayed_node);
Miao Xie16cdcec2011-04-22 18:12:22 +0800280 }
281}
282
283static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node)
284{
285 __btrfs_release_delayed_node(node, 0);
286}
287
Eric Sandeen48a3b632013-04-25 20:41:01 +0000288static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node(
Miao Xie16cdcec2011-04-22 18:12:22 +0800289 struct btrfs_delayed_root *delayed_root)
290{
291 struct list_head *p;
292 struct btrfs_delayed_node *node = NULL;
293
294 spin_lock(&delayed_root->lock);
295 if (list_empty(&delayed_root->prepare_list))
296 goto out;
297
298 p = delayed_root->prepare_list.next;
299 list_del_init(p);
300 node = list_entry(p, struct btrfs_delayed_node, p_list);
Elena Reshetova6de5f182017-03-03 10:55:16 +0200301 refcount_inc(&node->refs);
Miao Xie16cdcec2011-04-22 18:12:22 +0800302out:
303 spin_unlock(&delayed_root->lock);
304
305 return node;
306}
307
308static inline void btrfs_release_prepared_delayed_node(
309 struct btrfs_delayed_node *node)
310{
311 __btrfs_release_delayed_node(node, 1);
312}
313
Eric Sandeen48a3b632013-04-25 20:41:01 +0000314static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u32 data_len)
Miao Xie16cdcec2011-04-22 18:12:22 +0800315{
316 struct btrfs_delayed_item *item;
317 item = kmalloc(sizeof(*item) + data_len, GFP_NOFS);
318 if (item) {
319 item->data_len = data_len;
320 item->ins_or_del = 0;
321 item->bytes_reserved = 0;
Miao Xie16cdcec2011-04-22 18:12:22 +0800322 item->delayed_node = NULL;
Elena Reshetova089e77e2017-03-03 10:55:17 +0200323 refcount_set(&item->refs, 1);
Miao Xie16cdcec2011-04-22 18:12:22 +0800324 }
325 return item;
326}
327
328/*
329 * __btrfs_lookup_delayed_item - look up the delayed item by key
330 * @delayed_node: pointer to the delayed node
331 * @key: the key to look up
332 * @prev: used to store the prev item if the right item isn't found
333 * @next: used to store the next item if the right item isn't found
334 *
335 * Note: if we don't find the right item, we will return the prev item and
336 * the next item.
337 */
338static struct btrfs_delayed_item *__btrfs_lookup_delayed_item(
339 struct rb_root *root,
340 struct btrfs_key *key,
341 struct btrfs_delayed_item **prev,
342 struct btrfs_delayed_item **next)
343{
344 struct rb_node *node, *prev_node = NULL;
345 struct btrfs_delayed_item *delayed_item = NULL;
346 int ret = 0;
347
348 node = root->rb_node;
349
350 while (node) {
351 delayed_item = rb_entry(node, struct btrfs_delayed_item,
352 rb_node);
353 prev_node = node;
354 ret = btrfs_comp_cpu_keys(&delayed_item->key, key);
355 if (ret < 0)
356 node = node->rb_right;
357 else if (ret > 0)
358 node = node->rb_left;
359 else
360 return delayed_item;
361 }
362
363 if (prev) {
364 if (!prev_node)
365 *prev = NULL;
366 else if (ret < 0)
367 *prev = delayed_item;
368 else if ((node = rb_prev(prev_node)) != NULL) {
369 *prev = rb_entry(node, struct btrfs_delayed_item,
370 rb_node);
371 } else
372 *prev = NULL;
373 }
374
375 if (next) {
376 if (!prev_node)
377 *next = NULL;
378 else if (ret > 0)
379 *next = delayed_item;
380 else if ((node = rb_next(prev_node)) != NULL) {
381 *next = rb_entry(node, struct btrfs_delayed_item,
382 rb_node);
383 } else
384 *next = NULL;
385 }
386 return NULL;
387}
388
Eric Sandeen48a3b632013-04-25 20:41:01 +0000389static struct btrfs_delayed_item *__btrfs_lookup_delayed_insertion_item(
Miao Xie16cdcec2011-04-22 18:12:22 +0800390 struct btrfs_delayed_node *delayed_node,
391 struct btrfs_key *key)
392{
Liu Bo03a1d4c2018-08-23 03:51:51 +0800393 return __btrfs_lookup_delayed_item(&delayed_node->ins_root.rb_root, key,
Miao Xie16cdcec2011-04-22 18:12:22 +0800394 NULL, NULL);
Miao Xie16cdcec2011-04-22 18:12:22 +0800395}
396
Miao Xie16cdcec2011-04-22 18:12:22 +0800397static int __btrfs_add_delayed_item(struct btrfs_delayed_node *delayed_node,
398 struct btrfs_delayed_item *ins,
399 int action)
400{
401 struct rb_node **p, *node;
402 struct rb_node *parent_node = NULL;
Liu Bo03a1d4c2018-08-23 03:51:51 +0800403 struct rb_root_cached *root;
Miao Xie16cdcec2011-04-22 18:12:22 +0800404 struct btrfs_delayed_item *item;
405 int cmp;
Liu Bo03a1d4c2018-08-23 03:51:51 +0800406 bool leftmost = true;
Miao Xie16cdcec2011-04-22 18:12:22 +0800407
408 if (action == BTRFS_DELAYED_INSERTION_ITEM)
409 root = &delayed_node->ins_root;
410 else if (action == BTRFS_DELAYED_DELETION_ITEM)
411 root = &delayed_node->del_root;
412 else
413 BUG();
Liu Bo03a1d4c2018-08-23 03:51:51 +0800414 p = &root->rb_root.rb_node;
Miao Xie16cdcec2011-04-22 18:12:22 +0800415 node = &ins->rb_node;
416
417 while (*p) {
418 parent_node = *p;
419 item = rb_entry(parent_node, struct btrfs_delayed_item,
420 rb_node);
421
422 cmp = btrfs_comp_cpu_keys(&item->key, &ins->key);
Liu Bo03a1d4c2018-08-23 03:51:51 +0800423 if (cmp < 0) {
Miao Xie16cdcec2011-04-22 18:12:22 +0800424 p = &(*p)->rb_right;
Liu Bo03a1d4c2018-08-23 03:51:51 +0800425 leftmost = false;
426 } else if (cmp > 0) {
Miao Xie16cdcec2011-04-22 18:12:22 +0800427 p = &(*p)->rb_left;
Liu Bo03a1d4c2018-08-23 03:51:51 +0800428 } else {
Miao Xie16cdcec2011-04-22 18:12:22 +0800429 return -EEXIST;
Liu Bo03a1d4c2018-08-23 03:51:51 +0800430 }
Miao Xie16cdcec2011-04-22 18:12:22 +0800431 }
432
433 rb_link_node(node, parent_node, p);
Liu Bo03a1d4c2018-08-23 03:51:51 +0800434 rb_insert_color_cached(node, root, leftmost);
Miao Xie16cdcec2011-04-22 18:12:22 +0800435 ins->delayed_node = delayed_node;
436 ins->ins_or_del = action;
437
438 if (ins->key.type == BTRFS_DIR_INDEX_KEY &&
439 action == BTRFS_DELAYED_INSERTION_ITEM &&
440 ins->key.offset >= delayed_node->index_cnt)
441 delayed_node->index_cnt = ins->key.offset + 1;
442
443 delayed_node->count++;
444 atomic_inc(&delayed_node->root->fs_info->delayed_root->items);
445 return 0;
446}
447
448static int __btrfs_add_delayed_insertion_item(struct btrfs_delayed_node *node,
449 struct btrfs_delayed_item *item)
450{
451 return __btrfs_add_delayed_item(node, item,
452 BTRFS_DELAYED_INSERTION_ITEM);
453}
454
455static int __btrfs_add_delayed_deletion_item(struct btrfs_delayed_node *node,
456 struct btrfs_delayed_item *item)
457{
458 return __btrfs_add_delayed_item(node, item,
459 BTRFS_DELAYED_DELETION_ITEM);
460}
461
Chris Masonde3cb942013-03-04 17:13:31 -0500462static void finish_one_item(struct btrfs_delayed_root *delayed_root)
463{
464 int seq = atomic_inc_return(&delayed_root->items_seq);
David Sterbaee863952015-02-16 19:41:40 +0100465
David Sterba093258e62018-02-26 16:15:17 +0100466 /* atomic_dec_return implies a barrier */
Chris Masonde3cb942013-03-04 17:13:31 -0500467 if ((atomic_dec_return(&delayed_root->items) <
David Sterba093258e62018-02-26 16:15:17 +0100468 BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0))
469 cond_wake_up_nomb(&delayed_root->wait);
Chris Masonde3cb942013-03-04 17:13:31 -0500470}
471
Miao Xie16cdcec2011-04-22 18:12:22 +0800472static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item)
473{
Liu Bo03a1d4c2018-08-23 03:51:51 +0800474 struct rb_root_cached *root;
Miao Xie16cdcec2011-04-22 18:12:22 +0800475 struct btrfs_delayed_root *delayed_root;
476
477 delayed_root = delayed_item->delayed_node->root->fs_info->delayed_root;
478
479 BUG_ON(!delayed_root);
480 BUG_ON(delayed_item->ins_or_del != BTRFS_DELAYED_DELETION_ITEM &&
481 delayed_item->ins_or_del != BTRFS_DELAYED_INSERTION_ITEM);
482
483 if (delayed_item->ins_or_del == BTRFS_DELAYED_INSERTION_ITEM)
484 root = &delayed_item->delayed_node->ins_root;
485 else
486 root = &delayed_item->delayed_node->del_root;
487
Liu Bo03a1d4c2018-08-23 03:51:51 +0800488 rb_erase_cached(&delayed_item->rb_node, root);
Miao Xie16cdcec2011-04-22 18:12:22 +0800489 delayed_item->delayed_node->count--;
Chris Masonde3cb942013-03-04 17:13:31 -0500490
491 finish_one_item(delayed_root);
Miao Xie16cdcec2011-04-22 18:12:22 +0800492}
493
494static void btrfs_release_delayed_item(struct btrfs_delayed_item *item)
495{
496 if (item) {
497 __btrfs_remove_delayed_item(item);
Elena Reshetova089e77e2017-03-03 10:55:17 +0200498 if (refcount_dec_and_test(&item->refs))
Miao Xie16cdcec2011-04-22 18:12:22 +0800499 kfree(item);
500 }
501}
502
Eric Sandeen48a3b632013-04-25 20:41:01 +0000503static struct btrfs_delayed_item *__btrfs_first_delayed_insertion_item(
Miao Xie16cdcec2011-04-22 18:12:22 +0800504 struct btrfs_delayed_node *delayed_node)
505{
506 struct rb_node *p;
507 struct btrfs_delayed_item *item = NULL;
508
Liu Bo03a1d4c2018-08-23 03:51:51 +0800509 p = rb_first_cached(&delayed_node->ins_root);
Miao Xie16cdcec2011-04-22 18:12:22 +0800510 if (p)
511 item = rb_entry(p, struct btrfs_delayed_item, rb_node);
512
513 return item;
514}
515
Eric Sandeen48a3b632013-04-25 20:41:01 +0000516static struct btrfs_delayed_item *__btrfs_first_delayed_deletion_item(
Miao Xie16cdcec2011-04-22 18:12:22 +0800517 struct btrfs_delayed_node *delayed_node)
518{
519 struct rb_node *p;
520 struct btrfs_delayed_item *item = NULL;
521
Liu Bo03a1d4c2018-08-23 03:51:51 +0800522 p = rb_first_cached(&delayed_node->del_root);
Miao Xie16cdcec2011-04-22 18:12:22 +0800523 if (p)
524 item = rb_entry(p, struct btrfs_delayed_item, rb_node);
525
526 return item;
527}
528
Eric Sandeen48a3b632013-04-25 20:41:01 +0000529static struct btrfs_delayed_item *__btrfs_next_delayed_item(
Miao Xie16cdcec2011-04-22 18:12:22 +0800530 struct btrfs_delayed_item *item)
531{
532 struct rb_node *p;
533 struct btrfs_delayed_item *next = NULL;
534
535 p = rb_next(&item->rb_node);
536 if (p)
537 next = rb_entry(p, struct btrfs_delayed_item, rb_node);
538
539 return next;
540}
541
Miao Xie16cdcec2011-04-22 18:12:22 +0800542static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans,
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800543 struct btrfs_root *root,
Miao Xie16cdcec2011-04-22 18:12:22 +0800544 struct btrfs_delayed_item *item)
545{
546 struct btrfs_block_rsv *src_rsv;
547 struct btrfs_block_rsv *dst_rsv;
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800548 struct btrfs_fs_info *fs_info = root->fs_info;
Miao Xie16cdcec2011-04-22 18:12:22 +0800549 u64 num_bytes;
550 int ret;
551
552 if (!trans->bytes_reserved)
553 return 0;
554
555 src_rsv = trans->block_rsv;
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400556 dst_rsv = &fs_info->delayed_block_rsv;
Miao Xie16cdcec2011-04-22 18:12:22 +0800557
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400558 num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
Qu Wenruof218ea62018-04-17 16:52:45 +0800559
560 /*
561 * Here we migrate space rsv from transaction rsv, since have already
562 * reserved space when starting a transaction. So no need to reserve
563 * qgroup space here.
564 */
Lu Fengqi3a584172018-08-04 21:10:55 +0800565 ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true);
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500566 if (!ret) {
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400567 trace_btrfs_space_reservation(fs_info, "delayed_item",
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500568 item->key.objectid,
569 num_bytes, 1);
Miao Xie16cdcec2011-04-22 18:12:22 +0800570 item->bytes_reserved = num_bytes;
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500571 }
Miao Xie16cdcec2011-04-22 18:12:22 +0800572
573 return ret;
574}
575
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800576static void btrfs_delayed_item_release_metadata(struct btrfs_root *root,
Miao Xie16cdcec2011-04-22 18:12:22 +0800577 struct btrfs_delayed_item *item)
578{
Miao Xie19fd2942011-06-15 10:47:30 +0000579 struct btrfs_block_rsv *rsv;
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800580 struct btrfs_fs_info *fs_info = root->fs_info;
Miao Xie19fd2942011-06-15 10:47:30 +0000581
Miao Xie16cdcec2011-04-22 18:12:22 +0800582 if (!item->bytes_reserved)
583 return;
584
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400585 rsv = &fs_info->delayed_block_rsv;
Qu Wenruof218ea62018-04-17 16:52:45 +0800586 /*
587 * Check btrfs_delayed_item_reserve_metadata() to see why we don't need
588 * to release/reserve qgroup space.
589 */
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400590 trace_btrfs_space_reservation(fs_info, "delayed_item",
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500591 item->key.objectid, item->bytes_reserved,
592 0);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -0400593 btrfs_block_rsv_release(fs_info, rsv,
Miao Xie16cdcec2011-04-22 18:12:22 +0800594 item->bytes_reserved);
595}
596
597static int btrfs_delayed_inode_reserve_metadata(
598 struct btrfs_trans_handle *trans,
599 struct btrfs_root *root,
Nikolay Borisovfcabdd12017-01-10 20:35:34 +0200600 struct btrfs_inode *inode,
Miao Xie16cdcec2011-04-22 18:12:22 +0800601 struct btrfs_delayed_node *node)
602{
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400603 struct btrfs_fs_info *fs_info = root->fs_info;
Miao Xie16cdcec2011-04-22 18:12:22 +0800604 struct btrfs_block_rsv *src_rsv;
605 struct btrfs_block_rsv *dst_rsv;
606 u64 num_bytes;
607 int ret;
608
Miao Xie16cdcec2011-04-22 18:12:22 +0800609 src_rsv = trans->block_rsv;
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400610 dst_rsv = &fs_info->delayed_block_rsv;
Miao Xie16cdcec2011-04-22 18:12:22 +0800611
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400612 num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1);
Josef Bacikc06a0e12011-11-04 19:56:02 -0400613
614 /*
615 * btrfs_dirty_inode will update the inode under btrfs_join_transaction
616 * which doesn't reserve space for speed. This is a problem since we
617 * still need to reserve space for this update, so try to reserve the
618 * space.
619 *
620 * Now if src_rsv == delalloc_block_rsv we'll let it just steal since
Josef Bacik69fe2d72017-10-19 14:15:57 -0400621 * we always reserve enough to update the inode item.
Josef Bacikc06a0e12011-11-04 19:56:02 -0400622 */
Chris Masone755d9a2011-12-15 13:36:29 -0500623 if (!src_rsv || (!trans->bytes_reserved &&
Miao Xie66d8f3d2012-09-06 04:02:28 -0600624 src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) {
Qu Wenruof218ea62018-04-17 16:52:45 +0800625 ret = btrfs_qgroup_reserve_meta_prealloc(root,
626 fs_info->nodesize, true);
627 if (ret < 0)
628 return ret;
Miao Xie08e007d2012-10-16 11:33:38 +0000629 ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes,
630 BTRFS_RESERVE_NO_FLUSH);
Josef Bacikc06a0e12011-11-04 19:56:02 -0400631 /*
632 * Since we're under a transaction reserve_metadata_bytes could
633 * try to commit the transaction which will make it return
634 * EAGAIN to make us stop the transaction we have, so return
635 * ENOSPC instead so that btrfs_dirty_inode knows what to do.
636 */
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800637 if (ret == -EAGAIN) {
Josef Bacikc06a0e12011-11-04 19:56:02 -0400638 ret = -ENOSPC;
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800639 btrfs_qgroup_free_meta_prealloc(root, num_bytes);
640 }
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500641 if (!ret) {
Josef Bacikc06a0e12011-11-04 19:56:02 -0400642 node->bytes_reserved = num_bytes;
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400643 trace_btrfs_space_reservation(fs_info,
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500644 "delayed_inode",
Nikolay Borisovfcabdd12017-01-10 20:35:34 +0200645 btrfs_ino(inode),
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500646 num_bytes, 1);
Qu Wenruof218ea62018-04-17 16:52:45 +0800647 } else {
648 btrfs_qgroup_free_meta_prealloc(root, fs_info->nodesize);
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500649 }
Josef Bacikc06a0e12011-11-04 19:56:02 -0400650 return ret;
651 }
652
Lu Fengqi3a584172018-08-04 21:10:55 +0800653 ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true);
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500654 if (!ret) {
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400655 trace_btrfs_space_reservation(fs_info, "delayed_inode",
Nikolay Borisovfcabdd12017-01-10 20:35:34 +0200656 btrfs_ino(inode), num_bytes, 1);
Miao Xie16cdcec2011-04-22 18:12:22 +0800657 node->bytes_reserved = num_bytes;
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500658 }
Miao Xie16cdcec2011-04-22 18:12:22 +0800659
660 return ret;
661}
662
Jeff Mahoney2ff7e612016-06-22 18:54:24 -0400663static void btrfs_delayed_inode_release_metadata(struct btrfs_fs_info *fs_info,
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800664 struct btrfs_delayed_node *node,
665 bool qgroup_free)
Miao Xie16cdcec2011-04-22 18:12:22 +0800666{
667 struct btrfs_block_rsv *rsv;
668
669 if (!node->bytes_reserved)
670 return;
671
Jeff Mahoney0b246af2016-06-22 18:54:23 -0400672 rsv = &fs_info->delayed_block_rsv;
673 trace_btrfs_space_reservation(fs_info, "delayed_inode",
Josef Bacik8c2a3ca2012-01-10 10:31:31 -0500674 node->inode_id, node->bytes_reserved, 0);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -0400675 btrfs_block_rsv_release(fs_info, rsv,
Miao Xie16cdcec2011-04-22 18:12:22 +0800676 node->bytes_reserved);
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800677 if (qgroup_free)
678 btrfs_qgroup_free_meta_prealloc(node->root,
679 node->bytes_reserved);
680 else
681 btrfs_qgroup_convert_reserved_meta(node->root,
682 node->bytes_reserved);
Miao Xie16cdcec2011-04-22 18:12:22 +0800683 node->bytes_reserved = 0;
684}
685
686/*
687 * This helper will insert some continuous items into the same leaf according
688 * to the free space of the leaf.
689 */
Tsutomu Itohafe5fea2013-04-16 05:18:22 +0000690static int btrfs_batch_insert_items(struct btrfs_root *root,
691 struct btrfs_path *path,
692 struct btrfs_delayed_item *item)
Miao Xie16cdcec2011-04-22 18:12:22 +0800693{
Jeff Mahoney2ff7e612016-06-22 18:54:24 -0400694 struct btrfs_fs_info *fs_info = root->fs_info;
Miao Xie16cdcec2011-04-22 18:12:22 +0800695 struct btrfs_delayed_item *curr, *next;
696 int free_space;
697 int total_data_size = 0, total_size = 0;
698 struct extent_buffer *leaf;
699 char *data_ptr;
700 struct btrfs_key *keys;
701 u32 *data_size;
702 struct list_head head;
703 int slot;
704 int nitems;
705 int i;
706 int ret = 0;
707
708 BUG_ON(!path->nodes[0]);
709
710 leaf = path->nodes[0];
Jeff Mahoney2ff7e612016-06-22 18:54:24 -0400711 free_space = btrfs_leaf_free_space(fs_info, leaf);
Miao Xie16cdcec2011-04-22 18:12:22 +0800712 INIT_LIST_HEAD(&head);
713
714 next = item;
Chris Mason17aca1c2011-06-03 01:13:45 -0400715 nitems = 0;
Miao Xie16cdcec2011-04-22 18:12:22 +0800716
717 /*
718 * count the number of the continuous items that we can insert in batch
719 */
720 while (total_size + next->data_len + sizeof(struct btrfs_item) <=
721 free_space) {
722 total_data_size += next->data_len;
723 total_size += next->data_len + sizeof(struct btrfs_item);
724 list_add_tail(&next->tree_list, &head);
725 nitems++;
726
727 curr = next;
728 next = __btrfs_next_delayed_item(curr);
729 if (!next)
730 break;
731
732 if (!btrfs_is_continuous_delayed_item(curr, next))
733 break;
734 }
735
736 if (!nitems) {
737 ret = 0;
738 goto out;
739 }
740
741 /*
742 * we need allocate some memory space, but it might cause the task
743 * to sleep, so we set all locked nodes in the path to blocking locks
744 * first.
745 */
746 btrfs_set_path_blocking(path);
747
Dulshani Gunawardhanad9b0d9b2013-10-31 10:32:18 +0530748 keys = kmalloc_array(nitems, sizeof(struct btrfs_key), GFP_NOFS);
Miao Xie16cdcec2011-04-22 18:12:22 +0800749 if (!keys) {
750 ret = -ENOMEM;
751 goto out;
752 }
753
Dulshani Gunawardhanad9b0d9b2013-10-31 10:32:18 +0530754 data_size = kmalloc_array(nitems, sizeof(u32), GFP_NOFS);
Miao Xie16cdcec2011-04-22 18:12:22 +0800755 if (!data_size) {
756 ret = -ENOMEM;
757 goto error;
758 }
759
760 /* get keys of all the delayed items */
761 i = 0;
762 list_for_each_entry(next, &head, tree_list) {
763 keys[i] = next->key;
764 data_size[i] = next->data_len;
765 i++;
766 }
767
Miao Xie16cdcec2011-04-22 18:12:22 +0800768 /* insert the keys of the items */
Tsutomu Itohafe5fea2013-04-16 05:18:22 +0000769 setup_items_for_insert(root, path, keys, data_size,
Jeff Mahoney143bede2012-03-01 14:56:26 +0100770 total_data_size, total_size, nitems);
Miao Xie16cdcec2011-04-22 18:12:22 +0800771
772 /* insert the dir index items */
773 slot = path->slots[0];
774 list_for_each_entry_safe(curr, next, &head, tree_list) {
775 data_ptr = btrfs_item_ptr(leaf, slot, char);
776 write_extent_buffer(leaf, &curr->data,
777 (unsigned long)data_ptr,
778 curr->data_len);
779 slot++;
780
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800781 btrfs_delayed_item_release_metadata(root, curr);
Miao Xie16cdcec2011-04-22 18:12:22 +0800782
783 list_del(&curr->tree_list);
784 btrfs_release_delayed_item(curr);
785 }
786
787error:
788 kfree(data_size);
789 kfree(keys);
790out:
791 return ret;
792}
793
794/*
795 * This helper can just do simple insertion that needn't extend item for new
796 * data, such as directory name index insertion, inode insertion.
797 */
798static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans,
799 struct btrfs_root *root,
800 struct btrfs_path *path,
801 struct btrfs_delayed_item *delayed_item)
802{
803 struct extent_buffer *leaf;
Miao Xie16cdcec2011-04-22 18:12:22 +0800804 char *ptr;
805 int ret;
806
807 ret = btrfs_insert_empty_item(trans, root, path, &delayed_item->key,
808 delayed_item->data_len);
809 if (ret < 0 && ret != -EEXIST)
810 return ret;
811
812 leaf = path->nodes[0];
813
Miao Xie16cdcec2011-04-22 18:12:22 +0800814 ptr = btrfs_item_ptr(leaf, path->slots[0], char);
815
816 write_extent_buffer(leaf, delayed_item->data, (unsigned long)ptr,
817 delayed_item->data_len);
818 btrfs_mark_buffer_dirty(leaf);
819
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800820 btrfs_delayed_item_release_metadata(root, delayed_item);
Miao Xie16cdcec2011-04-22 18:12:22 +0800821 return 0;
822}
823
824/*
825 * we insert an item first, then if there are some continuous items, we try
826 * to insert those items into the same leaf.
827 */
828static int btrfs_insert_delayed_items(struct btrfs_trans_handle *trans,
829 struct btrfs_path *path,
830 struct btrfs_root *root,
831 struct btrfs_delayed_node *node)
832{
833 struct btrfs_delayed_item *curr, *prev;
834 int ret = 0;
835
836do_again:
837 mutex_lock(&node->mutex);
838 curr = __btrfs_first_delayed_insertion_item(node);
839 if (!curr)
840 goto insert_end;
841
842 ret = btrfs_insert_delayed_item(trans, root, path, curr);
843 if (ret < 0) {
Chris Mason945d8962011-05-22 12:33:42 -0400844 btrfs_release_path(path);
Miao Xie16cdcec2011-04-22 18:12:22 +0800845 goto insert_end;
846 }
847
848 prev = curr;
849 curr = __btrfs_next_delayed_item(prev);
850 if (curr && btrfs_is_continuous_delayed_item(prev, curr)) {
851 /* insert the continuous items into the same leaf */
852 path->slots[0]++;
Tsutomu Itohafe5fea2013-04-16 05:18:22 +0000853 btrfs_batch_insert_items(root, path, curr);
Miao Xie16cdcec2011-04-22 18:12:22 +0800854 }
855 btrfs_release_delayed_item(prev);
856 btrfs_mark_buffer_dirty(path->nodes[0]);
857
Chris Mason945d8962011-05-22 12:33:42 -0400858 btrfs_release_path(path);
Miao Xie16cdcec2011-04-22 18:12:22 +0800859 mutex_unlock(&node->mutex);
860 goto do_again;
861
862insert_end:
863 mutex_unlock(&node->mutex);
864 return ret;
865}
866
867static int btrfs_batch_delete_items(struct btrfs_trans_handle *trans,
868 struct btrfs_root *root,
869 struct btrfs_path *path,
870 struct btrfs_delayed_item *item)
871{
872 struct btrfs_delayed_item *curr, *next;
873 struct extent_buffer *leaf;
874 struct btrfs_key key;
875 struct list_head head;
876 int nitems, i, last_item;
877 int ret = 0;
878
879 BUG_ON(!path->nodes[0]);
880
881 leaf = path->nodes[0];
882
883 i = path->slots[0];
884 last_item = btrfs_header_nritems(leaf) - 1;
885 if (i > last_item)
886 return -ENOENT; /* FIXME: Is errno suitable? */
887
888 next = item;
889 INIT_LIST_HEAD(&head);
890 btrfs_item_key_to_cpu(leaf, &key, i);
891 nitems = 0;
892 /*
893 * count the number of the dir index items that we can delete in batch
894 */
895 while (btrfs_comp_cpu_keys(&next->key, &key) == 0) {
896 list_add_tail(&next->tree_list, &head);
897 nitems++;
898
899 curr = next;
900 next = __btrfs_next_delayed_item(curr);
901 if (!next)
902 break;
903
904 if (!btrfs_is_continuous_delayed_item(curr, next))
905 break;
906
907 i++;
908 if (i > last_item)
909 break;
910 btrfs_item_key_to_cpu(leaf, &key, i);
911 }
912
913 if (!nitems)
914 return 0;
915
916 ret = btrfs_del_items(trans, root, path, path->slots[0], nitems);
917 if (ret)
918 goto out;
919
920 list_for_each_entry_safe(curr, next, &head, tree_list) {
Qu Wenruo4f5427c2017-12-12 15:34:33 +0800921 btrfs_delayed_item_release_metadata(root, curr);
Miao Xie16cdcec2011-04-22 18:12:22 +0800922 list_del(&curr->tree_list);
923 btrfs_release_delayed_item(curr);
924 }
925
926out:
927 return ret;
928}
929
930static int btrfs_delete_delayed_items(struct btrfs_trans_handle *trans,
931 struct btrfs_path *path,
932 struct btrfs_root *root,
933 struct btrfs_delayed_node *node)
934{
935 struct btrfs_delayed_item *curr, *prev;
936 int ret = 0;
937
938do_again:
939 mutex_lock(&node->mutex);
940 curr = __btrfs_first_delayed_deletion_item(node);
941 if (!curr)
942 goto delete_fail;
943
944 ret = btrfs_search_slot(trans, root, &curr->key, path, -1, 1);
945 if (ret < 0)
946 goto delete_fail;
947 else if (ret > 0) {
948 /*
949 * can't find the item which the node points to, so this node
950 * is invalid, just drop it.
951 */
952 prev = curr;
953 curr = __btrfs_next_delayed_item(prev);
954 btrfs_release_delayed_item(prev);
955 ret = 0;
Chris Mason945d8962011-05-22 12:33:42 -0400956 btrfs_release_path(path);
Fengguang Wu62095262012-08-04 01:45:02 -0600957 if (curr) {
958 mutex_unlock(&node->mutex);
Miao Xie16cdcec2011-04-22 18:12:22 +0800959 goto do_again;
Fengguang Wu62095262012-08-04 01:45:02 -0600960 } else
Miao Xie16cdcec2011-04-22 18:12:22 +0800961 goto delete_fail;
962 }
963
964 btrfs_batch_delete_items(trans, root, path, curr);
Chris Mason945d8962011-05-22 12:33:42 -0400965 btrfs_release_path(path);
Miao Xie16cdcec2011-04-22 18:12:22 +0800966 mutex_unlock(&node->mutex);
967 goto do_again;
968
969delete_fail:
Chris Mason945d8962011-05-22 12:33:42 -0400970 btrfs_release_path(path);
Miao Xie16cdcec2011-04-22 18:12:22 +0800971 mutex_unlock(&node->mutex);
972 return ret;
973}
974
975static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node)
976{
977 struct btrfs_delayed_root *delayed_root;
978
Miao Xie7cf35d92013-12-26 13:07:05 +0800979 if (delayed_node &&
980 test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
Miao Xie16cdcec2011-04-22 18:12:22 +0800981 BUG_ON(!delayed_node->root);
Miao Xie7cf35d92013-12-26 13:07:05 +0800982 clear_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags);
Miao Xie16cdcec2011-04-22 18:12:22 +0800983 delayed_node->count--;
984
985 delayed_root = delayed_node->root->fs_info->delayed_root;
Chris Masonde3cb942013-03-04 17:13:31 -0500986 finish_one_item(delayed_root);
Miao Xie16cdcec2011-04-22 18:12:22 +0800987 }
988}
989
Miao Xie67de1172013-12-26 13:07:06 +0800990static void btrfs_release_delayed_iref(struct btrfs_delayed_node *delayed_node)
991{
992 struct btrfs_delayed_root *delayed_root;
993
994 ASSERT(delayed_node->root);
995 clear_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags);
996 delayed_node->count--;
997
998 delayed_root = delayed_node->root->fs_info->delayed_root;
999 finish_one_item(delayed_root);
1000}
1001
Miao Xie0e8c36a2012-12-19 06:59:51 +00001002static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
1003 struct btrfs_root *root,
1004 struct btrfs_path *path,
1005 struct btrfs_delayed_node *node)
Miao Xie16cdcec2011-04-22 18:12:22 +08001006{
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001007 struct btrfs_fs_info *fs_info = root->fs_info;
Miao Xie16cdcec2011-04-22 18:12:22 +08001008 struct btrfs_key key;
1009 struct btrfs_inode_item *inode_item;
1010 struct extent_buffer *leaf;
Miao Xie67de1172013-12-26 13:07:06 +08001011 int mod;
Miao Xie16cdcec2011-04-22 18:12:22 +08001012 int ret;
1013
Miao Xie16cdcec2011-04-22 18:12:22 +08001014 key.objectid = node->inode_id;
David Sterba962a2982014-06-04 18:41:45 +02001015 key.type = BTRFS_INODE_ITEM_KEY;
Miao Xie16cdcec2011-04-22 18:12:22 +08001016 key.offset = 0;
Miao Xie0e8c36a2012-12-19 06:59:51 +00001017
Miao Xie67de1172013-12-26 13:07:06 +08001018 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags))
1019 mod = -1;
1020 else
1021 mod = 1;
1022
1023 ret = btrfs_lookup_inode(trans, root, path, &key, mod);
Miao Xie16cdcec2011-04-22 18:12:22 +08001024 if (ret > 0) {
Chris Mason945d8962011-05-22 12:33:42 -04001025 btrfs_release_path(path);
Miao Xie16cdcec2011-04-22 18:12:22 +08001026 return -ENOENT;
1027 } else if (ret < 0) {
Miao Xie16cdcec2011-04-22 18:12:22 +08001028 return ret;
1029 }
1030
Miao Xie16cdcec2011-04-22 18:12:22 +08001031 leaf = path->nodes[0];
1032 inode_item = btrfs_item_ptr(leaf, path->slots[0],
1033 struct btrfs_inode_item);
1034 write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item,
1035 sizeof(struct btrfs_inode_item));
1036 btrfs_mark_buffer_dirty(leaf);
Miao Xie16cdcec2011-04-22 18:12:22 +08001037
Miao Xie67de1172013-12-26 13:07:06 +08001038 if (!test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags))
1039 goto no_iref;
1040
1041 path->slots[0]++;
1042 if (path->slots[0] >= btrfs_header_nritems(leaf))
1043 goto search;
1044again:
1045 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1046 if (key.objectid != node->inode_id)
1047 goto out;
1048
1049 if (key.type != BTRFS_INODE_REF_KEY &&
1050 key.type != BTRFS_INODE_EXTREF_KEY)
1051 goto out;
1052
1053 /*
1054 * Delayed iref deletion is for the inode who has only one link,
1055 * so there is only one iref. The case that several irefs are
1056 * in the same item doesn't exist.
1057 */
1058 btrfs_del_item(trans, root, path);
1059out:
1060 btrfs_release_delayed_iref(node);
1061no_iref:
1062 btrfs_release_path(path);
1063err_out:
Qu Wenruo4f5427c2017-12-12 15:34:33 +08001064 btrfs_delayed_inode_release_metadata(fs_info, node, (ret < 0));
Miao Xie16cdcec2011-04-22 18:12:22 +08001065 btrfs_release_delayed_inode(node);
Miao Xie16cdcec2011-04-22 18:12:22 +08001066
Miao Xie67de1172013-12-26 13:07:06 +08001067 return ret;
1068
1069search:
1070 btrfs_release_path(path);
1071
David Sterba962a2982014-06-04 18:41:45 +02001072 key.type = BTRFS_INODE_EXTREF_KEY;
Miao Xie67de1172013-12-26 13:07:06 +08001073 key.offset = -1;
1074 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1075 if (ret < 0)
1076 goto err_out;
1077 ASSERT(ret);
1078
1079 ret = 0;
1080 leaf = path->nodes[0];
1081 path->slots[0]--;
1082 goto again;
Miao Xie16cdcec2011-04-22 18:12:22 +08001083}
1084
Miao Xie0e8c36a2012-12-19 06:59:51 +00001085static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,
1086 struct btrfs_root *root,
1087 struct btrfs_path *path,
1088 struct btrfs_delayed_node *node)
1089{
1090 int ret;
1091
1092 mutex_lock(&node->mutex);
Miao Xie7cf35d92013-12-26 13:07:05 +08001093 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &node->flags)) {
Miao Xie0e8c36a2012-12-19 06:59:51 +00001094 mutex_unlock(&node->mutex);
1095 return 0;
1096 }
1097
1098 ret = __btrfs_update_delayed_inode(trans, root, path, node);
1099 mutex_unlock(&node->mutex);
1100 return ret;
1101}
1102
Miao Xie4ea41ce2012-12-19 06:59:03 +00001103static inline int
1104__btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
1105 struct btrfs_path *path,
1106 struct btrfs_delayed_node *node)
1107{
1108 int ret;
1109
1110 ret = btrfs_insert_delayed_items(trans, path, node->root, node);
1111 if (ret)
1112 return ret;
1113
1114 ret = btrfs_delete_delayed_items(trans, path, node->root, node);
1115 if (ret)
1116 return ret;
1117
1118 ret = btrfs_update_delayed_inode(trans, node->root, path, node);
1119 return ret;
1120}
1121
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001122/*
1123 * Called when committing the transaction.
1124 * Returns 0 on success.
1125 * Returns < 0 on error and returns with an aborted transaction with any
1126 * outstanding delayed items cleaned up.
1127 */
Nikolay Borisovb84acab2018-02-07 17:55:42 +02001128static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, int nr)
Miao Xie16cdcec2011-04-22 18:12:22 +08001129{
Nikolay Borisovb84acab2018-02-07 17:55:42 +02001130 struct btrfs_fs_info *fs_info = trans->fs_info;
Miao Xie16cdcec2011-04-22 18:12:22 +08001131 struct btrfs_delayed_root *delayed_root;
1132 struct btrfs_delayed_node *curr_node, *prev_node;
1133 struct btrfs_path *path;
Miao Xie19fd2942011-06-15 10:47:30 +00001134 struct btrfs_block_rsv *block_rsv;
Miao Xie16cdcec2011-04-22 18:12:22 +08001135 int ret = 0;
Josef Bacik96c3f432012-06-21 14:05:49 -04001136 bool count = (nr > 0);
Miao Xie16cdcec2011-04-22 18:12:22 +08001137
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001138 if (trans->aborted)
1139 return -EIO;
1140
Miao Xie16cdcec2011-04-22 18:12:22 +08001141 path = btrfs_alloc_path();
1142 if (!path)
1143 return -ENOMEM;
1144 path->leave_spinning = 1;
1145
Miao Xie19fd2942011-06-15 10:47:30 +00001146 block_rsv = trans->block_rsv;
Jeff Mahoney0b246af2016-06-22 18:54:23 -04001147 trans->block_rsv = &fs_info->delayed_block_rsv;
Miao Xie19fd2942011-06-15 10:47:30 +00001148
Jeff Mahoneyccdf9b32016-06-22 18:54:23 -04001149 delayed_root = fs_info->delayed_root;
Miao Xie16cdcec2011-04-22 18:12:22 +08001150
1151 curr_node = btrfs_first_delayed_node(delayed_root);
Josef Bacik96c3f432012-06-21 14:05:49 -04001152 while (curr_node && (!count || (count && nr--))) {
Miao Xie4ea41ce2012-12-19 06:59:03 +00001153 ret = __btrfs_commit_inode_delayed_items(trans, path,
1154 curr_node);
Miao Xie16cdcec2011-04-22 18:12:22 +08001155 if (ret) {
1156 btrfs_release_delayed_node(curr_node);
Josef Bacik96c3f432012-06-21 14:05:49 -04001157 curr_node = NULL;
Jeff Mahoney66642832016-06-10 18:19:25 -04001158 btrfs_abort_transaction(trans, ret);
Miao Xie16cdcec2011-04-22 18:12:22 +08001159 break;
1160 }
1161
1162 prev_node = curr_node;
1163 curr_node = btrfs_next_delayed_node(curr_node);
1164 btrfs_release_delayed_node(prev_node);
1165 }
1166
Josef Bacik96c3f432012-06-21 14:05:49 -04001167 if (curr_node)
1168 btrfs_release_delayed_node(curr_node);
Miao Xie16cdcec2011-04-22 18:12:22 +08001169 btrfs_free_path(path);
Miao Xie19fd2942011-06-15 10:47:30 +00001170 trans->block_rsv = block_rsv;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001171
Miao Xie16cdcec2011-04-22 18:12:22 +08001172 return ret;
1173}
1174
Nikolay Borisove5c304e62018-02-07 17:55:43 +02001175int btrfs_run_delayed_items(struct btrfs_trans_handle *trans)
Josef Bacik96c3f432012-06-21 14:05:49 -04001176{
Nikolay Borisovb84acab2018-02-07 17:55:42 +02001177 return __btrfs_run_delayed_items(trans, -1);
Josef Bacik96c3f432012-06-21 14:05:49 -04001178}
1179
Nikolay Borisove5c304e62018-02-07 17:55:43 +02001180int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, int nr)
Josef Bacik96c3f432012-06-21 14:05:49 -04001181{
Nikolay Borisovb84acab2018-02-07 17:55:42 +02001182 return __btrfs_run_delayed_items(trans, nr);
Josef Bacik96c3f432012-06-21 14:05:49 -04001183}
1184
Miao Xie16cdcec2011-04-22 18:12:22 +08001185int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
Nikolay Borisov5f4b32e2017-01-10 20:35:41 +02001186 struct btrfs_inode *inode)
Miao Xie16cdcec2011-04-22 18:12:22 +08001187{
Nikolay Borisov5f4b32e2017-01-10 20:35:41 +02001188 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
Miao Xie4ea41ce2012-12-19 06:59:03 +00001189 struct btrfs_path *path;
1190 struct btrfs_block_rsv *block_rsv;
Miao Xie16cdcec2011-04-22 18:12:22 +08001191 int ret;
1192
1193 if (!delayed_node)
1194 return 0;
1195
1196 mutex_lock(&delayed_node->mutex);
1197 if (!delayed_node->count) {
1198 mutex_unlock(&delayed_node->mutex);
1199 btrfs_release_delayed_node(delayed_node);
1200 return 0;
1201 }
1202 mutex_unlock(&delayed_node->mutex);
1203
Miao Xie4ea41ce2012-12-19 06:59:03 +00001204 path = btrfs_alloc_path();
Filipe David Borba Manana3c77bd92013-10-12 20:32:59 +01001205 if (!path) {
1206 btrfs_release_delayed_node(delayed_node);
Miao Xie4ea41ce2012-12-19 06:59:03 +00001207 return -ENOMEM;
Filipe David Borba Manana3c77bd92013-10-12 20:32:59 +01001208 }
Miao Xie4ea41ce2012-12-19 06:59:03 +00001209 path->leave_spinning = 1;
1210
1211 block_rsv = trans->block_rsv;
1212 trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv;
1213
1214 ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node);
1215
Miao Xie16cdcec2011-04-22 18:12:22 +08001216 btrfs_release_delayed_node(delayed_node);
Miao Xie4ea41ce2012-12-19 06:59:03 +00001217 btrfs_free_path(path);
1218 trans->block_rsv = block_rsv;
1219
Miao Xie16cdcec2011-04-22 18:12:22 +08001220 return ret;
1221}
1222
Nikolay Borisovaa790212017-01-10 20:35:40 +02001223int btrfs_commit_inode_delayed_inode(struct btrfs_inode *inode)
Miao Xie0e8c36a2012-12-19 06:59:51 +00001224{
David Sterba3ffbd682018-06-29 10:56:42 +02001225 struct btrfs_fs_info *fs_info = inode->root->fs_info;
Miao Xie0e8c36a2012-12-19 06:59:51 +00001226 struct btrfs_trans_handle *trans;
Nikolay Borisovaa790212017-01-10 20:35:40 +02001227 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
Miao Xie0e8c36a2012-12-19 06:59:51 +00001228 struct btrfs_path *path;
1229 struct btrfs_block_rsv *block_rsv;
1230 int ret;
1231
1232 if (!delayed_node)
1233 return 0;
1234
1235 mutex_lock(&delayed_node->mutex);
Miao Xie7cf35d92013-12-26 13:07:05 +08001236 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
Miao Xie0e8c36a2012-12-19 06:59:51 +00001237 mutex_unlock(&delayed_node->mutex);
1238 btrfs_release_delayed_node(delayed_node);
1239 return 0;
1240 }
1241 mutex_unlock(&delayed_node->mutex);
1242
1243 trans = btrfs_join_transaction(delayed_node->root);
1244 if (IS_ERR(trans)) {
1245 ret = PTR_ERR(trans);
1246 goto out;
1247 }
1248
1249 path = btrfs_alloc_path();
1250 if (!path) {
1251 ret = -ENOMEM;
1252 goto trans_out;
1253 }
1254 path->leave_spinning = 1;
1255
1256 block_rsv = trans->block_rsv;
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001257 trans->block_rsv = &fs_info->delayed_block_rsv;
Miao Xie0e8c36a2012-12-19 06:59:51 +00001258
1259 mutex_lock(&delayed_node->mutex);
Miao Xie7cf35d92013-12-26 13:07:05 +08001260 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags))
Miao Xie0e8c36a2012-12-19 06:59:51 +00001261 ret = __btrfs_update_delayed_inode(trans, delayed_node->root,
1262 path, delayed_node);
1263 else
1264 ret = 0;
1265 mutex_unlock(&delayed_node->mutex);
1266
1267 btrfs_free_path(path);
1268 trans->block_rsv = block_rsv;
1269trans_out:
Jeff Mahoney3a45bb22016-09-09 21:39:03 -04001270 btrfs_end_transaction(trans);
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001271 btrfs_btree_balance_dirty(fs_info);
Miao Xie0e8c36a2012-12-19 06:59:51 +00001272out:
1273 btrfs_release_delayed_node(delayed_node);
1274
1275 return ret;
1276}
1277
Nikolay Borisovf48d1cf2017-01-10 20:35:39 +02001278void btrfs_remove_delayed_node(struct btrfs_inode *inode)
Miao Xie16cdcec2011-04-22 18:12:22 +08001279{
1280 struct btrfs_delayed_node *delayed_node;
1281
Nikolay Borisovf48d1cf2017-01-10 20:35:39 +02001282 delayed_node = READ_ONCE(inode->delayed_node);
Miao Xie16cdcec2011-04-22 18:12:22 +08001283 if (!delayed_node)
1284 return;
1285
Nikolay Borisovf48d1cf2017-01-10 20:35:39 +02001286 inode->delayed_node = NULL;
Miao Xie16cdcec2011-04-22 18:12:22 +08001287 btrfs_release_delayed_node(delayed_node);
1288}
1289
Chris Masonde3cb942013-03-04 17:13:31 -05001290struct btrfs_async_delayed_work {
1291 struct btrfs_delayed_root *delayed_root;
1292 int nr;
Qu Wenruod458b052014-02-28 10:46:19 +08001293 struct btrfs_work work;
Miao Xie16cdcec2011-04-22 18:12:22 +08001294};
1295
Qu Wenruod458b052014-02-28 10:46:19 +08001296static void btrfs_async_run_delayed_root(struct btrfs_work *work)
Miao Xie16cdcec2011-04-22 18:12:22 +08001297{
Chris Masonde3cb942013-03-04 17:13:31 -05001298 struct btrfs_async_delayed_work *async_work;
1299 struct btrfs_delayed_root *delayed_root;
Miao Xie16cdcec2011-04-22 18:12:22 +08001300 struct btrfs_trans_handle *trans;
1301 struct btrfs_path *path;
1302 struct btrfs_delayed_node *delayed_node = NULL;
1303 struct btrfs_root *root;
Miao Xie19fd2942011-06-15 10:47:30 +00001304 struct btrfs_block_rsv *block_rsv;
Chris Masonde3cb942013-03-04 17:13:31 -05001305 int total_done = 0;
Miao Xie16cdcec2011-04-22 18:12:22 +08001306
Chris Masonde3cb942013-03-04 17:13:31 -05001307 async_work = container_of(work, struct btrfs_async_delayed_work, work);
1308 delayed_root = async_work->delayed_root;
Miao Xie16cdcec2011-04-22 18:12:22 +08001309
1310 path = btrfs_alloc_path();
1311 if (!path)
1312 goto out;
Miao Xie16cdcec2011-04-22 18:12:22 +08001313
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001314 do {
1315 if (atomic_read(&delayed_root->items) <
1316 BTRFS_DELAYED_BACKGROUND / 2)
1317 break;
Chris Masonde3cb942013-03-04 17:13:31 -05001318
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001319 delayed_node = btrfs_first_prepared_delayed_node(delayed_root);
1320 if (!delayed_node)
1321 break;
Chris Masonde3cb942013-03-04 17:13:31 -05001322
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001323 path->leave_spinning = 1;
1324 root = delayed_node->root;
Miao Xie16cdcec2011-04-22 18:12:22 +08001325
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001326 trans = btrfs_join_transaction(root);
1327 if (IS_ERR(trans)) {
1328 btrfs_release_path(path);
1329 btrfs_release_prepared_delayed_node(delayed_node);
1330 total_done++;
1331 continue;
1332 }
Miao Xie16cdcec2011-04-22 18:12:22 +08001333
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001334 block_rsv = trans->block_rsv;
1335 trans->block_rsv = &root->fs_info->delayed_block_rsv;
Miao Xie19fd2942011-06-15 10:47:30 +00001336
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001337 __btrfs_commit_inode_delayed_items(trans, path, delayed_node);
Miao Xie16cdcec2011-04-22 18:12:22 +08001338
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001339 trans->block_rsv = block_rsv;
1340 btrfs_end_transaction(trans);
1341 btrfs_btree_balance_dirty_nodelay(root->fs_info);
Chris Masonde3cb942013-03-04 17:13:31 -05001342
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001343 btrfs_release_path(path);
1344 btrfs_release_prepared_delayed_node(delayed_node);
1345 total_done++;
Chris Masonde3cb942013-03-04 17:13:31 -05001346
Nikolay Borisov617c54a2017-10-23 13:51:48 +03001347 } while ((async_work->nr == 0 && total_done < BTRFS_DELAYED_WRITEBACK)
1348 || total_done < async_work->nr);
Chris Masonde3cb942013-03-04 17:13:31 -05001349
Miao Xie16cdcec2011-04-22 18:12:22 +08001350 btrfs_free_path(path);
1351out:
Chris Masonde3cb942013-03-04 17:13:31 -05001352 wake_up(&delayed_root->wait);
1353 kfree(async_work);
Miao Xie16cdcec2011-04-22 18:12:22 +08001354}
1355
Miao Xie16cdcec2011-04-22 18:12:22 +08001356
Chris Masonde3cb942013-03-04 17:13:31 -05001357static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root,
Daniel Dresslera585e942014-11-17 22:05:02 +09001358 struct btrfs_fs_info *fs_info, int nr)
Chris Masonde3cb942013-03-04 17:13:31 -05001359{
1360 struct btrfs_async_delayed_work *async_work;
1361
Chris Masonde3cb942013-03-04 17:13:31 -05001362 async_work = kmalloc(sizeof(*async_work), GFP_NOFS);
1363 if (!async_work)
Miao Xie16cdcec2011-04-22 18:12:22 +08001364 return -ENOMEM;
Miao Xie16cdcec2011-04-22 18:12:22 +08001365
Chris Masonde3cb942013-03-04 17:13:31 -05001366 async_work->delayed_root = delayed_root;
Liu Bo9e0af232014-08-15 23:36:53 +08001367 btrfs_init_work(&async_work->work, btrfs_delayed_meta_helper,
1368 btrfs_async_run_delayed_root, NULL, NULL);
Chris Masonde3cb942013-03-04 17:13:31 -05001369 async_work->nr = nr;
Miao Xie16cdcec2011-04-22 18:12:22 +08001370
Daniel Dresslera585e942014-11-17 22:05:02 +09001371 btrfs_queue_work(fs_info->delayed_workers, &async_work->work);
Miao Xie16cdcec2011-04-22 18:12:22 +08001372 return 0;
1373}
1374
Jeff Mahoneyccdf9b32016-06-22 18:54:23 -04001375void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info)
Chris Masone9993762011-06-17 16:14:09 -04001376{
Jeff Mahoneyccdf9b32016-06-22 18:54:23 -04001377 WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root));
Chris Masone9993762011-06-17 16:14:09 -04001378}
1379
Miao Xie03538082013-12-26 13:07:03 +08001380static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)
Chris Masonde3cb942013-03-04 17:13:31 -05001381{
1382 int val = atomic_read(&delayed_root->items_seq);
1383
Miao Xie03538082013-12-26 13:07:03 +08001384 if (val < seq || val >= seq + BTRFS_DELAYED_BATCH)
Chris Masonde3cb942013-03-04 17:13:31 -05001385 return 1;
Miao Xie03538082013-12-26 13:07:03 +08001386
1387 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND)
1388 return 1;
1389
Chris Masonde3cb942013-03-04 17:13:31 -05001390 return 0;
1391}
1392
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001393void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info)
Miao Xie16cdcec2011-04-22 18:12:22 +08001394{
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001395 struct btrfs_delayed_root *delayed_root = fs_info->delayed_root;
Miao Xie16cdcec2011-04-22 18:12:22 +08001396
Nikolay Borisov85777872017-10-23 13:51:49 +03001397 if ((atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) ||
1398 btrfs_workqueue_normal_congested(fs_info->delayed_workers))
Miao Xie16cdcec2011-04-22 18:12:22 +08001399 return;
1400
1401 if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) {
Miao Xie03538082013-12-26 13:07:03 +08001402 int seq;
Miao Xie16cdcec2011-04-22 18:12:22 +08001403 int ret;
Miao Xie03538082013-12-26 13:07:03 +08001404
1405 seq = atomic_read(&delayed_root->items_seq);
Chris Masonde3cb942013-03-04 17:13:31 -05001406
Daniel Dresslera585e942014-11-17 22:05:02 +09001407 ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0);
Miao Xie16cdcec2011-04-22 18:12:22 +08001408 if (ret)
1409 return;
1410
Miao Xie03538082013-12-26 13:07:03 +08001411 wait_event_interruptible(delayed_root->wait,
1412 could_end_wait(delayed_root, seq));
Miao Xie4dd466d2013-12-26 13:07:02 +08001413 return;
Miao Xie16cdcec2011-04-22 18:12:22 +08001414 }
1415
Daniel Dresslera585e942014-11-17 22:05:02 +09001416 btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH);
Miao Xie16cdcec2011-04-22 18:12:22 +08001417}
1418
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001419/* Will return 0 or -ENOMEM */
Miao Xie16cdcec2011-04-22 18:12:22 +08001420int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001421 const char *name, int name_len,
Nikolay Borisov6f45d182017-01-10 20:35:35 +02001422 struct btrfs_inode *dir,
Miao Xie16cdcec2011-04-22 18:12:22 +08001423 struct btrfs_disk_key *disk_key, u8 type,
1424 u64 index)
1425{
1426 struct btrfs_delayed_node *delayed_node;
1427 struct btrfs_delayed_item *delayed_item;
1428 struct btrfs_dir_item *dir_item;
1429 int ret;
1430
Nikolay Borisov6f45d182017-01-10 20:35:35 +02001431 delayed_node = btrfs_get_or_create_delayed_node(dir);
Miao Xie16cdcec2011-04-22 18:12:22 +08001432 if (IS_ERR(delayed_node))
1433 return PTR_ERR(delayed_node);
1434
1435 delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len);
1436 if (!delayed_item) {
1437 ret = -ENOMEM;
1438 goto release_node;
1439 }
1440
Nikolay Borisov6f45d182017-01-10 20:35:35 +02001441 delayed_item->key.objectid = btrfs_ino(dir);
David Sterba962a2982014-06-04 18:41:45 +02001442 delayed_item->key.type = BTRFS_DIR_INDEX_KEY;
Miao Xie16cdcec2011-04-22 18:12:22 +08001443 delayed_item->key.offset = index;
1444
1445 dir_item = (struct btrfs_dir_item *)delayed_item->data;
1446 dir_item->location = *disk_key;
Qu Wenruo3cae2102013-07-16 11:19:18 +08001447 btrfs_set_stack_dir_transid(dir_item, trans->transid);
1448 btrfs_set_stack_dir_data_len(dir_item, 0);
1449 btrfs_set_stack_dir_name_len(dir_item, name_len);
1450 btrfs_set_stack_dir_type(dir_item, type);
Miao Xie16cdcec2011-04-22 18:12:22 +08001451 memcpy((char *)(dir_item + 1), name, name_len);
1452
Qu Wenruo4f5427c2017-12-12 15:34:33 +08001453 ret = btrfs_delayed_item_reserve_metadata(trans, dir->root, delayed_item);
Josef Bacik8c2a3ca2012-01-10 10:31:31 -05001454 /*
1455 * we have reserved enough space when we start a new transaction,
1456 * so reserving metadata failure is impossible
1457 */
1458 BUG_ON(ret);
1459
Miao Xie16cdcec2011-04-22 18:12:22 +08001460 mutex_lock(&delayed_node->mutex);
1461 ret = __btrfs_add_delayed_insertion_item(delayed_node, delayed_item);
1462 if (unlikely(ret)) {
Lu Fengqi4465c8b2018-08-01 11:32:25 +08001463 btrfs_err(trans->fs_info,
Jeff Mahoney5d163e02016-09-20 10:05:00 -04001464 "err add delayed dir index item(name: %.*s) into the insertion tree of the delayed node(root id: %llu, inode id: %llu, errno: %d)",
Misono Tomohiro4fd786e2018-08-06 14:25:24 +09001465 name_len, name, delayed_node->root->root_key.objectid,
Jeff Mahoney5d163e02016-09-20 10:05:00 -04001466 delayed_node->inode_id, ret);
Miao Xie16cdcec2011-04-22 18:12:22 +08001467 BUG();
1468 }
1469 mutex_unlock(&delayed_node->mutex);
1470
1471release_node:
1472 btrfs_release_delayed_node(delayed_node);
1473 return ret;
1474}
1475
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001476static int btrfs_delete_delayed_insertion_item(struct btrfs_fs_info *fs_info,
Miao Xie16cdcec2011-04-22 18:12:22 +08001477 struct btrfs_delayed_node *node,
1478 struct btrfs_key *key)
1479{
1480 struct btrfs_delayed_item *item;
1481
1482 mutex_lock(&node->mutex);
1483 item = __btrfs_lookup_delayed_insertion_item(node, key);
1484 if (!item) {
1485 mutex_unlock(&node->mutex);
1486 return 1;
1487 }
1488
Qu Wenruo4f5427c2017-12-12 15:34:33 +08001489 btrfs_delayed_item_release_metadata(node->root, item);
Miao Xie16cdcec2011-04-22 18:12:22 +08001490 btrfs_release_delayed_item(item);
1491 mutex_unlock(&node->mutex);
1492 return 0;
1493}
1494
1495int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans,
Nikolay Borisove67bbbb2017-01-10 20:35:36 +02001496 struct btrfs_inode *dir, u64 index)
Miao Xie16cdcec2011-04-22 18:12:22 +08001497{
1498 struct btrfs_delayed_node *node;
1499 struct btrfs_delayed_item *item;
1500 struct btrfs_key item_key;
1501 int ret;
1502
Nikolay Borisove67bbbb2017-01-10 20:35:36 +02001503 node = btrfs_get_or_create_delayed_node(dir);
Miao Xie16cdcec2011-04-22 18:12:22 +08001504 if (IS_ERR(node))
1505 return PTR_ERR(node);
1506
Nikolay Borisove67bbbb2017-01-10 20:35:36 +02001507 item_key.objectid = btrfs_ino(dir);
David Sterba962a2982014-06-04 18:41:45 +02001508 item_key.type = BTRFS_DIR_INDEX_KEY;
Miao Xie16cdcec2011-04-22 18:12:22 +08001509 item_key.offset = index;
1510
Lu Fengqi9add2942018-08-01 11:32:26 +08001511 ret = btrfs_delete_delayed_insertion_item(trans->fs_info, node,
1512 &item_key);
Miao Xie16cdcec2011-04-22 18:12:22 +08001513 if (!ret)
1514 goto end;
1515
1516 item = btrfs_alloc_delayed_item(0);
1517 if (!item) {
1518 ret = -ENOMEM;
1519 goto end;
1520 }
1521
1522 item->key = item_key;
1523
Qu Wenruo4f5427c2017-12-12 15:34:33 +08001524 ret = btrfs_delayed_item_reserve_metadata(trans, dir->root, item);
Miao Xie16cdcec2011-04-22 18:12:22 +08001525 /*
1526 * we have reserved enough space when we start a new transaction,
1527 * so reserving metadata failure is impossible.
1528 */
1529 BUG_ON(ret);
1530
1531 mutex_lock(&node->mutex);
1532 ret = __btrfs_add_delayed_deletion_item(node, item);
1533 if (unlikely(ret)) {
Lu Fengqi9add2942018-08-01 11:32:26 +08001534 btrfs_err(trans->fs_info,
Jeff Mahoney5d163e02016-09-20 10:05:00 -04001535 "err add delayed dir index item(index: %llu) into the deletion tree of the delayed node(root id: %llu, inode id: %llu, errno: %d)",
Misono Tomohiro4fd786e2018-08-06 14:25:24 +09001536 index, node->root->root_key.objectid,
1537 node->inode_id, ret);
Miao Xie16cdcec2011-04-22 18:12:22 +08001538 BUG();
1539 }
1540 mutex_unlock(&node->mutex);
1541end:
1542 btrfs_release_delayed_node(node);
1543 return ret;
1544}
1545
Nikolay Borisovf5cc7b82017-01-10 20:35:42 +02001546int btrfs_inode_delayed_dir_index_count(struct btrfs_inode *inode)
Miao Xie16cdcec2011-04-22 18:12:22 +08001547{
Nikolay Borisovf5cc7b82017-01-10 20:35:42 +02001548 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);
Miao Xie16cdcec2011-04-22 18:12:22 +08001549
1550 if (!delayed_node)
1551 return -ENOENT;
1552
1553 /*
1554 * Since we have held i_mutex of this directory, it is impossible that
1555 * a new directory index is added into the delayed node and index_cnt
1556 * is updated now. So we needn't lock the delayed node.
1557 */
Miao Xie2f7e33d2011-06-23 07:27:13 +00001558 if (!delayed_node->index_cnt) {
1559 btrfs_release_delayed_node(delayed_node);
Miao Xie16cdcec2011-04-22 18:12:22 +08001560 return -EINVAL;
Miao Xie2f7e33d2011-06-23 07:27:13 +00001561 }
Miao Xie16cdcec2011-04-22 18:12:22 +08001562
Nikolay Borisovf5cc7b82017-01-10 20:35:42 +02001563 inode->index_cnt = delayed_node->index_cnt;
Miao Xie2f7e33d2011-06-23 07:27:13 +00001564 btrfs_release_delayed_node(delayed_node);
1565 return 0;
Miao Xie16cdcec2011-04-22 18:12:22 +08001566}
1567
Omar Sandoval02dbfc92016-05-20 13:50:33 -07001568bool btrfs_readdir_get_delayed_items(struct inode *inode,
1569 struct list_head *ins_list,
1570 struct list_head *del_list)
Miao Xie16cdcec2011-04-22 18:12:22 +08001571{
1572 struct btrfs_delayed_node *delayed_node;
1573 struct btrfs_delayed_item *item;
1574
Nikolay Borisov340c6ca2017-01-10 20:35:32 +02001575 delayed_node = btrfs_get_delayed_node(BTRFS_I(inode));
Miao Xie16cdcec2011-04-22 18:12:22 +08001576 if (!delayed_node)
Omar Sandoval02dbfc92016-05-20 13:50:33 -07001577 return false;
1578
1579 /*
1580 * We can only do one readdir with delayed items at a time because of
1581 * item->readdir_list.
1582 */
1583 inode_unlock_shared(inode);
1584 inode_lock(inode);
Miao Xie16cdcec2011-04-22 18:12:22 +08001585
1586 mutex_lock(&delayed_node->mutex);
1587 item = __btrfs_first_delayed_insertion_item(delayed_node);
1588 while (item) {
Elena Reshetova089e77e2017-03-03 10:55:17 +02001589 refcount_inc(&item->refs);
Miao Xie16cdcec2011-04-22 18:12:22 +08001590 list_add_tail(&item->readdir_list, ins_list);
1591 item = __btrfs_next_delayed_item(item);
1592 }
1593
1594 item = __btrfs_first_delayed_deletion_item(delayed_node);
1595 while (item) {
Elena Reshetova089e77e2017-03-03 10:55:17 +02001596 refcount_inc(&item->refs);
Miao Xie16cdcec2011-04-22 18:12:22 +08001597 list_add_tail(&item->readdir_list, del_list);
1598 item = __btrfs_next_delayed_item(item);
1599 }
1600 mutex_unlock(&delayed_node->mutex);
1601 /*
1602 * This delayed node is still cached in the btrfs inode, so refs
1603 * must be > 1 now, and we needn't check it is going to be freed
1604 * or not.
1605 *
1606 * Besides that, this function is used to read dir, we do not
1607 * insert/delete delayed items in this period. So we also needn't
1608 * requeue or dequeue this delayed node.
1609 */
Elena Reshetova6de5f182017-03-03 10:55:16 +02001610 refcount_dec(&delayed_node->refs);
Omar Sandoval02dbfc92016-05-20 13:50:33 -07001611
1612 return true;
Miao Xie16cdcec2011-04-22 18:12:22 +08001613}
1614
Omar Sandoval02dbfc92016-05-20 13:50:33 -07001615void btrfs_readdir_put_delayed_items(struct inode *inode,
1616 struct list_head *ins_list,
1617 struct list_head *del_list)
Miao Xie16cdcec2011-04-22 18:12:22 +08001618{
1619 struct btrfs_delayed_item *curr, *next;
1620
1621 list_for_each_entry_safe(curr, next, ins_list, readdir_list) {
1622 list_del(&curr->readdir_list);
Elena Reshetova089e77e2017-03-03 10:55:17 +02001623 if (refcount_dec_and_test(&curr->refs))
Miao Xie16cdcec2011-04-22 18:12:22 +08001624 kfree(curr);
1625 }
1626
1627 list_for_each_entry_safe(curr, next, del_list, readdir_list) {
1628 list_del(&curr->readdir_list);
Elena Reshetova089e77e2017-03-03 10:55:17 +02001629 if (refcount_dec_and_test(&curr->refs))
Miao Xie16cdcec2011-04-22 18:12:22 +08001630 kfree(curr);
1631 }
Omar Sandoval02dbfc92016-05-20 13:50:33 -07001632
1633 /*
1634 * The VFS is going to do up_read(), so we need to downgrade back to a
1635 * read lock.
1636 */
1637 downgrade_write(&inode->i_rwsem);
Miao Xie16cdcec2011-04-22 18:12:22 +08001638}
1639
1640int btrfs_should_delete_dir_index(struct list_head *del_list,
1641 u64 index)
1642{
Josef Bacike4fd4932018-01-23 15:17:05 -05001643 struct btrfs_delayed_item *curr;
1644 int ret = 0;
Miao Xie16cdcec2011-04-22 18:12:22 +08001645
Josef Bacike4fd4932018-01-23 15:17:05 -05001646 list_for_each_entry(curr, del_list, readdir_list) {
Miao Xie16cdcec2011-04-22 18:12:22 +08001647 if (curr->key.offset > index)
1648 break;
Josef Bacike4fd4932018-01-23 15:17:05 -05001649 if (curr->key.offset == index) {
1650 ret = 1;
1651 break;
1652 }
Miao Xie16cdcec2011-04-22 18:12:22 +08001653 }
Josef Bacike4fd4932018-01-23 15:17:05 -05001654 return ret;
Miao Xie16cdcec2011-04-22 18:12:22 +08001655}
1656
1657/*
1658 * btrfs_readdir_delayed_dir_index - read dir info stored in the delayed tree
1659 *
1660 */
Al Viro9cdda8d2013-05-22 16:48:09 -04001661int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,
Jeff Mahoneyd2fbb2b2016-11-05 13:26:35 -04001662 struct list_head *ins_list)
Miao Xie16cdcec2011-04-22 18:12:22 +08001663{
1664 struct btrfs_dir_item *di;
1665 struct btrfs_delayed_item *curr, *next;
1666 struct btrfs_key location;
1667 char *name;
1668 int name_len;
1669 int over = 0;
1670 unsigned char d_type;
1671
1672 if (list_empty(ins_list))
1673 return 0;
1674
1675 /*
1676 * Changing the data of the delayed item is impossible. So
1677 * we needn't lock them. And we have held i_mutex of the
1678 * directory, nobody can delete any directory indexes now.
1679 */
1680 list_for_each_entry_safe(curr, next, ins_list, readdir_list) {
1681 list_del(&curr->readdir_list);
1682
Al Viro9cdda8d2013-05-22 16:48:09 -04001683 if (curr->key.offset < ctx->pos) {
Elena Reshetova089e77e2017-03-03 10:55:17 +02001684 if (refcount_dec_and_test(&curr->refs))
Miao Xie16cdcec2011-04-22 18:12:22 +08001685 kfree(curr);
1686 continue;
1687 }
1688
Al Viro9cdda8d2013-05-22 16:48:09 -04001689 ctx->pos = curr->key.offset;
Miao Xie16cdcec2011-04-22 18:12:22 +08001690
1691 di = (struct btrfs_dir_item *)curr->data;
1692 name = (char *)(di + 1);
Qu Wenruo3cae2102013-07-16 11:19:18 +08001693 name_len = btrfs_stack_dir_name_len(di);
Miao Xie16cdcec2011-04-22 18:12:22 +08001694
1695 d_type = btrfs_filetype_table[di->type];
1696 btrfs_disk_key_to_cpu(&location, &di->location);
1697
Al Viro9cdda8d2013-05-22 16:48:09 -04001698 over = !dir_emit(ctx, name, name_len,
Miao Xie16cdcec2011-04-22 18:12:22 +08001699 location.objectid, d_type);
1700
Elena Reshetova089e77e2017-03-03 10:55:17 +02001701 if (refcount_dec_and_test(&curr->refs))
Miao Xie16cdcec2011-04-22 18:12:22 +08001702 kfree(curr);
1703
1704 if (over)
1705 return 1;
Josef Bacik42e9cc42017-07-24 15:14:26 -04001706 ctx->pos++;
Miao Xie16cdcec2011-04-22 18:12:22 +08001707 }
1708 return 0;
1709}
1710
Miao Xie16cdcec2011-04-22 18:12:22 +08001711static void fill_stack_inode_item(struct btrfs_trans_handle *trans,
1712 struct btrfs_inode_item *inode_item,
1713 struct inode *inode)
1714{
Eric W. Biederman2f2f43d32012-02-10 11:05:07 -08001715 btrfs_set_stack_inode_uid(inode_item, i_uid_read(inode));
1716 btrfs_set_stack_inode_gid(inode_item, i_gid_read(inode));
Miao Xie16cdcec2011-04-22 18:12:22 +08001717 btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size);
1718 btrfs_set_stack_inode_mode(inode_item, inode->i_mode);
1719 btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink);
1720 btrfs_set_stack_inode_nbytes(inode_item, inode_get_bytes(inode));
1721 btrfs_set_stack_inode_generation(inode_item,
1722 BTRFS_I(inode)->generation);
Jeff Laytonc7f88c42017-12-11 06:35:12 -05001723 btrfs_set_stack_inode_sequence(inode_item,
1724 inode_peek_iversion(inode));
Miao Xie16cdcec2011-04-22 18:12:22 +08001725 btrfs_set_stack_inode_transid(inode_item, trans->transid);
1726 btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev);
1727 btrfs_set_stack_inode_flags(inode_item, BTRFS_I(inode)->flags);
Chris Masonff5714c2011-05-28 07:00:39 -04001728 btrfs_set_stack_inode_block_group(inode_item, 0);
Miao Xie16cdcec2011-04-22 18:12:22 +08001729
David Sterbaa937b972014-12-12 17:39:12 +01001730 btrfs_set_stack_timespec_sec(&inode_item->atime,
Miao Xie16cdcec2011-04-22 18:12:22 +08001731 inode->i_atime.tv_sec);
David Sterbaa937b972014-12-12 17:39:12 +01001732 btrfs_set_stack_timespec_nsec(&inode_item->atime,
Miao Xie16cdcec2011-04-22 18:12:22 +08001733 inode->i_atime.tv_nsec);
1734
David Sterbaa937b972014-12-12 17:39:12 +01001735 btrfs_set_stack_timespec_sec(&inode_item->mtime,
Miao Xie16cdcec2011-04-22 18:12:22 +08001736 inode->i_mtime.tv_sec);
David Sterbaa937b972014-12-12 17:39:12 +01001737 btrfs_set_stack_timespec_nsec(&inode_item->mtime,
Miao Xie16cdcec2011-04-22 18:12:22 +08001738 inode->i_mtime.tv_nsec);
1739
David Sterbaa937b972014-12-12 17:39:12 +01001740 btrfs_set_stack_timespec_sec(&inode_item->ctime,
Miao Xie16cdcec2011-04-22 18:12:22 +08001741 inode->i_ctime.tv_sec);
David Sterbaa937b972014-12-12 17:39:12 +01001742 btrfs_set_stack_timespec_nsec(&inode_item->ctime,
Miao Xie16cdcec2011-04-22 18:12:22 +08001743 inode->i_ctime.tv_nsec);
chandan r9cc97d62012-07-04 12:48:07 +05301744
1745 btrfs_set_stack_timespec_sec(&inode_item->otime,
1746 BTRFS_I(inode)->i_otime.tv_sec);
1747 btrfs_set_stack_timespec_nsec(&inode_item->otime,
1748 BTRFS_I(inode)->i_otime.tv_nsec);
Miao Xie16cdcec2011-04-22 18:12:22 +08001749}
1750
Miao Xie2f7e33d2011-06-23 07:27:13 +00001751int btrfs_fill_inode(struct inode *inode, u32 *rdev)
1752{
1753 struct btrfs_delayed_node *delayed_node;
1754 struct btrfs_inode_item *inode_item;
Miao Xie2f7e33d2011-06-23 07:27:13 +00001755
Nikolay Borisov340c6ca2017-01-10 20:35:32 +02001756 delayed_node = btrfs_get_delayed_node(BTRFS_I(inode));
Miao Xie2f7e33d2011-06-23 07:27:13 +00001757 if (!delayed_node)
1758 return -ENOENT;
1759
1760 mutex_lock(&delayed_node->mutex);
Miao Xie7cf35d92013-12-26 13:07:05 +08001761 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
Miao Xie2f7e33d2011-06-23 07:27:13 +00001762 mutex_unlock(&delayed_node->mutex);
1763 btrfs_release_delayed_node(delayed_node);
1764 return -ENOENT;
1765 }
1766
1767 inode_item = &delayed_node->inode_item;
1768
Eric W. Biederman2f2f43d32012-02-10 11:05:07 -08001769 i_uid_write(inode, btrfs_stack_inode_uid(inode_item));
1770 i_gid_write(inode, btrfs_stack_inode_gid(inode_item));
Nikolay Borisov6ef06d22017-02-20 13:50:34 +02001771 btrfs_i_size_write(BTRFS_I(inode), btrfs_stack_inode_size(inode_item));
Miao Xie2f7e33d2011-06-23 07:27:13 +00001772 inode->i_mode = btrfs_stack_inode_mode(inode_item);
Miklos Szeredibfe86842011-10-28 14:13:29 +02001773 set_nlink(inode, btrfs_stack_inode_nlink(inode_item));
Miao Xie2f7e33d2011-06-23 07:27:13 +00001774 inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item));
1775 BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item);
Yang Dongsheng6e17d302015-04-09 12:08:43 +08001776 BTRFS_I(inode)->last_trans = btrfs_stack_inode_transid(inode_item);
1777
Jeff Laytonc7f88c42017-12-11 06:35:12 -05001778 inode_set_iversion_queried(inode,
1779 btrfs_stack_inode_sequence(inode_item));
Miao Xie2f7e33d2011-06-23 07:27:13 +00001780 inode->i_rdev = 0;
1781 *rdev = btrfs_stack_inode_rdev(inode_item);
1782 BTRFS_I(inode)->flags = btrfs_stack_inode_flags(inode_item);
1783
David Sterbaa937b972014-12-12 17:39:12 +01001784 inode->i_atime.tv_sec = btrfs_stack_timespec_sec(&inode_item->atime);
1785 inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->atime);
Miao Xie2f7e33d2011-06-23 07:27:13 +00001786
David Sterbaa937b972014-12-12 17:39:12 +01001787 inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(&inode_item->mtime);
1788 inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->mtime);
Miao Xie2f7e33d2011-06-23 07:27:13 +00001789
David Sterbaa937b972014-12-12 17:39:12 +01001790 inode->i_ctime.tv_sec = btrfs_stack_timespec_sec(&inode_item->ctime);
1791 inode->i_ctime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->ctime);
Miao Xie2f7e33d2011-06-23 07:27:13 +00001792
chandan r9cc97d62012-07-04 12:48:07 +05301793 BTRFS_I(inode)->i_otime.tv_sec =
1794 btrfs_stack_timespec_sec(&inode_item->otime);
1795 BTRFS_I(inode)->i_otime.tv_nsec =
1796 btrfs_stack_timespec_nsec(&inode_item->otime);
1797
Miao Xie2f7e33d2011-06-23 07:27:13 +00001798 inode->i_generation = BTRFS_I(inode)->generation;
1799 BTRFS_I(inode)->index_cnt = (u64)-1;
1800
1801 mutex_unlock(&delayed_node->mutex);
1802 btrfs_release_delayed_node(delayed_node);
1803 return 0;
1804}
1805
Miao Xie16cdcec2011-04-22 18:12:22 +08001806int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans,
1807 struct btrfs_root *root, struct inode *inode)
1808{
1809 struct btrfs_delayed_node *delayed_node;
David Sterbaaa0467d2011-06-03 16:29:08 +02001810 int ret = 0;
Miao Xie16cdcec2011-04-22 18:12:22 +08001811
Nikolay Borisove5517a72017-01-10 20:35:33 +02001812 delayed_node = btrfs_get_or_create_delayed_node(BTRFS_I(inode));
Miao Xie16cdcec2011-04-22 18:12:22 +08001813 if (IS_ERR(delayed_node))
1814 return PTR_ERR(delayed_node);
1815
1816 mutex_lock(&delayed_node->mutex);
Miao Xie7cf35d92013-12-26 13:07:05 +08001817 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
Miao Xie16cdcec2011-04-22 18:12:22 +08001818 fill_stack_inode_item(trans, &delayed_node->inode_item, inode);
1819 goto release_node;
1820 }
1821
Nikolay Borisovfcabdd12017-01-10 20:35:34 +02001822 ret = btrfs_delayed_inode_reserve_metadata(trans, root, BTRFS_I(inode),
Josef Bacik7fd2ae22011-11-08 15:47:34 -05001823 delayed_node);
Josef Bacikc06a0e12011-11-04 19:56:02 -04001824 if (ret)
1825 goto release_node;
Miao Xie16cdcec2011-04-22 18:12:22 +08001826
1827 fill_stack_inode_item(trans, &delayed_node->inode_item, inode);
Miao Xie7cf35d92013-12-26 13:07:05 +08001828 set_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags);
Miao Xie16cdcec2011-04-22 18:12:22 +08001829 delayed_node->count++;
1830 atomic_inc(&root->fs_info->delayed_root->items);
1831release_node:
1832 mutex_unlock(&delayed_node->mutex);
1833 btrfs_release_delayed_node(delayed_node);
1834 return ret;
1835}
1836
Nikolay Borisove07222c2017-01-10 20:35:37 +02001837int btrfs_delayed_delete_inode_ref(struct btrfs_inode *inode)
Miao Xie67de1172013-12-26 13:07:06 +08001838{
David Sterba3ffbd682018-06-29 10:56:42 +02001839 struct btrfs_fs_info *fs_info = inode->root->fs_info;
Miao Xie67de1172013-12-26 13:07:06 +08001840 struct btrfs_delayed_node *delayed_node;
1841
Chris Mason6f896052014-12-31 12:18:29 -05001842 /*
1843 * we don't do delayed inode updates during log recovery because it
1844 * leads to enospc problems. This means we also can't do
1845 * delayed inode refs
1846 */
Jeff Mahoney0b246af2016-06-22 18:54:23 -04001847 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))
Chris Mason6f896052014-12-31 12:18:29 -05001848 return -EAGAIN;
1849
Nikolay Borisove07222c2017-01-10 20:35:37 +02001850 delayed_node = btrfs_get_or_create_delayed_node(inode);
Miao Xie67de1172013-12-26 13:07:06 +08001851 if (IS_ERR(delayed_node))
1852 return PTR_ERR(delayed_node);
1853
1854 /*
1855 * We don't reserve space for inode ref deletion is because:
1856 * - We ONLY do async inode ref deletion for the inode who has only
1857 * one link(i_nlink == 1), it means there is only one inode ref.
1858 * And in most case, the inode ref and the inode item are in the
1859 * same leaf, and we will deal with them at the same time.
1860 * Since we are sure we will reserve the space for the inode item,
1861 * it is unnecessary to reserve space for inode ref deletion.
1862 * - If the inode ref and the inode item are not in the same leaf,
1863 * We also needn't worry about enospc problem, because we reserve
1864 * much more space for the inode update than it needs.
1865 * - At the worst, we can steal some space from the global reservation.
1866 * It is very rare.
1867 */
1868 mutex_lock(&delayed_node->mutex);
1869 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags))
1870 goto release_node;
1871
1872 set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags);
1873 delayed_node->count++;
Jeff Mahoney0b246af2016-06-22 18:54:23 -04001874 atomic_inc(&fs_info->delayed_root->items);
Miao Xie67de1172013-12-26 13:07:06 +08001875release_node:
1876 mutex_unlock(&delayed_node->mutex);
1877 btrfs_release_delayed_node(delayed_node);
1878 return 0;
1879}
1880
Miao Xie16cdcec2011-04-22 18:12:22 +08001881static void __btrfs_kill_delayed_node(struct btrfs_delayed_node *delayed_node)
1882{
1883 struct btrfs_root *root = delayed_node->root;
Jeff Mahoney2ff7e612016-06-22 18:54:24 -04001884 struct btrfs_fs_info *fs_info = root->fs_info;
Miao Xie16cdcec2011-04-22 18:12:22 +08001885 struct btrfs_delayed_item *curr_item, *prev_item;
1886
1887 mutex_lock(&delayed_node->mutex);
1888 curr_item = __btrfs_first_delayed_insertion_item(delayed_node);
1889 while (curr_item) {
Qu Wenruo4f5427c2017-12-12 15:34:33 +08001890 btrfs_delayed_item_release_metadata(root, curr_item);
Miao Xie16cdcec2011-04-22 18:12:22 +08001891 prev_item = curr_item;
1892 curr_item = __btrfs_next_delayed_item(prev_item);
1893 btrfs_release_delayed_item(prev_item);
1894 }
1895
1896 curr_item = __btrfs_first_delayed_deletion_item(delayed_node);
1897 while (curr_item) {
Qu Wenruo4f5427c2017-12-12 15:34:33 +08001898 btrfs_delayed_item_release_metadata(root, curr_item);
Miao Xie16cdcec2011-04-22 18:12:22 +08001899 prev_item = curr_item;
1900 curr_item = __btrfs_next_delayed_item(prev_item);
1901 btrfs_release_delayed_item(prev_item);
1902 }
1903
Miao Xie67de1172013-12-26 13:07:06 +08001904 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags))
1905 btrfs_release_delayed_iref(delayed_node);
1906
Miao Xie7cf35d92013-12-26 13:07:05 +08001907 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {
Qu Wenruo4f5427c2017-12-12 15:34:33 +08001908 btrfs_delayed_inode_release_metadata(fs_info, delayed_node, false);
Miao Xie16cdcec2011-04-22 18:12:22 +08001909 btrfs_release_delayed_inode(delayed_node);
1910 }
1911 mutex_unlock(&delayed_node->mutex);
1912}
1913
Nikolay Borisov4ccb5c72017-01-10 20:35:38 +02001914void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode)
Miao Xie16cdcec2011-04-22 18:12:22 +08001915{
1916 struct btrfs_delayed_node *delayed_node;
1917
Nikolay Borisov4ccb5c72017-01-10 20:35:38 +02001918 delayed_node = btrfs_get_delayed_node(inode);
Miao Xie16cdcec2011-04-22 18:12:22 +08001919 if (!delayed_node)
1920 return;
1921
1922 __btrfs_kill_delayed_node(delayed_node);
1923 btrfs_release_delayed_node(delayed_node);
1924}
1925
1926void btrfs_kill_all_delayed_nodes(struct btrfs_root *root)
1927{
1928 u64 inode_id = 0;
1929 struct btrfs_delayed_node *delayed_nodes[8];
1930 int i, n;
1931
1932 while (1) {
1933 spin_lock(&root->inode_lock);
1934 n = radix_tree_gang_lookup(&root->delayed_nodes_tree,
1935 (void **)delayed_nodes, inode_id,
1936 ARRAY_SIZE(delayed_nodes));
1937 if (!n) {
1938 spin_unlock(&root->inode_lock);
1939 break;
1940 }
1941
1942 inode_id = delayed_nodes[n - 1]->inode_id + 1;
1943
1944 for (i = 0; i < n; i++)
Elena Reshetova6de5f182017-03-03 10:55:16 +02001945 refcount_inc(&delayed_nodes[i]->refs);
Miao Xie16cdcec2011-04-22 18:12:22 +08001946 spin_unlock(&root->inode_lock);
1947
1948 for (i = 0; i < n; i++) {
1949 __btrfs_kill_delayed_node(delayed_nodes[i]);
1950 btrfs_release_delayed_node(delayed_nodes[i]);
1951 }
1952 }
1953}
Miao Xie67cde342012-06-14 02:23:22 -06001954
Jeff Mahoneyccdf9b32016-06-22 18:54:23 -04001955void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info)
Miao Xie67cde342012-06-14 02:23:22 -06001956{
Miao Xie67cde342012-06-14 02:23:22 -06001957 struct btrfs_delayed_node *curr_node, *prev_node;
1958
Jeff Mahoneyccdf9b32016-06-22 18:54:23 -04001959 curr_node = btrfs_first_delayed_node(fs_info->delayed_root);
Miao Xie67cde342012-06-14 02:23:22 -06001960 while (curr_node) {
1961 __btrfs_kill_delayed_node(curr_node);
1962
1963 prev_node = curr_node;
1964 curr_node = btrfs_next_delayed_node(curr_node);
1965 btrfs_release_delayed_node(prev_node);
1966 }
1967}
1968