2212 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (C) 2011 Fujitsu. All rights reserved.4 * Written by Miao Xie <miaox@cn.fujitsu.com>5 */6 7#include <linux/slab.h>8#include <linux/iversion.h>9#include "ctree.h"10#include "fs.h"11#include "messages.h"12#include "misc.h"13#include "delayed-inode.h"14#include "disk-io.h"15#include "transaction.h"16#include "qgroup.h"17#include "locking.h"18#include "inode-item.h"19#include "space-info.h"20#include "accessors.h"21#include "file-item.h"22 23#define BTRFS_DELAYED_WRITEBACK 51224#define BTRFS_DELAYED_BACKGROUND 12825#define BTRFS_DELAYED_BATCH 1626 27static struct kmem_cache *delayed_node_cache;28 29int __init btrfs_delayed_inode_init(void)30{31 delayed_node_cache = KMEM_CACHE(btrfs_delayed_node, 0);32 if (!delayed_node_cache)33 return -ENOMEM;34 return 0;35}36 37void __cold btrfs_delayed_inode_exit(void)38{39 kmem_cache_destroy(delayed_node_cache);40}41 42void btrfs_init_delayed_root(struct btrfs_delayed_root *delayed_root)43{44 atomic_set(&delayed_root->items, 0);45 atomic_set(&delayed_root->items_seq, 0);46 delayed_root->nodes = 0;47 spin_lock_init(&delayed_root->lock);48 init_waitqueue_head(&delayed_root->wait);49 INIT_LIST_HEAD(&delayed_root->node_list);50 INIT_LIST_HEAD(&delayed_root->prepare_list);51}52 53static inline void btrfs_init_delayed_node(54 struct btrfs_delayed_node *delayed_node,55 struct btrfs_root *root, u64 inode_id)56{57 delayed_node->root = root;58 delayed_node->inode_id = inode_id;59 refcount_set(&delayed_node->refs, 0);60 delayed_node->ins_root = RB_ROOT_CACHED;61 delayed_node->del_root = RB_ROOT_CACHED;62 mutex_init(&delayed_node->mutex);63 INIT_LIST_HEAD(&delayed_node->n_list);64 INIT_LIST_HEAD(&delayed_node->p_list);65}66 67static struct btrfs_delayed_node *btrfs_get_delayed_node(68 struct btrfs_inode *btrfs_inode)69{70 struct btrfs_root *root = btrfs_inode->root;71 u64 ino = btrfs_ino(btrfs_inode);72 struct btrfs_delayed_node *node;73 74 node = READ_ONCE(btrfs_inode->delayed_node);75 if (node) {76 refcount_inc(&node->refs);77 return node;78 }79 80 xa_lock(&root->delayed_nodes);81 node = xa_load(&root->delayed_nodes, ino);82 83 if (node) {84 if (btrfs_inode->delayed_node) {85 refcount_inc(&node->refs); /* can be accessed */86 BUG_ON(btrfs_inode->delayed_node != node);87 xa_unlock(&root->delayed_nodes);88 return node;89 }90 91 /*92 * It's possible that we're racing into the middle of removing93 * this node from the xarray. In this case, the refcount94 * was zero and it should never go back to one. Just return95 * NULL like it was never in the xarray at all; our release96 * function is in the process of removing it.97 *98 * Some implementations of refcount_inc refuse to bump the99 * refcount once it has hit zero. If we don't do this dance100 * here, refcount_inc() may decide to just WARN_ONCE() instead101 * of actually bumping the refcount.102 *103 * If this node is properly in the xarray, we want to bump the104 * refcount twice, once for the inode and once for this get105 * operation.106 */107 if (refcount_inc_not_zero(&node->refs)) {108 refcount_inc(&node->refs);109 btrfs_inode->delayed_node = node;110 } else {111 node = NULL;112 }113 114 xa_unlock(&root->delayed_nodes);115 return node;116 }117 xa_unlock(&root->delayed_nodes);118 119 return NULL;120}121 122/* Will return either the node or PTR_ERR(-ENOMEM) */123static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node(124 struct btrfs_inode *btrfs_inode)125{126 struct btrfs_delayed_node *node;127 struct btrfs_root *root = btrfs_inode->root;128 u64 ino = btrfs_ino(btrfs_inode);129 int ret;130 void *ptr;131 132again:133 node = btrfs_get_delayed_node(btrfs_inode);134 if (node)135 return node;136 137 node = kmem_cache_zalloc(delayed_node_cache, GFP_NOFS);138 if (!node)139 return ERR_PTR(-ENOMEM);140 btrfs_init_delayed_node(node, root, ino);141 142 /* Cached in the inode and can be accessed. */143 refcount_set(&node->refs, 2);144 145 /* Allocate and reserve the slot, from now it can return a NULL from xa_load(). */146 ret = xa_reserve(&root->delayed_nodes, ino, GFP_NOFS);147 if (ret == -ENOMEM) {148 kmem_cache_free(delayed_node_cache, node);149 return ERR_PTR(-ENOMEM);150 }151 xa_lock(&root->delayed_nodes);152 ptr = xa_load(&root->delayed_nodes, ino);153 if (ptr) {154 /* Somebody inserted it, go back and read it. */155 xa_unlock(&root->delayed_nodes);156 kmem_cache_free(delayed_node_cache, node);157 node = NULL;158 goto again;159 }160 ptr = __xa_store(&root->delayed_nodes, ino, node, GFP_ATOMIC);161 ASSERT(xa_err(ptr) != -EINVAL);162 ASSERT(xa_err(ptr) != -ENOMEM);163 ASSERT(ptr == NULL);164 btrfs_inode->delayed_node = node;165 xa_unlock(&root->delayed_nodes);166 167 return node;168}169 170/*171 * Call it when holding delayed_node->mutex172 *173 * If mod = 1, add this node into the prepared list.174 */175static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root,176 struct btrfs_delayed_node *node,177 int mod)178{179 spin_lock(&root->lock);180 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {181 if (!list_empty(&node->p_list))182 list_move_tail(&node->p_list, &root->prepare_list);183 else if (mod)184 list_add_tail(&node->p_list, &root->prepare_list);185 } else {186 list_add_tail(&node->n_list, &root->node_list);187 list_add_tail(&node->p_list, &root->prepare_list);188 refcount_inc(&node->refs); /* inserted into list */189 root->nodes++;190 set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags);191 }192 spin_unlock(&root->lock);193}194 195/* Call it when holding delayed_node->mutex */196static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root,197 struct btrfs_delayed_node *node)198{199 spin_lock(&root->lock);200 if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {201 root->nodes--;202 refcount_dec(&node->refs); /* not in the list */203 list_del_init(&node->n_list);204 if (!list_empty(&node->p_list))205 list_del_init(&node->p_list);206 clear_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags);207 }208 spin_unlock(&root->lock);209}210 211static struct btrfs_delayed_node *btrfs_first_delayed_node(212 struct btrfs_delayed_root *delayed_root)213{214 struct list_head *p;215 struct btrfs_delayed_node *node = NULL;216 217 spin_lock(&delayed_root->lock);218 if (list_empty(&delayed_root->node_list))219 goto out;220 221 p = delayed_root->node_list.next;222 node = list_entry(p, struct btrfs_delayed_node, n_list);223 refcount_inc(&node->refs);224out:225 spin_unlock(&delayed_root->lock);226 227 return node;228}229 230static struct btrfs_delayed_node *btrfs_next_delayed_node(231 struct btrfs_delayed_node *node)232{233 struct btrfs_delayed_root *delayed_root;234 struct list_head *p;235 struct btrfs_delayed_node *next = NULL;236 237 delayed_root = node->root->fs_info->delayed_root;238 spin_lock(&delayed_root->lock);239 if (!test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) {240 /* not in the list */241 if (list_empty(&delayed_root->node_list))242 goto out;243 p = delayed_root->node_list.next;244 } else if (list_is_last(&node->n_list, &delayed_root->node_list))245 goto out;246 else247 p = node->n_list.next;248 249 next = list_entry(p, struct btrfs_delayed_node, n_list);250 refcount_inc(&next->refs);251out:252 spin_unlock(&delayed_root->lock);253 254 return next;255}256 257static void __btrfs_release_delayed_node(258 struct btrfs_delayed_node *delayed_node,259 int mod)260{261 struct btrfs_delayed_root *delayed_root;262 263 if (!delayed_node)264 return;265 266 delayed_root = delayed_node->root->fs_info->delayed_root;267 268 mutex_lock(&delayed_node->mutex);269 if (delayed_node->count)270 btrfs_queue_delayed_node(delayed_root, delayed_node, mod);271 else272 btrfs_dequeue_delayed_node(delayed_root, delayed_node);273 mutex_unlock(&delayed_node->mutex);274 275 if (refcount_dec_and_test(&delayed_node->refs)) {276 struct btrfs_root *root = delayed_node->root;277 278 xa_erase(&root->delayed_nodes, delayed_node->inode_id);279 /*280 * Once our refcount goes to zero, nobody is allowed to bump it281 * back up. We can delete it now.282 */283 ASSERT(refcount_read(&delayed_node->refs) == 0);284 kmem_cache_free(delayed_node_cache, delayed_node);285 }286}287 288static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node)289{290 __btrfs_release_delayed_node(node, 0);291}292 293static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node(294 struct btrfs_delayed_root *delayed_root)295{296 struct list_head *p;297 struct btrfs_delayed_node *node = NULL;298 299 spin_lock(&delayed_root->lock);300 if (list_empty(&delayed_root->prepare_list))301 goto out;302 303 p = delayed_root->prepare_list.next;304 list_del_init(p);305 node = list_entry(p, struct btrfs_delayed_node, p_list);306 refcount_inc(&node->refs);307out:308 spin_unlock(&delayed_root->lock);309 310 return node;311}312 313static inline void btrfs_release_prepared_delayed_node(314 struct btrfs_delayed_node *node)315{316 __btrfs_release_delayed_node(node, 1);317}318 319static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u16 data_len,320 struct btrfs_delayed_node *node,321 enum btrfs_delayed_item_type type)322{323 struct btrfs_delayed_item *item;324 325 item = kmalloc(struct_size(item, data, data_len), GFP_NOFS);326 if (item) {327 item->data_len = data_len;328 item->type = type;329 item->bytes_reserved = 0;330 item->delayed_node = node;331 RB_CLEAR_NODE(&item->rb_node);332 INIT_LIST_HEAD(&item->log_list);333 item->logged = false;334 refcount_set(&item->refs, 1);335 }336 return item;337}338 339/*340 * Look up the delayed item by key.341 *342 * @delayed_node: pointer to the delayed node343 * @index: the dir index value to lookup (offset of a dir index key)344 *345 * Note: if we don't find the right item, we will return the prev item and346 * the next item.347 */348static struct btrfs_delayed_item *__btrfs_lookup_delayed_item(349 struct rb_root *root,350 u64 index)351{352 struct rb_node *node = root->rb_node;353 struct btrfs_delayed_item *delayed_item = NULL;354 355 while (node) {356 delayed_item = rb_entry(node, struct btrfs_delayed_item,357 rb_node);358 if (delayed_item->index < index)359 node = node->rb_right;360 else if (delayed_item->index > index)361 node = node->rb_left;362 else363 return delayed_item;364 }365 366 return NULL;367}368 369static int __btrfs_add_delayed_item(struct btrfs_delayed_node *delayed_node,370 struct btrfs_delayed_item *ins)371{372 struct rb_node **p, *node;373 struct rb_node *parent_node = NULL;374 struct rb_root_cached *root;375 struct btrfs_delayed_item *item;376 bool leftmost = true;377 378 if (ins->type == BTRFS_DELAYED_INSERTION_ITEM)379 root = &delayed_node->ins_root;380 else381 root = &delayed_node->del_root;382 383 p = &root->rb_root.rb_node;384 node = &ins->rb_node;385 386 while (*p) {387 parent_node = *p;388 item = rb_entry(parent_node, struct btrfs_delayed_item,389 rb_node);390 391 if (item->index < ins->index) {392 p = &(*p)->rb_right;393 leftmost = false;394 } else if (item->index > ins->index) {395 p = &(*p)->rb_left;396 } else {397 return -EEXIST;398 }399 }400 401 rb_link_node(node, parent_node, p);402 rb_insert_color_cached(node, root, leftmost);403 404 if (ins->type == BTRFS_DELAYED_INSERTION_ITEM &&405 ins->index >= delayed_node->index_cnt)406 delayed_node->index_cnt = ins->index + 1;407 408 delayed_node->count++;409 atomic_inc(&delayed_node->root->fs_info->delayed_root->items);410 return 0;411}412 413static void finish_one_item(struct btrfs_delayed_root *delayed_root)414{415 int seq = atomic_inc_return(&delayed_root->items_seq);416 417 /* atomic_dec_return implies a barrier */418 if ((atomic_dec_return(&delayed_root->items) <419 BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0))420 cond_wake_up_nomb(&delayed_root->wait);421}422 423static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item)424{425 struct btrfs_delayed_node *delayed_node = delayed_item->delayed_node;426 struct rb_root_cached *root;427 struct btrfs_delayed_root *delayed_root;428 429 /* Not inserted, ignore it. */430 if (RB_EMPTY_NODE(&delayed_item->rb_node))431 return;432 433 /* If it's in a rbtree, then we need to have delayed node locked. */434 lockdep_assert_held(&delayed_node->mutex);435 436 delayed_root = delayed_node->root->fs_info->delayed_root;437 438 if (delayed_item->type == BTRFS_DELAYED_INSERTION_ITEM)439 root = &delayed_node->ins_root;440 else441 root = &delayed_node->del_root;442 443 rb_erase_cached(&delayed_item->rb_node, root);444 RB_CLEAR_NODE(&delayed_item->rb_node);445 delayed_node->count--;446 447 finish_one_item(delayed_root);448}449 450static void btrfs_release_delayed_item(struct btrfs_delayed_item *item)451{452 if (item) {453 __btrfs_remove_delayed_item(item);454 if (refcount_dec_and_test(&item->refs))455 kfree(item);456 }457}458 459static struct btrfs_delayed_item *__btrfs_first_delayed_insertion_item(460 struct btrfs_delayed_node *delayed_node)461{462 struct rb_node *p;463 struct btrfs_delayed_item *item = NULL;464 465 p = rb_first_cached(&delayed_node->ins_root);466 if (p)467 item = rb_entry(p, struct btrfs_delayed_item, rb_node);468 469 return item;470}471 472static struct btrfs_delayed_item *__btrfs_first_delayed_deletion_item(473 struct btrfs_delayed_node *delayed_node)474{475 struct rb_node *p;476 struct btrfs_delayed_item *item = NULL;477 478 p = rb_first_cached(&delayed_node->del_root);479 if (p)480 item = rb_entry(p, struct btrfs_delayed_item, rb_node);481 482 return item;483}484 485static struct btrfs_delayed_item *__btrfs_next_delayed_item(486 struct btrfs_delayed_item *item)487{488 struct rb_node *p;489 struct btrfs_delayed_item *next = NULL;490 491 p = rb_next(&item->rb_node);492 if (p)493 next = rb_entry(p, struct btrfs_delayed_item, rb_node);494 495 return next;496}497 498static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans,499 struct btrfs_delayed_item *item)500{501 struct btrfs_block_rsv *src_rsv;502 struct btrfs_block_rsv *dst_rsv;503 struct btrfs_fs_info *fs_info = trans->fs_info;504 u64 num_bytes;505 int ret;506 507 if (!trans->bytes_reserved)508 return 0;509 510 src_rsv = trans->block_rsv;511 dst_rsv = &fs_info->delayed_block_rsv;512 513 num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1);514 515 /*516 * Here we migrate space rsv from transaction rsv, since have already517 * reserved space when starting a transaction. So no need to reserve518 * qgroup space here.519 */520 ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true);521 if (!ret) {522 trace_btrfs_space_reservation(fs_info, "delayed_item",523 item->delayed_node->inode_id,524 num_bytes, 1);525 /*526 * For insertions we track reserved metadata space by accounting527 * for the number of leaves that will be used, based on the delayed528 * node's curr_index_batch_size and index_item_leaves fields.529 */530 if (item->type == BTRFS_DELAYED_DELETION_ITEM)531 item->bytes_reserved = num_bytes;532 }533 534 return ret;535}536 537static void btrfs_delayed_item_release_metadata(struct btrfs_root *root,538 struct btrfs_delayed_item *item)539{540 struct btrfs_block_rsv *rsv;541 struct btrfs_fs_info *fs_info = root->fs_info;542 543 if (!item->bytes_reserved)544 return;545 546 rsv = &fs_info->delayed_block_rsv;547 /*548 * Check btrfs_delayed_item_reserve_metadata() to see why we don't need549 * to release/reserve qgroup space.550 */551 trace_btrfs_space_reservation(fs_info, "delayed_item",552 item->delayed_node->inode_id,553 item->bytes_reserved, 0);554 btrfs_block_rsv_release(fs_info, rsv, item->bytes_reserved, NULL);555}556 557static void btrfs_delayed_item_release_leaves(struct btrfs_delayed_node *node,558 unsigned int num_leaves)559{560 struct btrfs_fs_info *fs_info = node->root->fs_info;561 const u64 bytes = btrfs_calc_insert_metadata_size(fs_info, num_leaves);562 563 /* There are no space reservations during log replay, bail out. */564 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))565 return;566 567 trace_btrfs_space_reservation(fs_info, "delayed_item", node->inode_id,568 bytes, 0);569 btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv, bytes, NULL);570}571 572static int btrfs_delayed_inode_reserve_metadata(573 struct btrfs_trans_handle *trans,574 struct btrfs_root *root,575 struct btrfs_delayed_node *node)576{577 struct btrfs_fs_info *fs_info = root->fs_info;578 struct btrfs_block_rsv *src_rsv;579 struct btrfs_block_rsv *dst_rsv;580 u64 num_bytes;581 int ret;582 583 src_rsv = trans->block_rsv;584 dst_rsv = &fs_info->delayed_block_rsv;585 586 num_bytes = btrfs_calc_metadata_size(fs_info, 1);587 588 /*589 * btrfs_dirty_inode will update the inode under btrfs_join_transaction590 * which doesn't reserve space for speed. This is a problem since we591 * still need to reserve space for this update, so try to reserve the592 * space.593 *594 * Now if src_rsv == delalloc_block_rsv we'll let it just steal since595 * we always reserve enough to update the inode item.596 */597 if (!src_rsv || (!trans->bytes_reserved &&598 src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) {599 ret = btrfs_qgroup_reserve_meta(root, num_bytes,600 BTRFS_QGROUP_RSV_META_PREALLOC, true);601 if (ret < 0)602 return ret;603 ret = btrfs_block_rsv_add(fs_info, dst_rsv, num_bytes,604 BTRFS_RESERVE_NO_FLUSH);605 /* NO_FLUSH could only fail with -ENOSPC */606 ASSERT(ret == 0 || ret == -ENOSPC);607 if (ret)608 btrfs_qgroup_free_meta_prealloc(root, num_bytes);609 } else {610 ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true);611 }612 613 if (!ret) {614 trace_btrfs_space_reservation(fs_info, "delayed_inode",615 node->inode_id, num_bytes, 1);616 node->bytes_reserved = num_bytes;617 }618 619 return ret;620}621 622static void btrfs_delayed_inode_release_metadata(struct btrfs_fs_info *fs_info,623 struct btrfs_delayed_node *node,624 bool qgroup_free)625{626 struct btrfs_block_rsv *rsv;627 628 if (!node->bytes_reserved)629 return;630 631 rsv = &fs_info->delayed_block_rsv;632 trace_btrfs_space_reservation(fs_info, "delayed_inode",633 node->inode_id, node->bytes_reserved, 0);634 btrfs_block_rsv_release(fs_info, rsv, node->bytes_reserved, NULL);635 if (qgroup_free)636 btrfs_qgroup_free_meta_prealloc(node->root,637 node->bytes_reserved);638 else639 btrfs_qgroup_convert_reserved_meta(node->root,640 node->bytes_reserved);641 node->bytes_reserved = 0;642}643 644/*645 * Insert a single delayed item or a batch of delayed items, as many as possible646 * that fit in a leaf. The delayed items (dir index keys) are sorted by their key647 * in the rbtree, and if there's a gap between two consecutive dir index items,648 * then it means at some point we had delayed dir indexes to add but they got649 * removed (by btrfs_delete_delayed_dir_index()) before we attempted to flush them650 * into the subvolume tree. Dir index keys also have their offsets coming from a651 * monotonically increasing counter, so we can't get new keys with an offset that652 * fits within a gap between delayed dir index items.653 */654static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans,655 struct btrfs_root *root,656 struct btrfs_path *path,657 struct btrfs_delayed_item *first_item)658{659 struct btrfs_fs_info *fs_info = root->fs_info;660 struct btrfs_delayed_node *node = first_item->delayed_node;661 LIST_HEAD(item_list);662 struct btrfs_delayed_item *curr;663 struct btrfs_delayed_item *next;664 const int max_size = BTRFS_LEAF_DATA_SIZE(fs_info);665 struct btrfs_item_batch batch;666 struct btrfs_key first_key;667 const u32 first_data_size = first_item->data_len;668 int total_size;669 char *ins_data = NULL;670 int ret;671 bool continuous_keys_only = false;672 673 lockdep_assert_held(&node->mutex);674 675 /*676 * During normal operation the delayed index offset is continuously677 * increasing, so we can batch insert all items as there will not be any678 * overlapping keys in the tree.679 *680 * The exception to this is log replay, where we may have interleaved681 * offsets in the tree, so our batch needs to be continuous keys only in682 * order to ensure we do not end up with out of order items in our leaf.683 */684 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))685 continuous_keys_only = true;686 687 /*688 * For delayed items to insert, we track reserved metadata bytes based689 * on the number of leaves that we will use.690 * See btrfs_insert_delayed_dir_index() and691 * btrfs_delayed_item_reserve_metadata()).692 */693 ASSERT(first_item->bytes_reserved == 0);694 695 list_add_tail(&first_item->tree_list, &item_list);696 batch.total_data_size = first_data_size;697 batch.nr = 1;698 total_size = first_data_size + sizeof(struct btrfs_item);699 curr = first_item;700 701 while (true) {702 int next_size;703 704 next = __btrfs_next_delayed_item(curr);705 if (!next)706 break;707 708 /*709 * We cannot allow gaps in the key space if we're doing log710 * replay.711 */712 if (continuous_keys_only && (next->index != curr->index + 1))713 break;714 715 ASSERT(next->bytes_reserved == 0);716 717 next_size = next->data_len + sizeof(struct btrfs_item);718 if (total_size + next_size > max_size)719 break;720 721 list_add_tail(&next->tree_list, &item_list);722 batch.nr++;723 total_size += next_size;724 batch.total_data_size += next->data_len;725 curr = next;726 }727 728 if (batch.nr == 1) {729 first_key.objectid = node->inode_id;730 first_key.type = BTRFS_DIR_INDEX_KEY;731 first_key.offset = first_item->index;732 batch.keys = &first_key;733 batch.data_sizes = &first_data_size;734 } else {735 struct btrfs_key *ins_keys;736 u32 *ins_sizes;737 int i = 0;738 739 ins_data = kmalloc(batch.nr * sizeof(u32) +740 batch.nr * sizeof(struct btrfs_key), GFP_NOFS);741 if (!ins_data) {742 ret = -ENOMEM;743 goto out;744 }745 ins_sizes = (u32 *)ins_data;746 ins_keys = (struct btrfs_key *)(ins_data + batch.nr * sizeof(u32));747 batch.keys = ins_keys;748 batch.data_sizes = ins_sizes;749 list_for_each_entry(curr, &item_list, tree_list) {750 ins_keys[i].objectid = node->inode_id;751 ins_keys[i].type = BTRFS_DIR_INDEX_KEY;752 ins_keys[i].offset = curr->index;753 ins_sizes[i] = curr->data_len;754 i++;755 }756 }757 758 ret = btrfs_insert_empty_items(trans, root, path, &batch);759 if (ret)760 goto out;761 762 list_for_each_entry(curr, &item_list, tree_list) {763 char *data_ptr;764 765 data_ptr = btrfs_item_ptr(path->nodes[0], path->slots[0], char);766 write_extent_buffer(path->nodes[0], &curr->data,767 (unsigned long)data_ptr, curr->data_len);768 path->slots[0]++;769 }770 771 /*772 * Now release our path before releasing the delayed items and their773 * metadata reservations, so that we don't block other tasks for more774 * time than needed.775 */776 btrfs_release_path(path);777 778 ASSERT(node->index_item_leaves > 0);779 780 /*781 * For normal operations we will batch an entire leaf's worth of delayed782 * items, so if there are more items to process we can decrement783 * index_item_leaves by 1 as we inserted 1 leaf's worth of items.784 *785 * However for log replay we may not have inserted an entire leaf's786 * worth of items, we may have not had continuous items, so decrementing787 * here would mess up the index_item_leaves accounting. For this case788 * only clean up the accounting when there are no items left.789 */790 if (next && !continuous_keys_only) {791 /*792 * We inserted one batch of items into a leaf a there are more793 * items to flush in a future batch, now release one unit of794 * metadata space from the delayed block reserve, corresponding795 * the leaf we just flushed to.796 */797 btrfs_delayed_item_release_leaves(node, 1);798 node->index_item_leaves--;799 } else if (!next) {800 /*801 * There are no more items to insert. We can have a number of802 * reserved leaves > 1 here - this happens when many dir index803 * items are added and then removed before they are flushed (file804 * names with a very short life, never span a transaction). So805 * release all remaining leaves.806 */807 btrfs_delayed_item_release_leaves(node, node->index_item_leaves);808 node->index_item_leaves = 0;809 }810 811 list_for_each_entry_safe(curr, next, &item_list, tree_list) {812 list_del(&curr->tree_list);813 btrfs_release_delayed_item(curr);814 }815out:816 kfree(ins_data);817 return ret;818}819 820static int btrfs_insert_delayed_items(struct btrfs_trans_handle *trans,821 struct btrfs_path *path,822 struct btrfs_root *root,823 struct btrfs_delayed_node *node)824{825 int ret = 0;826 827 while (ret == 0) {828 struct btrfs_delayed_item *curr;829 830 mutex_lock(&node->mutex);831 curr = __btrfs_first_delayed_insertion_item(node);832 if (!curr) {833 mutex_unlock(&node->mutex);834 break;835 }836 ret = btrfs_insert_delayed_item(trans, root, path, curr);837 mutex_unlock(&node->mutex);838 }839 840 return ret;841}842 843static int btrfs_batch_delete_items(struct btrfs_trans_handle *trans,844 struct btrfs_root *root,845 struct btrfs_path *path,846 struct btrfs_delayed_item *item)847{848 const u64 ino = item->delayed_node->inode_id;849 struct btrfs_fs_info *fs_info = root->fs_info;850 struct btrfs_delayed_item *curr, *next;851 struct extent_buffer *leaf = path->nodes[0];852 LIST_HEAD(batch_list);853 int nitems, slot, last_slot;854 int ret;855 u64 total_reserved_size = item->bytes_reserved;856 857 ASSERT(leaf != NULL);858 859 slot = path->slots[0];860 last_slot = btrfs_header_nritems(leaf) - 1;861 /*862 * Our caller always gives us a path pointing to an existing item, so863 * this can not happen.864 */865 ASSERT(slot <= last_slot);866 if (WARN_ON(slot > last_slot))867 return -ENOENT;868 869 nitems = 1;870 curr = item;871 list_add_tail(&curr->tree_list, &batch_list);872 873 /*874 * Keep checking if the next delayed item matches the next item in the875 * leaf - if so, we can add it to the batch of items to delete from the876 * leaf.877 */878 while (slot < last_slot) {879 struct btrfs_key key;880 881 next = __btrfs_next_delayed_item(curr);882 if (!next)883 break;884 885 slot++;886 btrfs_item_key_to_cpu(leaf, &key, slot);887 if (key.objectid != ino ||888 key.type != BTRFS_DIR_INDEX_KEY ||889 key.offset != next->index)890 break;891 nitems++;892 curr = next;893 list_add_tail(&curr->tree_list, &batch_list);894 total_reserved_size += curr->bytes_reserved;895 }896 897 ret = btrfs_del_items(trans, root, path, path->slots[0], nitems);898 if (ret)899 return ret;900 901 /* In case of BTRFS_FS_LOG_RECOVERING items won't have reserved space */902 if (total_reserved_size > 0) {903 /*904 * Check btrfs_delayed_item_reserve_metadata() to see why we905 * don't need to release/reserve qgroup space.906 */907 trace_btrfs_space_reservation(fs_info, "delayed_item", ino,908 total_reserved_size, 0);909 btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv,910 total_reserved_size, NULL);911 }912 913 list_for_each_entry_safe(curr, next, &batch_list, tree_list) {914 list_del(&curr->tree_list);915 btrfs_release_delayed_item(curr);916 }917 918 return 0;919}920 921static int btrfs_delete_delayed_items(struct btrfs_trans_handle *trans,922 struct btrfs_path *path,923 struct btrfs_root *root,924 struct btrfs_delayed_node *node)925{926 struct btrfs_key key;927 int ret = 0;928 929 key.objectid = node->inode_id;930 key.type = BTRFS_DIR_INDEX_KEY;931 932 while (ret == 0) {933 struct btrfs_delayed_item *item;934 935 mutex_lock(&node->mutex);936 item = __btrfs_first_delayed_deletion_item(node);937 if (!item) {938 mutex_unlock(&node->mutex);939 break;940 }941 942 key.offset = item->index;943 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);944 if (ret > 0) {945 /*946 * There's no matching item in the leaf. This means we947 * have already deleted this item in a past run of the948 * delayed items. We ignore errors when running delayed949 * items from an async context, through a work queue job950 * running btrfs_async_run_delayed_root(), and don't951 * release delayed items that failed to complete. This952 * is because we will retry later, and at transaction953 * commit time we always run delayed items and will954 * then deal with errors if they fail to run again.955 *956 * So just release delayed items for which we can't find957 * an item in the tree, and move to the next item.958 */959 btrfs_release_path(path);960 btrfs_release_delayed_item(item);961 ret = 0;962 } else if (ret == 0) {963 ret = btrfs_batch_delete_items(trans, root, path, item);964 btrfs_release_path(path);965 }966 967 /*968 * We unlock and relock on each iteration, this is to prevent969 * blocking other tasks for too long while we are being run from970 * the async context (work queue job). Those tasks are typically971 * running system calls like creat/mkdir/rename/unlink/etc which972 * need to add delayed items to this delayed node.973 */974 mutex_unlock(&node->mutex);975 }976 977 return ret;978}979 980static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node)981{982 struct btrfs_delayed_root *delayed_root;983 984 if (delayed_node &&985 test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {986 ASSERT(delayed_node->root);987 clear_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags);988 delayed_node->count--;989 990 delayed_root = delayed_node->root->fs_info->delayed_root;991 finish_one_item(delayed_root);992 }993}994 995static void btrfs_release_delayed_iref(struct btrfs_delayed_node *delayed_node)996{997 998 if (test_and_clear_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) {999 struct btrfs_delayed_root *delayed_root;1000 1001 ASSERT(delayed_node->root);1002 delayed_node->count--;1003 1004 delayed_root = delayed_node->root->fs_info->delayed_root;1005 finish_one_item(delayed_root);1006 }1007}1008 1009static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,1010 struct btrfs_root *root,1011 struct btrfs_path *path,1012 struct btrfs_delayed_node *node)1013{1014 struct btrfs_fs_info *fs_info = root->fs_info;1015 struct btrfs_key key;1016 struct btrfs_inode_item *inode_item;1017 struct extent_buffer *leaf;1018 int mod;1019 int ret;1020 1021 key.objectid = node->inode_id;1022 key.type = BTRFS_INODE_ITEM_KEY;1023 key.offset = 0;1024 1025 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags))1026 mod = -1;1027 else1028 mod = 1;1029 1030 ret = btrfs_lookup_inode(trans, root, path, &key, mod);1031 if (ret > 0)1032 ret = -ENOENT;1033 if (ret < 0)1034 goto out;1035 1036 leaf = path->nodes[0];1037 inode_item = btrfs_item_ptr(leaf, path->slots[0],1038 struct btrfs_inode_item);1039 write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item,1040 sizeof(struct btrfs_inode_item));1041 btrfs_mark_buffer_dirty(trans, leaf);1042 1043 if (!test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags))1044 goto out;1045 1046 /*1047 * Now we're going to delete the INODE_REF/EXTREF, which should be the1048 * only one ref left. Check if the next item is an INODE_REF/EXTREF.1049 *1050 * But if we're the last item already, release and search for the last1051 * INODE_REF/EXTREF.1052 */1053 if (path->slots[0] + 1 >= btrfs_header_nritems(leaf)) {1054 key.objectid = node->inode_id;1055 key.type = BTRFS_INODE_EXTREF_KEY;1056 key.offset = (u64)-1;1057 1058 btrfs_release_path(path);1059 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);1060 if (ret < 0)1061 goto err_out;1062 ASSERT(ret > 0);1063 ASSERT(path->slots[0] > 0);1064 ret = 0;1065 path->slots[0]--;1066 leaf = path->nodes[0];1067 } else {1068 path->slots[0]++;1069 }1070 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);1071 if (key.objectid != node->inode_id)1072 goto out;1073 if (key.type != BTRFS_INODE_REF_KEY &&1074 key.type != BTRFS_INODE_EXTREF_KEY)1075 goto out;1076 1077 /*1078 * Delayed iref deletion is for the inode who has only one link,1079 * so there is only one iref. The case that several irefs are1080 * in the same item doesn't exist.1081 */1082 ret = btrfs_del_item(trans, root, path);1083out:1084 btrfs_release_delayed_iref(node);1085 btrfs_release_path(path);1086err_out:1087 btrfs_delayed_inode_release_metadata(fs_info, node, (ret < 0));1088 btrfs_release_delayed_inode(node);1089 1090 /*1091 * If we fail to update the delayed inode we need to abort the1092 * transaction, because we could leave the inode with the improper1093 * counts behind.1094 */1095 if (ret && ret != -ENOENT)1096 btrfs_abort_transaction(trans, ret);1097 1098 return ret;1099}1100 1101static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans,1102 struct btrfs_root *root,1103 struct btrfs_path *path,1104 struct btrfs_delayed_node *node)1105{1106 int ret;1107 1108 mutex_lock(&node->mutex);1109 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &node->flags)) {1110 mutex_unlock(&node->mutex);1111 return 0;1112 }1113 1114 ret = __btrfs_update_delayed_inode(trans, root, path, node);1115 mutex_unlock(&node->mutex);1116 return ret;1117}1118 1119static inline int1120__btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,1121 struct btrfs_path *path,1122 struct btrfs_delayed_node *node)1123{1124 int ret;1125 1126 ret = btrfs_insert_delayed_items(trans, path, node->root, node);1127 if (ret)1128 return ret;1129 1130 ret = btrfs_delete_delayed_items(trans, path, node->root, node);1131 if (ret)1132 return ret;1133 1134 ret = btrfs_record_root_in_trans(trans, node->root);1135 if (ret)1136 return ret;1137 ret = btrfs_update_delayed_inode(trans, node->root, path, node);1138 return ret;1139}1140 1141/*1142 * Called when committing the transaction.1143 * Returns 0 on success.1144 * Returns < 0 on error and returns with an aborted transaction with any1145 * outstanding delayed items cleaned up.1146 */1147static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, int nr)1148{1149 struct btrfs_fs_info *fs_info = trans->fs_info;1150 struct btrfs_delayed_root *delayed_root;1151 struct btrfs_delayed_node *curr_node, *prev_node;1152 struct btrfs_path *path;1153 struct btrfs_block_rsv *block_rsv;1154 int ret = 0;1155 bool count = (nr > 0);1156 1157 if (TRANS_ABORTED(trans))1158 return -EIO;1159 1160 path = btrfs_alloc_path();1161 if (!path)1162 return -ENOMEM;1163 1164 block_rsv = trans->block_rsv;1165 trans->block_rsv = &fs_info->delayed_block_rsv;1166 1167 delayed_root = fs_info->delayed_root;1168 1169 curr_node = btrfs_first_delayed_node(delayed_root);1170 while (curr_node && (!count || nr--)) {1171 ret = __btrfs_commit_inode_delayed_items(trans, path,1172 curr_node);1173 if (ret) {1174 btrfs_abort_transaction(trans, ret);1175 break;1176 }1177 1178 prev_node = curr_node;1179 curr_node = btrfs_next_delayed_node(curr_node);1180 /*1181 * See the comment below about releasing path before releasing1182 * node. If the commit of delayed items was successful the path1183 * should always be released, but in case of an error, it may1184 * point to locked extent buffers (a leaf at the very least).1185 */1186 ASSERT(path->nodes[0] == NULL);1187 btrfs_release_delayed_node(prev_node);1188 }1189 1190 /*1191 * Release the path to avoid a potential deadlock and lockdep splat when1192 * releasing the delayed node, as that requires taking the delayed node's1193 * mutex. If another task starts running delayed items before we take1194 * the mutex, it will first lock the mutex and then it may try to lock1195 * the same btree path (leaf).1196 */1197 btrfs_free_path(path);1198 1199 if (curr_node)1200 btrfs_release_delayed_node(curr_node);1201 trans->block_rsv = block_rsv;1202 1203 return ret;1204}1205 1206int btrfs_run_delayed_items(struct btrfs_trans_handle *trans)1207{1208 return __btrfs_run_delayed_items(trans, -1);1209}1210 1211int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, int nr)1212{1213 return __btrfs_run_delayed_items(trans, nr);1214}1215 1216int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,1217 struct btrfs_inode *inode)1218{1219 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);1220 struct btrfs_path *path;1221 struct btrfs_block_rsv *block_rsv;1222 int ret;1223 1224 if (!delayed_node)1225 return 0;1226 1227 mutex_lock(&delayed_node->mutex);1228 if (!delayed_node->count) {1229 mutex_unlock(&delayed_node->mutex);1230 btrfs_release_delayed_node(delayed_node);1231 return 0;1232 }1233 mutex_unlock(&delayed_node->mutex);1234 1235 path = btrfs_alloc_path();1236 if (!path) {1237 btrfs_release_delayed_node(delayed_node);1238 return -ENOMEM;1239 }1240 1241 block_rsv = trans->block_rsv;1242 trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv;1243 1244 ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node);1245 1246 btrfs_release_delayed_node(delayed_node);1247 btrfs_free_path(path);1248 trans->block_rsv = block_rsv;1249 1250 return ret;1251}1252 1253int btrfs_commit_inode_delayed_inode(struct btrfs_inode *inode)1254{1255 struct btrfs_fs_info *fs_info = inode->root->fs_info;1256 struct btrfs_trans_handle *trans;1257 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);1258 struct btrfs_path *path;1259 struct btrfs_block_rsv *block_rsv;1260 int ret;1261 1262 if (!delayed_node)1263 return 0;1264 1265 mutex_lock(&delayed_node->mutex);1266 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {1267 mutex_unlock(&delayed_node->mutex);1268 btrfs_release_delayed_node(delayed_node);1269 return 0;1270 }1271 mutex_unlock(&delayed_node->mutex);1272 1273 trans = btrfs_join_transaction(delayed_node->root);1274 if (IS_ERR(trans)) {1275 ret = PTR_ERR(trans);1276 goto out;1277 }1278 1279 path = btrfs_alloc_path();1280 if (!path) {1281 ret = -ENOMEM;1282 goto trans_out;1283 }1284 1285 block_rsv = trans->block_rsv;1286 trans->block_rsv = &fs_info->delayed_block_rsv;1287 1288 mutex_lock(&delayed_node->mutex);1289 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags))1290 ret = __btrfs_update_delayed_inode(trans, delayed_node->root,1291 path, delayed_node);1292 else1293 ret = 0;1294 mutex_unlock(&delayed_node->mutex);1295 1296 btrfs_free_path(path);1297 trans->block_rsv = block_rsv;1298trans_out:1299 btrfs_end_transaction(trans);1300 btrfs_btree_balance_dirty(fs_info);1301out:1302 btrfs_release_delayed_node(delayed_node);1303 1304 return ret;1305}1306 1307void btrfs_remove_delayed_node(struct btrfs_inode *inode)1308{1309 struct btrfs_delayed_node *delayed_node;1310 1311 delayed_node = READ_ONCE(inode->delayed_node);1312 if (!delayed_node)1313 return;1314 1315 inode->delayed_node = NULL;1316 btrfs_release_delayed_node(delayed_node);1317}1318 1319struct btrfs_async_delayed_work {1320 struct btrfs_delayed_root *delayed_root;1321 int nr;1322 struct btrfs_work work;1323};1324 1325static void btrfs_async_run_delayed_root(struct btrfs_work *work)1326{1327 struct btrfs_async_delayed_work *async_work;1328 struct btrfs_delayed_root *delayed_root;1329 struct btrfs_trans_handle *trans;1330 struct btrfs_path *path;1331 struct btrfs_delayed_node *delayed_node = NULL;1332 struct btrfs_root *root;1333 struct btrfs_block_rsv *block_rsv;1334 int total_done = 0;1335 1336 async_work = container_of(work, struct btrfs_async_delayed_work, work);1337 delayed_root = async_work->delayed_root;1338 1339 path = btrfs_alloc_path();1340 if (!path)1341 goto out;1342 1343 do {1344 if (atomic_read(&delayed_root->items) <1345 BTRFS_DELAYED_BACKGROUND / 2)1346 break;1347 1348 delayed_node = btrfs_first_prepared_delayed_node(delayed_root);1349 if (!delayed_node)1350 break;1351 1352 root = delayed_node->root;1353 1354 trans = btrfs_join_transaction(root);1355 if (IS_ERR(trans)) {1356 btrfs_release_path(path);1357 btrfs_release_prepared_delayed_node(delayed_node);1358 total_done++;1359 continue;1360 }1361 1362 block_rsv = trans->block_rsv;1363 trans->block_rsv = &root->fs_info->delayed_block_rsv;1364 1365 __btrfs_commit_inode_delayed_items(trans, path, delayed_node);1366 1367 trans->block_rsv = block_rsv;1368 btrfs_end_transaction(trans);1369 btrfs_btree_balance_dirty_nodelay(root->fs_info);1370 1371 btrfs_release_path(path);1372 btrfs_release_prepared_delayed_node(delayed_node);1373 total_done++;1374 1375 } while ((async_work->nr == 0 && total_done < BTRFS_DELAYED_WRITEBACK)1376 || total_done < async_work->nr);1377 1378 btrfs_free_path(path);1379out:1380 wake_up(&delayed_root->wait);1381 kfree(async_work);1382}1383 1384 1385static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root,1386 struct btrfs_fs_info *fs_info, int nr)1387{1388 struct btrfs_async_delayed_work *async_work;1389 1390 async_work = kmalloc(sizeof(*async_work), GFP_NOFS);1391 if (!async_work)1392 return -ENOMEM;1393 1394 async_work->delayed_root = delayed_root;1395 btrfs_init_work(&async_work->work, btrfs_async_run_delayed_root, NULL);1396 async_work->nr = nr;1397 1398 btrfs_queue_work(fs_info->delayed_workers, &async_work->work);1399 return 0;1400}1401 1402void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info)1403{1404 WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root));1405}1406 1407static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq)1408{1409 int val = atomic_read(&delayed_root->items_seq);1410 1411 if (val < seq || val >= seq + BTRFS_DELAYED_BATCH)1412 return 1;1413 1414 if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND)1415 return 1;1416 1417 return 0;1418}1419 1420void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info)1421{1422 struct btrfs_delayed_root *delayed_root = fs_info->delayed_root;1423 1424 if ((atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) ||1425 btrfs_workqueue_normal_congested(fs_info->delayed_workers))1426 return;1427 1428 if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) {1429 int seq;1430 int ret;1431 1432 seq = atomic_read(&delayed_root->items_seq);1433 1434 ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0);1435 if (ret)1436 return;1437 1438 wait_event_interruptible(delayed_root->wait,1439 could_end_wait(delayed_root, seq));1440 return;1441 }1442 1443 btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH);1444}1445 1446static void btrfs_release_dir_index_item_space(struct btrfs_trans_handle *trans)1447{1448 struct btrfs_fs_info *fs_info = trans->fs_info;1449 const u64 bytes = btrfs_calc_insert_metadata_size(fs_info, 1);1450 1451 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))1452 return;1453 1454 /*1455 * Adding the new dir index item does not require touching another1456 * leaf, so we can release 1 unit of metadata that was previously1457 * reserved when starting the transaction. This applies only to1458 * the case where we had a transaction start and excludes the1459 * transaction join case (when replaying log trees).1460 */1461 trace_btrfs_space_reservation(fs_info, "transaction",1462 trans->transid, bytes, 0);1463 btrfs_block_rsv_release(fs_info, trans->block_rsv, bytes, NULL);1464 ASSERT(trans->bytes_reserved >= bytes);1465 trans->bytes_reserved -= bytes;1466}1467 1468/* Will return 0, -ENOMEM or -EEXIST (index number collision, unexpected). */1469int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans,1470 const char *name, int name_len,1471 struct btrfs_inode *dir,1472 const struct btrfs_disk_key *disk_key, u8 flags,1473 u64 index)1474{1475 struct btrfs_fs_info *fs_info = trans->fs_info;1476 const unsigned int leaf_data_size = BTRFS_LEAF_DATA_SIZE(fs_info);1477 struct btrfs_delayed_node *delayed_node;1478 struct btrfs_delayed_item *delayed_item;1479 struct btrfs_dir_item *dir_item;1480 bool reserve_leaf_space;1481 u32 data_len;1482 int ret;1483 1484 delayed_node = btrfs_get_or_create_delayed_node(dir);1485 if (IS_ERR(delayed_node))1486 return PTR_ERR(delayed_node);1487 1488 delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len,1489 delayed_node,1490 BTRFS_DELAYED_INSERTION_ITEM);1491 if (!delayed_item) {1492 ret = -ENOMEM;1493 goto release_node;1494 }1495 1496 delayed_item->index = index;1497 1498 dir_item = (struct btrfs_dir_item *)delayed_item->data;1499 dir_item->location = *disk_key;1500 btrfs_set_stack_dir_transid(dir_item, trans->transid);1501 btrfs_set_stack_dir_data_len(dir_item, 0);1502 btrfs_set_stack_dir_name_len(dir_item, name_len);1503 btrfs_set_stack_dir_flags(dir_item, flags);1504 memcpy((char *)(dir_item + 1), name, name_len);1505 1506 data_len = delayed_item->data_len + sizeof(struct btrfs_item);1507 1508 mutex_lock(&delayed_node->mutex);1509 1510 /*1511 * First attempt to insert the delayed item. This is to make the error1512 * handling path simpler in case we fail (-EEXIST). There's no risk of1513 * any other task coming in and running the delayed item before we do1514 * the metadata space reservation below, because we are holding the1515 * delayed node's mutex and that mutex must also be locked before the1516 * node's delayed items can be run.1517 */1518 ret = __btrfs_add_delayed_item(delayed_node, delayed_item);1519 if (unlikely(ret)) {1520 btrfs_err(trans->fs_info,1521"error adding delayed dir index item, name: %.*s, index: %llu, root: %llu, dir: %llu, dir->index_cnt: %llu, delayed_node->index_cnt: %llu, error: %d",1522 name_len, name, index, btrfs_root_id(delayed_node->root),1523 delayed_node->inode_id, dir->index_cnt,1524 delayed_node->index_cnt, ret);1525 btrfs_release_delayed_item(delayed_item);1526 btrfs_release_dir_index_item_space(trans);1527 mutex_unlock(&delayed_node->mutex);1528 goto release_node;1529 }1530 1531 if (delayed_node->index_item_leaves == 0 ||1532 delayed_node->curr_index_batch_size + data_len > leaf_data_size) {1533 delayed_node->curr_index_batch_size = data_len;1534 reserve_leaf_space = true;1535 } else {1536 delayed_node->curr_index_batch_size += data_len;1537 reserve_leaf_space = false;1538 }1539 1540 if (reserve_leaf_space) {1541 ret = btrfs_delayed_item_reserve_metadata(trans, delayed_item);1542 /*1543 * Space was reserved for a dir index item insertion when we1544 * started the transaction, so getting a failure here should be1545 * impossible.1546 */1547 if (WARN_ON(ret)) {1548 btrfs_release_delayed_item(delayed_item);1549 mutex_unlock(&delayed_node->mutex);1550 goto release_node;1551 }1552 1553 delayed_node->index_item_leaves++;1554 } else {1555 btrfs_release_dir_index_item_space(trans);1556 }1557 mutex_unlock(&delayed_node->mutex);1558 1559release_node:1560 btrfs_release_delayed_node(delayed_node);1561 return ret;1562}1563 1564static int btrfs_delete_delayed_insertion_item(struct btrfs_fs_info *fs_info,1565 struct btrfs_delayed_node *node,1566 u64 index)1567{1568 struct btrfs_delayed_item *item;1569 1570 mutex_lock(&node->mutex);1571 item = __btrfs_lookup_delayed_item(&node->ins_root.rb_root, index);1572 if (!item) {1573 mutex_unlock(&node->mutex);1574 return 1;1575 }1576 1577 /*1578 * For delayed items to insert, we track reserved metadata bytes based1579 * on the number of leaves that we will use.1580 * See btrfs_insert_delayed_dir_index() and1581 * btrfs_delayed_item_reserve_metadata()).1582 */1583 ASSERT(item->bytes_reserved == 0);1584 ASSERT(node->index_item_leaves > 0);1585 1586 /*1587 * If there's only one leaf reserved, we can decrement this item from the1588 * current batch, otherwise we can not because we don't know which leaf1589 * it belongs to. With the current limit on delayed items, we rarely1590 * accumulate enough dir index items to fill more than one leaf (even1591 * when using a leaf size of 4K).1592 */1593 if (node->index_item_leaves == 1) {1594 const u32 data_len = item->data_len + sizeof(struct btrfs_item);1595 1596 ASSERT(node->curr_index_batch_size >= data_len);1597 node->curr_index_batch_size -= data_len;1598 }1599 1600 btrfs_release_delayed_item(item);1601 1602 /* If we now have no more dir index items, we can release all leaves. */1603 if (RB_EMPTY_ROOT(&node->ins_root.rb_root)) {1604 btrfs_delayed_item_release_leaves(node, node->index_item_leaves);1605 node->index_item_leaves = 0;1606 }1607 1608 mutex_unlock(&node->mutex);1609 return 0;1610}1611 1612int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans,1613 struct btrfs_inode *dir, u64 index)1614{1615 struct btrfs_delayed_node *node;1616 struct btrfs_delayed_item *item;1617 int ret;1618 1619 node = btrfs_get_or_create_delayed_node(dir);1620 if (IS_ERR(node))1621 return PTR_ERR(node);1622 1623 ret = btrfs_delete_delayed_insertion_item(trans->fs_info, node, index);1624 if (!ret)1625 goto end;1626 1627 item = btrfs_alloc_delayed_item(0, node, BTRFS_DELAYED_DELETION_ITEM);1628 if (!item) {1629 ret = -ENOMEM;1630 goto end;1631 }1632 1633 item->index = index;1634 1635 ret = btrfs_delayed_item_reserve_metadata(trans, item);1636 /*1637 * we have reserved enough space when we start a new transaction,1638 * so reserving metadata failure is impossible.1639 */1640 if (ret < 0) {1641 btrfs_err(trans->fs_info,1642"metadata reservation failed for delayed dir item deltiona, should have been reserved");1643 btrfs_release_delayed_item(item);1644 goto end;1645 }1646 1647 mutex_lock(&node->mutex);1648 ret = __btrfs_add_delayed_item(node, item);1649 if (unlikely(ret)) {1650 btrfs_err(trans->fs_info,1651 "err add delayed dir index item(index: %llu) into the deletion tree of the delayed node(root id: %llu, inode id: %llu, errno: %d)",1652 index, btrfs_root_id(node->root),1653 node->inode_id, ret);1654 btrfs_delayed_item_release_metadata(dir->root, item);1655 btrfs_release_delayed_item(item);1656 }1657 mutex_unlock(&node->mutex);1658end:1659 btrfs_release_delayed_node(node);1660 return ret;1661}1662 1663int btrfs_inode_delayed_dir_index_count(struct btrfs_inode *inode)1664{1665 struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode);1666 1667 if (!delayed_node)1668 return -ENOENT;1669 1670 /*1671 * Since we have held i_mutex of this directory, it is impossible that1672 * a new directory index is added into the delayed node and index_cnt1673 * is updated now. So we needn't lock the delayed node.1674 */1675 if (!delayed_node->index_cnt) {1676 btrfs_release_delayed_node(delayed_node);1677 return -EINVAL;1678 }1679 1680 inode->index_cnt = delayed_node->index_cnt;1681 btrfs_release_delayed_node(delayed_node);1682 return 0;1683}1684 1685bool btrfs_readdir_get_delayed_items(struct btrfs_inode *inode,1686 u64 last_index,1687 struct list_head *ins_list,1688 struct list_head *del_list)1689{1690 struct btrfs_delayed_node *delayed_node;1691 struct btrfs_delayed_item *item;1692 1693 delayed_node = btrfs_get_delayed_node(inode);1694 if (!delayed_node)1695 return false;1696 1697 /*1698 * We can only do one readdir with delayed items at a time because of1699 * item->readdir_list.1700 */1701 btrfs_inode_unlock(inode, BTRFS_ILOCK_SHARED);1702 btrfs_inode_lock(inode, 0);1703 1704 mutex_lock(&delayed_node->mutex);1705 item = __btrfs_first_delayed_insertion_item(delayed_node);1706 while (item && item->index <= last_index) {1707 refcount_inc(&item->refs);1708 list_add_tail(&item->readdir_list, ins_list);1709 item = __btrfs_next_delayed_item(item);1710 }1711 1712 item = __btrfs_first_delayed_deletion_item(delayed_node);1713 while (item && item->index <= last_index) {1714 refcount_inc(&item->refs);1715 list_add_tail(&item->readdir_list, del_list);1716 item = __btrfs_next_delayed_item(item);1717 }1718 mutex_unlock(&delayed_node->mutex);1719 /*1720 * This delayed node is still cached in the btrfs inode, so refs1721 * must be > 1 now, and we needn't check it is going to be freed1722 * or not.1723 *1724 * Besides that, this function is used to read dir, we do not1725 * insert/delete delayed items in this period. So we also needn't1726 * requeue or dequeue this delayed node.1727 */1728 refcount_dec(&delayed_node->refs);1729 1730 return true;1731}1732 1733void btrfs_readdir_put_delayed_items(struct btrfs_inode *inode,1734 struct list_head *ins_list,1735 struct list_head *del_list)1736{1737 struct btrfs_delayed_item *curr, *next;1738 1739 list_for_each_entry_safe(curr, next, ins_list, readdir_list) {1740 list_del(&curr->readdir_list);1741 if (refcount_dec_and_test(&curr->refs))1742 kfree(curr);1743 }1744 1745 list_for_each_entry_safe(curr, next, del_list, readdir_list) {1746 list_del(&curr->readdir_list);1747 if (refcount_dec_and_test(&curr->refs))1748 kfree(curr);1749 }1750 1751 /*1752 * The VFS is going to do up_read(), so we need to downgrade back to a1753 * read lock.1754 */1755 downgrade_write(&inode->vfs_inode.i_rwsem);1756}1757 1758int btrfs_should_delete_dir_index(const struct list_head *del_list,1759 u64 index)1760{1761 struct btrfs_delayed_item *curr;1762 int ret = 0;1763 1764 list_for_each_entry(curr, del_list, readdir_list) {1765 if (curr->index > index)1766 break;1767 if (curr->index == index) {1768 ret = 1;1769 break;1770 }1771 }1772 return ret;1773}1774 1775/*1776 * Read dir info stored in the delayed tree.1777 */1778int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,1779 const struct list_head *ins_list)1780{1781 struct btrfs_dir_item *di;1782 struct btrfs_delayed_item *curr, *next;1783 struct btrfs_key location;1784 char *name;1785 int name_len;1786 int over = 0;1787 unsigned char d_type;1788 1789 /*1790 * Changing the data of the delayed item is impossible. So1791 * we needn't lock them. And we have held i_mutex of the1792 * directory, nobody can delete any directory indexes now.1793 */1794 list_for_each_entry_safe(curr, next, ins_list, readdir_list) {1795 list_del(&curr->readdir_list);1796 1797 if (curr->index < ctx->pos) {1798 if (refcount_dec_and_test(&curr->refs))1799 kfree(curr);1800 continue;1801 }1802 1803 ctx->pos = curr->index;1804 1805 di = (struct btrfs_dir_item *)curr->data;1806 name = (char *)(di + 1);1807 name_len = btrfs_stack_dir_name_len(di);1808 1809 d_type = fs_ftype_to_dtype(btrfs_dir_flags_to_ftype(di->type));1810 btrfs_disk_key_to_cpu(&location, &di->location);1811 1812 over = !dir_emit(ctx, name, name_len,1813 location.objectid, d_type);1814 1815 if (refcount_dec_and_test(&curr->refs))1816 kfree(curr);1817 1818 if (over)1819 return 1;1820 ctx->pos++;1821 }1822 return 0;1823}1824 1825static void fill_stack_inode_item(struct btrfs_trans_handle *trans,1826 struct btrfs_inode_item *inode_item,1827 struct inode *inode)1828{1829 u64 flags;1830 1831 btrfs_set_stack_inode_uid(inode_item, i_uid_read(inode));1832 btrfs_set_stack_inode_gid(inode_item, i_gid_read(inode));1833 btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size);1834 btrfs_set_stack_inode_mode(inode_item, inode->i_mode);1835 btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink);1836 btrfs_set_stack_inode_nbytes(inode_item, inode_get_bytes(inode));1837 btrfs_set_stack_inode_generation(inode_item,1838 BTRFS_I(inode)->generation);1839 btrfs_set_stack_inode_sequence(inode_item,1840 inode_peek_iversion(inode));1841 btrfs_set_stack_inode_transid(inode_item, trans->transid);1842 btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev);1843 flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags,1844 BTRFS_I(inode)->ro_flags);1845 btrfs_set_stack_inode_flags(inode_item, flags);1846 btrfs_set_stack_inode_block_group(inode_item, 0);1847 1848 btrfs_set_stack_timespec_sec(&inode_item->atime,1849 inode_get_atime_sec(inode));1850 btrfs_set_stack_timespec_nsec(&inode_item->atime,1851 inode_get_atime_nsec(inode));1852 1853 btrfs_set_stack_timespec_sec(&inode_item->mtime,1854 inode_get_mtime_sec(inode));1855 btrfs_set_stack_timespec_nsec(&inode_item->mtime,1856 inode_get_mtime_nsec(inode));1857 1858 btrfs_set_stack_timespec_sec(&inode_item->ctime,1859 inode_get_ctime_sec(inode));1860 btrfs_set_stack_timespec_nsec(&inode_item->ctime,1861 inode_get_ctime_nsec(inode));1862 1863 btrfs_set_stack_timespec_sec(&inode_item->otime, BTRFS_I(inode)->i_otime_sec);1864 btrfs_set_stack_timespec_nsec(&inode_item->otime, BTRFS_I(inode)->i_otime_nsec);1865}1866 1867int btrfs_fill_inode(struct inode *inode, u32 *rdev)1868{1869 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;1870 struct btrfs_delayed_node *delayed_node;1871 struct btrfs_inode_item *inode_item;1872 1873 delayed_node = btrfs_get_delayed_node(BTRFS_I(inode));1874 if (!delayed_node)1875 return -ENOENT;1876 1877 mutex_lock(&delayed_node->mutex);1878 if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {1879 mutex_unlock(&delayed_node->mutex);1880 btrfs_release_delayed_node(delayed_node);1881 return -ENOENT;1882 }1883 1884 inode_item = &delayed_node->inode_item;1885 1886 i_uid_write(inode, btrfs_stack_inode_uid(inode_item));1887 i_gid_write(inode, btrfs_stack_inode_gid(inode_item));1888 btrfs_i_size_write(BTRFS_I(inode), btrfs_stack_inode_size(inode_item));1889 btrfs_inode_set_file_extent_range(BTRFS_I(inode), 0,1890 round_up(i_size_read(inode), fs_info->sectorsize));1891 inode->i_mode = btrfs_stack_inode_mode(inode_item);1892 set_nlink(inode, btrfs_stack_inode_nlink(inode_item));1893 inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item));1894 BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item);1895 BTRFS_I(inode)->last_trans = btrfs_stack_inode_transid(inode_item);1896 1897 inode_set_iversion_queried(inode,1898 btrfs_stack_inode_sequence(inode_item));1899 inode->i_rdev = 0;1900 *rdev = btrfs_stack_inode_rdev(inode_item);1901 btrfs_inode_split_flags(btrfs_stack_inode_flags(inode_item),1902 &BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags);1903 1904 inode_set_atime(inode, btrfs_stack_timespec_sec(&inode_item->atime),1905 btrfs_stack_timespec_nsec(&inode_item->atime));1906 1907 inode_set_mtime(inode, btrfs_stack_timespec_sec(&inode_item->mtime),1908 btrfs_stack_timespec_nsec(&inode_item->mtime));1909 1910 inode_set_ctime(inode, btrfs_stack_timespec_sec(&inode_item->ctime),1911 btrfs_stack_timespec_nsec(&inode_item->ctime));1912 1913 BTRFS_I(inode)->i_otime_sec = btrfs_stack_timespec_sec(&inode_item->otime);1914 BTRFS_I(inode)->i_otime_nsec = btrfs_stack_timespec_nsec(&inode_item->otime);1915 1916 inode->i_generation = BTRFS_I(inode)->generation;1917 if (S_ISDIR(inode->i_mode))1918 BTRFS_I(inode)->index_cnt = (u64)-1;1919 1920 mutex_unlock(&delayed_node->mutex);1921 btrfs_release_delayed_node(delayed_node);1922 return 0;1923}1924 1925int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans,1926 struct btrfs_inode *inode)1927{1928 struct btrfs_root *root = inode->root;1929 struct btrfs_delayed_node *delayed_node;1930 int ret = 0;1931 1932 delayed_node = btrfs_get_or_create_delayed_node(inode);1933 if (IS_ERR(delayed_node))1934 return PTR_ERR(delayed_node);1935 1936 mutex_lock(&delayed_node->mutex);1937 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {1938 fill_stack_inode_item(trans, &delayed_node->inode_item,1939 &inode->vfs_inode);1940 goto release_node;1941 }1942 1943 ret = btrfs_delayed_inode_reserve_metadata(trans, root, delayed_node);1944 if (ret)1945 goto release_node;1946 1947 fill_stack_inode_item(trans, &delayed_node->inode_item, &inode->vfs_inode);1948 set_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags);1949 delayed_node->count++;1950 atomic_inc(&root->fs_info->delayed_root->items);1951release_node:1952 mutex_unlock(&delayed_node->mutex);1953 btrfs_release_delayed_node(delayed_node);1954 return ret;1955}1956 1957int btrfs_delayed_delete_inode_ref(struct btrfs_inode *inode)1958{1959 struct btrfs_fs_info *fs_info = inode->root->fs_info;1960 struct btrfs_delayed_node *delayed_node;1961 1962 /*1963 * we don't do delayed inode updates during log recovery because it1964 * leads to enospc problems. This means we also can't do1965 * delayed inode refs1966 */1967 if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags))1968 return -EAGAIN;1969 1970 delayed_node = btrfs_get_or_create_delayed_node(inode);1971 if (IS_ERR(delayed_node))1972 return PTR_ERR(delayed_node);1973 1974 /*1975 * We don't reserve space for inode ref deletion is because:1976 * - We ONLY do async inode ref deletion for the inode who has only1977 * one link(i_nlink == 1), it means there is only one inode ref.1978 * And in most case, the inode ref and the inode item are in the1979 * same leaf, and we will deal with them at the same time.1980 * Since we are sure we will reserve the space for the inode item,1981 * it is unnecessary to reserve space for inode ref deletion.1982 * - If the inode ref and the inode item are not in the same leaf,1983 * We also needn't worry about enospc problem, because we reserve1984 * much more space for the inode update than it needs.1985 * - At the worst, we can steal some space from the global reservation.1986 * It is very rare.1987 */1988 mutex_lock(&delayed_node->mutex);1989 if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags))1990 goto release_node;1991 1992 set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags);1993 delayed_node->count++;1994 atomic_inc(&fs_info->delayed_root->items);1995release_node:1996 mutex_unlock(&delayed_node->mutex);1997 btrfs_release_delayed_node(delayed_node);1998 return 0;1999}2000 2001static void __btrfs_kill_delayed_node(struct btrfs_delayed_node *delayed_node)2002{2003 struct btrfs_root *root = delayed_node->root;2004 struct btrfs_fs_info *fs_info = root->fs_info;2005 struct btrfs_delayed_item *curr_item, *prev_item;2006 2007 mutex_lock(&delayed_node->mutex);2008 curr_item = __btrfs_first_delayed_insertion_item(delayed_node);2009 while (curr_item) {2010 prev_item = curr_item;2011 curr_item = __btrfs_next_delayed_item(prev_item);2012 btrfs_release_delayed_item(prev_item);2013 }2014 2015 if (delayed_node->index_item_leaves > 0) {2016 btrfs_delayed_item_release_leaves(delayed_node,2017 delayed_node->index_item_leaves);2018 delayed_node->index_item_leaves = 0;2019 }2020 2021 curr_item = __btrfs_first_delayed_deletion_item(delayed_node);2022 while (curr_item) {2023 btrfs_delayed_item_release_metadata(root, curr_item);2024 prev_item = curr_item;2025 curr_item = __btrfs_next_delayed_item(prev_item);2026 btrfs_release_delayed_item(prev_item);2027 }2028 2029 btrfs_release_delayed_iref(delayed_node);2030 2031 if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) {2032 btrfs_delayed_inode_release_metadata(fs_info, delayed_node, false);2033 btrfs_release_delayed_inode(delayed_node);2034 }2035 mutex_unlock(&delayed_node->mutex);2036}2037 2038void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode)2039{2040 struct btrfs_delayed_node *delayed_node;2041 2042 delayed_node = btrfs_get_delayed_node(inode);2043 if (!delayed_node)2044 return;2045 2046 __btrfs_kill_delayed_node(delayed_node);2047 btrfs_release_delayed_node(delayed_node);2048}2049 2050void btrfs_kill_all_delayed_nodes(struct btrfs_root *root)2051{2052 unsigned long index = 0;2053 struct btrfs_delayed_node *delayed_nodes[8];2054 2055 while (1) {2056 struct btrfs_delayed_node *node;2057 int count;2058 2059 xa_lock(&root->delayed_nodes);2060 if (xa_empty(&root->delayed_nodes)) {2061 xa_unlock(&root->delayed_nodes);2062 return;2063 }2064 2065 count = 0;2066 xa_for_each_start(&root->delayed_nodes, index, node, index) {2067 /*2068 * Don't increase refs in case the node is dead and2069 * about to be removed from the tree in the loop below2070 */2071 if (refcount_inc_not_zero(&node->refs)) {2072 delayed_nodes[count] = node;2073 count++;2074 }2075 if (count >= ARRAY_SIZE(delayed_nodes))2076 break;2077 }2078 xa_unlock(&root->delayed_nodes);2079 index++;2080 2081 for (int i = 0; i < count; i++) {2082 __btrfs_kill_delayed_node(delayed_nodes[i]);2083 btrfs_release_delayed_node(delayed_nodes[i]);2084 }2085 }2086}2087 2088void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info)2089{2090 struct btrfs_delayed_node *curr_node, *prev_node;2091 2092 curr_node = btrfs_first_delayed_node(fs_info->delayed_root);2093 while (curr_node) {2094 __btrfs_kill_delayed_node(curr_node);2095 2096 prev_node = curr_node;2097 curr_node = btrfs_next_delayed_node(curr_node);2098 btrfs_release_delayed_node(prev_node);2099 }2100}2101 2102void btrfs_log_get_delayed_items(struct btrfs_inode *inode,2103 struct list_head *ins_list,2104 struct list_head *del_list)2105{2106 struct btrfs_delayed_node *node;2107 struct btrfs_delayed_item *item;2108 2109 node = btrfs_get_delayed_node(inode);2110 if (!node)2111 return;2112 2113 mutex_lock(&node->mutex);2114 item = __btrfs_first_delayed_insertion_item(node);2115 while (item) {2116 /*2117 * It's possible that the item is already in a log list. This2118 * can happen in case two tasks are trying to log the same2119 * directory. For example if we have tasks A and task B:2120 *2121 * Task A collected the delayed items into a log list while2122 * under the inode's log_mutex (at btrfs_log_inode()), but it2123 * only releases the items after logging the inodes they point2124 * to (if they are new inodes), which happens after unlocking2125 * the log mutex;2126 *2127 * Task B enters btrfs_log_inode() and acquires the log_mutex2128 * of the same directory inode, before task B releases the2129 * delayed items. This can happen for example when logging some2130 * inode we need to trigger logging of its parent directory, so2131 * logging two files that have the same parent directory can2132 * lead to this.2133 *2134 * If this happens, just ignore delayed items already in a log2135 * list. All the tasks logging the directory are under a log2136 * transaction and whichever finishes first can not sync the log2137 * before the other completes and leaves the log transaction.2138 */2139 if (!item->logged && list_empty(&item->log_list)) {2140 refcount_inc(&item->refs);2141 list_add_tail(&item->log_list, ins_list);2142 }2143 item = __btrfs_next_delayed_item(item);2144 }2145 2146 item = __btrfs_first_delayed_deletion_item(node);2147 while (item) {2148 /* It may be non-empty, for the same reason mentioned above. */2149 if (!item->logged && list_empty(&item->log_list)) {2150 refcount_inc(&item->refs);2151 list_add_tail(&item->log_list, del_list);2152 }2153 item = __btrfs_next_delayed_item(item);2154 }2155 mutex_unlock(&node->mutex);2156 2157 /*2158 * We are called during inode logging, which means the inode is in use2159 * and can not be evicted before we finish logging the inode. So we never2160 * have the last reference on the delayed inode.2161 * Also, we don't use btrfs_release_delayed_node() because that would2162 * requeue the delayed inode (change its order in the list of prepared2163 * nodes) and we don't want to do such change because we don't create or2164 * delete delayed items.2165 */2166 ASSERT(refcount_read(&node->refs) > 1);2167 refcount_dec(&node->refs);2168}2169 2170void btrfs_log_put_delayed_items(struct btrfs_inode *inode,2171 struct list_head *ins_list,2172 struct list_head *del_list)2173{2174 struct btrfs_delayed_node *node;2175 struct btrfs_delayed_item *item;2176 struct btrfs_delayed_item *next;2177 2178 node = btrfs_get_delayed_node(inode);2179 if (!node)2180 return;2181 2182 mutex_lock(&node->mutex);2183 2184 list_for_each_entry_safe(item, next, ins_list, log_list) {2185 item->logged = true;2186 list_del_init(&item->log_list);2187 if (refcount_dec_and_test(&item->refs))2188 kfree(item);2189 }2190 2191 list_for_each_entry_safe(item, next, del_list, log_list) {2192 item->logged = true;2193 list_del_init(&item->log_list);2194 if (refcount_dec_and_test(&item->refs))2195 kfree(item);2196 }2197 2198 mutex_unlock(&node->mutex);2199 2200 /*2201 * We are called during inode logging, which means the inode is in use2202 * and can not be evicted before we finish logging the inode. So we never2203 * have the last reference on the delayed inode.2204 * Also, we don't use btrfs_release_delayed_node() because that would2205 * requeue the delayed inode (change its order in the list of prepared2206 * nodes) and we don't want to do such change because we don't create or2207 * delete delayed items.2208 */2209 ASSERT(refcount_read(&node->refs) > 1);2210 refcount_dec(&node->refs);2211}2212