1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 216cdcec7SMiao Xie /* 316cdcec7SMiao Xie * Copyright (C) 2011 Fujitsu. All rights reserved. 416cdcec7SMiao Xie * Written by Miao Xie <miaox@cn.fujitsu.com> 516cdcec7SMiao Xie */ 616cdcec7SMiao Xie 716cdcec7SMiao Xie #include <linux/slab.h> 8c7f88c4eSJeff Layton #include <linux/iversion.h> 9ec8eb376SJosef Bacik #include "ctree.h" 10ec8eb376SJosef Bacik #include "fs.h" 119b569ea0SJosef Bacik #include "messages.h" 12602cbe91SDavid Sterba #include "misc.h" 1316cdcec7SMiao Xie #include "delayed-inode.h" 1416cdcec7SMiao Xie #include "disk-io.h" 1516cdcec7SMiao Xie #include "transaction.h" 164f5427ccSQu Wenruo #include "qgroup.h" 171f95ec01SDavid Sterba #include "locking.h" 1826c2c454SJosef Bacik #include "inode-item.h" 19f1e5c618SJosef Bacik #include "space-info.h" 2007e81dc9SJosef Bacik #include "accessors.h" 217c8ede16SJosef Bacik #include "file-item.h" 2216cdcec7SMiao Xie 23de3cb945SChris Mason #define BTRFS_DELAYED_WRITEBACK 512 24de3cb945SChris Mason #define BTRFS_DELAYED_BACKGROUND 128 25de3cb945SChris Mason #define BTRFS_DELAYED_BATCH 16 2616cdcec7SMiao Xie 2716cdcec7SMiao Xie static struct kmem_cache *delayed_node_cache; 2816cdcec7SMiao Xie 2916cdcec7SMiao Xie int __init btrfs_delayed_inode_init(void) 3016cdcec7SMiao Xie { 31837e1972SDavid Sterba delayed_node_cache = kmem_cache_create("btrfs_delayed_node", 3216cdcec7SMiao Xie sizeof(struct btrfs_delayed_node), 3316cdcec7SMiao Xie 0, 34fba4b697SNikolay Borisov SLAB_MEM_SPREAD, 3516cdcec7SMiao Xie NULL); 3616cdcec7SMiao Xie if (!delayed_node_cache) 3716cdcec7SMiao Xie return -ENOMEM; 3816cdcec7SMiao Xie return 0; 3916cdcec7SMiao Xie } 4016cdcec7SMiao Xie 41e67c718bSDavid Sterba void __cold btrfs_delayed_inode_exit(void) 4216cdcec7SMiao Xie { 4316cdcec7SMiao Xie kmem_cache_destroy(delayed_node_cache); 4416cdcec7SMiao Xie } 4516cdcec7SMiao Xie 4616cdcec7SMiao Xie static inline void btrfs_init_delayed_node( 4716cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 4816cdcec7SMiao Xie struct btrfs_root *root, u64 inode_id) 4916cdcec7SMiao Xie { 5016cdcec7SMiao Xie delayed_node->root = root; 5116cdcec7SMiao Xie delayed_node->inode_id = inode_id; 526de5f18eSElena Reshetova refcount_set(&delayed_node->refs, 0); 5303a1d4c8SLiu Bo delayed_node->ins_root = RB_ROOT_CACHED; 5403a1d4c8SLiu Bo delayed_node->del_root = RB_ROOT_CACHED; 5516cdcec7SMiao Xie mutex_init(&delayed_node->mutex); 5616cdcec7SMiao Xie INIT_LIST_HEAD(&delayed_node->n_list); 5716cdcec7SMiao Xie INIT_LIST_HEAD(&delayed_node->p_list); 5816cdcec7SMiao Xie } 5916cdcec7SMiao Xie 60f85b7379SDavid Sterba static struct btrfs_delayed_node *btrfs_get_delayed_node( 61f85b7379SDavid Sterba struct btrfs_inode *btrfs_inode) 622f7e33d4SMiao Xie { 632f7e33d4SMiao Xie struct btrfs_root *root = btrfs_inode->root; 644a0cc7caSNikolay Borisov u64 ino = btrfs_ino(btrfs_inode); 652f7e33d4SMiao Xie struct btrfs_delayed_node *node; 662f7e33d4SMiao Xie 6720c7bcecSSeraphime Kirkovski node = READ_ONCE(btrfs_inode->delayed_node); 682f7e33d4SMiao Xie if (node) { 696de5f18eSElena Reshetova refcount_inc(&node->refs); 702f7e33d4SMiao Xie return node; 712f7e33d4SMiao Xie } 722f7e33d4SMiao Xie 732f7e33d4SMiao Xie spin_lock(&root->inode_lock); 74088aea3bSDavid Sterba node = radix_tree_lookup(&root->delayed_nodes_tree, ino); 75ec35e48bSChris Mason 762f7e33d4SMiao Xie if (node) { 772f7e33d4SMiao Xie if (btrfs_inode->delayed_node) { 786de5f18eSElena Reshetova refcount_inc(&node->refs); /* can be accessed */ 792f7e33d4SMiao Xie BUG_ON(btrfs_inode->delayed_node != node); 802f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 812f7e33d4SMiao Xie return node; 822f7e33d4SMiao Xie } 83ec35e48bSChris Mason 84ec35e48bSChris Mason /* 85ec35e48bSChris Mason * It's possible that we're racing into the middle of removing 86088aea3bSDavid Sterba * this node from the radix tree. In this case, the refcount 87ec35e48bSChris Mason * was zero and it should never go back to one. Just return 88088aea3bSDavid Sterba * NULL like it was never in the radix at all; our release 89ec35e48bSChris Mason * function is in the process of removing it. 90ec35e48bSChris Mason * 91ec35e48bSChris Mason * Some implementations of refcount_inc refuse to bump the 92ec35e48bSChris Mason * refcount once it has hit zero. If we don't do this dance 93ec35e48bSChris Mason * here, refcount_inc() may decide to just WARN_ONCE() instead 94ec35e48bSChris Mason * of actually bumping the refcount. 95ec35e48bSChris Mason * 96088aea3bSDavid Sterba * If this node is properly in the radix, we want to bump the 97ec35e48bSChris Mason * refcount twice, once for the inode and once for this get 98ec35e48bSChris Mason * operation. 99ec35e48bSChris Mason */ 100ec35e48bSChris Mason if (refcount_inc_not_zero(&node->refs)) { 101ec35e48bSChris Mason refcount_inc(&node->refs); 1022f7e33d4SMiao Xie btrfs_inode->delayed_node = node; 103ec35e48bSChris Mason } else { 104ec35e48bSChris Mason node = NULL; 105ec35e48bSChris Mason } 106ec35e48bSChris Mason 1072f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 1082f7e33d4SMiao Xie return node; 1092f7e33d4SMiao Xie } 1102f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 1112f7e33d4SMiao Xie 1122f7e33d4SMiao Xie return NULL; 1132f7e33d4SMiao Xie } 1142f7e33d4SMiao Xie 11579787eaaSJeff Mahoney /* Will return either the node or PTR_ERR(-ENOMEM) */ 11616cdcec7SMiao Xie static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node( 117e5517a7bSNikolay Borisov struct btrfs_inode *btrfs_inode) 11816cdcec7SMiao Xie { 11916cdcec7SMiao Xie struct btrfs_delayed_node *node; 12016cdcec7SMiao Xie struct btrfs_root *root = btrfs_inode->root; 1214a0cc7caSNikolay Borisov u64 ino = btrfs_ino(btrfs_inode); 12216cdcec7SMiao Xie int ret; 12316cdcec7SMiao Xie 124088aea3bSDavid Sterba again: 125340c6ca9SNikolay Borisov node = btrfs_get_delayed_node(btrfs_inode); 1262f7e33d4SMiao Xie if (node) 12716cdcec7SMiao Xie return node; 12816cdcec7SMiao Xie 129352dd9c8SAlexandru Moise node = kmem_cache_zalloc(delayed_node_cache, GFP_NOFS); 13016cdcec7SMiao Xie if (!node) 13116cdcec7SMiao Xie return ERR_PTR(-ENOMEM); 1320d0ca30fSChris Mason btrfs_init_delayed_node(node, root, ino); 13316cdcec7SMiao Xie 134088aea3bSDavid Sterba /* cached in the btrfs inode and can be accessed */ 1356de5f18eSElena Reshetova refcount_set(&node->refs, 2); 13616cdcec7SMiao Xie 137088aea3bSDavid Sterba ret = radix_tree_preload(GFP_NOFS); 13816cdcec7SMiao Xie if (ret) { 13916cdcec7SMiao Xie kmem_cache_free(delayed_node_cache, node); 14016cdcec7SMiao Xie return ERR_PTR(ret); 14116cdcec7SMiao Xie } 142088aea3bSDavid Sterba 143088aea3bSDavid Sterba spin_lock(&root->inode_lock); 144088aea3bSDavid Sterba ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node); 145088aea3bSDavid Sterba if (ret == -EEXIST) { 146088aea3bSDavid Sterba spin_unlock(&root->inode_lock); 147088aea3bSDavid Sterba kmem_cache_free(delayed_node_cache, node); 148088aea3bSDavid Sterba radix_tree_preload_end(); 149088aea3bSDavid Sterba goto again; 150088aea3bSDavid Sterba } 15116cdcec7SMiao Xie btrfs_inode->delayed_node = node; 15216cdcec7SMiao Xie spin_unlock(&root->inode_lock); 153088aea3bSDavid Sterba radix_tree_preload_end(); 15416cdcec7SMiao Xie 15516cdcec7SMiao Xie return node; 15616cdcec7SMiao Xie } 15716cdcec7SMiao Xie 15816cdcec7SMiao Xie /* 15916cdcec7SMiao Xie * Call it when holding delayed_node->mutex 16016cdcec7SMiao Xie * 16116cdcec7SMiao Xie * If mod = 1, add this node into the prepared list. 16216cdcec7SMiao Xie */ 16316cdcec7SMiao Xie static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root, 16416cdcec7SMiao Xie struct btrfs_delayed_node *node, 16516cdcec7SMiao Xie int mod) 16616cdcec7SMiao Xie { 16716cdcec7SMiao Xie spin_lock(&root->lock); 1687cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 16916cdcec7SMiao Xie if (!list_empty(&node->p_list)) 17016cdcec7SMiao Xie list_move_tail(&node->p_list, &root->prepare_list); 17116cdcec7SMiao Xie else if (mod) 17216cdcec7SMiao Xie list_add_tail(&node->p_list, &root->prepare_list); 17316cdcec7SMiao Xie } else { 17416cdcec7SMiao Xie list_add_tail(&node->n_list, &root->node_list); 17516cdcec7SMiao Xie list_add_tail(&node->p_list, &root->prepare_list); 1766de5f18eSElena Reshetova refcount_inc(&node->refs); /* inserted into list */ 17716cdcec7SMiao Xie root->nodes++; 1787cf35d91SMiao Xie set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); 17916cdcec7SMiao Xie } 18016cdcec7SMiao Xie spin_unlock(&root->lock); 18116cdcec7SMiao Xie } 18216cdcec7SMiao Xie 18316cdcec7SMiao Xie /* Call it when holding delayed_node->mutex */ 18416cdcec7SMiao Xie static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root, 18516cdcec7SMiao Xie struct btrfs_delayed_node *node) 18616cdcec7SMiao Xie { 18716cdcec7SMiao Xie spin_lock(&root->lock); 1887cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 18916cdcec7SMiao Xie root->nodes--; 1906de5f18eSElena Reshetova refcount_dec(&node->refs); /* not in the list */ 19116cdcec7SMiao Xie list_del_init(&node->n_list); 19216cdcec7SMiao Xie if (!list_empty(&node->p_list)) 19316cdcec7SMiao Xie list_del_init(&node->p_list); 1947cf35d91SMiao Xie clear_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); 19516cdcec7SMiao Xie } 19616cdcec7SMiao Xie spin_unlock(&root->lock); 19716cdcec7SMiao Xie } 19816cdcec7SMiao Xie 19948a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_first_delayed_node( 20016cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root) 20116cdcec7SMiao Xie { 20216cdcec7SMiao Xie struct list_head *p; 20316cdcec7SMiao Xie struct btrfs_delayed_node *node = NULL; 20416cdcec7SMiao Xie 20516cdcec7SMiao Xie spin_lock(&delayed_root->lock); 20616cdcec7SMiao Xie if (list_empty(&delayed_root->node_list)) 20716cdcec7SMiao Xie goto out; 20816cdcec7SMiao Xie 20916cdcec7SMiao Xie p = delayed_root->node_list.next; 21016cdcec7SMiao Xie node = list_entry(p, struct btrfs_delayed_node, n_list); 2116de5f18eSElena Reshetova refcount_inc(&node->refs); 21216cdcec7SMiao Xie out: 21316cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 21416cdcec7SMiao Xie 21516cdcec7SMiao Xie return node; 21616cdcec7SMiao Xie } 21716cdcec7SMiao Xie 21848a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_next_delayed_node( 21916cdcec7SMiao Xie struct btrfs_delayed_node *node) 22016cdcec7SMiao Xie { 22116cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 22216cdcec7SMiao Xie struct list_head *p; 22316cdcec7SMiao Xie struct btrfs_delayed_node *next = NULL; 22416cdcec7SMiao Xie 22516cdcec7SMiao Xie delayed_root = node->root->fs_info->delayed_root; 22616cdcec7SMiao Xie spin_lock(&delayed_root->lock); 2277cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 2287cf35d91SMiao Xie /* not in the list */ 22916cdcec7SMiao Xie if (list_empty(&delayed_root->node_list)) 23016cdcec7SMiao Xie goto out; 23116cdcec7SMiao Xie p = delayed_root->node_list.next; 23216cdcec7SMiao Xie } else if (list_is_last(&node->n_list, &delayed_root->node_list)) 23316cdcec7SMiao Xie goto out; 23416cdcec7SMiao Xie else 23516cdcec7SMiao Xie p = node->n_list.next; 23616cdcec7SMiao Xie 23716cdcec7SMiao Xie next = list_entry(p, struct btrfs_delayed_node, n_list); 2386de5f18eSElena Reshetova refcount_inc(&next->refs); 23916cdcec7SMiao Xie out: 24016cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 24116cdcec7SMiao Xie 24216cdcec7SMiao Xie return next; 24316cdcec7SMiao Xie } 24416cdcec7SMiao Xie 24516cdcec7SMiao Xie static void __btrfs_release_delayed_node( 24616cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 24716cdcec7SMiao Xie int mod) 24816cdcec7SMiao Xie { 24916cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 25016cdcec7SMiao Xie 25116cdcec7SMiao Xie if (!delayed_node) 25216cdcec7SMiao Xie return; 25316cdcec7SMiao Xie 25416cdcec7SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 25516cdcec7SMiao Xie 25616cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 25716cdcec7SMiao Xie if (delayed_node->count) 25816cdcec7SMiao Xie btrfs_queue_delayed_node(delayed_root, delayed_node, mod); 25916cdcec7SMiao Xie else 26016cdcec7SMiao Xie btrfs_dequeue_delayed_node(delayed_root, delayed_node); 26116cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 26216cdcec7SMiao Xie 2636de5f18eSElena Reshetova if (refcount_dec_and_test(&delayed_node->refs)) { 26416cdcec7SMiao Xie struct btrfs_root *root = delayed_node->root; 265ec35e48bSChris Mason 26616cdcec7SMiao Xie spin_lock(&root->inode_lock); 267ec35e48bSChris Mason /* 268ec35e48bSChris Mason * Once our refcount goes to zero, nobody is allowed to bump it 269ec35e48bSChris Mason * back up. We can delete it now. 270ec35e48bSChris Mason */ 271ec35e48bSChris Mason ASSERT(refcount_read(&delayed_node->refs) == 0); 272088aea3bSDavid Sterba radix_tree_delete(&root->delayed_nodes_tree, 273088aea3bSDavid Sterba delayed_node->inode_id); 27416cdcec7SMiao Xie spin_unlock(&root->inode_lock); 27596493031SJeff Mahoney kmem_cache_free(delayed_node_cache, delayed_node); 27616cdcec7SMiao Xie } 27716cdcec7SMiao Xie } 27816cdcec7SMiao Xie 27916cdcec7SMiao Xie static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node) 28016cdcec7SMiao Xie { 28116cdcec7SMiao Xie __btrfs_release_delayed_node(node, 0); 28216cdcec7SMiao Xie } 28316cdcec7SMiao Xie 28448a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node( 28516cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root) 28616cdcec7SMiao Xie { 28716cdcec7SMiao Xie struct list_head *p; 28816cdcec7SMiao Xie struct btrfs_delayed_node *node = NULL; 28916cdcec7SMiao Xie 29016cdcec7SMiao Xie spin_lock(&delayed_root->lock); 29116cdcec7SMiao Xie if (list_empty(&delayed_root->prepare_list)) 29216cdcec7SMiao Xie goto out; 29316cdcec7SMiao Xie 29416cdcec7SMiao Xie p = delayed_root->prepare_list.next; 29516cdcec7SMiao Xie list_del_init(p); 29616cdcec7SMiao Xie node = list_entry(p, struct btrfs_delayed_node, p_list); 2976de5f18eSElena Reshetova refcount_inc(&node->refs); 29816cdcec7SMiao Xie out: 29916cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 30016cdcec7SMiao Xie 30116cdcec7SMiao Xie return node; 30216cdcec7SMiao Xie } 30316cdcec7SMiao Xie 30416cdcec7SMiao Xie static inline void btrfs_release_prepared_delayed_node( 30516cdcec7SMiao Xie struct btrfs_delayed_node *node) 30616cdcec7SMiao Xie { 30716cdcec7SMiao Xie __btrfs_release_delayed_node(node, 1); 30816cdcec7SMiao Xie } 30916cdcec7SMiao Xie 3104c469798SFilipe Manana static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u16 data_len, 3114c469798SFilipe Manana struct btrfs_delayed_node *node, 3124c469798SFilipe Manana enum btrfs_delayed_item_type type) 31316cdcec7SMiao Xie { 31416cdcec7SMiao Xie struct btrfs_delayed_item *item; 3154c469798SFilipe Manana 31616cdcec7SMiao Xie item = kmalloc(sizeof(*item) + data_len, GFP_NOFS); 31716cdcec7SMiao Xie if (item) { 31816cdcec7SMiao Xie item->data_len = data_len; 3194c469798SFilipe Manana item->type = type; 32016cdcec7SMiao Xie item->bytes_reserved = 0; 32196d89923SFilipe Manana item->delayed_node = node; 32296d89923SFilipe Manana RB_CLEAR_NODE(&item->rb_node); 32330b80f3cSFilipe Manana INIT_LIST_HEAD(&item->log_list); 32430b80f3cSFilipe Manana item->logged = false; 325089e77e1SElena Reshetova refcount_set(&item->refs, 1); 32616cdcec7SMiao Xie } 32716cdcec7SMiao Xie return item; 32816cdcec7SMiao Xie } 32916cdcec7SMiao Xie 33016cdcec7SMiao Xie /* 33116cdcec7SMiao Xie * __btrfs_lookup_delayed_item - look up the delayed item by key 33216cdcec7SMiao Xie * @delayed_node: pointer to the delayed node 33396d89923SFilipe Manana * @index: the dir index value to lookup (offset of a dir index key) 33416cdcec7SMiao Xie * 33516cdcec7SMiao Xie * Note: if we don't find the right item, we will return the prev item and 33616cdcec7SMiao Xie * the next item. 33716cdcec7SMiao Xie */ 33816cdcec7SMiao Xie static struct btrfs_delayed_item *__btrfs_lookup_delayed_item( 33916cdcec7SMiao Xie struct rb_root *root, 3404cbf37f5SFilipe Manana u64 index) 34116cdcec7SMiao Xie { 3424cbf37f5SFilipe Manana struct rb_node *node = root->rb_node; 34316cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item = NULL; 34416cdcec7SMiao Xie 34516cdcec7SMiao Xie while (node) { 34616cdcec7SMiao Xie delayed_item = rb_entry(node, struct btrfs_delayed_item, 34716cdcec7SMiao Xie rb_node); 34896d89923SFilipe Manana if (delayed_item->index < index) 34916cdcec7SMiao Xie node = node->rb_right; 35096d89923SFilipe Manana else if (delayed_item->index > index) 35116cdcec7SMiao Xie node = node->rb_left; 35216cdcec7SMiao Xie else 35316cdcec7SMiao Xie return delayed_item; 35416cdcec7SMiao Xie } 35516cdcec7SMiao Xie 35616cdcec7SMiao Xie return NULL; 35716cdcec7SMiao Xie } 35816cdcec7SMiao Xie 35916cdcec7SMiao Xie static int __btrfs_add_delayed_item(struct btrfs_delayed_node *delayed_node, 360c9d02ab4SFilipe Manana struct btrfs_delayed_item *ins) 36116cdcec7SMiao Xie { 36216cdcec7SMiao Xie struct rb_node **p, *node; 36316cdcec7SMiao Xie struct rb_node *parent_node = NULL; 36403a1d4c8SLiu Bo struct rb_root_cached *root; 36516cdcec7SMiao Xie struct btrfs_delayed_item *item; 36603a1d4c8SLiu Bo bool leftmost = true; 36716cdcec7SMiao Xie 3684c469798SFilipe Manana if (ins->type == BTRFS_DELAYED_INSERTION_ITEM) 36916cdcec7SMiao Xie root = &delayed_node->ins_root; 37016cdcec7SMiao Xie else 3714c469798SFilipe Manana root = &delayed_node->del_root; 3724c469798SFilipe Manana 37303a1d4c8SLiu Bo p = &root->rb_root.rb_node; 37416cdcec7SMiao Xie node = &ins->rb_node; 37516cdcec7SMiao Xie 37616cdcec7SMiao Xie while (*p) { 37716cdcec7SMiao Xie parent_node = *p; 37816cdcec7SMiao Xie item = rb_entry(parent_node, struct btrfs_delayed_item, 37916cdcec7SMiao Xie rb_node); 38016cdcec7SMiao Xie 38196d89923SFilipe Manana if (item->index < ins->index) { 38216cdcec7SMiao Xie p = &(*p)->rb_right; 38303a1d4c8SLiu Bo leftmost = false; 38496d89923SFilipe Manana } else if (item->index > ins->index) { 38516cdcec7SMiao Xie p = &(*p)->rb_left; 38603a1d4c8SLiu Bo } else { 38716cdcec7SMiao Xie return -EEXIST; 38816cdcec7SMiao Xie } 38903a1d4c8SLiu Bo } 39016cdcec7SMiao Xie 39116cdcec7SMiao Xie rb_link_node(node, parent_node, p); 39203a1d4c8SLiu Bo rb_insert_color_cached(node, root, leftmost); 393a176affeSFilipe Manana 3944c469798SFilipe Manana if (ins->type == BTRFS_DELAYED_INSERTION_ITEM && 39596d89923SFilipe Manana ins->index >= delayed_node->index_cnt) 39696d89923SFilipe Manana delayed_node->index_cnt = ins->index + 1; 39716cdcec7SMiao Xie 39816cdcec7SMiao Xie delayed_node->count++; 39916cdcec7SMiao Xie atomic_inc(&delayed_node->root->fs_info->delayed_root->items); 40016cdcec7SMiao Xie return 0; 40116cdcec7SMiao Xie } 40216cdcec7SMiao Xie 403de3cb945SChris Mason static void finish_one_item(struct btrfs_delayed_root *delayed_root) 404de3cb945SChris Mason { 405de3cb945SChris Mason int seq = atomic_inc_return(&delayed_root->items_seq); 406ee863954SDavid Sterba 407093258e6SDavid Sterba /* atomic_dec_return implies a barrier */ 408de3cb945SChris Mason if ((atomic_dec_return(&delayed_root->items) < 409093258e6SDavid Sterba BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0)) 410093258e6SDavid Sterba cond_wake_up_nomb(&delayed_root->wait); 411de3cb945SChris Mason } 412de3cb945SChris Mason 41316cdcec7SMiao Xie static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item) 41416cdcec7SMiao Xie { 41503a1d4c8SLiu Bo struct rb_root_cached *root; 41616cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 41716cdcec7SMiao Xie 41896d89923SFilipe Manana /* Not inserted, ignore it. */ 41996d89923SFilipe Manana if (RB_EMPTY_NODE(&delayed_item->rb_node)) 420933c22a7SQu Wenruo return; 42196d89923SFilipe Manana 42216cdcec7SMiao Xie delayed_root = delayed_item->delayed_node->root->fs_info->delayed_root; 42316cdcec7SMiao Xie 42416cdcec7SMiao Xie BUG_ON(!delayed_root); 42516cdcec7SMiao Xie 4264c469798SFilipe Manana if (delayed_item->type == BTRFS_DELAYED_INSERTION_ITEM) 42716cdcec7SMiao Xie root = &delayed_item->delayed_node->ins_root; 42816cdcec7SMiao Xie else 42916cdcec7SMiao Xie root = &delayed_item->delayed_node->del_root; 43016cdcec7SMiao Xie 43103a1d4c8SLiu Bo rb_erase_cached(&delayed_item->rb_node, root); 43296d89923SFilipe Manana RB_CLEAR_NODE(&delayed_item->rb_node); 43316cdcec7SMiao Xie delayed_item->delayed_node->count--; 434de3cb945SChris Mason 435de3cb945SChris Mason finish_one_item(delayed_root); 43616cdcec7SMiao Xie } 43716cdcec7SMiao Xie 43816cdcec7SMiao Xie static void btrfs_release_delayed_item(struct btrfs_delayed_item *item) 43916cdcec7SMiao Xie { 44016cdcec7SMiao Xie if (item) { 44116cdcec7SMiao Xie __btrfs_remove_delayed_item(item); 442089e77e1SElena Reshetova if (refcount_dec_and_test(&item->refs)) 44316cdcec7SMiao Xie kfree(item); 44416cdcec7SMiao Xie } 44516cdcec7SMiao Xie } 44616cdcec7SMiao Xie 44748a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_first_delayed_insertion_item( 44816cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node) 44916cdcec7SMiao Xie { 45016cdcec7SMiao Xie struct rb_node *p; 45116cdcec7SMiao Xie struct btrfs_delayed_item *item = NULL; 45216cdcec7SMiao Xie 45303a1d4c8SLiu Bo p = rb_first_cached(&delayed_node->ins_root); 45416cdcec7SMiao Xie if (p) 45516cdcec7SMiao Xie item = rb_entry(p, struct btrfs_delayed_item, rb_node); 45616cdcec7SMiao Xie 45716cdcec7SMiao Xie return item; 45816cdcec7SMiao Xie } 45916cdcec7SMiao Xie 46048a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_first_delayed_deletion_item( 46116cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node) 46216cdcec7SMiao Xie { 46316cdcec7SMiao Xie struct rb_node *p; 46416cdcec7SMiao Xie struct btrfs_delayed_item *item = NULL; 46516cdcec7SMiao Xie 46603a1d4c8SLiu Bo p = rb_first_cached(&delayed_node->del_root); 46716cdcec7SMiao Xie if (p) 46816cdcec7SMiao Xie item = rb_entry(p, struct btrfs_delayed_item, rb_node); 46916cdcec7SMiao Xie 47016cdcec7SMiao Xie return item; 47116cdcec7SMiao Xie } 47216cdcec7SMiao Xie 47348a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_next_delayed_item( 47416cdcec7SMiao Xie struct btrfs_delayed_item *item) 47516cdcec7SMiao Xie { 47616cdcec7SMiao Xie struct rb_node *p; 47716cdcec7SMiao Xie struct btrfs_delayed_item *next = NULL; 47816cdcec7SMiao Xie 47916cdcec7SMiao Xie p = rb_next(&item->rb_node); 48016cdcec7SMiao Xie if (p) 48116cdcec7SMiao Xie next = rb_entry(p, struct btrfs_delayed_item, rb_node); 48216cdcec7SMiao Xie 48316cdcec7SMiao Xie return next; 48416cdcec7SMiao Xie } 48516cdcec7SMiao Xie 48616cdcec7SMiao Xie static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans, 48716cdcec7SMiao Xie struct btrfs_delayed_item *item) 48816cdcec7SMiao Xie { 48916cdcec7SMiao Xie struct btrfs_block_rsv *src_rsv; 49016cdcec7SMiao Xie struct btrfs_block_rsv *dst_rsv; 491df492881SFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 49216cdcec7SMiao Xie u64 num_bytes; 49316cdcec7SMiao Xie int ret; 49416cdcec7SMiao Xie 49516cdcec7SMiao Xie if (!trans->bytes_reserved) 49616cdcec7SMiao Xie return 0; 49716cdcec7SMiao Xie 49816cdcec7SMiao Xie src_rsv = trans->block_rsv; 4990b246afaSJeff Mahoney dst_rsv = &fs_info->delayed_block_rsv; 50016cdcec7SMiao Xie 5012bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, 1); 502f218ea6cSQu Wenruo 503f218ea6cSQu Wenruo /* 504f218ea6cSQu Wenruo * Here we migrate space rsv from transaction rsv, since have already 505f218ea6cSQu Wenruo * reserved space when starting a transaction. So no need to reserve 506f218ea6cSQu Wenruo * qgroup space here. 507f218ea6cSQu Wenruo */ 5083a584174SLu Fengqi ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true); 5098c2a3ca2SJosef Bacik if (!ret) { 5100b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_item", 51196d89923SFilipe Manana item->delayed_node->inode_id, 5128c2a3ca2SJosef Bacik num_bytes, 1); 513763748b2SFilipe Manana /* 514763748b2SFilipe Manana * For insertions we track reserved metadata space by accounting 515763748b2SFilipe Manana * for the number of leaves that will be used, based on the delayed 516763748b2SFilipe Manana * node's index_items_size field. 517763748b2SFilipe Manana */ 5184c469798SFilipe Manana if (item->type == BTRFS_DELAYED_DELETION_ITEM) 51916cdcec7SMiao Xie item->bytes_reserved = num_bytes; 5208c2a3ca2SJosef Bacik } 52116cdcec7SMiao Xie 52216cdcec7SMiao Xie return ret; 52316cdcec7SMiao Xie } 52416cdcec7SMiao Xie 5254f5427ccSQu Wenruo static void btrfs_delayed_item_release_metadata(struct btrfs_root *root, 52616cdcec7SMiao Xie struct btrfs_delayed_item *item) 52716cdcec7SMiao Xie { 52819fd2949SMiao Xie struct btrfs_block_rsv *rsv; 5294f5427ccSQu Wenruo struct btrfs_fs_info *fs_info = root->fs_info; 53019fd2949SMiao Xie 53116cdcec7SMiao Xie if (!item->bytes_reserved) 53216cdcec7SMiao Xie return; 53316cdcec7SMiao Xie 5340b246afaSJeff Mahoney rsv = &fs_info->delayed_block_rsv; 535f218ea6cSQu Wenruo /* 536f218ea6cSQu Wenruo * Check btrfs_delayed_item_reserve_metadata() to see why we don't need 537f218ea6cSQu Wenruo * to release/reserve qgroup space. 538f218ea6cSQu Wenruo */ 5390b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_item", 54096d89923SFilipe Manana item->delayed_node->inode_id, 54196d89923SFilipe Manana item->bytes_reserved, 0); 54263f018beSNikolay Borisov btrfs_block_rsv_release(fs_info, rsv, item->bytes_reserved, NULL); 54316cdcec7SMiao Xie } 54416cdcec7SMiao Xie 545763748b2SFilipe Manana static void btrfs_delayed_item_release_leaves(struct btrfs_delayed_node *node, 546763748b2SFilipe Manana unsigned int num_leaves) 547763748b2SFilipe Manana { 548763748b2SFilipe Manana struct btrfs_fs_info *fs_info = node->root->fs_info; 549763748b2SFilipe Manana const u64 bytes = btrfs_calc_insert_metadata_size(fs_info, num_leaves); 550763748b2SFilipe Manana 551763748b2SFilipe Manana /* There are no space reservations during log replay, bail out. */ 552763748b2SFilipe Manana if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 553763748b2SFilipe Manana return; 554763748b2SFilipe Manana 555763748b2SFilipe Manana trace_btrfs_space_reservation(fs_info, "delayed_item", node->inode_id, 556763748b2SFilipe Manana bytes, 0); 557763748b2SFilipe Manana btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv, bytes, NULL); 558763748b2SFilipe Manana } 559763748b2SFilipe Manana 56016cdcec7SMiao Xie static int btrfs_delayed_inode_reserve_metadata( 56116cdcec7SMiao Xie struct btrfs_trans_handle *trans, 56216cdcec7SMiao Xie struct btrfs_root *root, 56316cdcec7SMiao Xie struct btrfs_delayed_node *node) 56416cdcec7SMiao Xie { 5650b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 56616cdcec7SMiao Xie struct btrfs_block_rsv *src_rsv; 56716cdcec7SMiao Xie struct btrfs_block_rsv *dst_rsv; 56816cdcec7SMiao Xie u64 num_bytes; 56916cdcec7SMiao Xie int ret; 57016cdcec7SMiao Xie 57116cdcec7SMiao Xie src_rsv = trans->block_rsv; 5720b246afaSJeff Mahoney dst_rsv = &fs_info->delayed_block_rsv; 57316cdcec7SMiao Xie 574bcacf5f3SJosef Bacik num_bytes = btrfs_calc_metadata_size(fs_info, 1); 575c06a0e12SJosef Bacik 576c06a0e12SJosef Bacik /* 577c06a0e12SJosef Bacik * btrfs_dirty_inode will update the inode under btrfs_join_transaction 578c06a0e12SJosef Bacik * which doesn't reserve space for speed. This is a problem since we 579c06a0e12SJosef Bacik * still need to reserve space for this update, so try to reserve the 580c06a0e12SJosef Bacik * space. 581c06a0e12SJosef Bacik * 582c06a0e12SJosef Bacik * Now if src_rsv == delalloc_block_rsv we'll let it just steal since 58369fe2d75SJosef Bacik * we always reserve enough to update the inode item. 584c06a0e12SJosef Bacik */ 585e755d9abSChris Mason if (!src_rsv || (!trans->bytes_reserved && 58666d8f3ddSMiao Xie src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) { 5874d14c5cdSNikolay Borisov ret = btrfs_qgroup_reserve_meta(root, num_bytes, 5884d14c5cdSNikolay Borisov BTRFS_QGROUP_RSV_META_PREALLOC, true); 589f218ea6cSQu Wenruo if (ret < 0) 590f218ea6cSQu Wenruo return ret; 5919270501cSJosef Bacik ret = btrfs_block_rsv_add(fs_info, dst_rsv, num_bytes, 59208e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 59398686ffcSNikolay Borisov /* NO_FLUSH could only fail with -ENOSPC */ 59498686ffcSNikolay Borisov ASSERT(ret == 0 || ret == -ENOSPC); 59598686ffcSNikolay Borisov if (ret) 5964f5427ccSQu Wenruo btrfs_qgroup_free_meta_prealloc(root, num_bytes); 597f218ea6cSQu Wenruo } else { 59898686ffcSNikolay Borisov ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, true); 599c06a0e12SJosef Bacik } 600c06a0e12SJosef Bacik 6018c2a3ca2SJosef Bacik if (!ret) { 6020b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_inode", 6038e3c9d3cSNikolay Borisov node->inode_id, num_bytes, 1); 60416cdcec7SMiao Xie node->bytes_reserved = num_bytes; 6058c2a3ca2SJosef Bacik } 60616cdcec7SMiao Xie 60716cdcec7SMiao Xie return ret; 60816cdcec7SMiao Xie } 60916cdcec7SMiao Xie 6102ff7e61eSJeff Mahoney static void btrfs_delayed_inode_release_metadata(struct btrfs_fs_info *fs_info, 6114f5427ccSQu Wenruo struct btrfs_delayed_node *node, 6124f5427ccSQu Wenruo bool qgroup_free) 61316cdcec7SMiao Xie { 61416cdcec7SMiao Xie struct btrfs_block_rsv *rsv; 61516cdcec7SMiao Xie 61616cdcec7SMiao Xie if (!node->bytes_reserved) 61716cdcec7SMiao Xie return; 61816cdcec7SMiao Xie 6190b246afaSJeff Mahoney rsv = &fs_info->delayed_block_rsv; 6200b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_inode", 6218c2a3ca2SJosef Bacik node->inode_id, node->bytes_reserved, 0); 62263f018beSNikolay Borisov btrfs_block_rsv_release(fs_info, rsv, node->bytes_reserved, NULL); 6234f5427ccSQu Wenruo if (qgroup_free) 6244f5427ccSQu Wenruo btrfs_qgroup_free_meta_prealloc(node->root, 6254f5427ccSQu Wenruo node->bytes_reserved); 6264f5427ccSQu Wenruo else 6274f5427ccSQu Wenruo btrfs_qgroup_convert_reserved_meta(node->root, 6284f5427ccSQu Wenruo node->bytes_reserved); 62916cdcec7SMiao Xie node->bytes_reserved = 0; 63016cdcec7SMiao Xie } 63116cdcec7SMiao Xie 63216cdcec7SMiao Xie /* 63306ac264fSFilipe Manana * Insert a single delayed item or a batch of delayed items, as many as possible 63406ac264fSFilipe Manana * that fit in a leaf. The delayed items (dir index keys) are sorted by their key 63506ac264fSFilipe Manana * in the rbtree, and if there's a gap between two consecutive dir index items, 63606ac264fSFilipe Manana * then it means at some point we had delayed dir indexes to add but they got 63706ac264fSFilipe Manana * removed (by btrfs_delete_delayed_dir_index()) before we attempted to flush them 63806ac264fSFilipe Manana * into the subvolume tree. Dir index keys also have their offsets coming from a 63906ac264fSFilipe Manana * monotonically increasing counter, so we can't get new keys with an offset that 64006ac264fSFilipe Manana * fits within a gap between delayed dir index items. 64116cdcec7SMiao Xie */ 64216cdcec7SMiao Xie static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans, 64316cdcec7SMiao Xie struct btrfs_root *root, 64416cdcec7SMiao Xie struct btrfs_path *path, 645506650dcSFilipe Manana struct btrfs_delayed_item *first_item) 64616cdcec7SMiao Xie { 647763748b2SFilipe Manana struct btrfs_fs_info *fs_info = root->fs_info; 648763748b2SFilipe Manana struct btrfs_delayed_node *node = first_item->delayed_node; 649b7ef5f3aSFilipe Manana LIST_HEAD(item_list); 650506650dcSFilipe Manana struct btrfs_delayed_item *curr; 651506650dcSFilipe Manana struct btrfs_delayed_item *next; 652763748b2SFilipe Manana const int max_size = BTRFS_LEAF_DATA_SIZE(fs_info); 653b7ef5f3aSFilipe Manana struct btrfs_item_batch batch; 65496d89923SFilipe Manana struct btrfs_key first_key; 6554c469798SFilipe Manana const u32 first_data_size = first_item->data_len; 656506650dcSFilipe Manana int total_size; 657506650dcSFilipe Manana char *ins_data = NULL; 65816cdcec7SMiao Xie int ret; 65971b68e9eSJosef Bacik bool continuous_keys_only = false; 66016cdcec7SMiao Xie 661763748b2SFilipe Manana lockdep_assert_held(&node->mutex); 662763748b2SFilipe Manana 663763748b2SFilipe Manana /* 66471b68e9eSJosef Bacik * During normal operation the delayed index offset is continuously 66571b68e9eSJosef Bacik * increasing, so we can batch insert all items as there will not be any 66671b68e9eSJosef Bacik * overlapping keys in the tree. 66771b68e9eSJosef Bacik * 66871b68e9eSJosef Bacik * The exception to this is log replay, where we may have interleaved 66971b68e9eSJosef Bacik * offsets in the tree, so our batch needs to be continuous keys only in 67071b68e9eSJosef Bacik * order to ensure we do not end up with out of order items in our leaf. 67171b68e9eSJosef Bacik */ 67271b68e9eSJosef Bacik if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 67371b68e9eSJosef Bacik continuous_keys_only = true; 67471b68e9eSJosef Bacik 67571b68e9eSJosef Bacik /* 676763748b2SFilipe Manana * For delayed items to insert, we track reserved metadata bytes based 677763748b2SFilipe Manana * on the number of leaves that we will use. 678763748b2SFilipe Manana * See btrfs_insert_delayed_dir_index() and 679763748b2SFilipe Manana * btrfs_delayed_item_reserve_metadata()). 680763748b2SFilipe Manana */ 681763748b2SFilipe Manana ASSERT(first_item->bytes_reserved == 0); 682763748b2SFilipe Manana 683b7ef5f3aSFilipe Manana list_add_tail(&first_item->tree_list, &item_list); 6844c469798SFilipe Manana batch.total_data_size = first_data_size; 685b7ef5f3aSFilipe Manana batch.nr = 1; 6864c469798SFilipe Manana total_size = first_data_size + sizeof(struct btrfs_item); 687506650dcSFilipe Manana curr = first_item; 688506650dcSFilipe Manana 689506650dcSFilipe Manana while (true) { 690506650dcSFilipe Manana int next_size; 691506650dcSFilipe Manana 692506650dcSFilipe Manana next = __btrfs_next_delayed_item(curr); 69306ac264fSFilipe Manana if (!next) 694506650dcSFilipe Manana break; 695506650dcSFilipe Manana 69671b68e9eSJosef Bacik /* 69771b68e9eSJosef Bacik * We cannot allow gaps in the key space if we're doing log 69871b68e9eSJosef Bacik * replay. 69971b68e9eSJosef Bacik */ 70096d89923SFilipe Manana if (continuous_keys_only && (next->index != curr->index + 1)) 70171b68e9eSJosef Bacik break; 70271b68e9eSJosef Bacik 703763748b2SFilipe Manana ASSERT(next->bytes_reserved == 0); 704763748b2SFilipe Manana 705506650dcSFilipe Manana next_size = next->data_len + sizeof(struct btrfs_item); 706506650dcSFilipe Manana if (total_size + next_size > max_size) 707506650dcSFilipe Manana break; 708506650dcSFilipe Manana 709b7ef5f3aSFilipe Manana list_add_tail(&next->tree_list, &item_list); 710b7ef5f3aSFilipe Manana batch.nr++; 711506650dcSFilipe Manana total_size += next_size; 712b7ef5f3aSFilipe Manana batch.total_data_size += next->data_len; 713506650dcSFilipe Manana curr = next; 714506650dcSFilipe Manana } 715506650dcSFilipe Manana 716b7ef5f3aSFilipe Manana if (batch.nr == 1) { 71796d89923SFilipe Manana first_key.objectid = node->inode_id; 71896d89923SFilipe Manana first_key.type = BTRFS_DIR_INDEX_KEY; 71996d89923SFilipe Manana first_key.offset = first_item->index; 72096d89923SFilipe Manana batch.keys = &first_key; 7214c469798SFilipe Manana batch.data_sizes = &first_data_size; 722506650dcSFilipe Manana } else { 723b7ef5f3aSFilipe Manana struct btrfs_key *ins_keys; 724b7ef5f3aSFilipe Manana u32 *ins_sizes; 725506650dcSFilipe Manana int i = 0; 726506650dcSFilipe Manana 727b7ef5f3aSFilipe Manana ins_data = kmalloc(batch.nr * sizeof(u32) + 728b7ef5f3aSFilipe Manana batch.nr * sizeof(struct btrfs_key), GFP_NOFS); 729506650dcSFilipe Manana if (!ins_data) { 730506650dcSFilipe Manana ret = -ENOMEM; 731506650dcSFilipe Manana goto out; 732506650dcSFilipe Manana } 733506650dcSFilipe Manana ins_sizes = (u32 *)ins_data; 734b7ef5f3aSFilipe Manana ins_keys = (struct btrfs_key *)(ins_data + batch.nr * sizeof(u32)); 735b7ef5f3aSFilipe Manana batch.keys = ins_keys; 736b7ef5f3aSFilipe Manana batch.data_sizes = ins_sizes; 737b7ef5f3aSFilipe Manana list_for_each_entry(curr, &item_list, tree_list) { 73896d89923SFilipe Manana ins_keys[i].objectid = node->inode_id; 73996d89923SFilipe Manana ins_keys[i].type = BTRFS_DIR_INDEX_KEY; 74096d89923SFilipe Manana ins_keys[i].offset = curr->index; 741506650dcSFilipe Manana ins_sizes[i] = curr->data_len; 742506650dcSFilipe Manana i++; 743506650dcSFilipe Manana } 744506650dcSFilipe Manana } 745506650dcSFilipe Manana 746b7ef5f3aSFilipe Manana ret = btrfs_insert_empty_items(trans, root, path, &batch); 747506650dcSFilipe Manana if (ret) 748506650dcSFilipe Manana goto out; 74916cdcec7SMiao Xie 750b7ef5f3aSFilipe Manana list_for_each_entry(curr, &item_list, tree_list) { 751506650dcSFilipe Manana char *data_ptr; 75216cdcec7SMiao Xie 753506650dcSFilipe Manana data_ptr = btrfs_item_ptr(path->nodes[0], path->slots[0], char); 754506650dcSFilipe Manana write_extent_buffer(path->nodes[0], &curr->data, 755506650dcSFilipe Manana (unsigned long)data_ptr, curr->data_len); 756506650dcSFilipe Manana path->slots[0]++; 75716cdcec7SMiao Xie } 75816cdcec7SMiao Xie 75916cdcec7SMiao Xie /* 760506650dcSFilipe Manana * Now release our path before releasing the delayed items and their 761506650dcSFilipe Manana * metadata reservations, so that we don't block other tasks for more 762506650dcSFilipe Manana * time than needed. 76316cdcec7SMiao Xie */ 764506650dcSFilipe Manana btrfs_release_path(path); 765506650dcSFilipe Manana 766763748b2SFilipe Manana ASSERT(node->index_item_leaves > 0); 767763748b2SFilipe Manana 76871b68e9eSJosef Bacik /* 76971b68e9eSJosef Bacik * For normal operations we will batch an entire leaf's worth of delayed 77071b68e9eSJosef Bacik * items, so if there are more items to process we can decrement 77171b68e9eSJosef Bacik * index_item_leaves by 1 as we inserted 1 leaf's worth of items. 77271b68e9eSJosef Bacik * 77371b68e9eSJosef Bacik * However for log replay we may not have inserted an entire leaf's 77471b68e9eSJosef Bacik * worth of items, we may have not had continuous items, so decrementing 77571b68e9eSJosef Bacik * here would mess up the index_item_leaves accounting. For this case 77671b68e9eSJosef Bacik * only clean up the accounting when there are no items left. 77771b68e9eSJosef Bacik */ 77871b68e9eSJosef Bacik if (next && !continuous_keys_only) { 779763748b2SFilipe Manana /* 780763748b2SFilipe Manana * We inserted one batch of items into a leaf a there are more 781763748b2SFilipe Manana * items to flush in a future batch, now release one unit of 782763748b2SFilipe Manana * metadata space from the delayed block reserve, corresponding 783763748b2SFilipe Manana * the leaf we just flushed to. 784763748b2SFilipe Manana */ 785763748b2SFilipe Manana btrfs_delayed_item_release_leaves(node, 1); 786763748b2SFilipe Manana node->index_item_leaves--; 78771b68e9eSJosef Bacik } else if (!next) { 788763748b2SFilipe Manana /* 789763748b2SFilipe Manana * There are no more items to insert. We can have a number of 790763748b2SFilipe Manana * reserved leaves > 1 here - this happens when many dir index 791763748b2SFilipe Manana * items are added and then removed before they are flushed (file 792763748b2SFilipe Manana * names with a very short life, never span a transaction). So 793763748b2SFilipe Manana * release all remaining leaves. 794763748b2SFilipe Manana */ 795763748b2SFilipe Manana btrfs_delayed_item_release_leaves(node, node->index_item_leaves); 796763748b2SFilipe Manana node->index_item_leaves = 0; 797763748b2SFilipe Manana } 798763748b2SFilipe Manana 799b7ef5f3aSFilipe Manana list_for_each_entry_safe(curr, next, &item_list, tree_list) { 800506650dcSFilipe Manana list_del(&curr->tree_list); 801506650dcSFilipe Manana btrfs_release_delayed_item(curr); 802506650dcSFilipe Manana } 803506650dcSFilipe Manana out: 804506650dcSFilipe Manana kfree(ins_data); 805506650dcSFilipe Manana return ret; 806506650dcSFilipe Manana } 807506650dcSFilipe Manana 80816cdcec7SMiao Xie static int btrfs_insert_delayed_items(struct btrfs_trans_handle *trans, 80916cdcec7SMiao Xie struct btrfs_path *path, 81016cdcec7SMiao Xie struct btrfs_root *root, 81116cdcec7SMiao Xie struct btrfs_delayed_node *node) 81216cdcec7SMiao Xie { 81316cdcec7SMiao Xie int ret = 0; 81416cdcec7SMiao Xie 815506650dcSFilipe Manana while (ret == 0) { 816506650dcSFilipe Manana struct btrfs_delayed_item *curr; 817506650dcSFilipe Manana 81816cdcec7SMiao Xie mutex_lock(&node->mutex); 81916cdcec7SMiao Xie curr = __btrfs_first_delayed_insertion_item(node); 820506650dcSFilipe Manana if (!curr) { 821506650dcSFilipe Manana mutex_unlock(&node->mutex); 822506650dcSFilipe Manana break; 823506650dcSFilipe Manana } 82416cdcec7SMiao Xie ret = btrfs_insert_delayed_item(trans, root, path, curr); 825506650dcSFilipe Manana mutex_unlock(&node->mutex); 82616cdcec7SMiao Xie } 82716cdcec7SMiao Xie 82816cdcec7SMiao Xie return ret; 82916cdcec7SMiao Xie } 83016cdcec7SMiao Xie 83116cdcec7SMiao Xie static int btrfs_batch_delete_items(struct btrfs_trans_handle *trans, 83216cdcec7SMiao Xie struct btrfs_root *root, 83316cdcec7SMiao Xie struct btrfs_path *path, 83416cdcec7SMiao Xie struct btrfs_delayed_item *item) 83516cdcec7SMiao Xie { 83696d89923SFilipe Manana const u64 ino = item->delayed_node->inode_id; 8371f4f639fSNikolay Borisov struct btrfs_fs_info *fs_info = root->fs_info; 83816cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 839659192e6SFilipe Manana struct extent_buffer *leaf = path->nodes[0]; 8404bd02d90SFilipe Manana LIST_HEAD(batch_list); 8414bd02d90SFilipe Manana int nitems, slot, last_slot; 8424bd02d90SFilipe Manana int ret; 8431f4f639fSNikolay Borisov u64 total_reserved_size = item->bytes_reserved; 84416cdcec7SMiao Xie 845659192e6SFilipe Manana ASSERT(leaf != NULL); 84616cdcec7SMiao Xie 8474bd02d90SFilipe Manana slot = path->slots[0]; 8484bd02d90SFilipe Manana last_slot = btrfs_header_nritems(leaf) - 1; 849659192e6SFilipe Manana /* 850659192e6SFilipe Manana * Our caller always gives us a path pointing to an existing item, so 851659192e6SFilipe Manana * this can not happen. 852659192e6SFilipe Manana */ 8534bd02d90SFilipe Manana ASSERT(slot <= last_slot); 8544bd02d90SFilipe Manana if (WARN_ON(slot > last_slot)) 855659192e6SFilipe Manana return -ENOENT; 85616cdcec7SMiao Xie 8574bd02d90SFilipe Manana nitems = 1; 8584bd02d90SFilipe Manana curr = item; 8594bd02d90SFilipe Manana list_add_tail(&curr->tree_list, &batch_list); 86016cdcec7SMiao Xie 8614bd02d90SFilipe Manana /* 8624bd02d90SFilipe Manana * Keep checking if the next delayed item matches the next item in the 8634bd02d90SFilipe Manana * leaf - if so, we can add it to the batch of items to delete from the 8644bd02d90SFilipe Manana * leaf. 8654bd02d90SFilipe Manana */ 8664bd02d90SFilipe Manana while (slot < last_slot) { 8674bd02d90SFilipe Manana struct btrfs_key key; 8684bd02d90SFilipe Manana 86916cdcec7SMiao Xie next = __btrfs_next_delayed_item(curr); 87016cdcec7SMiao Xie if (!next) 87116cdcec7SMiao Xie break; 87216cdcec7SMiao Xie 8734bd02d90SFilipe Manana slot++; 8744bd02d90SFilipe Manana btrfs_item_key_to_cpu(leaf, &key, slot); 87596d89923SFilipe Manana if (key.objectid != ino || 87696d89923SFilipe Manana key.type != BTRFS_DIR_INDEX_KEY || 87796d89923SFilipe Manana key.offset != next->index) 87816cdcec7SMiao Xie break; 8794bd02d90SFilipe Manana nitems++; 8804bd02d90SFilipe Manana curr = next; 8814bd02d90SFilipe Manana list_add_tail(&curr->tree_list, &batch_list); 8821f4f639fSNikolay Borisov total_reserved_size += curr->bytes_reserved; 88316cdcec7SMiao Xie } 88416cdcec7SMiao Xie 88516cdcec7SMiao Xie ret = btrfs_del_items(trans, root, path, path->slots[0], nitems); 88616cdcec7SMiao Xie if (ret) 8874bd02d90SFilipe Manana return ret; 88816cdcec7SMiao Xie 8891f4f639fSNikolay Borisov /* In case of BTRFS_FS_LOG_RECOVERING items won't have reserved space */ 8901f4f639fSNikolay Borisov if (total_reserved_size > 0) { 8911f4f639fSNikolay Borisov /* 8921f4f639fSNikolay Borisov * Check btrfs_delayed_item_reserve_metadata() to see why we 8931f4f639fSNikolay Borisov * don't need to release/reserve qgroup space. 8941f4f639fSNikolay Borisov */ 89596d89923SFilipe Manana trace_btrfs_space_reservation(fs_info, "delayed_item", ino, 89696d89923SFilipe Manana total_reserved_size, 0); 8971f4f639fSNikolay Borisov btrfs_block_rsv_release(fs_info, &fs_info->delayed_block_rsv, 8981f4f639fSNikolay Borisov total_reserved_size, NULL); 8991f4f639fSNikolay Borisov } 9001f4f639fSNikolay Borisov 9014bd02d90SFilipe Manana list_for_each_entry_safe(curr, next, &batch_list, tree_list) { 90216cdcec7SMiao Xie list_del(&curr->tree_list); 90316cdcec7SMiao Xie btrfs_release_delayed_item(curr); 90416cdcec7SMiao Xie } 90516cdcec7SMiao Xie 9064bd02d90SFilipe Manana return 0; 90716cdcec7SMiao Xie } 90816cdcec7SMiao Xie 90916cdcec7SMiao Xie static int btrfs_delete_delayed_items(struct btrfs_trans_handle *trans, 91016cdcec7SMiao Xie struct btrfs_path *path, 91116cdcec7SMiao Xie struct btrfs_root *root, 91216cdcec7SMiao Xie struct btrfs_delayed_node *node) 91316cdcec7SMiao Xie { 91496d89923SFilipe Manana struct btrfs_key key; 91516cdcec7SMiao Xie int ret = 0; 91616cdcec7SMiao Xie 91796d89923SFilipe Manana key.objectid = node->inode_id; 91896d89923SFilipe Manana key.type = BTRFS_DIR_INDEX_KEY; 91996d89923SFilipe Manana 92036baa2c7SFilipe Manana while (ret == 0) { 92136baa2c7SFilipe Manana struct btrfs_delayed_item *item; 92216cdcec7SMiao Xie 92336baa2c7SFilipe Manana mutex_lock(&node->mutex); 92436baa2c7SFilipe Manana item = __btrfs_first_delayed_deletion_item(node); 92536baa2c7SFilipe Manana if (!item) { 92662095265SFengguang Wu mutex_unlock(&node->mutex); 92736baa2c7SFilipe Manana break; 92816cdcec7SMiao Xie } 92916cdcec7SMiao Xie 93096d89923SFilipe Manana key.offset = item->index; 93196d89923SFilipe Manana ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 93236baa2c7SFilipe Manana if (ret > 0) { 93336baa2c7SFilipe Manana /* 93436baa2c7SFilipe Manana * There's no matching item in the leaf. This means we 93536baa2c7SFilipe Manana * have already deleted this item in a past run of the 93636baa2c7SFilipe Manana * delayed items. We ignore errors when running delayed 93736baa2c7SFilipe Manana * items from an async context, through a work queue job 93836baa2c7SFilipe Manana * running btrfs_async_run_delayed_root(), and don't 93936baa2c7SFilipe Manana * release delayed items that failed to complete. This 94036baa2c7SFilipe Manana * is because we will retry later, and at transaction 94136baa2c7SFilipe Manana * commit time we always run delayed items and will 94236baa2c7SFilipe Manana * then deal with errors if they fail to run again. 94336baa2c7SFilipe Manana * 94436baa2c7SFilipe Manana * So just release delayed items for which we can't find 94536baa2c7SFilipe Manana * an item in the tree, and move to the next item. 94636baa2c7SFilipe Manana */ 947945d8962SChris Mason btrfs_release_path(path); 94836baa2c7SFilipe Manana btrfs_release_delayed_item(item); 94936baa2c7SFilipe Manana ret = 0; 95036baa2c7SFilipe Manana } else if (ret == 0) { 95136baa2c7SFilipe Manana ret = btrfs_batch_delete_items(trans, root, path, item); 95236baa2c7SFilipe Manana btrfs_release_path(path); 95336baa2c7SFilipe Manana } 95416cdcec7SMiao Xie 95536baa2c7SFilipe Manana /* 95636baa2c7SFilipe Manana * We unlock and relock on each iteration, this is to prevent 95736baa2c7SFilipe Manana * blocking other tasks for too long while we are being run from 95836baa2c7SFilipe Manana * the async context (work queue job). Those tasks are typically 95936baa2c7SFilipe Manana * running system calls like creat/mkdir/rename/unlink/etc which 96036baa2c7SFilipe Manana * need to add delayed items to this delayed node. 96136baa2c7SFilipe Manana */ 96216cdcec7SMiao Xie mutex_unlock(&node->mutex); 96336baa2c7SFilipe Manana } 96436baa2c7SFilipe Manana 96516cdcec7SMiao Xie return ret; 96616cdcec7SMiao Xie } 96716cdcec7SMiao Xie 96816cdcec7SMiao Xie static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node) 96916cdcec7SMiao Xie { 97016cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 97116cdcec7SMiao Xie 9727cf35d91SMiao Xie if (delayed_node && 9737cf35d91SMiao Xie test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 97416cdcec7SMiao Xie BUG_ON(!delayed_node->root); 9757cf35d91SMiao Xie clear_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); 97616cdcec7SMiao Xie delayed_node->count--; 97716cdcec7SMiao Xie 97816cdcec7SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 979de3cb945SChris Mason finish_one_item(delayed_root); 98016cdcec7SMiao Xie } 98116cdcec7SMiao Xie } 98216cdcec7SMiao Xie 98367de1176SMiao Xie static void btrfs_release_delayed_iref(struct btrfs_delayed_node *delayed_node) 98467de1176SMiao Xie { 985a4cb90dcSJosef Bacik 986a4cb90dcSJosef Bacik if (test_and_clear_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) { 98767de1176SMiao Xie struct btrfs_delayed_root *delayed_root; 98867de1176SMiao Xie 98967de1176SMiao Xie ASSERT(delayed_node->root); 99067de1176SMiao Xie delayed_node->count--; 99167de1176SMiao Xie 99267de1176SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 99367de1176SMiao Xie finish_one_item(delayed_root); 99467de1176SMiao Xie } 995a4cb90dcSJosef Bacik } 99667de1176SMiao Xie 9970e8c36a9SMiao Xie static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 99816cdcec7SMiao Xie struct btrfs_root *root, 99916cdcec7SMiao Xie struct btrfs_path *path, 100016cdcec7SMiao Xie struct btrfs_delayed_node *node) 100116cdcec7SMiao Xie { 10022ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 100316cdcec7SMiao Xie struct btrfs_key key; 100416cdcec7SMiao Xie struct btrfs_inode_item *inode_item; 100516cdcec7SMiao Xie struct extent_buffer *leaf; 100667de1176SMiao Xie int mod; 100716cdcec7SMiao Xie int ret; 100816cdcec7SMiao Xie 100916cdcec7SMiao Xie key.objectid = node->inode_id; 1010962a298fSDavid Sterba key.type = BTRFS_INODE_ITEM_KEY; 101116cdcec7SMiao Xie key.offset = 0; 10120e8c36a9SMiao Xie 101367de1176SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) 101467de1176SMiao Xie mod = -1; 101567de1176SMiao Xie else 101667de1176SMiao Xie mod = 1; 101767de1176SMiao Xie 101867de1176SMiao Xie ret = btrfs_lookup_inode(trans, root, path, &key, mod); 1019bb385bedSJosef Bacik if (ret > 0) 1020bb385bedSJosef Bacik ret = -ENOENT; 1021bb385bedSJosef Bacik if (ret < 0) 1022bb385bedSJosef Bacik goto out; 102316cdcec7SMiao Xie 102416cdcec7SMiao Xie leaf = path->nodes[0]; 102516cdcec7SMiao Xie inode_item = btrfs_item_ptr(leaf, path->slots[0], 102616cdcec7SMiao Xie struct btrfs_inode_item); 102716cdcec7SMiao Xie write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item, 102816cdcec7SMiao Xie sizeof(struct btrfs_inode_item)); 102916cdcec7SMiao Xie btrfs_mark_buffer_dirty(leaf); 103016cdcec7SMiao Xie 103167de1176SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) 1032a4cb90dcSJosef Bacik goto out; 103367de1176SMiao Xie 103467de1176SMiao Xie path->slots[0]++; 103567de1176SMiao Xie if (path->slots[0] >= btrfs_header_nritems(leaf)) 103667de1176SMiao Xie goto search; 103767de1176SMiao Xie again: 103867de1176SMiao Xie btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 103967de1176SMiao Xie if (key.objectid != node->inode_id) 104067de1176SMiao Xie goto out; 104167de1176SMiao Xie 104267de1176SMiao Xie if (key.type != BTRFS_INODE_REF_KEY && 104367de1176SMiao Xie key.type != BTRFS_INODE_EXTREF_KEY) 104467de1176SMiao Xie goto out; 104567de1176SMiao Xie 104667de1176SMiao Xie /* 104767de1176SMiao Xie * Delayed iref deletion is for the inode who has only one link, 104867de1176SMiao Xie * so there is only one iref. The case that several irefs are 104967de1176SMiao Xie * in the same item doesn't exist. 105067de1176SMiao Xie */ 1051c06016a0Svoid0red ret = btrfs_del_item(trans, root, path); 105267de1176SMiao Xie out: 105367de1176SMiao Xie btrfs_release_delayed_iref(node); 105467de1176SMiao Xie btrfs_release_path(path); 105567de1176SMiao Xie err_out: 10564f5427ccSQu Wenruo btrfs_delayed_inode_release_metadata(fs_info, node, (ret < 0)); 105716cdcec7SMiao Xie btrfs_release_delayed_inode(node); 105816cdcec7SMiao Xie 105904587ad9SJosef Bacik /* 106004587ad9SJosef Bacik * If we fail to update the delayed inode we need to abort the 106104587ad9SJosef Bacik * transaction, because we could leave the inode with the improper 106204587ad9SJosef Bacik * counts behind. 106304587ad9SJosef Bacik */ 106404587ad9SJosef Bacik if (ret && ret != -ENOENT) 106504587ad9SJosef Bacik btrfs_abort_transaction(trans, ret); 106604587ad9SJosef Bacik 106767de1176SMiao Xie return ret; 106867de1176SMiao Xie 106967de1176SMiao Xie search: 107067de1176SMiao Xie btrfs_release_path(path); 107167de1176SMiao Xie 1072962a298fSDavid Sterba key.type = BTRFS_INODE_EXTREF_KEY; 107367de1176SMiao Xie key.offset = -1; 1074351cbf6eSJosef Bacik 107567de1176SMiao Xie ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 107667de1176SMiao Xie if (ret < 0) 107767de1176SMiao Xie goto err_out; 107867de1176SMiao Xie ASSERT(ret); 107967de1176SMiao Xie 108067de1176SMiao Xie ret = 0; 108167de1176SMiao Xie leaf = path->nodes[0]; 108267de1176SMiao Xie path->slots[0]--; 108367de1176SMiao Xie goto again; 108416cdcec7SMiao Xie } 108516cdcec7SMiao Xie 10860e8c36a9SMiao Xie static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 10870e8c36a9SMiao Xie struct btrfs_root *root, 10880e8c36a9SMiao Xie struct btrfs_path *path, 10890e8c36a9SMiao Xie struct btrfs_delayed_node *node) 10900e8c36a9SMiao Xie { 10910e8c36a9SMiao Xie int ret; 10920e8c36a9SMiao Xie 10930e8c36a9SMiao Xie mutex_lock(&node->mutex); 10947cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &node->flags)) { 10950e8c36a9SMiao Xie mutex_unlock(&node->mutex); 10960e8c36a9SMiao Xie return 0; 10970e8c36a9SMiao Xie } 10980e8c36a9SMiao Xie 10990e8c36a9SMiao Xie ret = __btrfs_update_delayed_inode(trans, root, path, node); 11000e8c36a9SMiao Xie mutex_unlock(&node->mutex); 11010e8c36a9SMiao Xie return ret; 11020e8c36a9SMiao Xie } 11030e8c36a9SMiao Xie 11044ea41ce0SMiao Xie static inline int 11054ea41ce0SMiao Xie __btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 11064ea41ce0SMiao Xie struct btrfs_path *path, 11074ea41ce0SMiao Xie struct btrfs_delayed_node *node) 11084ea41ce0SMiao Xie { 11094ea41ce0SMiao Xie int ret; 11104ea41ce0SMiao Xie 11114ea41ce0SMiao Xie ret = btrfs_insert_delayed_items(trans, path, node->root, node); 11124ea41ce0SMiao Xie if (ret) 11134ea41ce0SMiao Xie return ret; 11144ea41ce0SMiao Xie 11154ea41ce0SMiao Xie ret = btrfs_delete_delayed_items(trans, path, node->root, node); 11164ea41ce0SMiao Xie if (ret) 11174ea41ce0SMiao Xie return ret; 11184ea41ce0SMiao Xie 11194ea41ce0SMiao Xie ret = btrfs_update_delayed_inode(trans, node->root, path, node); 11204ea41ce0SMiao Xie return ret; 11214ea41ce0SMiao Xie } 11224ea41ce0SMiao Xie 112379787eaaSJeff Mahoney /* 112479787eaaSJeff Mahoney * Called when committing the transaction. 112579787eaaSJeff Mahoney * Returns 0 on success. 112679787eaaSJeff Mahoney * Returns < 0 on error and returns with an aborted transaction with any 112779787eaaSJeff Mahoney * outstanding delayed items cleaned up. 112879787eaaSJeff Mahoney */ 1129b84acab3SNikolay Borisov static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, int nr) 113016cdcec7SMiao Xie { 1131b84acab3SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 113216cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 113316cdcec7SMiao Xie struct btrfs_delayed_node *curr_node, *prev_node; 113416cdcec7SMiao Xie struct btrfs_path *path; 113519fd2949SMiao Xie struct btrfs_block_rsv *block_rsv; 113616cdcec7SMiao Xie int ret = 0; 113796c3f433SJosef Bacik bool count = (nr > 0); 113816cdcec7SMiao Xie 1139bf31f87fSDavid Sterba if (TRANS_ABORTED(trans)) 114079787eaaSJeff Mahoney return -EIO; 114179787eaaSJeff Mahoney 114216cdcec7SMiao Xie path = btrfs_alloc_path(); 114316cdcec7SMiao Xie if (!path) 114416cdcec7SMiao Xie return -ENOMEM; 114516cdcec7SMiao Xie 114619fd2949SMiao Xie block_rsv = trans->block_rsv; 11470b246afaSJeff Mahoney trans->block_rsv = &fs_info->delayed_block_rsv; 114819fd2949SMiao Xie 1149ccdf9b30SJeff Mahoney delayed_root = fs_info->delayed_root; 115016cdcec7SMiao Xie 115116cdcec7SMiao Xie curr_node = btrfs_first_delayed_node(delayed_root); 1152a4559e6fSAbaci Team while (curr_node && (!count || nr--)) { 11534ea41ce0SMiao Xie ret = __btrfs_commit_inode_delayed_items(trans, path, 115416cdcec7SMiao Xie curr_node); 115516cdcec7SMiao Xie if (ret) { 115616cdcec7SMiao Xie btrfs_release_delayed_node(curr_node); 115796c3f433SJosef Bacik curr_node = NULL; 115866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 115916cdcec7SMiao Xie break; 116016cdcec7SMiao Xie } 116116cdcec7SMiao Xie 116216cdcec7SMiao Xie prev_node = curr_node; 116316cdcec7SMiao Xie curr_node = btrfs_next_delayed_node(curr_node); 116416cdcec7SMiao Xie btrfs_release_delayed_node(prev_node); 116516cdcec7SMiao Xie } 116616cdcec7SMiao Xie 116796c3f433SJosef Bacik if (curr_node) 116896c3f433SJosef Bacik btrfs_release_delayed_node(curr_node); 116916cdcec7SMiao Xie btrfs_free_path(path); 117019fd2949SMiao Xie trans->block_rsv = block_rsv; 117179787eaaSJeff Mahoney 117216cdcec7SMiao Xie return ret; 117316cdcec7SMiao Xie } 117416cdcec7SMiao Xie 1175e5c304e6SNikolay Borisov int btrfs_run_delayed_items(struct btrfs_trans_handle *trans) 117696c3f433SJosef Bacik { 1177b84acab3SNikolay Borisov return __btrfs_run_delayed_items(trans, -1); 117896c3f433SJosef Bacik } 117996c3f433SJosef Bacik 1180e5c304e6SNikolay Borisov int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, int nr) 118196c3f433SJosef Bacik { 1182b84acab3SNikolay Borisov return __btrfs_run_delayed_items(trans, nr); 118396c3f433SJosef Bacik } 118496c3f433SJosef Bacik 118516cdcec7SMiao Xie int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 11865f4b32e9SNikolay Borisov struct btrfs_inode *inode) 118716cdcec7SMiao Xie { 11885f4b32e9SNikolay Borisov struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 11894ea41ce0SMiao Xie struct btrfs_path *path; 11904ea41ce0SMiao Xie struct btrfs_block_rsv *block_rsv; 119116cdcec7SMiao Xie int ret; 119216cdcec7SMiao Xie 119316cdcec7SMiao Xie if (!delayed_node) 119416cdcec7SMiao Xie return 0; 119516cdcec7SMiao Xie 119616cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 119716cdcec7SMiao Xie if (!delayed_node->count) { 119816cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 119916cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 120016cdcec7SMiao Xie return 0; 120116cdcec7SMiao Xie } 120216cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 120316cdcec7SMiao Xie 12044ea41ce0SMiao Xie path = btrfs_alloc_path(); 12053c77bd94SFilipe David Borba Manana if (!path) { 12063c77bd94SFilipe David Borba Manana btrfs_release_delayed_node(delayed_node); 12074ea41ce0SMiao Xie return -ENOMEM; 12083c77bd94SFilipe David Borba Manana } 12094ea41ce0SMiao Xie 12104ea41ce0SMiao Xie block_rsv = trans->block_rsv; 12114ea41ce0SMiao Xie trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv; 12124ea41ce0SMiao Xie 12134ea41ce0SMiao Xie ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 12144ea41ce0SMiao Xie 121516cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 12164ea41ce0SMiao Xie btrfs_free_path(path); 12174ea41ce0SMiao Xie trans->block_rsv = block_rsv; 12184ea41ce0SMiao Xie 121916cdcec7SMiao Xie return ret; 122016cdcec7SMiao Xie } 122116cdcec7SMiao Xie 1222aa79021fSNikolay Borisov int btrfs_commit_inode_delayed_inode(struct btrfs_inode *inode) 12230e8c36a9SMiao Xie { 12243ffbd68cSDavid Sterba struct btrfs_fs_info *fs_info = inode->root->fs_info; 12250e8c36a9SMiao Xie struct btrfs_trans_handle *trans; 1226aa79021fSNikolay Borisov struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 12270e8c36a9SMiao Xie struct btrfs_path *path; 12280e8c36a9SMiao Xie struct btrfs_block_rsv *block_rsv; 12290e8c36a9SMiao Xie int ret; 12300e8c36a9SMiao Xie 12310e8c36a9SMiao Xie if (!delayed_node) 12320e8c36a9SMiao Xie return 0; 12330e8c36a9SMiao Xie 12340e8c36a9SMiao Xie mutex_lock(&delayed_node->mutex); 12357cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 12360e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12370e8c36a9SMiao Xie btrfs_release_delayed_node(delayed_node); 12380e8c36a9SMiao Xie return 0; 12390e8c36a9SMiao Xie } 12400e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12410e8c36a9SMiao Xie 12420e8c36a9SMiao Xie trans = btrfs_join_transaction(delayed_node->root); 12430e8c36a9SMiao Xie if (IS_ERR(trans)) { 12440e8c36a9SMiao Xie ret = PTR_ERR(trans); 12450e8c36a9SMiao Xie goto out; 12460e8c36a9SMiao Xie } 12470e8c36a9SMiao Xie 12480e8c36a9SMiao Xie path = btrfs_alloc_path(); 12490e8c36a9SMiao Xie if (!path) { 12500e8c36a9SMiao Xie ret = -ENOMEM; 12510e8c36a9SMiao Xie goto trans_out; 12520e8c36a9SMiao Xie } 12530e8c36a9SMiao Xie 12540e8c36a9SMiao Xie block_rsv = trans->block_rsv; 12552ff7e61eSJeff Mahoney trans->block_rsv = &fs_info->delayed_block_rsv; 12560e8c36a9SMiao Xie 12570e8c36a9SMiao Xie mutex_lock(&delayed_node->mutex); 12587cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) 12590e8c36a9SMiao Xie ret = __btrfs_update_delayed_inode(trans, delayed_node->root, 12600e8c36a9SMiao Xie path, delayed_node); 12610e8c36a9SMiao Xie else 12620e8c36a9SMiao Xie ret = 0; 12630e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12640e8c36a9SMiao Xie 12650e8c36a9SMiao Xie btrfs_free_path(path); 12660e8c36a9SMiao Xie trans->block_rsv = block_rsv; 12670e8c36a9SMiao Xie trans_out: 12683a45bb20SJeff Mahoney btrfs_end_transaction(trans); 12692ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(fs_info); 12700e8c36a9SMiao Xie out: 12710e8c36a9SMiao Xie btrfs_release_delayed_node(delayed_node); 12720e8c36a9SMiao Xie 12730e8c36a9SMiao Xie return ret; 12740e8c36a9SMiao Xie } 12750e8c36a9SMiao Xie 1276f48d1cf5SNikolay Borisov void btrfs_remove_delayed_node(struct btrfs_inode *inode) 127716cdcec7SMiao Xie { 127816cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 127916cdcec7SMiao Xie 1280f48d1cf5SNikolay Borisov delayed_node = READ_ONCE(inode->delayed_node); 128116cdcec7SMiao Xie if (!delayed_node) 128216cdcec7SMiao Xie return; 128316cdcec7SMiao Xie 1284f48d1cf5SNikolay Borisov inode->delayed_node = NULL; 128516cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 128616cdcec7SMiao Xie } 128716cdcec7SMiao Xie 1288de3cb945SChris Mason struct btrfs_async_delayed_work { 1289de3cb945SChris Mason struct btrfs_delayed_root *delayed_root; 1290de3cb945SChris Mason int nr; 1291d458b054SQu Wenruo struct btrfs_work work; 129216cdcec7SMiao Xie }; 129316cdcec7SMiao Xie 1294d458b054SQu Wenruo static void btrfs_async_run_delayed_root(struct btrfs_work *work) 129516cdcec7SMiao Xie { 1296de3cb945SChris Mason struct btrfs_async_delayed_work *async_work; 1297de3cb945SChris Mason struct btrfs_delayed_root *delayed_root; 129816cdcec7SMiao Xie struct btrfs_trans_handle *trans; 129916cdcec7SMiao Xie struct btrfs_path *path; 130016cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node = NULL; 130116cdcec7SMiao Xie struct btrfs_root *root; 130219fd2949SMiao Xie struct btrfs_block_rsv *block_rsv; 1303de3cb945SChris Mason int total_done = 0; 130416cdcec7SMiao Xie 1305de3cb945SChris Mason async_work = container_of(work, struct btrfs_async_delayed_work, work); 1306de3cb945SChris Mason delayed_root = async_work->delayed_root; 130716cdcec7SMiao Xie 130816cdcec7SMiao Xie path = btrfs_alloc_path(); 130916cdcec7SMiao Xie if (!path) 131016cdcec7SMiao Xie goto out; 131116cdcec7SMiao Xie 1312617c54a8SNikolay Borisov do { 1313617c54a8SNikolay Borisov if (atomic_read(&delayed_root->items) < 1314617c54a8SNikolay Borisov BTRFS_DELAYED_BACKGROUND / 2) 1315617c54a8SNikolay Borisov break; 1316de3cb945SChris Mason 1317de3cb945SChris Mason delayed_node = btrfs_first_prepared_delayed_node(delayed_root); 1318de3cb945SChris Mason if (!delayed_node) 1319617c54a8SNikolay Borisov break; 1320de3cb945SChris Mason 132116cdcec7SMiao Xie root = delayed_node->root; 132216cdcec7SMiao Xie 1323ff5714ccSChris Mason trans = btrfs_join_transaction(root); 1324617c54a8SNikolay Borisov if (IS_ERR(trans)) { 1325617c54a8SNikolay Borisov btrfs_release_path(path); 1326617c54a8SNikolay Borisov btrfs_release_prepared_delayed_node(delayed_node); 1327617c54a8SNikolay Borisov total_done++; 1328617c54a8SNikolay Borisov continue; 1329617c54a8SNikolay Borisov } 133016cdcec7SMiao Xie 133119fd2949SMiao Xie block_rsv = trans->block_rsv; 13326d668ddaSJosef Bacik trans->block_rsv = &root->fs_info->delayed_block_rsv; 133319fd2949SMiao Xie 13344ea41ce0SMiao Xie __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 133516cdcec7SMiao Xie 133619fd2949SMiao Xie trans->block_rsv = block_rsv; 13373a45bb20SJeff Mahoney btrfs_end_transaction(trans); 13382ff7e61eSJeff Mahoney btrfs_btree_balance_dirty_nodelay(root->fs_info); 1339de3cb945SChris Mason 1340de3cb945SChris Mason btrfs_release_path(path); 1341617c54a8SNikolay Borisov btrfs_release_prepared_delayed_node(delayed_node); 1342de3cb945SChris Mason total_done++; 1343de3cb945SChris Mason 1344617c54a8SNikolay Borisov } while ((async_work->nr == 0 && total_done < BTRFS_DELAYED_WRITEBACK) 1345617c54a8SNikolay Borisov || total_done < async_work->nr); 1346de3cb945SChris Mason 134716cdcec7SMiao Xie btrfs_free_path(path); 134816cdcec7SMiao Xie out: 1349de3cb945SChris Mason wake_up(&delayed_root->wait); 1350de3cb945SChris Mason kfree(async_work); 135116cdcec7SMiao Xie } 1352de3cb945SChris Mason 135316cdcec7SMiao Xie 135416cdcec7SMiao Xie static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root, 1355a585e948SDaniel Dressler struct btrfs_fs_info *fs_info, int nr) 135616cdcec7SMiao Xie { 1357de3cb945SChris Mason struct btrfs_async_delayed_work *async_work; 135816cdcec7SMiao Xie 1359de3cb945SChris Mason async_work = kmalloc(sizeof(*async_work), GFP_NOFS); 1360de3cb945SChris Mason if (!async_work) 136116cdcec7SMiao Xie return -ENOMEM; 136216cdcec7SMiao Xie 1363de3cb945SChris Mason async_work->delayed_root = delayed_root; 1364a0cac0ecSOmar Sandoval btrfs_init_work(&async_work->work, btrfs_async_run_delayed_root, NULL, 1365a0cac0ecSOmar Sandoval NULL); 1366de3cb945SChris Mason async_work->nr = nr; 136716cdcec7SMiao Xie 1368a585e948SDaniel Dressler btrfs_queue_work(fs_info->delayed_workers, &async_work->work); 136916cdcec7SMiao Xie return 0; 137016cdcec7SMiao Xie } 137116cdcec7SMiao Xie 1372ccdf9b30SJeff Mahoney void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info) 1373e999376fSChris Mason { 1374ccdf9b30SJeff Mahoney WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root)); 1375e999376fSChris Mason } 1376e999376fSChris Mason 13770353808cSMiao Xie static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq) 1378de3cb945SChris Mason { 1379de3cb945SChris Mason int val = atomic_read(&delayed_root->items_seq); 1380de3cb945SChris Mason 13810353808cSMiao Xie if (val < seq || val >= seq + BTRFS_DELAYED_BATCH) 1382de3cb945SChris Mason return 1; 13830353808cSMiao Xie 13840353808cSMiao Xie if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 13850353808cSMiao Xie return 1; 13860353808cSMiao Xie 1387de3cb945SChris Mason return 0; 1388de3cb945SChris Mason } 1389de3cb945SChris Mason 13902ff7e61eSJeff Mahoney void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info) 139116cdcec7SMiao Xie { 13922ff7e61eSJeff Mahoney struct btrfs_delayed_root *delayed_root = fs_info->delayed_root; 139316cdcec7SMiao Xie 13948577787fSNikolay Borisov if ((atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) || 13958577787fSNikolay Borisov btrfs_workqueue_normal_congested(fs_info->delayed_workers)) 139616cdcec7SMiao Xie return; 139716cdcec7SMiao Xie 139816cdcec7SMiao Xie if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) { 13990353808cSMiao Xie int seq; 140016cdcec7SMiao Xie int ret; 14010353808cSMiao Xie 14020353808cSMiao Xie seq = atomic_read(&delayed_root->items_seq); 1403de3cb945SChris Mason 1404a585e948SDaniel Dressler ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0); 140516cdcec7SMiao Xie if (ret) 140616cdcec7SMiao Xie return; 140716cdcec7SMiao Xie 14080353808cSMiao Xie wait_event_interruptible(delayed_root->wait, 14090353808cSMiao Xie could_end_wait(delayed_root, seq)); 14104dd466d3SMiao Xie return; 141116cdcec7SMiao Xie } 141216cdcec7SMiao Xie 1413a585e948SDaniel Dressler btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH); 141416cdcec7SMiao Xie } 141516cdcec7SMiao Xie 141679787eaaSJeff Mahoney /* Will return 0 or -ENOMEM */ 141716cdcec7SMiao Xie int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans, 14182ff7e61eSJeff Mahoney const char *name, int name_len, 14196f45d185SNikolay Borisov struct btrfs_inode *dir, 142094a48aefSOmar Sandoval struct btrfs_disk_key *disk_key, u8 flags, 142116cdcec7SMiao Xie u64 index) 142216cdcec7SMiao Xie { 1423763748b2SFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 1424763748b2SFilipe Manana const unsigned int leaf_data_size = BTRFS_LEAF_DATA_SIZE(fs_info); 142516cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 142616cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item; 142716cdcec7SMiao Xie struct btrfs_dir_item *dir_item; 1428763748b2SFilipe Manana bool reserve_leaf_space; 1429763748b2SFilipe Manana u32 data_len; 143016cdcec7SMiao Xie int ret; 143116cdcec7SMiao Xie 14326f45d185SNikolay Borisov delayed_node = btrfs_get_or_create_delayed_node(dir); 143316cdcec7SMiao Xie if (IS_ERR(delayed_node)) 143416cdcec7SMiao Xie return PTR_ERR(delayed_node); 143516cdcec7SMiao Xie 143696d89923SFilipe Manana delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len, 14374c469798SFilipe Manana delayed_node, 14384c469798SFilipe Manana BTRFS_DELAYED_INSERTION_ITEM); 143916cdcec7SMiao Xie if (!delayed_item) { 144016cdcec7SMiao Xie ret = -ENOMEM; 144116cdcec7SMiao Xie goto release_node; 144216cdcec7SMiao Xie } 144316cdcec7SMiao Xie 144496d89923SFilipe Manana delayed_item->index = index; 144516cdcec7SMiao Xie 144616cdcec7SMiao Xie dir_item = (struct btrfs_dir_item *)delayed_item->data; 144716cdcec7SMiao Xie dir_item->location = *disk_key; 14483cae210fSQu Wenruo btrfs_set_stack_dir_transid(dir_item, trans->transid); 14493cae210fSQu Wenruo btrfs_set_stack_dir_data_len(dir_item, 0); 14503cae210fSQu Wenruo btrfs_set_stack_dir_name_len(dir_item, name_len); 145194a48aefSOmar Sandoval btrfs_set_stack_dir_flags(dir_item, flags); 145216cdcec7SMiao Xie memcpy((char *)(dir_item + 1), name, name_len); 145316cdcec7SMiao Xie 1454763748b2SFilipe Manana data_len = delayed_item->data_len + sizeof(struct btrfs_item); 1455763748b2SFilipe Manana 1456763748b2SFilipe Manana mutex_lock(&delayed_node->mutex); 1457763748b2SFilipe Manana 1458763748b2SFilipe Manana if (delayed_node->index_item_leaves == 0 || 1459763748b2SFilipe Manana delayed_node->curr_index_batch_size + data_len > leaf_data_size) { 1460763748b2SFilipe Manana delayed_node->curr_index_batch_size = data_len; 1461763748b2SFilipe Manana reserve_leaf_space = true; 1462763748b2SFilipe Manana } else { 1463763748b2SFilipe Manana delayed_node->curr_index_batch_size += data_len; 1464763748b2SFilipe Manana reserve_leaf_space = false; 1465763748b2SFilipe Manana } 1466763748b2SFilipe Manana 1467763748b2SFilipe Manana if (reserve_leaf_space) { 1468df492881SFilipe Manana ret = btrfs_delayed_item_reserve_metadata(trans, delayed_item); 14698c2a3ca2SJosef Bacik /* 1470763748b2SFilipe Manana * Space was reserved for a dir index item insertion when we 1471763748b2SFilipe Manana * started the transaction, so getting a failure here should be 1472763748b2SFilipe Manana * impossible. 14738c2a3ca2SJosef Bacik */ 14743bae13e9SFilipe Manana if (WARN_ON(ret)) { 1475763748b2SFilipe Manana mutex_unlock(&delayed_node->mutex); 14763bae13e9SFilipe Manana btrfs_release_delayed_item(delayed_item); 14773bae13e9SFilipe Manana goto release_node; 14783bae13e9SFilipe Manana } 14798c2a3ca2SJosef Bacik 1480763748b2SFilipe Manana delayed_node->index_item_leaves++; 1481763748b2SFilipe Manana } else if (!test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) { 1482763748b2SFilipe Manana const u64 bytes = btrfs_calc_insert_metadata_size(fs_info, 1); 1483763748b2SFilipe Manana 1484763748b2SFilipe Manana /* 1485763748b2SFilipe Manana * Adding the new dir index item does not require touching another 1486763748b2SFilipe Manana * leaf, so we can release 1 unit of metadata that was previously 1487763748b2SFilipe Manana * reserved when starting the transaction. This applies only to 1488763748b2SFilipe Manana * the case where we had a transaction start and excludes the 1489763748b2SFilipe Manana * transaction join case (when replaying log trees). 1490763748b2SFilipe Manana */ 1491763748b2SFilipe Manana trace_btrfs_space_reservation(fs_info, "transaction", 1492763748b2SFilipe Manana trans->transid, bytes, 0); 1493763748b2SFilipe Manana btrfs_block_rsv_release(fs_info, trans->block_rsv, bytes, NULL); 1494763748b2SFilipe Manana ASSERT(trans->bytes_reserved >= bytes); 1495763748b2SFilipe Manana trans->bytes_reserved -= bytes; 1496763748b2SFilipe Manana } 1497763748b2SFilipe Manana 1498c9d02ab4SFilipe Manana ret = __btrfs_add_delayed_item(delayed_node, delayed_item); 149916cdcec7SMiao Xie if (unlikely(ret)) { 15004465c8b4SLu Fengqi btrfs_err(trans->fs_info, 15015d163e0eSJeff Mahoney "err add delayed dir index item(name: %.*s) into the insertion tree of the delayed node(root id: %llu, inode id: %llu, errno: %d)", 15024fd786e6SMisono Tomohiro name_len, name, delayed_node->root->root_key.objectid, 1503c1c9ff7cSGeert Uytterhoeven delayed_node->inode_id, ret); 150416cdcec7SMiao Xie BUG(); 150516cdcec7SMiao Xie } 150616cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 150716cdcec7SMiao Xie 150816cdcec7SMiao Xie release_node: 150916cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 151016cdcec7SMiao Xie return ret; 151116cdcec7SMiao Xie } 151216cdcec7SMiao Xie 15132ff7e61eSJeff Mahoney static int btrfs_delete_delayed_insertion_item(struct btrfs_fs_info *fs_info, 151416cdcec7SMiao Xie struct btrfs_delayed_node *node, 151596d89923SFilipe Manana u64 index) 151616cdcec7SMiao Xie { 151716cdcec7SMiao Xie struct btrfs_delayed_item *item; 151816cdcec7SMiao Xie 151916cdcec7SMiao Xie mutex_lock(&node->mutex); 15204cbf37f5SFilipe Manana item = __btrfs_lookup_delayed_item(&node->ins_root.rb_root, index); 152116cdcec7SMiao Xie if (!item) { 152216cdcec7SMiao Xie mutex_unlock(&node->mutex); 152316cdcec7SMiao Xie return 1; 152416cdcec7SMiao Xie } 152516cdcec7SMiao Xie 1526763748b2SFilipe Manana /* 1527763748b2SFilipe Manana * For delayed items to insert, we track reserved metadata bytes based 1528763748b2SFilipe Manana * on the number of leaves that we will use. 1529763748b2SFilipe Manana * See btrfs_insert_delayed_dir_index() and 1530763748b2SFilipe Manana * btrfs_delayed_item_reserve_metadata()). 1531763748b2SFilipe Manana */ 1532763748b2SFilipe Manana ASSERT(item->bytes_reserved == 0); 1533763748b2SFilipe Manana ASSERT(node->index_item_leaves > 0); 1534763748b2SFilipe Manana 1535763748b2SFilipe Manana /* 1536763748b2SFilipe Manana * If there's only one leaf reserved, we can decrement this item from the 1537763748b2SFilipe Manana * current batch, otherwise we can not because we don't know which leaf 1538763748b2SFilipe Manana * it belongs to. With the current limit on delayed items, we rarely 1539763748b2SFilipe Manana * accumulate enough dir index items to fill more than one leaf (even 1540763748b2SFilipe Manana * when using a leaf size of 4K). 1541763748b2SFilipe Manana */ 1542763748b2SFilipe Manana if (node->index_item_leaves == 1) { 1543763748b2SFilipe Manana const u32 data_len = item->data_len + sizeof(struct btrfs_item); 1544763748b2SFilipe Manana 1545763748b2SFilipe Manana ASSERT(node->curr_index_batch_size >= data_len); 1546763748b2SFilipe Manana node->curr_index_batch_size -= data_len; 1547763748b2SFilipe Manana } 1548763748b2SFilipe Manana 154916cdcec7SMiao Xie btrfs_release_delayed_item(item); 1550763748b2SFilipe Manana 1551763748b2SFilipe Manana /* If we now have no more dir index items, we can release all leaves. */ 1552763748b2SFilipe Manana if (RB_EMPTY_ROOT(&node->ins_root.rb_root)) { 1553763748b2SFilipe Manana btrfs_delayed_item_release_leaves(node, node->index_item_leaves); 1554763748b2SFilipe Manana node->index_item_leaves = 0; 1555763748b2SFilipe Manana } 1556763748b2SFilipe Manana 155716cdcec7SMiao Xie mutex_unlock(&node->mutex); 155816cdcec7SMiao Xie return 0; 155916cdcec7SMiao Xie } 156016cdcec7SMiao Xie 156116cdcec7SMiao Xie int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans, 1562e67bbbb9SNikolay Borisov struct btrfs_inode *dir, u64 index) 156316cdcec7SMiao Xie { 156416cdcec7SMiao Xie struct btrfs_delayed_node *node; 156516cdcec7SMiao Xie struct btrfs_delayed_item *item; 156616cdcec7SMiao Xie int ret; 156716cdcec7SMiao Xie 1568e67bbbb9SNikolay Borisov node = btrfs_get_or_create_delayed_node(dir); 156916cdcec7SMiao Xie if (IS_ERR(node)) 157016cdcec7SMiao Xie return PTR_ERR(node); 157116cdcec7SMiao Xie 157296d89923SFilipe Manana ret = btrfs_delete_delayed_insertion_item(trans->fs_info, node, index); 157316cdcec7SMiao Xie if (!ret) 157416cdcec7SMiao Xie goto end; 157516cdcec7SMiao Xie 15764c469798SFilipe Manana item = btrfs_alloc_delayed_item(0, node, BTRFS_DELAYED_DELETION_ITEM); 157716cdcec7SMiao Xie if (!item) { 157816cdcec7SMiao Xie ret = -ENOMEM; 157916cdcec7SMiao Xie goto end; 158016cdcec7SMiao Xie } 158116cdcec7SMiao Xie 158296d89923SFilipe Manana item->index = index; 158316cdcec7SMiao Xie 1584df492881SFilipe Manana ret = btrfs_delayed_item_reserve_metadata(trans, item); 158516cdcec7SMiao Xie /* 158616cdcec7SMiao Xie * we have reserved enough space when we start a new transaction, 158716cdcec7SMiao Xie * so reserving metadata failure is impossible. 158816cdcec7SMiao Xie */ 1589933c22a7SQu Wenruo if (ret < 0) { 1590933c22a7SQu Wenruo btrfs_err(trans->fs_info, 1591933c22a7SQu Wenruo "metadata reservation failed for delayed dir item deltiona, should have been reserved"); 1592933c22a7SQu Wenruo btrfs_release_delayed_item(item); 1593933c22a7SQu Wenruo goto end; 1594933c22a7SQu Wenruo } 159516cdcec7SMiao Xie 159616cdcec7SMiao Xie mutex_lock(&node->mutex); 1597c9d02ab4SFilipe Manana ret = __btrfs_add_delayed_item(node, item); 159816cdcec7SMiao Xie if (unlikely(ret)) { 15999add2945SLu Fengqi btrfs_err(trans->fs_info, 16005d163e0eSJeff Mahoney "err add delayed dir index item(index: %llu) into the deletion tree of the delayed node(root id: %llu, inode id: %llu, errno: %d)", 16014fd786e6SMisono Tomohiro index, node->root->root_key.objectid, 16024fd786e6SMisono Tomohiro node->inode_id, ret); 1603933c22a7SQu Wenruo btrfs_delayed_item_release_metadata(dir->root, item); 1604933c22a7SQu Wenruo btrfs_release_delayed_item(item); 160516cdcec7SMiao Xie } 160616cdcec7SMiao Xie mutex_unlock(&node->mutex); 160716cdcec7SMiao Xie end: 160816cdcec7SMiao Xie btrfs_release_delayed_node(node); 160916cdcec7SMiao Xie return ret; 161016cdcec7SMiao Xie } 161116cdcec7SMiao Xie 1612f5cc7b80SNikolay Borisov int btrfs_inode_delayed_dir_index_count(struct btrfs_inode *inode) 161316cdcec7SMiao Xie { 1614f5cc7b80SNikolay Borisov struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 161516cdcec7SMiao Xie 161616cdcec7SMiao Xie if (!delayed_node) 161716cdcec7SMiao Xie return -ENOENT; 161816cdcec7SMiao Xie 161916cdcec7SMiao Xie /* 162016cdcec7SMiao Xie * Since we have held i_mutex of this directory, it is impossible that 162116cdcec7SMiao Xie * a new directory index is added into the delayed node and index_cnt 162216cdcec7SMiao Xie * is updated now. So we needn't lock the delayed node. 162316cdcec7SMiao Xie */ 16242f7e33d4SMiao Xie if (!delayed_node->index_cnt) { 16252f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 162616cdcec7SMiao Xie return -EINVAL; 16272f7e33d4SMiao Xie } 162816cdcec7SMiao Xie 1629f5cc7b80SNikolay Borisov inode->index_cnt = delayed_node->index_cnt; 16302f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 16312f7e33d4SMiao Xie return 0; 163216cdcec7SMiao Xie } 163316cdcec7SMiao Xie 163402dbfc99SOmar Sandoval bool btrfs_readdir_get_delayed_items(struct inode *inode, 1635*9b378f6aSFilipe Manana u64 last_index, 163602dbfc99SOmar Sandoval struct list_head *ins_list, 163716cdcec7SMiao Xie struct list_head *del_list) 163816cdcec7SMiao Xie { 163916cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 164016cdcec7SMiao Xie struct btrfs_delayed_item *item; 164116cdcec7SMiao Xie 1642340c6ca9SNikolay Borisov delayed_node = btrfs_get_delayed_node(BTRFS_I(inode)); 164316cdcec7SMiao Xie if (!delayed_node) 164402dbfc99SOmar Sandoval return false; 164502dbfc99SOmar Sandoval 164602dbfc99SOmar Sandoval /* 164702dbfc99SOmar Sandoval * We can only do one readdir with delayed items at a time because of 164802dbfc99SOmar Sandoval * item->readdir_list. 164902dbfc99SOmar Sandoval */ 1650e5d4d75bSDavid Sterba btrfs_inode_unlock(BTRFS_I(inode), BTRFS_ILOCK_SHARED); 165129b6352bSDavid Sterba btrfs_inode_lock(BTRFS_I(inode), 0); 165216cdcec7SMiao Xie 165316cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 165416cdcec7SMiao Xie item = __btrfs_first_delayed_insertion_item(delayed_node); 1655*9b378f6aSFilipe Manana while (item && item->index <= last_index) { 1656089e77e1SElena Reshetova refcount_inc(&item->refs); 165716cdcec7SMiao Xie list_add_tail(&item->readdir_list, ins_list); 165816cdcec7SMiao Xie item = __btrfs_next_delayed_item(item); 165916cdcec7SMiao Xie } 166016cdcec7SMiao Xie 166116cdcec7SMiao Xie item = __btrfs_first_delayed_deletion_item(delayed_node); 1662*9b378f6aSFilipe Manana while (item && item->index <= last_index) { 1663089e77e1SElena Reshetova refcount_inc(&item->refs); 166416cdcec7SMiao Xie list_add_tail(&item->readdir_list, del_list); 166516cdcec7SMiao Xie item = __btrfs_next_delayed_item(item); 166616cdcec7SMiao Xie } 166716cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 166816cdcec7SMiao Xie /* 166916cdcec7SMiao Xie * This delayed node is still cached in the btrfs inode, so refs 167016cdcec7SMiao Xie * must be > 1 now, and we needn't check it is going to be freed 167116cdcec7SMiao Xie * or not. 167216cdcec7SMiao Xie * 167316cdcec7SMiao Xie * Besides that, this function is used to read dir, we do not 167416cdcec7SMiao Xie * insert/delete delayed items in this period. So we also needn't 167516cdcec7SMiao Xie * requeue or dequeue this delayed node. 167616cdcec7SMiao Xie */ 16776de5f18eSElena Reshetova refcount_dec(&delayed_node->refs); 167802dbfc99SOmar Sandoval 167902dbfc99SOmar Sandoval return true; 168016cdcec7SMiao Xie } 168116cdcec7SMiao Xie 168202dbfc99SOmar Sandoval void btrfs_readdir_put_delayed_items(struct inode *inode, 168302dbfc99SOmar Sandoval struct list_head *ins_list, 168416cdcec7SMiao Xie struct list_head *del_list) 168516cdcec7SMiao Xie { 168616cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 168716cdcec7SMiao Xie 168816cdcec7SMiao Xie list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 168916cdcec7SMiao Xie list_del(&curr->readdir_list); 1690089e77e1SElena Reshetova if (refcount_dec_and_test(&curr->refs)) 169116cdcec7SMiao Xie kfree(curr); 169216cdcec7SMiao Xie } 169316cdcec7SMiao Xie 169416cdcec7SMiao Xie list_for_each_entry_safe(curr, next, del_list, readdir_list) { 169516cdcec7SMiao Xie list_del(&curr->readdir_list); 1696089e77e1SElena Reshetova if (refcount_dec_and_test(&curr->refs)) 169716cdcec7SMiao Xie kfree(curr); 169816cdcec7SMiao Xie } 169902dbfc99SOmar Sandoval 170002dbfc99SOmar Sandoval /* 170102dbfc99SOmar Sandoval * The VFS is going to do up_read(), so we need to downgrade back to a 170202dbfc99SOmar Sandoval * read lock. 170302dbfc99SOmar Sandoval */ 170402dbfc99SOmar Sandoval downgrade_write(&inode->i_rwsem); 170516cdcec7SMiao Xie } 170616cdcec7SMiao Xie 170716cdcec7SMiao Xie int btrfs_should_delete_dir_index(struct list_head *del_list, 170816cdcec7SMiao Xie u64 index) 170916cdcec7SMiao Xie { 1710e4fd493cSJosef Bacik struct btrfs_delayed_item *curr; 1711e4fd493cSJosef Bacik int ret = 0; 171216cdcec7SMiao Xie 1713e4fd493cSJosef Bacik list_for_each_entry(curr, del_list, readdir_list) { 171496d89923SFilipe Manana if (curr->index > index) 171516cdcec7SMiao Xie break; 171696d89923SFilipe Manana if (curr->index == index) { 1717e4fd493cSJosef Bacik ret = 1; 1718e4fd493cSJosef Bacik break; 171916cdcec7SMiao Xie } 1720e4fd493cSJosef Bacik } 1721e4fd493cSJosef Bacik return ret; 172216cdcec7SMiao Xie } 172316cdcec7SMiao Xie 172416cdcec7SMiao Xie /* 172516cdcec7SMiao Xie * btrfs_readdir_delayed_dir_index - read dir info stored in the delayed tree 172616cdcec7SMiao Xie * 172716cdcec7SMiao Xie */ 17289cdda8d3SAl Viro int btrfs_readdir_delayed_dir_index(struct dir_context *ctx, 1729d2fbb2b5SJeff Mahoney struct list_head *ins_list) 173016cdcec7SMiao Xie { 173116cdcec7SMiao Xie struct btrfs_dir_item *di; 173216cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 173316cdcec7SMiao Xie struct btrfs_key location; 173416cdcec7SMiao Xie char *name; 173516cdcec7SMiao Xie int name_len; 173616cdcec7SMiao Xie int over = 0; 173716cdcec7SMiao Xie unsigned char d_type; 173816cdcec7SMiao Xie 173916cdcec7SMiao Xie if (list_empty(ins_list)) 174016cdcec7SMiao Xie return 0; 174116cdcec7SMiao Xie 174216cdcec7SMiao Xie /* 174316cdcec7SMiao Xie * Changing the data of the delayed item is impossible. So 174416cdcec7SMiao Xie * we needn't lock them. And we have held i_mutex of the 174516cdcec7SMiao Xie * directory, nobody can delete any directory indexes now. 174616cdcec7SMiao Xie */ 174716cdcec7SMiao Xie list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 174816cdcec7SMiao Xie list_del(&curr->readdir_list); 174916cdcec7SMiao Xie 175096d89923SFilipe Manana if (curr->index < ctx->pos) { 1751089e77e1SElena Reshetova if (refcount_dec_and_test(&curr->refs)) 175216cdcec7SMiao Xie kfree(curr); 175316cdcec7SMiao Xie continue; 175416cdcec7SMiao Xie } 175516cdcec7SMiao Xie 175696d89923SFilipe Manana ctx->pos = curr->index; 175716cdcec7SMiao Xie 175816cdcec7SMiao Xie di = (struct btrfs_dir_item *)curr->data; 175916cdcec7SMiao Xie name = (char *)(di + 1); 17603cae210fSQu Wenruo name_len = btrfs_stack_dir_name_len(di); 176116cdcec7SMiao Xie 176294a48aefSOmar Sandoval d_type = fs_ftype_to_dtype(btrfs_dir_flags_to_ftype(di->type)); 176316cdcec7SMiao Xie btrfs_disk_key_to_cpu(&location, &di->location); 176416cdcec7SMiao Xie 17659cdda8d3SAl Viro over = !dir_emit(ctx, name, name_len, 176616cdcec7SMiao Xie location.objectid, d_type); 176716cdcec7SMiao Xie 1768089e77e1SElena Reshetova if (refcount_dec_and_test(&curr->refs)) 176916cdcec7SMiao Xie kfree(curr); 177016cdcec7SMiao Xie 177116cdcec7SMiao Xie if (over) 177216cdcec7SMiao Xie return 1; 177342e9cc46SJosef Bacik ctx->pos++; 177416cdcec7SMiao Xie } 177516cdcec7SMiao Xie return 0; 177616cdcec7SMiao Xie } 177716cdcec7SMiao Xie 177816cdcec7SMiao Xie static void fill_stack_inode_item(struct btrfs_trans_handle *trans, 177916cdcec7SMiao Xie struct btrfs_inode_item *inode_item, 178016cdcec7SMiao Xie struct inode *inode) 178116cdcec7SMiao Xie { 178277eea05eSBoris Burkov u64 flags; 178377eea05eSBoris Burkov 17842f2f43d3SEric W. Biederman btrfs_set_stack_inode_uid(inode_item, i_uid_read(inode)); 17852f2f43d3SEric W. Biederman btrfs_set_stack_inode_gid(inode_item, i_gid_read(inode)); 178616cdcec7SMiao Xie btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size); 178716cdcec7SMiao Xie btrfs_set_stack_inode_mode(inode_item, inode->i_mode); 178816cdcec7SMiao Xie btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink); 178916cdcec7SMiao Xie btrfs_set_stack_inode_nbytes(inode_item, inode_get_bytes(inode)); 179016cdcec7SMiao Xie btrfs_set_stack_inode_generation(inode_item, 179116cdcec7SMiao Xie BTRFS_I(inode)->generation); 1792c7f88c4eSJeff Layton btrfs_set_stack_inode_sequence(inode_item, 1793c7f88c4eSJeff Layton inode_peek_iversion(inode)); 179416cdcec7SMiao Xie btrfs_set_stack_inode_transid(inode_item, trans->transid); 179516cdcec7SMiao Xie btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev); 179677eea05eSBoris Burkov flags = btrfs_inode_combine_flags(BTRFS_I(inode)->flags, 179777eea05eSBoris Burkov BTRFS_I(inode)->ro_flags); 179877eea05eSBoris Burkov btrfs_set_stack_inode_flags(inode_item, flags); 1799ff5714ccSChris Mason btrfs_set_stack_inode_block_group(inode_item, 0); 180016cdcec7SMiao Xie 1801a937b979SDavid Sterba btrfs_set_stack_timespec_sec(&inode_item->atime, 180216cdcec7SMiao Xie inode->i_atime.tv_sec); 1803a937b979SDavid Sterba btrfs_set_stack_timespec_nsec(&inode_item->atime, 180416cdcec7SMiao Xie inode->i_atime.tv_nsec); 180516cdcec7SMiao Xie 1806a937b979SDavid Sterba btrfs_set_stack_timespec_sec(&inode_item->mtime, 180716cdcec7SMiao Xie inode->i_mtime.tv_sec); 1808a937b979SDavid Sterba btrfs_set_stack_timespec_nsec(&inode_item->mtime, 180916cdcec7SMiao Xie inode->i_mtime.tv_nsec); 181016cdcec7SMiao Xie 1811a937b979SDavid Sterba btrfs_set_stack_timespec_sec(&inode_item->ctime, 181216cdcec7SMiao Xie inode->i_ctime.tv_sec); 1813a937b979SDavid Sterba btrfs_set_stack_timespec_nsec(&inode_item->ctime, 181416cdcec7SMiao Xie inode->i_ctime.tv_nsec); 18159cc97d64Schandan r 18169cc97d64Schandan r btrfs_set_stack_timespec_sec(&inode_item->otime, 18179cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_sec); 18189cc97d64Schandan r btrfs_set_stack_timespec_nsec(&inode_item->otime, 18199cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_nsec); 182016cdcec7SMiao Xie } 182116cdcec7SMiao Xie 18222f7e33d4SMiao Xie int btrfs_fill_inode(struct inode *inode, u32 *rdev) 18232f7e33d4SMiao Xie { 18249ddc959eSJosef Bacik struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; 18252f7e33d4SMiao Xie struct btrfs_delayed_node *delayed_node; 18262f7e33d4SMiao Xie struct btrfs_inode_item *inode_item; 18272f7e33d4SMiao Xie 1828340c6ca9SNikolay Borisov delayed_node = btrfs_get_delayed_node(BTRFS_I(inode)); 18292f7e33d4SMiao Xie if (!delayed_node) 18302f7e33d4SMiao Xie return -ENOENT; 18312f7e33d4SMiao Xie 18322f7e33d4SMiao Xie mutex_lock(&delayed_node->mutex); 18337cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 18342f7e33d4SMiao Xie mutex_unlock(&delayed_node->mutex); 18352f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 18362f7e33d4SMiao Xie return -ENOENT; 18372f7e33d4SMiao Xie } 18382f7e33d4SMiao Xie 18392f7e33d4SMiao Xie inode_item = &delayed_node->inode_item; 18402f7e33d4SMiao Xie 18412f2f43d3SEric W. Biederman i_uid_write(inode, btrfs_stack_inode_uid(inode_item)); 18422f2f43d3SEric W. Biederman i_gid_write(inode, btrfs_stack_inode_gid(inode_item)); 18436ef06d27SNikolay Borisov btrfs_i_size_write(BTRFS_I(inode), btrfs_stack_inode_size(inode_item)); 18449ddc959eSJosef Bacik btrfs_inode_set_file_extent_range(BTRFS_I(inode), 0, 18459ddc959eSJosef Bacik round_up(i_size_read(inode), fs_info->sectorsize)); 18462f7e33d4SMiao Xie inode->i_mode = btrfs_stack_inode_mode(inode_item); 1847bfe86848SMiklos Szeredi set_nlink(inode, btrfs_stack_inode_nlink(inode_item)); 18482f7e33d4SMiao Xie inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item)); 18492f7e33d4SMiao Xie BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item); 18506e17d30bSYang Dongsheng BTRFS_I(inode)->last_trans = btrfs_stack_inode_transid(inode_item); 18516e17d30bSYang Dongsheng 1852c7f88c4eSJeff Layton inode_set_iversion_queried(inode, 1853c7f88c4eSJeff Layton btrfs_stack_inode_sequence(inode_item)); 18542f7e33d4SMiao Xie inode->i_rdev = 0; 18552f7e33d4SMiao Xie *rdev = btrfs_stack_inode_rdev(inode_item); 185677eea05eSBoris Burkov btrfs_inode_split_flags(btrfs_stack_inode_flags(inode_item), 185777eea05eSBoris Burkov &BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags); 18582f7e33d4SMiao Xie 1859a937b979SDavid Sterba inode->i_atime.tv_sec = btrfs_stack_timespec_sec(&inode_item->atime); 1860a937b979SDavid Sterba inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->atime); 18612f7e33d4SMiao Xie 1862a937b979SDavid Sterba inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(&inode_item->mtime); 1863a937b979SDavid Sterba inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->mtime); 18642f7e33d4SMiao Xie 1865a937b979SDavid Sterba inode->i_ctime.tv_sec = btrfs_stack_timespec_sec(&inode_item->ctime); 1866a937b979SDavid Sterba inode->i_ctime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->ctime); 18672f7e33d4SMiao Xie 18689cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_sec = 18699cc97d64Schandan r btrfs_stack_timespec_sec(&inode_item->otime); 18709cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_nsec = 18719cc97d64Schandan r btrfs_stack_timespec_nsec(&inode_item->otime); 18729cc97d64Schandan r 18732f7e33d4SMiao Xie inode->i_generation = BTRFS_I(inode)->generation; 18742f7e33d4SMiao Xie BTRFS_I(inode)->index_cnt = (u64)-1; 18752f7e33d4SMiao Xie 18762f7e33d4SMiao Xie mutex_unlock(&delayed_node->mutex); 18772f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 18782f7e33d4SMiao Xie return 0; 18792f7e33d4SMiao Xie } 18802f7e33d4SMiao Xie 188116cdcec7SMiao Xie int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans, 1882f3fbcaefSNikolay Borisov struct btrfs_root *root, 1883f3fbcaefSNikolay Borisov struct btrfs_inode *inode) 188416cdcec7SMiao Xie { 188516cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 1886aa0467d8SDavid Sterba int ret = 0; 188716cdcec7SMiao Xie 1888f3fbcaefSNikolay Borisov delayed_node = btrfs_get_or_create_delayed_node(inode); 188916cdcec7SMiao Xie if (IS_ERR(delayed_node)) 189016cdcec7SMiao Xie return PTR_ERR(delayed_node); 189116cdcec7SMiao Xie 189216cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 18937cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 1894f3fbcaefSNikolay Borisov fill_stack_inode_item(trans, &delayed_node->inode_item, 1895f3fbcaefSNikolay Borisov &inode->vfs_inode); 189616cdcec7SMiao Xie goto release_node; 189716cdcec7SMiao Xie } 189816cdcec7SMiao Xie 18998e3c9d3cSNikolay Borisov ret = btrfs_delayed_inode_reserve_metadata(trans, root, delayed_node); 1900c06a0e12SJosef Bacik if (ret) 1901c06a0e12SJosef Bacik goto release_node; 190216cdcec7SMiao Xie 1903f3fbcaefSNikolay Borisov fill_stack_inode_item(trans, &delayed_node->inode_item, &inode->vfs_inode); 19047cf35d91SMiao Xie set_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); 190516cdcec7SMiao Xie delayed_node->count++; 190616cdcec7SMiao Xie atomic_inc(&root->fs_info->delayed_root->items); 190716cdcec7SMiao Xie release_node: 190816cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 190916cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 191016cdcec7SMiao Xie return ret; 191116cdcec7SMiao Xie } 191216cdcec7SMiao Xie 1913e07222c7SNikolay Borisov int btrfs_delayed_delete_inode_ref(struct btrfs_inode *inode) 191467de1176SMiao Xie { 19153ffbd68cSDavid Sterba struct btrfs_fs_info *fs_info = inode->root->fs_info; 191667de1176SMiao Xie struct btrfs_delayed_node *delayed_node; 191767de1176SMiao Xie 19186f896054SChris Mason /* 19196f896054SChris Mason * we don't do delayed inode updates during log recovery because it 19206f896054SChris Mason * leads to enospc problems. This means we also can't do 19216f896054SChris Mason * delayed inode refs 19226f896054SChris Mason */ 19230b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 19246f896054SChris Mason return -EAGAIN; 19256f896054SChris Mason 1926e07222c7SNikolay Borisov delayed_node = btrfs_get_or_create_delayed_node(inode); 192767de1176SMiao Xie if (IS_ERR(delayed_node)) 192867de1176SMiao Xie return PTR_ERR(delayed_node); 192967de1176SMiao Xie 193067de1176SMiao Xie /* 193167de1176SMiao Xie * We don't reserve space for inode ref deletion is because: 193267de1176SMiao Xie * - We ONLY do async inode ref deletion for the inode who has only 193367de1176SMiao Xie * one link(i_nlink == 1), it means there is only one inode ref. 193467de1176SMiao Xie * And in most case, the inode ref and the inode item are in the 193567de1176SMiao Xie * same leaf, and we will deal with them at the same time. 193667de1176SMiao Xie * Since we are sure we will reserve the space for the inode item, 193767de1176SMiao Xie * it is unnecessary to reserve space for inode ref deletion. 193867de1176SMiao Xie * - If the inode ref and the inode item are not in the same leaf, 193967de1176SMiao Xie * We also needn't worry about enospc problem, because we reserve 194067de1176SMiao Xie * much more space for the inode update than it needs. 194167de1176SMiao Xie * - At the worst, we can steal some space from the global reservation. 194267de1176SMiao Xie * It is very rare. 194367de1176SMiao Xie */ 194467de1176SMiao Xie mutex_lock(&delayed_node->mutex); 194567de1176SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) 194667de1176SMiao Xie goto release_node; 194767de1176SMiao Xie 194867de1176SMiao Xie set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags); 194967de1176SMiao Xie delayed_node->count++; 19500b246afaSJeff Mahoney atomic_inc(&fs_info->delayed_root->items); 195167de1176SMiao Xie release_node: 195267de1176SMiao Xie mutex_unlock(&delayed_node->mutex); 195367de1176SMiao Xie btrfs_release_delayed_node(delayed_node); 195467de1176SMiao Xie return 0; 195567de1176SMiao Xie } 195667de1176SMiao Xie 195716cdcec7SMiao Xie static void __btrfs_kill_delayed_node(struct btrfs_delayed_node *delayed_node) 195816cdcec7SMiao Xie { 195916cdcec7SMiao Xie struct btrfs_root *root = delayed_node->root; 19602ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 196116cdcec7SMiao Xie struct btrfs_delayed_item *curr_item, *prev_item; 196216cdcec7SMiao Xie 196316cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 196416cdcec7SMiao Xie curr_item = __btrfs_first_delayed_insertion_item(delayed_node); 196516cdcec7SMiao Xie while (curr_item) { 196616cdcec7SMiao Xie prev_item = curr_item; 196716cdcec7SMiao Xie curr_item = __btrfs_next_delayed_item(prev_item); 196816cdcec7SMiao Xie btrfs_release_delayed_item(prev_item); 196916cdcec7SMiao Xie } 197016cdcec7SMiao Xie 1971763748b2SFilipe Manana if (delayed_node->index_item_leaves > 0) { 1972763748b2SFilipe Manana btrfs_delayed_item_release_leaves(delayed_node, 1973763748b2SFilipe Manana delayed_node->index_item_leaves); 1974763748b2SFilipe Manana delayed_node->index_item_leaves = 0; 1975763748b2SFilipe Manana } 1976763748b2SFilipe Manana 197716cdcec7SMiao Xie curr_item = __btrfs_first_delayed_deletion_item(delayed_node); 197816cdcec7SMiao Xie while (curr_item) { 19794f5427ccSQu Wenruo btrfs_delayed_item_release_metadata(root, curr_item); 198016cdcec7SMiao Xie prev_item = curr_item; 198116cdcec7SMiao Xie curr_item = __btrfs_next_delayed_item(prev_item); 198216cdcec7SMiao Xie btrfs_release_delayed_item(prev_item); 198316cdcec7SMiao Xie } 198416cdcec7SMiao Xie 198567de1176SMiao Xie btrfs_release_delayed_iref(delayed_node); 198667de1176SMiao Xie 19877cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 19884f5427ccSQu Wenruo btrfs_delayed_inode_release_metadata(fs_info, delayed_node, false); 198916cdcec7SMiao Xie btrfs_release_delayed_inode(delayed_node); 199016cdcec7SMiao Xie } 199116cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 199216cdcec7SMiao Xie } 199316cdcec7SMiao Xie 19944ccb5c72SNikolay Borisov void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode) 199516cdcec7SMiao Xie { 199616cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 199716cdcec7SMiao Xie 19984ccb5c72SNikolay Borisov delayed_node = btrfs_get_delayed_node(inode); 199916cdcec7SMiao Xie if (!delayed_node) 200016cdcec7SMiao Xie return; 200116cdcec7SMiao Xie 200216cdcec7SMiao Xie __btrfs_kill_delayed_node(delayed_node); 200316cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 200416cdcec7SMiao Xie } 200516cdcec7SMiao Xie 200616cdcec7SMiao Xie void btrfs_kill_all_delayed_nodes(struct btrfs_root *root) 200716cdcec7SMiao Xie { 2008088aea3bSDavid Sterba u64 inode_id = 0; 200916cdcec7SMiao Xie struct btrfs_delayed_node *delayed_nodes[8]; 2010088aea3bSDavid Sterba int i, n; 201116cdcec7SMiao Xie 201216cdcec7SMiao Xie while (1) { 201316cdcec7SMiao Xie spin_lock(&root->inode_lock); 2014088aea3bSDavid Sterba n = radix_tree_gang_lookup(&root->delayed_nodes_tree, 2015088aea3bSDavid Sterba (void **)delayed_nodes, inode_id, 2016088aea3bSDavid Sterba ARRAY_SIZE(delayed_nodes)); 2017088aea3bSDavid Sterba if (!n) { 201816cdcec7SMiao Xie spin_unlock(&root->inode_lock); 2019088aea3bSDavid Sterba break; 202016cdcec7SMiao Xie } 202116cdcec7SMiao Xie 2022088aea3bSDavid Sterba inode_id = delayed_nodes[n - 1]->inode_id + 1; 2023088aea3bSDavid Sterba for (i = 0; i < n; i++) { 2024baf320b9SJosef Bacik /* 2025baf320b9SJosef Bacik * Don't increase refs in case the node is dead and 2026baf320b9SJosef Bacik * about to be removed from the tree in the loop below 2027baf320b9SJosef Bacik */ 2028088aea3bSDavid Sterba if (!refcount_inc_not_zero(&delayed_nodes[i]->refs)) 2029088aea3bSDavid Sterba delayed_nodes[i] = NULL; 2030baf320b9SJosef Bacik } 203116cdcec7SMiao Xie spin_unlock(&root->inode_lock); 203216cdcec7SMiao Xie 2033088aea3bSDavid Sterba for (i = 0; i < n; i++) { 2034088aea3bSDavid Sterba if (!delayed_nodes[i]) 2035088aea3bSDavid Sterba continue; 203616cdcec7SMiao Xie __btrfs_kill_delayed_node(delayed_nodes[i]); 203716cdcec7SMiao Xie btrfs_release_delayed_node(delayed_nodes[i]); 203816cdcec7SMiao Xie } 203916cdcec7SMiao Xie } 204016cdcec7SMiao Xie } 204167cde344SMiao Xie 2042ccdf9b30SJeff Mahoney void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info) 204367cde344SMiao Xie { 204467cde344SMiao Xie struct btrfs_delayed_node *curr_node, *prev_node; 204567cde344SMiao Xie 2046ccdf9b30SJeff Mahoney curr_node = btrfs_first_delayed_node(fs_info->delayed_root); 204767cde344SMiao Xie while (curr_node) { 204867cde344SMiao Xie __btrfs_kill_delayed_node(curr_node); 204967cde344SMiao Xie 205067cde344SMiao Xie prev_node = curr_node; 205167cde344SMiao Xie curr_node = btrfs_next_delayed_node(curr_node); 205267cde344SMiao Xie btrfs_release_delayed_node(prev_node); 205367cde344SMiao Xie } 205467cde344SMiao Xie } 205567cde344SMiao Xie 205630b80f3cSFilipe Manana void btrfs_log_get_delayed_items(struct btrfs_inode *inode, 205730b80f3cSFilipe Manana struct list_head *ins_list, 205830b80f3cSFilipe Manana struct list_head *del_list) 205930b80f3cSFilipe Manana { 206030b80f3cSFilipe Manana struct btrfs_delayed_node *node; 206130b80f3cSFilipe Manana struct btrfs_delayed_item *item; 206230b80f3cSFilipe Manana 206330b80f3cSFilipe Manana node = btrfs_get_delayed_node(inode); 206430b80f3cSFilipe Manana if (!node) 206530b80f3cSFilipe Manana return; 206630b80f3cSFilipe Manana 206730b80f3cSFilipe Manana mutex_lock(&node->mutex); 206830b80f3cSFilipe Manana item = __btrfs_first_delayed_insertion_item(node); 206930b80f3cSFilipe Manana while (item) { 207030b80f3cSFilipe Manana /* 207130b80f3cSFilipe Manana * It's possible that the item is already in a log list. This 207230b80f3cSFilipe Manana * can happen in case two tasks are trying to log the same 207330b80f3cSFilipe Manana * directory. For example if we have tasks A and task B: 207430b80f3cSFilipe Manana * 207530b80f3cSFilipe Manana * Task A collected the delayed items into a log list while 207630b80f3cSFilipe Manana * under the inode's log_mutex (at btrfs_log_inode()), but it 207730b80f3cSFilipe Manana * only releases the items after logging the inodes they point 207830b80f3cSFilipe Manana * to (if they are new inodes), which happens after unlocking 207930b80f3cSFilipe Manana * the log mutex; 208030b80f3cSFilipe Manana * 208130b80f3cSFilipe Manana * Task B enters btrfs_log_inode() and acquires the log_mutex 208230b80f3cSFilipe Manana * of the same directory inode, before task B releases the 208330b80f3cSFilipe Manana * delayed items. This can happen for example when logging some 208430b80f3cSFilipe Manana * inode we need to trigger logging of its parent directory, so 208530b80f3cSFilipe Manana * logging two files that have the same parent directory can 208630b80f3cSFilipe Manana * lead to this. 208730b80f3cSFilipe Manana * 208830b80f3cSFilipe Manana * If this happens, just ignore delayed items already in a log 208930b80f3cSFilipe Manana * list. All the tasks logging the directory are under a log 209030b80f3cSFilipe Manana * transaction and whichever finishes first can not sync the log 209130b80f3cSFilipe Manana * before the other completes and leaves the log transaction. 209230b80f3cSFilipe Manana */ 209330b80f3cSFilipe Manana if (!item->logged && list_empty(&item->log_list)) { 209430b80f3cSFilipe Manana refcount_inc(&item->refs); 209530b80f3cSFilipe Manana list_add_tail(&item->log_list, ins_list); 209630b80f3cSFilipe Manana } 209730b80f3cSFilipe Manana item = __btrfs_next_delayed_item(item); 209830b80f3cSFilipe Manana } 209930b80f3cSFilipe Manana 210030b80f3cSFilipe Manana item = __btrfs_first_delayed_deletion_item(node); 210130b80f3cSFilipe Manana while (item) { 210230b80f3cSFilipe Manana /* It may be non-empty, for the same reason mentioned above. */ 210330b80f3cSFilipe Manana if (!item->logged && list_empty(&item->log_list)) { 210430b80f3cSFilipe Manana refcount_inc(&item->refs); 210530b80f3cSFilipe Manana list_add_tail(&item->log_list, del_list); 210630b80f3cSFilipe Manana } 210730b80f3cSFilipe Manana item = __btrfs_next_delayed_item(item); 210830b80f3cSFilipe Manana } 210930b80f3cSFilipe Manana mutex_unlock(&node->mutex); 211030b80f3cSFilipe Manana 211130b80f3cSFilipe Manana /* 211230b80f3cSFilipe Manana * We are called during inode logging, which means the inode is in use 211330b80f3cSFilipe Manana * and can not be evicted before we finish logging the inode. So we never 211430b80f3cSFilipe Manana * have the last reference on the delayed inode. 211530b80f3cSFilipe Manana * Also, we don't use btrfs_release_delayed_node() because that would 211630b80f3cSFilipe Manana * requeue the delayed inode (change its order in the list of prepared 211730b80f3cSFilipe Manana * nodes) and we don't want to do such change because we don't create or 211830b80f3cSFilipe Manana * delete delayed items. 211930b80f3cSFilipe Manana */ 212030b80f3cSFilipe Manana ASSERT(refcount_read(&node->refs) > 1); 212130b80f3cSFilipe Manana refcount_dec(&node->refs); 212230b80f3cSFilipe Manana } 212330b80f3cSFilipe Manana 212430b80f3cSFilipe Manana void btrfs_log_put_delayed_items(struct btrfs_inode *inode, 212530b80f3cSFilipe Manana struct list_head *ins_list, 212630b80f3cSFilipe Manana struct list_head *del_list) 212730b80f3cSFilipe Manana { 212830b80f3cSFilipe Manana struct btrfs_delayed_node *node; 212930b80f3cSFilipe Manana struct btrfs_delayed_item *item; 213030b80f3cSFilipe Manana struct btrfs_delayed_item *next; 213130b80f3cSFilipe Manana 213230b80f3cSFilipe Manana node = btrfs_get_delayed_node(inode); 213330b80f3cSFilipe Manana if (!node) 213430b80f3cSFilipe Manana return; 213530b80f3cSFilipe Manana 213630b80f3cSFilipe Manana mutex_lock(&node->mutex); 213730b80f3cSFilipe Manana 213830b80f3cSFilipe Manana list_for_each_entry_safe(item, next, ins_list, log_list) { 213930b80f3cSFilipe Manana item->logged = true; 214030b80f3cSFilipe Manana list_del_init(&item->log_list); 214130b80f3cSFilipe Manana if (refcount_dec_and_test(&item->refs)) 214230b80f3cSFilipe Manana kfree(item); 214330b80f3cSFilipe Manana } 214430b80f3cSFilipe Manana 214530b80f3cSFilipe Manana list_for_each_entry_safe(item, next, del_list, log_list) { 214630b80f3cSFilipe Manana item->logged = true; 214730b80f3cSFilipe Manana list_del_init(&item->log_list); 214830b80f3cSFilipe Manana if (refcount_dec_and_test(&item->refs)) 214930b80f3cSFilipe Manana kfree(item); 215030b80f3cSFilipe Manana } 215130b80f3cSFilipe Manana 215230b80f3cSFilipe Manana mutex_unlock(&node->mutex); 215330b80f3cSFilipe Manana 215430b80f3cSFilipe Manana /* 215530b80f3cSFilipe Manana * We are called during inode logging, which means the inode is in use 215630b80f3cSFilipe Manana * and can not be evicted before we finish logging the inode. So we never 215730b80f3cSFilipe Manana * have the last reference on the delayed inode. 215830b80f3cSFilipe Manana * Also, we don't use btrfs_release_delayed_node() because that would 215930b80f3cSFilipe Manana * requeue the delayed inode (change its order in the list of prepared 216030b80f3cSFilipe Manana * nodes) and we don't want to do such change because we don't create or 216130b80f3cSFilipe Manana * delete delayed items. 216230b80f3cSFilipe Manana */ 216330b80f3cSFilipe Manana ASSERT(refcount_read(&node->refs) > 1); 216430b80f3cSFilipe Manana refcount_dec(&node->refs); 216530b80f3cSFilipe Manana } 2166