116cdcec7SMiao Xie /* 216cdcec7SMiao Xie * Copyright (C) 2011 Fujitsu. All rights reserved. 316cdcec7SMiao Xie * Written by Miao Xie <miaox@cn.fujitsu.com> 416cdcec7SMiao Xie * 516cdcec7SMiao Xie * This program is free software; you can redistribute it and/or 616cdcec7SMiao Xie * modify it under the terms of the GNU General Public 716cdcec7SMiao Xie * License v2 as published by the Free Software Foundation. 816cdcec7SMiao Xie * 916cdcec7SMiao Xie * This program is distributed in the hope that it will be useful, 1016cdcec7SMiao Xie * but WITHOUT ANY WARRANTY; without even the implied warranty of 1116cdcec7SMiao Xie * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 1216cdcec7SMiao Xie * General Public License for more details. 1316cdcec7SMiao Xie * 1416cdcec7SMiao Xie * You should have received a copy of the GNU General Public 1516cdcec7SMiao Xie * License along with this program; if not, write to the 1616cdcec7SMiao Xie * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 1716cdcec7SMiao Xie * Boston, MA 021110-1307, USA. 1816cdcec7SMiao Xie */ 1916cdcec7SMiao Xie 2016cdcec7SMiao Xie #include <linux/slab.h> 2116cdcec7SMiao Xie #include "delayed-inode.h" 2216cdcec7SMiao Xie #include "disk-io.h" 2316cdcec7SMiao Xie #include "transaction.h" 243cae210fSQu Wenruo #include "ctree.h" 2516cdcec7SMiao Xie 26de3cb945SChris Mason #define BTRFS_DELAYED_WRITEBACK 512 27de3cb945SChris Mason #define BTRFS_DELAYED_BACKGROUND 128 28de3cb945SChris Mason #define BTRFS_DELAYED_BATCH 16 2916cdcec7SMiao Xie 3016cdcec7SMiao Xie static struct kmem_cache *delayed_node_cache; 3116cdcec7SMiao Xie 3216cdcec7SMiao Xie int __init btrfs_delayed_inode_init(void) 3316cdcec7SMiao Xie { 34837e1972SDavid Sterba delayed_node_cache = kmem_cache_create("btrfs_delayed_node", 3516cdcec7SMiao Xie sizeof(struct btrfs_delayed_node), 3616cdcec7SMiao Xie 0, 37fba4b697SNikolay Borisov SLAB_MEM_SPREAD, 3816cdcec7SMiao Xie NULL); 3916cdcec7SMiao Xie if (!delayed_node_cache) 4016cdcec7SMiao Xie return -ENOMEM; 4116cdcec7SMiao Xie return 0; 4216cdcec7SMiao Xie } 4316cdcec7SMiao Xie 4416cdcec7SMiao Xie void btrfs_delayed_inode_exit(void) 4516cdcec7SMiao Xie { 4616cdcec7SMiao Xie kmem_cache_destroy(delayed_node_cache); 4716cdcec7SMiao Xie } 4816cdcec7SMiao Xie 4916cdcec7SMiao Xie static inline void btrfs_init_delayed_node( 5016cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 5116cdcec7SMiao Xie struct btrfs_root *root, u64 inode_id) 5216cdcec7SMiao Xie { 5316cdcec7SMiao Xie delayed_node->root = root; 5416cdcec7SMiao Xie delayed_node->inode_id = inode_id; 5516cdcec7SMiao Xie atomic_set(&delayed_node->refs, 0); 5616cdcec7SMiao Xie delayed_node->ins_root = RB_ROOT; 5716cdcec7SMiao Xie delayed_node->del_root = RB_ROOT; 5816cdcec7SMiao Xie mutex_init(&delayed_node->mutex); 5916cdcec7SMiao Xie INIT_LIST_HEAD(&delayed_node->n_list); 6016cdcec7SMiao Xie INIT_LIST_HEAD(&delayed_node->p_list); 6116cdcec7SMiao Xie } 6216cdcec7SMiao Xie 6316cdcec7SMiao Xie static inline int btrfs_is_continuous_delayed_item( 6416cdcec7SMiao Xie struct btrfs_delayed_item *item1, 6516cdcec7SMiao Xie struct btrfs_delayed_item *item2) 6616cdcec7SMiao Xie { 6716cdcec7SMiao Xie if (item1->key.type == BTRFS_DIR_INDEX_KEY && 6816cdcec7SMiao Xie item1->key.objectid == item2->key.objectid && 6916cdcec7SMiao Xie item1->key.type == item2->key.type && 7016cdcec7SMiao Xie item1->key.offset + 1 == item2->key.offset) 7116cdcec7SMiao Xie return 1; 7216cdcec7SMiao Xie return 0; 7316cdcec7SMiao Xie } 7416cdcec7SMiao Xie 75340c6ca9SNikolay Borisov static struct btrfs_delayed_node *btrfs_get_delayed_node(struct btrfs_inode *btrfs_inode) 762f7e33d4SMiao Xie { 772f7e33d4SMiao Xie struct btrfs_root *root = btrfs_inode->root; 784a0cc7caSNikolay Borisov u64 ino = btrfs_ino(btrfs_inode); 792f7e33d4SMiao Xie struct btrfs_delayed_node *node; 802f7e33d4SMiao Xie 8120c7bcecSSeraphime Kirkovski node = READ_ONCE(btrfs_inode->delayed_node); 822f7e33d4SMiao Xie if (node) { 832f7e33d4SMiao Xie atomic_inc(&node->refs); 842f7e33d4SMiao Xie return node; 852f7e33d4SMiao Xie } 862f7e33d4SMiao Xie 872f7e33d4SMiao Xie spin_lock(&root->inode_lock); 882f7e33d4SMiao Xie node = radix_tree_lookup(&root->delayed_nodes_tree, ino); 892f7e33d4SMiao Xie if (node) { 902f7e33d4SMiao Xie if (btrfs_inode->delayed_node) { 912f7e33d4SMiao Xie atomic_inc(&node->refs); /* can be accessed */ 922f7e33d4SMiao Xie BUG_ON(btrfs_inode->delayed_node != node); 932f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 942f7e33d4SMiao Xie return node; 952f7e33d4SMiao Xie } 962f7e33d4SMiao Xie btrfs_inode->delayed_node = node; 9795e94d14SRashika /* can be accessed and cached in the inode */ 9895e94d14SRashika atomic_add(2, &node->refs); 992f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 1002f7e33d4SMiao Xie return node; 1012f7e33d4SMiao Xie } 1022f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 1032f7e33d4SMiao Xie 1042f7e33d4SMiao Xie return NULL; 1052f7e33d4SMiao Xie } 1062f7e33d4SMiao Xie 10779787eaaSJeff Mahoney /* Will return either the node or PTR_ERR(-ENOMEM) */ 10816cdcec7SMiao Xie static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node( 109e5517a7bSNikolay Borisov struct btrfs_inode *btrfs_inode) 11016cdcec7SMiao Xie { 11116cdcec7SMiao Xie struct btrfs_delayed_node *node; 11216cdcec7SMiao Xie struct btrfs_root *root = btrfs_inode->root; 1134a0cc7caSNikolay Borisov u64 ino = btrfs_ino(btrfs_inode); 11416cdcec7SMiao Xie int ret; 11516cdcec7SMiao Xie 11616cdcec7SMiao Xie again: 117340c6ca9SNikolay Borisov node = btrfs_get_delayed_node(btrfs_inode); 1182f7e33d4SMiao Xie if (node) 11916cdcec7SMiao Xie return node; 12016cdcec7SMiao Xie 121352dd9c8SAlexandru Moise node = kmem_cache_zalloc(delayed_node_cache, GFP_NOFS); 12216cdcec7SMiao Xie if (!node) 12316cdcec7SMiao Xie return ERR_PTR(-ENOMEM); 1240d0ca30fSChris Mason btrfs_init_delayed_node(node, root, ino); 12516cdcec7SMiao Xie 12695e94d14SRashika /* cached in the btrfs inode and can be accessed */ 12795e94d14SRashika atomic_add(2, &node->refs); 12816cdcec7SMiao Xie 129e1860a77SDavid Sterba ret = radix_tree_preload(GFP_NOFS); 13016cdcec7SMiao Xie if (ret) { 13116cdcec7SMiao Xie kmem_cache_free(delayed_node_cache, node); 13216cdcec7SMiao Xie return ERR_PTR(ret); 13316cdcec7SMiao Xie } 13416cdcec7SMiao Xie 13516cdcec7SMiao Xie spin_lock(&root->inode_lock); 1360d0ca30fSChris Mason ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node); 13716cdcec7SMiao Xie if (ret == -EEXIST) { 13816cdcec7SMiao Xie spin_unlock(&root->inode_lock); 13996493031SJeff Mahoney kmem_cache_free(delayed_node_cache, node); 14016cdcec7SMiao Xie radix_tree_preload_end(); 14116cdcec7SMiao Xie goto again; 14216cdcec7SMiao Xie } 14316cdcec7SMiao Xie btrfs_inode->delayed_node = node; 14416cdcec7SMiao Xie spin_unlock(&root->inode_lock); 14516cdcec7SMiao Xie radix_tree_preload_end(); 14616cdcec7SMiao Xie 14716cdcec7SMiao Xie return node; 14816cdcec7SMiao Xie } 14916cdcec7SMiao Xie 15016cdcec7SMiao Xie /* 15116cdcec7SMiao Xie * Call it when holding delayed_node->mutex 15216cdcec7SMiao Xie * 15316cdcec7SMiao Xie * If mod = 1, add this node into the prepared list. 15416cdcec7SMiao Xie */ 15516cdcec7SMiao Xie static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root, 15616cdcec7SMiao Xie struct btrfs_delayed_node *node, 15716cdcec7SMiao Xie int mod) 15816cdcec7SMiao Xie { 15916cdcec7SMiao Xie spin_lock(&root->lock); 1607cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 16116cdcec7SMiao Xie if (!list_empty(&node->p_list)) 16216cdcec7SMiao Xie list_move_tail(&node->p_list, &root->prepare_list); 16316cdcec7SMiao Xie else if (mod) 16416cdcec7SMiao Xie list_add_tail(&node->p_list, &root->prepare_list); 16516cdcec7SMiao Xie } else { 16616cdcec7SMiao Xie list_add_tail(&node->n_list, &root->node_list); 16716cdcec7SMiao Xie list_add_tail(&node->p_list, &root->prepare_list); 16816cdcec7SMiao Xie atomic_inc(&node->refs); /* inserted into list */ 16916cdcec7SMiao Xie root->nodes++; 1707cf35d91SMiao Xie set_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); 17116cdcec7SMiao Xie } 17216cdcec7SMiao Xie spin_unlock(&root->lock); 17316cdcec7SMiao Xie } 17416cdcec7SMiao Xie 17516cdcec7SMiao Xie /* Call it when holding delayed_node->mutex */ 17616cdcec7SMiao Xie static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root, 17716cdcec7SMiao Xie struct btrfs_delayed_node *node) 17816cdcec7SMiao Xie { 17916cdcec7SMiao Xie spin_lock(&root->lock); 1807cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 18116cdcec7SMiao Xie root->nodes--; 18216cdcec7SMiao Xie atomic_dec(&node->refs); /* not in the list */ 18316cdcec7SMiao Xie list_del_init(&node->n_list); 18416cdcec7SMiao Xie if (!list_empty(&node->p_list)) 18516cdcec7SMiao Xie list_del_init(&node->p_list); 1867cf35d91SMiao Xie clear_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags); 18716cdcec7SMiao Xie } 18816cdcec7SMiao Xie spin_unlock(&root->lock); 18916cdcec7SMiao Xie } 19016cdcec7SMiao Xie 19148a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_first_delayed_node( 19216cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root) 19316cdcec7SMiao Xie { 19416cdcec7SMiao Xie struct list_head *p; 19516cdcec7SMiao Xie struct btrfs_delayed_node *node = NULL; 19616cdcec7SMiao Xie 19716cdcec7SMiao Xie spin_lock(&delayed_root->lock); 19816cdcec7SMiao Xie if (list_empty(&delayed_root->node_list)) 19916cdcec7SMiao Xie goto out; 20016cdcec7SMiao Xie 20116cdcec7SMiao Xie p = delayed_root->node_list.next; 20216cdcec7SMiao Xie node = list_entry(p, struct btrfs_delayed_node, n_list); 20316cdcec7SMiao Xie atomic_inc(&node->refs); 20416cdcec7SMiao Xie out: 20516cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 20616cdcec7SMiao Xie 20716cdcec7SMiao Xie return node; 20816cdcec7SMiao Xie } 20916cdcec7SMiao Xie 21048a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_next_delayed_node( 21116cdcec7SMiao Xie struct btrfs_delayed_node *node) 21216cdcec7SMiao Xie { 21316cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 21416cdcec7SMiao Xie struct list_head *p; 21516cdcec7SMiao Xie struct btrfs_delayed_node *next = NULL; 21616cdcec7SMiao Xie 21716cdcec7SMiao Xie delayed_root = node->root->fs_info->delayed_root; 21816cdcec7SMiao Xie spin_lock(&delayed_root->lock); 2197cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_IN_LIST, &node->flags)) { 2207cf35d91SMiao Xie /* not in the list */ 22116cdcec7SMiao Xie if (list_empty(&delayed_root->node_list)) 22216cdcec7SMiao Xie goto out; 22316cdcec7SMiao Xie p = delayed_root->node_list.next; 22416cdcec7SMiao Xie } else if (list_is_last(&node->n_list, &delayed_root->node_list)) 22516cdcec7SMiao Xie goto out; 22616cdcec7SMiao Xie else 22716cdcec7SMiao Xie p = node->n_list.next; 22816cdcec7SMiao Xie 22916cdcec7SMiao Xie next = list_entry(p, struct btrfs_delayed_node, n_list); 23016cdcec7SMiao Xie atomic_inc(&next->refs); 23116cdcec7SMiao Xie out: 23216cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 23316cdcec7SMiao Xie 23416cdcec7SMiao Xie return next; 23516cdcec7SMiao Xie } 23616cdcec7SMiao Xie 23716cdcec7SMiao Xie static void __btrfs_release_delayed_node( 23816cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 23916cdcec7SMiao Xie int mod) 24016cdcec7SMiao Xie { 24116cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 24216cdcec7SMiao Xie 24316cdcec7SMiao Xie if (!delayed_node) 24416cdcec7SMiao Xie return; 24516cdcec7SMiao Xie 24616cdcec7SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 24716cdcec7SMiao Xie 24816cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 24916cdcec7SMiao Xie if (delayed_node->count) 25016cdcec7SMiao Xie btrfs_queue_delayed_node(delayed_root, delayed_node, mod); 25116cdcec7SMiao Xie else 25216cdcec7SMiao Xie btrfs_dequeue_delayed_node(delayed_root, delayed_node); 25316cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 25416cdcec7SMiao Xie 25516cdcec7SMiao Xie if (atomic_dec_and_test(&delayed_node->refs)) { 25696493031SJeff Mahoney bool free = false; 25716cdcec7SMiao Xie struct btrfs_root *root = delayed_node->root; 25816cdcec7SMiao Xie spin_lock(&root->inode_lock); 25916cdcec7SMiao Xie if (atomic_read(&delayed_node->refs) == 0) { 26016cdcec7SMiao Xie radix_tree_delete(&root->delayed_nodes_tree, 26116cdcec7SMiao Xie delayed_node->inode_id); 26296493031SJeff Mahoney free = true; 26316cdcec7SMiao Xie } 26416cdcec7SMiao Xie spin_unlock(&root->inode_lock); 26596493031SJeff Mahoney if (free) 26696493031SJeff Mahoney kmem_cache_free(delayed_node_cache, delayed_node); 26716cdcec7SMiao Xie } 26816cdcec7SMiao Xie } 26916cdcec7SMiao Xie 27016cdcec7SMiao Xie static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node) 27116cdcec7SMiao Xie { 27216cdcec7SMiao Xie __btrfs_release_delayed_node(node, 0); 27316cdcec7SMiao Xie } 27416cdcec7SMiao Xie 27548a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node( 27616cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root) 27716cdcec7SMiao Xie { 27816cdcec7SMiao Xie struct list_head *p; 27916cdcec7SMiao Xie struct btrfs_delayed_node *node = NULL; 28016cdcec7SMiao Xie 28116cdcec7SMiao Xie spin_lock(&delayed_root->lock); 28216cdcec7SMiao Xie if (list_empty(&delayed_root->prepare_list)) 28316cdcec7SMiao Xie goto out; 28416cdcec7SMiao Xie 28516cdcec7SMiao Xie p = delayed_root->prepare_list.next; 28616cdcec7SMiao Xie list_del_init(p); 28716cdcec7SMiao Xie node = list_entry(p, struct btrfs_delayed_node, p_list); 28816cdcec7SMiao Xie atomic_inc(&node->refs); 28916cdcec7SMiao Xie out: 29016cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 29116cdcec7SMiao Xie 29216cdcec7SMiao Xie return node; 29316cdcec7SMiao Xie } 29416cdcec7SMiao Xie 29516cdcec7SMiao Xie static inline void btrfs_release_prepared_delayed_node( 29616cdcec7SMiao Xie struct btrfs_delayed_node *node) 29716cdcec7SMiao Xie { 29816cdcec7SMiao Xie __btrfs_release_delayed_node(node, 1); 29916cdcec7SMiao Xie } 30016cdcec7SMiao Xie 30148a3b636SEric Sandeen static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u32 data_len) 30216cdcec7SMiao Xie { 30316cdcec7SMiao Xie struct btrfs_delayed_item *item; 30416cdcec7SMiao Xie item = kmalloc(sizeof(*item) + data_len, GFP_NOFS); 30516cdcec7SMiao Xie if (item) { 30616cdcec7SMiao Xie item->data_len = data_len; 30716cdcec7SMiao Xie item->ins_or_del = 0; 30816cdcec7SMiao Xie item->bytes_reserved = 0; 30916cdcec7SMiao Xie item->delayed_node = NULL; 31016cdcec7SMiao Xie atomic_set(&item->refs, 1); 31116cdcec7SMiao Xie } 31216cdcec7SMiao Xie return item; 31316cdcec7SMiao Xie } 31416cdcec7SMiao Xie 31516cdcec7SMiao Xie /* 31616cdcec7SMiao Xie * __btrfs_lookup_delayed_item - look up the delayed item by key 31716cdcec7SMiao Xie * @delayed_node: pointer to the delayed node 31816cdcec7SMiao Xie * @key: the key to look up 31916cdcec7SMiao Xie * @prev: used to store the prev item if the right item isn't found 32016cdcec7SMiao Xie * @next: used to store the next item if the right item isn't found 32116cdcec7SMiao Xie * 32216cdcec7SMiao Xie * Note: if we don't find the right item, we will return the prev item and 32316cdcec7SMiao Xie * the next item. 32416cdcec7SMiao Xie */ 32516cdcec7SMiao Xie static struct btrfs_delayed_item *__btrfs_lookup_delayed_item( 32616cdcec7SMiao Xie struct rb_root *root, 32716cdcec7SMiao Xie struct btrfs_key *key, 32816cdcec7SMiao Xie struct btrfs_delayed_item **prev, 32916cdcec7SMiao Xie struct btrfs_delayed_item **next) 33016cdcec7SMiao Xie { 33116cdcec7SMiao Xie struct rb_node *node, *prev_node = NULL; 33216cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item = NULL; 33316cdcec7SMiao Xie int ret = 0; 33416cdcec7SMiao Xie 33516cdcec7SMiao Xie node = root->rb_node; 33616cdcec7SMiao Xie 33716cdcec7SMiao Xie while (node) { 33816cdcec7SMiao Xie delayed_item = rb_entry(node, struct btrfs_delayed_item, 33916cdcec7SMiao Xie rb_node); 34016cdcec7SMiao Xie prev_node = node; 34116cdcec7SMiao Xie ret = btrfs_comp_cpu_keys(&delayed_item->key, key); 34216cdcec7SMiao Xie if (ret < 0) 34316cdcec7SMiao Xie node = node->rb_right; 34416cdcec7SMiao Xie else if (ret > 0) 34516cdcec7SMiao Xie node = node->rb_left; 34616cdcec7SMiao Xie else 34716cdcec7SMiao Xie return delayed_item; 34816cdcec7SMiao Xie } 34916cdcec7SMiao Xie 35016cdcec7SMiao Xie if (prev) { 35116cdcec7SMiao Xie if (!prev_node) 35216cdcec7SMiao Xie *prev = NULL; 35316cdcec7SMiao Xie else if (ret < 0) 35416cdcec7SMiao Xie *prev = delayed_item; 35516cdcec7SMiao Xie else if ((node = rb_prev(prev_node)) != NULL) { 35616cdcec7SMiao Xie *prev = rb_entry(node, struct btrfs_delayed_item, 35716cdcec7SMiao Xie rb_node); 35816cdcec7SMiao Xie } else 35916cdcec7SMiao Xie *prev = NULL; 36016cdcec7SMiao Xie } 36116cdcec7SMiao Xie 36216cdcec7SMiao Xie if (next) { 36316cdcec7SMiao Xie if (!prev_node) 36416cdcec7SMiao Xie *next = NULL; 36516cdcec7SMiao Xie else if (ret > 0) 36616cdcec7SMiao Xie *next = delayed_item; 36716cdcec7SMiao Xie else if ((node = rb_next(prev_node)) != NULL) { 36816cdcec7SMiao Xie *next = rb_entry(node, struct btrfs_delayed_item, 36916cdcec7SMiao Xie rb_node); 37016cdcec7SMiao Xie } else 37116cdcec7SMiao Xie *next = NULL; 37216cdcec7SMiao Xie } 37316cdcec7SMiao Xie return NULL; 37416cdcec7SMiao Xie } 37516cdcec7SMiao Xie 37648a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_lookup_delayed_insertion_item( 37716cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 37816cdcec7SMiao Xie struct btrfs_key *key) 37916cdcec7SMiao Xie { 380e2c89907SMasahiro Yamada return __btrfs_lookup_delayed_item(&delayed_node->ins_root, key, 38116cdcec7SMiao Xie NULL, NULL); 38216cdcec7SMiao Xie } 38316cdcec7SMiao Xie 38416cdcec7SMiao Xie static int __btrfs_add_delayed_item(struct btrfs_delayed_node *delayed_node, 38516cdcec7SMiao Xie struct btrfs_delayed_item *ins, 38616cdcec7SMiao Xie int action) 38716cdcec7SMiao Xie { 38816cdcec7SMiao Xie struct rb_node **p, *node; 38916cdcec7SMiao Xie struct rb_node *parent_node = NULL; 39016cdcec7SMiao Xie struct rb_root *root; 39116cdcec7SMiao Xie struct btrfs_delayed_item *item; 39216cdcec7SMiao Xie int cmp; 39316cdcec7SMiao Xie 39416cdcec7SMiao Xie if (action == BTRFS_DELAYED_INSERTION_ITEM) 39516cdcec7SMiao Xie root = &delayed_node->ins_root; 39616cdcec7SMiao Xie else if (action == BTRFS_DELAYED_DELETION_ITEM) 39716cdcec7SMiao Xie root = &delayed_node->del_root; 39816cdcec7SMiao Xie else 39916cdcec7SMiao Xie BUG(); 40016cdcec7SMiao Xie p = &root->rb_node; 40116cdcec7SMiao Xie node = &ins->rb_node; 40216cdcec7SMiao Xie 40316cdcec7SMiao Xie while (*p) { 40416cdcec7SMiao Xie parent_node = *p; 40516cdcec7SMiao Xie item = rb_entry(parent_node, struct btrfs_delayed_item, 40616cdcec7SMiao Xie rb_node); 40716cdcec7SMiao Xie 40816cdcec7SMiao Xie cmp = btrfs_comp_cpu_keys(&item->key, &ins->key); 40916cdcec7SMiao Xie if (cmp < 0) 41016cdcec7SMiao Xie p = &(*p)->rb_right; 41116cdcec7SMiao Xie else if (cmp > 0) 41216cdcec7SMiao Xie p = &(*p)->rb_left; 41316cdcec7SMiao Xie else 41416cdcec7SMiao Xie return -EEXIST; 41516cdcec7SMiao Xie } 41616cdcec7SMiao Xie 41716cdcec7SMiao Xie rb_link_node(node, parent_node, p); 41816cdcec7SMiao Xie rb_insert_color(node, root); 41916cdcec7SMiao Xie ins->delayed_node = delayed_node; 42016cdcec7SMiao Xie ins->ins_or_del = action; 42116cdcec7SMiao Xie 42216cdcec7SMiao Xie if (ins->key.type == BTRFS_DIR_INDEX_KEY && 42316cdcec7SMiao Xie action == BTRFS_DELAYED_INSERTION_ITEM && 42416cdcec7SMiao Xie ins->key.offset >= delayed_node->index_cnt) 42516cdcec7SMiao Xie delayed_node->index_cnt = ins->key.offset + 1; 42616cdcec7SMiao Xie 42716cdcec7SMiao Xie delayed_node->count++; 42816cdcec7SMiao Xie atomic_inc(&delayed_node->root->fs_info->delayed_root->items); 42916cdcec7SMiao Xie return 0; 43016cdcec7SMiao Xie } 43116cdcec7SMiao Xie 43216cdcec7SMiao Xie static int __btrfs_add_delayed_insertion_item(struct btrfs_delayed_node *node, 43316cdcec7SMiao Xie struct btrfs_delayed_item *item) 43416cdcec7SMiao Xie { 43516cdcec7SMiao Xie return __btrfs_add_delayed_item(node, item, 43616cdcec7SMiao Xie BTRFS_DELAYED_INSERTION_ITEM); 43716cdcec7SMiao Xie } 43816cdcec7SMiao Xie 43916cdcec7SMiao Xie static int __btrfs_add_delayed_deletion_item(struct btrfs_delayed_node *node, 44016cdcec7SMiao Xie struct btrfs_delayed_item *item) 44116cdcec7SMiao Xie { 44216cdcec7SMiao Xie return __btrfs_add_delayed_item(node, item, 44316cdcec7SMiao Xie BTRFS_DELAYED_DELETION_ITEM); 44416cdcec7SMiao Xie } 44516cdcec7SMiao Xie 446de3cb945SChris Mason static void finish_one_item(struct btrfs_delayed_root *delayed_root) 447de3cb945SChris Mason { 448de3cb945SChris Mason int seq = atomic_inc_return(&delayed_root->items_seq); 449ee863954SDavid Sterba 450ee863954SDavid Sterba /* 451ee863954SDavid Sterba * atomic_dec_return implies a barrier for waitqueue_active 452ee863954SDavid Sterba */ 453de3cb945SChris Mason if ((atomic_dec_return(&delayed_root->items) < 454de3cb945SChris Mason BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0) && 455de3cb945SChris Mason waitqueue_active(&delayed_root->wait)) 456de3cb945SChris Mason wake_up(&delayed_root->wait); 457de3cb945SChris Mason } 458de3cb945SChris Mason 45916cdcec7SMiao Xie static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item) 46016cdcec7SMiao Xie { 46116cdcec7SMiao Xie struct rb_root *root; 46216cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 46316cdcec7SMiao Xie 46416cdcec7SMiao Xie delayed_root = delayed_item->delayed_node->root->fs_info->delayed_root; 46516cdcec7SMiao Xie 46616cdcec7SMiao Xie BUG_ON(!delayed_root); 46716cdcec7SMiao Xie BUG_ON(delayed_item->ins_or_del != BTRFS_DELAYED_DELETION_ITEM && 46816cdcec7SMiao Xie delayed_item->ins_or_del != BTRFS_DELAYED_INSERTION_ITEM); 46916cdcec7SMiao Xie 47016cdcec7SMiao Xie if (delayed_item->ins_or_del == BTRFS_DELAYED_INSERTION_ITEM) 47116cdcec7SMiao Xie root = &delayed_item->delayed_node->ins_root; 47216cdcec7SMiao Xie else 47316cdcec7SMiao Xie root = &delayed_item->delayed_node->del_root; 47416cdcec7SMiao Xie 47516cdcec7SMiao Xie rb_erase(&delayed_item->rb_node, root); 47616cdcec7SMiao Xie delayed_item->delayed_node->count--; 477de3cb945SChris Mason 478de3cb945SChris Mason finish_one_item(delayed_root); 47916cdcec7SMiao Xie } 48016cdcec7SMiao Xie 48116cdcec7SMiao Xie static void btrfs_release_delayed_item(struct btrfs_delayed_item *item) 48216cdcec7SMiao Xie { 48316cdcec7SMiao Xie if (item) { 48416cdcec7SMiao Xie __btrfs_remove_delayed_item(item); 48516cdcec7SMiao Xie if (atomic_dec_and_test(&item->refs)) 48616cdcec7SMiao Xie kfree(item); 48716cdcec7SMiao Xie } 48816cdcec7SMiao Xie } 48916cdcec7SMiao Xie 49048a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_first_delayed_insertion_item( 49116cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node) 49216cdcec7SMiao Xie { 49316cdcec7SMiao Xie struct rb_node *p; 49416cdcec7SMiao Xie struct btrfs_delayed_item *item = NULL; 49516cdcec7SMiao Xie 49616cdcec7SMiao Xie p = rb_first(&delayed_node->ins_root); 49716cdcec7SMiao Xie if (p) 49816cdcec7SMiao Xie item = rb_entry(p, struct btrfs_delayed_item, rb_node); 49916cdcec7SMiao Xie 50016cdcec7SMiao Xie return item; 50116cdcec7SMiao Xie } 50216cdcec7SMiao Xie 50348a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_first_delayed_deletion_item( 50416cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node) 50516cdcec7SMiao Xie { 50616cdcec7SMiao Xie struct rb_node *p; 50716cdcec7SMiao Xie struct btrfs_delayed_item *item = NULL; 50816cdcec7SMiao Xie 50916cdcec7SMiao Xie p = rb_first(&delayed_node->del_root); 51016cdcec7SMiao Xie if (p) 51116cdcec7SMiao Xie item = rb_entry(p, struct btrfs_delayed_item, rb_node); 51216cdcec7SMiao Xie 51316cdcec7SMiao Xie return item; 51416cdcec7SMiao Xie } 51516cdcec7SMiao Xie 51648a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_next_delayed_item( 51716cdcec7SMiao Xie struct btrfs_delayed_item *item) 51816cdcec7SMiao Xie { 51916cdcec7SMiao Xie struct rb_node *p; 52016cdcec7SMiao Xie struct btrfs_delayed_item *next = NULL; 52116cdcec7SMiao Xie 52216cdcec7SMiao Xie p = rb_next(&item->rb_node); 52316cdcec7SMiao Xie if (p) 52416cdcec7SMiao Xie next = rb_entry(p, struct btrfs_delayed_item, rb_node); 52516cdcec7SMiao Xie 52616cdcec7SMiao Xie return next; 52716cdcec7SMiao Xie } 52816cdcec7SMiao Xie 52916cdcec7SMiao Xie static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans, 5302ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info, 53116cdcec7SMiao Xie struct btrfs_delayed_item *item) 53216cdcec7SMiao Xie { 53316cdcec7SMiao Xie struct btrfs_block_rsv *src_rsv; 53416cdcec7SMiao Xie struct btrfs_block_rsv *dst_rsv; 53516cdcec7SMiao Xie u64 num_bytes; 53616cdcec7SMiao Xie int ret; 53716cdcec7SMiao Xie 53816cdcec7SMiao Xie if (!trans->bytes_reserved) 53916cdcec7SMiao Xie return 0; 54016cdcec7SMiao Xie 54116cdcec7SMiao Xie src_rsv = trans->block_rsv; 5420b246afaSJeff Mahoney dst_rsv = &fs_info->delayed_block_rsv; 54316cdcec7SMiao Xie 5440b246afaSJeff Mahoney num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1); 54525d609f8SJosef Bacik ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, 1); 5468c2a3ca2SJosef Bacik if (!ret) { 5470b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_item", 5488c2a3ca2SJosef Bacik item->key.objectid, 5498c2a3ca2SJosef Bacik num_bytes, 1); 55016cdcec7SMiao Xie item->bytes_reserved = num_bytes; 5518c2a3ca2SJosef Bacik } 55216cdcec7SMiao Xie 55316cdcec7SMiao Xie return ret; 55416cdcec7SMiao Xie } 55516cdcec7SMiao Xie 5562ff7e61eSJeff Mahoney static void btrfs_delayed_item_release_metadata(struct btrfs_fs_info *fs_info, 55716cdcec7SMiao Xie struct btrfs_delayed_item *item) 55816cdcec7SMiao Xie { 55919fd2949SMiao Xie struct btrfs_block_rsv *rsv; 56019fd2949SMiao Xie 56116cdcec7SMiao Xie if (!item->bytes_reserved) 56216cdcec7SMiao Xie return; 56316cdcec7SMiao Xie 5640b246afaSJeff Mahoney rsv = &fs_info->delayed_block_rsv; 5650b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_item", 5668c2a3ca2SJosef Bacik item->key.objectid, item->bytes_reserved, 5678c2a3ca2SJosef Bacik 0); 5682ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, rsv, 56916cdcec7SMiao Xie item->bytes_reserved); 57016cdcec7SMiao Xie } 57116cdcec7SMiao Xie 57216cdcec7SMiao Xie static int btrfs_delayed_inode_reserve_metadata( 57316cdcec7SMiao Xie struct btrfs_trans_handle *trans, 57416cdcec7SMiao Xie struct btrfs_root *root, 575fcabdd1cSNikolay Borisov struct btrfs_inode *inode, 57616cdcec7SMiao Xie struct btrfs_delayed_node *node) 57716cdcec7SMiao Xie { 5780b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 57916cdcec7SMiao Xie struct btrfs_block_rsv *src_rsv; 58016cdcec7SMiao Xie struct btrfs_block_rsv *dst_rsv; 58116cdcec7SMiao Xie u64 num_bytes; 58216cdcec7SMiao Xie int ret; 5838c2a3ca2SJosef Bacik bool release = false; 58416cdcec7SMiao Xie 58516cdcec7SMiao Xie src_rsv = trans->block_rsv; 5860b246afaSJeff Mahoney dst_rsv = &fs_info->delayed_block_rsv; 58716cdcec7SMiao Xie 5880b246afaSJeff Mahoney num_bytes = btrfs_calc_trans_metadata_size(fs_info, 1); 589c06a0e12SJosef Bacik 590c06a0e12SJosef Bacik /* 591c48f49d6SJosef Bacik * If our block_rsv is the delalloc block reserve then check and see if 592c48f49d6SJosef Bacik * we have our extra reservation for updating the inode. If not fall 593c48f49d6SJosef Bacik * through and try to reserve space quickly. 594c48f49d6SJosef Bacik * 595c48f49d6SJosef Bacik * We used to try and steal from the delalloc block rsv or the global 596c48f49d6SJosef Bacik * reserve, but we'd steal a full reservation, which isn't kind. We are 597c48f49d6SJosef Bacik * here through delalloc which means we've likely just cowed down close 598c48f49d6SJosef Bacik * to the leaf that contains the inode, so we would steal less just 599c48f49d6SJosef Bacik * doing the fallback inode update, so if we do end up having to steal 600c48f49d6SJosef Bacik * from the global block rsv we hopefully only steal one or two blocks 601c48f49d6SJosef Bacik * worth which is less likely to hurt us. 602c48f49d6SJosef Bacik */ 603c48f49d6SJosef Bacik if (src_rsv && src_rsv->type == BTRFS_BLOCK_RSV_DELALLOC) { 604fcabdd1cSNikolay Borisov spin_lock(&inode->lock); 605c48f49d6SJosef Bacik if (test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED, 606fcabdd1cSNikolay Borisov &inode->runtime_flags)) 607c48f49d6SJosef Bacik release = true; 608c48f49d6SJosef Bacik else 609c48f49d6SJosef Bacik src_rsv = NULL; 610fcabdd1cSNikolay Borisov spin_unlock(&inode->lock); 611c48f49d6SJosef Bacik } 612c48f49d6SJosef Bacik 613c48f49d6SJosef Bacik /* 614c06a0e12SJosef Bacik * btrfs_dirty_inode will update the inode under btrfs_join_transaction 615c06a0e12SJosef Bacik * which doesn't reserve space for speed. This is a problem since we 616c06a0e12SJosef Bacik * still need to reserve space for this update, so try to reserve the 617c06a0e12SJosef Bacik * space. 618c06a0e12SJosef Bacik * 619c06a0e12SJosef Bacik * Now if src_rsv == delalloc_block_rsv we'll let it just steal since 620c06a0e12SJosef Bacik * we're accounted for. 621c06a0e12SJosef Bacik */ 622e755d9abSChris Mason if (!src_rsv || (!trans->bytes_reserved && 62366d8f3ddSMiao Xie src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) { 62408e007d2SMiao Xie ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes, 62508e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 626c06a0e12SJosef Bacik /* 627c06a0e12SJosef Bacik * Since we're under a transaction reserve_metadata_bytes could 628c06a0e12SJosef Bacik * try to commit the transaction which will make it return 629c06a0e12SJosef Bacik * EAGAIN to make us stop the transaction we have, so return 630c06a0e12SJosef Bacik * ENOSPC instead so that btrfs_dirty_inode knows what to do. 631c06a0e12SJosef Bacik */ 632c06a0e12SJosef Bacik if (ret == -EAGAIN) 633c06a0e12SJosef Bacik ret = -ENOSPC; 6348c2a3ca2SJosef Bacik if (!ret) { 635c06a0e12SJosef Bacik node->bytes_reserved = num_bytes; 6360b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, 6378c2a3ca2SJosef Bacik "delayed_inode", 638fcabdd1cSNikolay Borisov btrfs_ino(inode), 6398c2a3ca2SJosef Bacik num_bytes, 1); 6408c2a3ca2SJosef Bacik } 641c06a0e12SJosef Bacik return ret; 642c06a0e12SJosef Bacik } 643c06a0e12SJosef Bacik 64425d609f8SJosef Bacik ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes, 1); 6457fd2ae21SJosef Bacik 6467fd2ae21SJosef Bacik /* 6477fd2ae21SJosef Bacik * Migrate only takes a reservation, it doesn't touch the size of the 6487fd2ae21SJosef Bacik * block_rsv. This is to simplify people who don't normally have things 6497fd2ae21SJosef Bacik * migrated from their block rsv. If they go to release their 6507fd2ae21SJosef Bacik * reservation, that will decrease the size as well, so if migrate 6517fd2ae21SJosef Bacik * reduced size we'd end up with a negative size. But for the 6527fd2ae21SJosef Bacik * delalloc_meta_reserved stuff we will only know to drop 1 reservation, 6537fd2ae21SJosef Bacik * but we could in fact do this reserve/migrate dance several times 6547fd2ae21SJosef Bacik * between the time we did the original reservation and we'd clean it 6557fd2ae21SJosef Bacik * up. So to take care of this, release the space for the meta 6567fd2ae21SJosef Bacik * reservation here. I think it may be time for a documentation page on 6577fd2ae21SJosef Bacik * how block rsvs. work. 6587fd2ae21SJosef Bacik */ 6598c2a3ca2SJosef Bacik if (!ret) { 6600b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_inode", 661fcabdd1cSNikolay Borisov btrfs_ino(inode), num_bytes, 1); 66216cdcec7SMiao Xie node->bytes_reserved = num_bytes; 6638c2a3ca2SJosef Bacik } 66416cdcec7SMiao Xie 6658c2a3ca2SJosef Bacik if (release) { 6660b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delalloc", 667fcabdd1cSNikolay Borisov btrfs_ino(inode), num_bytes, 0); 6682ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, src_rsv, num_bytes); 6698c2a3ca2SJosef Bacik } 67016cdcec7SMiao Xie 67116cdcec7SMiao Xie return ret; 67216cdcec7SMiao Xie } 67316cdcec7SMiao Xie 6742ff7e61eSJeff Mahoney static void btrfs_delayed_inode_release_metadata(struct btrfs_fs_info *fs_info, 67516cdcec7SMiao Xie struct btrfs_delayed_node *node) 67616cdcec7SMiao Xie { 67716cdcec7SMiao Xie struct btrfs_block_rsv *rsv; 67816cdcec7SMiao Xie 67916cdcec7SMiao Xie if (!node->bytes_reserved) 68016cdcec7SMiao Xie return; 68116cdcec7SMiao Xie 6820b246afaSJeff Mahoney rsv = &fs_info->delayed_block_rsv; 6830b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "delayed_inode", 6848c2a3ca2SJosef Bacik node->inode_id, node->bytes_reserved, 0); 6852ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, rsv, 68616cdcec7SMiao Xie node->bytes_reserved); 68716cdcec7SMiao Xie node->bytes_reserved = 0; 68816cdcec7SMiao Xie } 68916cdcec7SMiao Xie 69016cdcec7SMiao Xie /* 69116cdcec7SMiao Xie * This helper will insert some continuous items into the same leaf according 69216cdcec7SMiao Xie * to the free space of the leaf. 69316cdcec7SMiao Xie */ 694afe5fea7STsutomu Itoh static int btrfs_batch_insert_items(struct btrfs_root *root, 69516cdcec7SMiao Xie struct btrfs_path *path, 69616cdcec7SMiao Xie struct btrfs_delayed_item *item) 69716cdcec7SMiao Xie { 6982ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 69916cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 70016cdcec7SMiao Xie int free_space; 70116cdcec7SMiao Xie int total_data_size = 0, total_size = 0; 70216cdcec7SMiao Xie struct extent_buffer *leaf; 70316cdcec7SMiao Xie char *data_ptr; 70416cdcec7SMiao Xie struct btrfs_key *keys; 70516cdcec7SMiao Xie u32 *data_size; 70616cdcec7SMiao Xie struct list_head head; 70716cdcec7SMiao Xie int slot; 70816cdcec7SMiao Xie int nitems; 70916cdcec7SMiao Xie int i; 71016cdcec7SMiao Xie int ret = 0; 71116cdcec7SMiao Xie 71216cdcec7SMiao Xie BUG_ON(!path->nodes[0]); 71316cdcec7SMiao Xie 71416cdcec7SMiao Xie leaf = path->nodes[0]; 7152ff7e61eSJeff Mahoney free_space = btrfs_leaf_free_space(fs_info, leaf); 71616cdcec7SMiao Xie INIT_LIST_HEAD(&head); 71716cdcec7SMiao Xie 71816cdcec7SMiao Xie next = item; 71917aca1c9SChris Mason nitems = 0; 72016cdcec7SMiao Xie 72116cdcec7SMiao Xie /* 72216cdcec7SMiao Xie * count the number of the continuous items that we can insert in batch 72316cdcec7SMiao Xie */ 72416cdcec7SMiao Xie while (total_size + next->data_len + sizeof(struct btrfs_item) <= 72516cdcec7SMiao Xie free_space) { 72616cdcec7SMiao Xie total_data_size += next->data_len; 72716cdcec7SMiao Xie total_size += next->data_len + sizeof(struct btrfs_item); 72816cdcec7SMiao Xie list_add_tail(&next->tree_list, &head); 72916cdcec7SMiao Xie nitems++; 73016cdcec7SMiao Xie 73116cdcec7SMiao Xie curr = next; 73216cdcec7SMiao Xie next = __btrfs_next_delayed_item(curr); 73316cdcec7SMiao Xie if (!next) 73416cdcec7SMiao Xie break; 73516cdcec7SMiao Xie 73616cdcec7SMiao Xie if (!btrfs_is_continuous_delayed_item(curr, next)) 73716cdcec7SMiao Xie break; 73816cdcec7SMiao Xie } 73916cdcec7SMiao Xie 74016cdcec7SMiao Xie if (!nitems) { 74116cdcec7SMiao Xie ret = 0; 74216cdcec7SMiao Xie goto out; 74316cdcec7SMiao Xie } 74416cdcec7SMiao Xie 74516cdcec7SMiao Xie /* 74616cdcec7SMiao Xie * we need allocate some memory space, but it might cause the task 74716cdcec7SMiao Xie * to sleep, so we set all locked nodes in the path to blocking locks 74816cdcec7SMiao Xie * first. 74916cdcec7SMiao Xie */ 75016cdcec7SMiao Xie btrfs_set_path_blocking(path); 75116cdcec7SMiao Xie 752d9b0d9baSDulshani Gunawardhana keys = kmalloc_array(nitems, sizeof(struct btrfs_key), GFP_NOFS); 75316cdcec7SMiao Xie if (!keys) { 75416cdcec7SMiao Xie ret = -ENOMEM; 75516cdcec7SMiao Xie goto out; 75616cdcec7SMiao Xie } 75716cdcec7SMiao Xie 758d9b0d9baSDulshani Gunawardhana data_size = kmalloc_array(nitems, sizeof(u32), GFP_NOFS); 75916cdcec7SMiao Xie if (!data_size) { 76016cdcec7SMiao Xie ret = -ENOMEM; 76116cdcec7SMiao Xie goto error; 76216cdcec7SMiao Xie } 76316cdcec7SMiao Xie 76416cdcec7SMiao Xie /* get keys of all the delayed items */ 76516cdcec7SMiao Xie i = 0; 76616cdcec7SMiao Xie list_for_each_entry(next, &head, tree_list) { 76716cdcec7SMiao Xie keys[i] = next->key; 76816cdcec7SMiao Xie data_size[i] = next->data_len; 76916cdcec7SMiao Xie i++; 77016cdcec7SMiao Xie } 77116cdcec7SMiao Xie 77216cdcec7SMiao Xie /* reset all the locked nodes in the patch to spinning locks. */ 773bd681513SChris Mason btrfs_clear_path_blocking(path, NULL, 0); 77416cdcec7SMiao Xie 77516cdcec7SMiao Xie /* insert the keys of the items */ 776afe5fea7STsutomu Itoh setup_items_for_insert(root, path, keys, data_size, 77716cdcec7SMiao Xie total_data_size, total_size, nitems); 77816cdcec7SMiao Xie 77916cdcec7SMiao Xie /* insert the dir index items */ 78016cdcec7SMiao Xie slot = path->slots[0]; 78116cdcec7SMiao Xie list_for_each_entry_safe(curr, next, &head, tree_list) { 78216cdcec7SMiao Xie data_ptr = btrfs_item_ptr(leaf, slot, char); 78316cdcec7SMiao Xie write_extent_buffer(leaf, &curr->data, 78416cdcec7SMiao Xie (unsigned long)data_ptr, 78516cdcec7SMiao Xie curr->data_len); 78616cdcec7SMiao Xie slot++; 78716cdcec7SMiao Xie 7882ff7e61eSJeff Mahoney btrfs_delayed_item_release_metadata(fs_info, curr); 78916cdcec7SMiao Xie 79016cdcec7SMiao Xie list_del(&curr->tree_list); 79116cdcec7SMiao Xie btrfs_release_delayed_item(curr); 79216cdcec7SMiao Xie } 79316cdcec7SMiao Xie 79416cdcec7SMiao Xie error: 79516cdcec7SMiao Xie kfree(data_size); 79616cdcec7SMiao Xie kfree(keys); 79716cdcec7SMiao Xie out: 79816cdcec7SMiao Xie return ret; 79916cdcec7SMiao Xie } 80016cdcec7SMiao Xie 80116cdcec7SMiao Xie /* 80216cdcec7SMiao Xie * This helper can just do simple insertion that needn't extend item for new 80316cdcec7SMiao Xie * data, such as directory name index insertion, inode insertion. 80416cdcec7SMiao Xie */ 80516cdcec7SMiao Xie static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans, 80616cdcec7SMiao Xie struct btrfs_root *root, 80716cdcec7SMiao Xie struct btrfs_path *path, 80816cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item) 80916cdcec7SMiao Xie { 8102ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 81116cdcec7SMiao Xie struct extent_buffer *leaf; 81216cdcec7SMiao Xie char *ptr; 81316cdcec7SMiao Xie int ret; 81416cdcec7SMiao Xie 81516cdcec7SMiao Xie ret = btrfs_insert_empty_item(trans, root, path, &delayed_item->key, 81616cdcec7SMiao Xie delayed_item->data_len); 81716cdcec7SMiao Xie if (ret < 0 && ret != -EEXIST) 81816cdcec7SMiao Xie return ret; 81916cdcec7SMiao Xie 82016cdcec7SMiao Xie leaf = path->nodes[0]; 82116cdcec7SMiao Xie 82216cdcec7SMiao Xie ptr = btrfs_item_ptr(leaf, path->slots[0], char); 82316cdcec7SMiao Xie 82416cdcec7SMiao Xie write_extent_buffer(leaf, delayed_item->data, (unsigned long)ptr, 82516cdcec7SMiao Xie delayed_item->data_len); 82616cdcec7SMiao Xie btrfs_mark_buffer_dirty(leaf); 82716cdcec7SMiao Xie 8282ff7e61eSJeff Mahoney btrfs_delayed_item_release_metadata(fs_info, delayed_item); 82916cdcec7SMiao Xie return 0; 83016cdcec7SMiao Xie } 83116cdcec7SMiao Xie 83216cdcec7SMiao Xie /* 83316cdcec7SMiao Xie * we insert an item first, then if there are some continuous items, we try 83416cdcec7SMiao Xie * to insert those items into the same leaf. 83516cdcec7SMiao Xie */ 83616cdcec7SMiao Xie static int btrfs_insert_delayed_items(struct btrfs_trans_handle *trans, 83716cdcec7SMiao Xie struct btrfs_path *path, 83816cdcec7SMiao Xie struct btrfs_root *root, 83916cdcec7SMiao Xie struct btrfs_delayed_node *node) 84016cdcec7SMiao Xie { 84116cdcec7SMiao Xie struct btrfs_delayed_item *curr, *prev; 84216cdcec7SMiao Xie int ret = 0; 84316cdcec7SMiao Xie 84416cdcec7SMiao Xie do_again: 84516cdcec7SMiao Xie mutex_lock(&node->mutex); 84616cdcec7SMiao Xie curr = __btrfs_first_delayed_insertion_item(node); 84716cdcec7SMiao Xie if (!curr) 84816cdcec7SMiao Xie goto insert_end; 84916cdcec7SMiao Xie 85016cdcec7SMiao Xie ret = btrfs_insert_delayed_item(trans, root, path, curr); 85116cdcec7SMiao Xie if (ret < 0) { 852945d8962SChris Mason btrfs_release_path(path); 85316cdcec7SMiao Xie goto insert_end; 85416cdcec7SMiao Xie } 85516cdcec7SMiao Xie 85616cdcec7SMiao Xie prev = curr; 85716cdcec7SMiao Xie curr = __btrfs_next_delayed_item(prev); 85816cdcec7SMiao Xie if (curr && btrfs_is_continuous_delayed_item(prev, curr)) { 85916cdcec7SMiao Xie /* insert the continuous items into the same leaf */ 86016cdcec7SMiao Xie path->slots[0]++; 861afe5fea7STsutomu Itoh btrfs_batch_insert_items(root, path, curr); 86216cdcec7SMiao Xie } 86316cdcec7SMiao Xie btrfs_release_delayed_item(prev); 86416cdcec7SMiao Xie btrfs_mark_buffer_dirty(path->nodes[0]); 86516cdcec7SMiao Xie 866945d8962SChris Mason btrfs_release_path(path); 86716cdcec7SMiao Xie mutex_unlock(&node->mutex); 86816cdcec7SMiao Xie goto do_again; 86916cdcec7SMiao Xie 87016cdcec7SMiao Xie insert_end: 87116cdcec7SMiao Xie mutex_unlock(&node->mutex); 87216cdcec7SMiao Xie return ret; 87316cdcec7SMiao Xie } 87416cdcec7SMiao Xie 87516cdcec7SMiao Xie static int btrfs_batch_delete_items(struct btrfs_trans_handle *trans, 87616cdcec7SMiao Xie struct btrfs_root *root, 87716cdcec7SMiao Xie struct btrfs_path *path, 87816cdcec7SMiao Xie struct btrfs_delayed_item *item) 87916cdcec7SMiao Xie { 8802ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 88116cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 88216cdcec7SMiao Xie struct extent_buffer *leaf; 88316cdcec7SMiao Xie struct btrfs_key key; 88416cdcec7SMiao Xie struct list_head head; 88516cdcec7SMiao Xie int nitems, i, last_item; 88616cdcec7SMiao Xie int ret = 0; 88716cdcec7SMiao Xie 88816cdcec7SMiao Xie BUG_ON(!path->nodes[0]); 88916cdcec7SMiao Xie 89016cdcec7SMiao Xie leaf = path->nodes[0]; 89116cdcec7SMiao Xie 89216cdcec7SMiao Xie i = path->slots[0]; 89316cdcec7SMiao Xie last_item = btrfs_header_nritems(leaf) - 1; 89416cdcec7SMiao Xie if (i > last_item) 89516cdcec7SMiao Xie return -ENOENT; /* FIXME: Is errno suitable? */ 89616cdcec7SMiao Xie 89716cdcec7SMiao Xie next = item; 89816cdcec7SMiao Xie INIT_LIST_HEAD(&head); 89916cdcec7SMiao Xie btrfs_item_key_to_cpu(leaf, &key, i); 90016cdcec7SMiao Xie nitems = 0; 90116cdcec7SMiao Xie /* 90216cdcec7SMiao Xie * count the number of the dir index items that we can delete in batch 90316cdcec7SMiao Xie */ 90416cdcec7SMiao Xie while (btrfs_comp_cpu_keys(&next->key, &key) == 0) { 90516cdcec7SMiao Xie list_add_tail(&next->tree_list, &head); 90616cdcec7SMiao Xie nitems++; 90716cdcec7SMiao Xie 90816cdcec7SMiao Xie curr = next; 90916cdcec7SMiao Xie next = __btrfs_next_delayed_item(curr); 91016cdcec7SMiao Xie if (!next) 91116cdcec7SMiao Xie break; 91216cdcec7SMiao Xie 91316cdcec7SMiao Xie if (!btrfs_is_continuous_delayed_item(curr, next)) 91416cdcec7SMiao Xie break; 91516cdcec7SMiao Xie 91616cdcec7SMiao Xie i++; 91716cdcec7SMiao Xie if (i > last_item) 91816cdcec7SMiao Xie break; 91916cdcec7SMiao Xie btrfs_item_key_to_cpu(leaf, &key, i); 92016cdcec7SMiao Xie } 92116cdcec7SMiao Xie 92216cdcec7SMiao Xie if (!nitems) 92316cdcec7SMiao Xie return 0; 92416cdcec7SMiao Xie 92516cdcec7SMiao Xie ret = btrfs_del_items(trans, root, path, path->slots[0], nitems); 92616cdcec7SMiao Xie if (ret) 92716cdcec7SMiao Xie goto out; 92816cdcec7SMiao Xie 92916cdcec7SMiao Xie list_for_each_entry_safe(curr, next, &head, tree_list) { 9302ff7e61eSJeff Mahoney btrfs_delayed_item_release_metadata(fs_info, curr); 93116cdcec7SMiao Xie list_del(&curr->tree_list); 93216cdcec7SMiao Xie btrfs_release_delayed_item(curr); 93316cdcec7SMiao Xie } 93416cdcec7SMiao Xie 93516cdcec7SMiao Xie out: 93616cdcec7SMiao Xie return ret; 93716cdcec7SMiao Xie } 93816cdcec7SMiao Xie 93916cdcec7SMiao Xie static int btrfs_delete_delayed_items(struct btrfs_trans_handle *trans, 94016cdcec7SMiao Xie struct btrfs_path *path, 94116cdcec7SMiao Xie struct btrfs_root *root, 94216cdcec7SMiao Xie struct btrfs_delayed_node *node) 94316cdcec7SMiao Xie { 94416cdcec7SMiao Xie struct btrfs_delayed_item *curr, *prev; 94516cdcec7SMiao Xie int ret = 0; 94616cdcec7SMiao Xie 94716cdcec7SMiao Xie do_again: 94816cdcec7SMiao Xie mutex_lock(&node->mutex); 94916cdcec7SMiao Xie curr = __btrfs_first_delayed_deletion_item(node); 95016cdcec7SMiao Xie if (!curr) 95116cdcec7SMiao Xie goto delete_fail; 95216cdcec7SMiao Xie 95316cdcec7SMiao Xie ret = btrfs_search_slot(trans, root, &curr->key, path, -1, 1); 95416cdcec7SMiao Xie if (ret < 0) 95516cdcec7SMiao Xie goto delete_fail; 95616cdcec7SMiao Xie else if (ret > 0) { 95716cdcec7SMiao Xie /* 95816cdcec7SMiao Xie * can't find the item which the node points to, so this node 95916cdcec7SMiao Xie * is invalid, just drop it. 96016cdcec7SMiao Xie */ 96116cdcec7SMiao Xie prev = curr; 96216cdcec7SMiao Xie curr = __btrfs_next_delayed_item(prev); 96316cdcec7SMiao Xie btrfs_release_delayed_item(prev); 96416cdcec7SMiao Xie ret = 0; 965945d8962SChris Mason btrfs_release_path(path); 96662095265SFengguang Wu if (curr) { 96762095265SFengguang Wu mutex_unlock(&node->mutex); 96816cdcec7SMiao Xie goto do_again; 96962095265SFengguang Wu } else 97016cdcec7SMiao Xie goto delete_fail; 97116cdcec7SMiao Xie } 97216cdcec7SMiao Xie 97316cdcec7SMiao Xie btrfs_batch_delete_items(trans, root, path, curr); 974945d8962SChris Mason btrfs_release_path(path); 97516cdcec7SMiao Xie mutex_unlock(&node->mutex); 97616cdcec7SMiao Xie goto do_again; 97716cdcec7SMiao Xie 97816cdcec7SMiao Xie delete_fail: 979945d8962SChris Mason btrfs_release_path(path); 98016cdcec7SMiao Xie mutex_unlock(&node->mutex); 98116cdcec7SMiao Xie return ret; 98216cdcec7SMiao Xie } 98316cdcec7SMiao Xie 98416cdcec7SMiao Xie static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node) 98516cdcec7SMiao Xie { 98616cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 98716cdcec7SMiao Xie 9887cf35d91SMiao Xie if (delayed_node && 9897cf35d91SMiao Xie test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 99016cdcec7SMiao Xie BUG_ON(!delayed_node->root); 9917cf35d91SMiao Xie clear_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); 99216cdcec7SMiao Xie delayed_node->count--; 99316cdcec7SMiao Xie 99416cdcec7SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 995de3cb945SChris Mason finish_one_item(delayed_root); 99616cdcec7SMiao Xie } 99716cdcec7SMiao Xie } 99816cdcec7SMiao Xie 99967de1176SMiao Xie static void btrfs_release_delayed_iref(struct btrfs_delayed_node *delayed_node) 100067de1176SMiao Xie { 100167de1176SMiao Xie struct btrfs_delayed_root *delayed_root; 100267de1176SMiao Xie 100367de1176SMiao Xie ASSERT(delayed_node->root); 100467de1176SMiao Xie clear_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags); 100567de1176SMiao Xie delayed_node->count--; 100667de1176SMiao Xie 100767de1176SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 100867de1176SMiao Xie finish_one_item(delayed_root); 100967de1176SMiao Xie } 101067de1176SMiao Xie 10110e8c36a9SMiao Xie static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 101216cdcec7SMiao Xie struct btrfs_root *root, 101316cdcec7SMiao Xie struct btrfs_path *path, 101416cdcec7SMiao Xie struct btrfs_delayed_node *node) 101516cdcec7SMiao Xie { 10162ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 101716cdcec7SMiao Xie struct btrfs_key key; 101816cdcec7SMiao Xie struct btrfs_inode_item *inode_item; 101916cdcec7SMiao Xie struct extent_buffer *leaf; 102067de1176SMiao Xie int mod; 102116cdcec7SMiao Xie int ret; 102216cdcec7SMiao Xie 102316cdcec7SMiao Xie key.objectid = node->inode_id; 1024962a298fSDavid Sterba key.type = BTRFS_INODE_ITEM_KEY; 102516cdcec7SMiao Xie key.offset = 0; 10260e8c36a9SMiao Xie 102767de1176SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) 102867de1176SMiao Xie mod = -1; 102967de1176SMiao Xie else 103067de1176SMiao Xie mod = 1; 103167de1176SMiao Xie 103267de1176SMiao Xie ret = btrfs_lookup_inode(trans, root, path, &key, mod); 103316cdcec7SMiao Xie if (ret > 0) { 1034945d8962SChris Mason btrfs_release_path(path); 103516cdcec7SMiao Xie return -ENOENT; 103616cdcec7SMiao Xie } else if (ret < 0) { 103716cdcec7SMiao Xie return ret; 103816cdcec7SMiao Xie } 103916cdcec7SMiao Xie 104016cdcec7SMiao Xie leaf = path->nodes[0]; 104116cdcec7SMiao Xie inode_item = btrfs_item_ptr(leaf, path->slots[0], 104216cdcec7SMiao Xie struct btrfs_inode_item); 104316cdcec7SMiao Xie write_extent_buffer(leaf, &node->inode_item, (unsigned long)inode_item, 104416cdcec7SMiao Xie sizeof(struct btrfs_inode_item)); 104516cdcec7SMiao Xie btrfs_mark_buffer_dirty(leaf); 104616cdcec7SMiao Xie 104767de1176SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &node->flags)) 104867de1176SMiao Xie goto no_iref; 104967de1176SMiao Xie 105067de1176SMiao Xie path->slots[0]++; 105167de1176SMiao Xie if (path->slots[0] >= btrfs_header_nritems(leaf)) 105267de1176SMiao Xie goto search; 105367de1176SMiao Xie again: 105467de1176SMiao Xie btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 105567de1176SMiao Xie if (key.objectid != node->inode_id) 105667de1176SMiao Xie goto out; 105767de1176SMiao Xie 105867de1176SMiao Xie if (key.type != BTRFS_INODE_REF_KEY && 105967de1176SMiao Xie key.type != BTRFS_INODE_EXTREF_KEY) 106067de1176SMiao Xie goto out; 106167de1176SMiao Xie 106267de1176SMiao Xie /* 106367de1176SMiao Xie * Delayed iref deletion is for the inode who has only one link, 106467de1176SMiao Xie * so there is only one iref. The case that several irefs are 106567de1176SMiao Xie * in the same item doesn't exist. 106667de1176SMiao Xie */ 106767de1176SMiao Xie btrfs_del_item(trans, root, path); 106867de1176SMiao Xie out: 106967de1176SMiao Xie btrfs_release_delayed_iref(node); 107067de1176SMiao Xie no_iref: 107167de1176SMiao Xie btrfs_release_path(path); 107267de1176SMiao Xie err_out: 10732ff7e61eSJeff Mahoney btrfs_delayed_inode_release_metadata(fs_info, node); 107416cdcec7SMiao Xie btrfs_release_delayed_inode(node); 107516cdcec7SMiao Xie 107667de1176SMiao Xie return ret; 107767de1176SMiao Xie 107867de1176SMiao Xie search: 107967de1176SMiao Xie btrfs_release_path(path); 108067de1176SMiao Xie 1081962a298fSDavid Sterba key.type = BTRFS_INODE_EXTREF_KEY; 108267de1176SMiao Xie key.offset = -1; 108367de1176SMiao Xie ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 108467de1176SMiao Xie if (ret < 0) 108567de1176SMiao Xie goto err_out; 108667de1176SMiao Xie ASSERT(ret); 108767de1176SMiao Xie 108867de1176SMiao Xie ret = 0; 108967de1176SMiao Xie leaf = path->nodes[0]; 109067de1176SMiao Xie path->slots[0]--; 109167de1176SMiao Xie goto again; 109216cdcec7SMiao Xie } 109316cdcec7SMiao Xie 10940e8c36a9SMiao Xie static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 10950e8c36a9SMiao Xie struct btrfs_root *root, 10960e8c36a9SMiao Xie struct btrfs_path *path, 10970e8c36a9SMiao Xie struct btrfs_delayed_node *node) 10980e8c36a9SMiao Xie { 10990e8c36a9SMiao Xie int ret; 11000e8c36a9SMiao Xie 11010e8c36a9SMiao Xie mutex_lock(&node->mutex); 11027cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &node->flags)) { 11030e8c36a9SMiao Xie mutex_unlock(&node->mutex); 11040e8c36a9SMiao Xie return 0; 11050e8c36a9SMiao Xie } 11060e8c36a9SMiao Xie 11070e8c36a9SMiao Xie ret = __btrfs_update_delayed_inode(trans, root, path, node); 11080e8c36a9SMiao Xie mutex_unlock(&node->mutex); 11090e8c36a9SMiao Xie return ret; 11100e8c36a9SMiao Xie } 11110e8c36a9SMiao Xie 11124ea41ce0SMiao Xie static inline int 11134ea41ce0SMiao Xie __btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 11144ea41ce0SMiao Xie struct btrfs_path *path, 11154ea41ce0SMiao Xie struct btrfs_delayed_node *node) 11164ea41ce0SMiao Xie { 11174ea41ce0SMiao Xie int ret; 11184ea41ce0SMiao Xie 11194ea41ce0SMiao Xie ret = btrfs_insert_delayed_items(trans, path, node->root, node); 11204ea41ce0SMiao Xie if (ret) 11214ea41ce0SMiao Xie return ret; 11224ea41ce0SMiao Xie 11234ea41ce0SMiao Xie ret = btrfs_delete_delayed_items(trans, path, node->root, node); 11244ea41ce0SMiao Xie if (ret) 11254ea41ce0SMiao Xie return ret; 11264ea41ce0SMiao Xie 11274ea41ce0SMiao Xie ret = btrfs_update_delayed_inode(trans, node->root, path, node); 11284ea41ce0SMiao Xie return ret; 11294ea41ce0SMiao Xie } 11304ea41ce0SMiao Xie 113179787eaaSJeff Mahoney /* 113279787eaaSJeff Mahoney * Called when committing the transaction. 113379787eaaSJeff Mahoney * Returns 0 on success. 113479787eaaSJeff Mahoney * Returns < 0 on error and returns with an aborted transaction with any 113579787eaaSJeff Mahoney * outstanding delayed items cleaned up. 113679787eaaSJeff Mahoney */ 113796c3f433SJosef Bacik static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, 11382ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info, int nr) 113916cdcec7SMiao Xie { 114016cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 114116cdcec7SMiao Xie struct btrfs_delayed_node *curr_node, *prev_node; 114216cdcec7SMiao Xie struct btrfs_path *path; 114319fd2949SMiao Xie struct btrfs_block_rsv *block_rsv; 114416cdcec7SMiao Xie int ret = 0; 114596c3f433SJosef Bacik bool count = (nr > 0); 114616cdcec7SMiao Xie 114779787eaaSJeff Mahoney if (trans->aborted) 114879787eaaSJeff Mahoney return -EIO; 114979787eaaSJeff Mahoney 115016cdcec7SMiao Xie path = btrfs_alloc_path(); 115116cdcec7SMiao Xie if (!path) 115216cdcec7SMiao Xie return -ENOMEM; 115316cdcec7SMiao Xie path->leave_spinning = 1; 115416cdcec7SMiao Xie 115519fd2949SMiao Xie block_rsv = trans->block_rsv; 11560b246afaSJeff Mahoney trans->block_rsv = &fs_info->delayed_block_rsv; 115719fd2949SMiao Xie 1158ccdf9b30SJeff Mahoney delayed_root = fs_info->delayed_root; 115916cdcec7SMiao Xie 116016cdcec7SMiao Xie curr_node = btrfs_first_delayed_node(delayed_root); 116196c3f433SJosef Bacik while (curr_node && (!count || (count && nr--))) { 11624ea41ce0SMiao Xie ret = __btrfs_commit_inode_delayed_items(trans, path, 116316cdcec7SMiao Xie curr_node); 116416cdcec7SMiao Xie if (ret) { 116516cdcec7SMiao Xie btrfs_release_delayed_node(curr_node); 116696c3f433SJosef Bacik curr_node = NULL; 116766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 116816cdcec7SMiao Xie break; 116916cdcec7SMiao Xie } 117016cdcec7SMiao Xie 117116cdcec7SMiao Xie prev_node = curr_node; 117216cdcec7SMiao Xie curr_node = btrfs_next_delayed_node(curr_node); 117316cdcec7SMiao Xie btrfs_release_delayed_node(prev_node); 117416cdcec7SMiao Xie } 117516cdcec7SMiao Xie 117696c3f433SJosef Bacik if (curr_node) 117796c3f433SJosef Bacik btrfs_release_delayed_node(curr_node); 117816cdcec7SMiao Xie btrfs_free_path(path); 117919fd2949SMiao Xie trans->block_rsv = block_rsv; 118079787eaaSJeff Mahoney 118116cdcec7SMiao Xie return ret; 118216cdcec7SMiao Xie } 118316cdcec7SMiao Xie 118496c3f433SJosef Bacik int btrfs_run_delayed_items(struct btrfs_trans_handle *trans, 11852ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info) 118696c3f433SJosef Bacik { 11872ff7e61eSJeff Mahoney return __btrfs_run_delayed_items(trans, fs_info, -1); 118896c3f433SJosef Bacik } 118996c3f433SJosef Bacik 119096c3f433SJosef Bacik int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, 11912ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info, int nr) 119296c3f433SJosef Bacik { 11932ff7e61eSJeff Mahoney return __btrfs_run_delayed_items(trans, fs_info, nr); 119496c3f433SJosef Bacik } 119596c3f433SJosef Bacik 119616cdcec7SMiao Xie int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 11975f4b32e9SNikolay Borisov struct btrfs_inode *inode) 119816cdcec7SMiao Xie { 11995f4b32e9SNikolay Borisov struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 12004ea41ce0SMiao Xie struct btrfs_path *path; 12014ea41ce0SMiao Xie struct btrfs_block_rsv *block_rsv; 120216cdcec7SMiao Xie int ret; 120316cdcec7SMiao Xie 120416cdcec7SMiao Xie if (!delayed_node) 120516cdcec7SMiao Xie return 0; 120616cdcec7SMiao Xie 120716cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 120816cdcec7SMiao Xie if (!delayed_node->count) { 120916cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 121016cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 121116cdcec7SMiao Xie return 0; 121216cdcec7SMiao Xie } 121316cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 121416cdcec7SMiao Xie 12154ea41ce0SMiao Xie path = btrfs_alloc_path(); 12163c77bd94SFilipe David Borba Manana if (!path) { 12173c77bd94SFilipe David Borba Manana btrfs_release_delayed_node(delayed_node); 12184ea41ce0SMiao Xie return -ENOMEM; 12193c77bd94SFilipe David Borba Manana } 12204ea41ce0SMiao Xie path->leave_spinning = 1; 12214ea41ce0SMiao Xie 12224ea41ce0SMiao Xie block_rsv = trans->block_rsv; 12234ea41ce0SMiao Xie trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv; 12244ea41ce0SMiao Xie 12254ea41ce0SMiao Xie ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 12264ea41ce0SMiao Xie 122716cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 12284ea41ce0SMiao Xie btrfs_free_path(path); 12294ea41ce0SMiao Xie trans->block_rsv = block_rsv; 12304ea41ce0SMiao Xie 123116cdcec7SMiao Xie return ret; 123216cdcec7SMiao Xie } 123316cdcec7SMiao Xie 1234aa79021fSNikolay Borisov int btrfs_commit_inode_delayed_inode(struct btrfs_inode *inode) 12350e8c36a9SMiao Xie { 1236aa79021fSNikolay Borisov struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb); 12370e8c36a9SMiao Xie struct btrfs_trans_handle *trans; 1238aa79021fSNikolay Borisov struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 12390e8c36a9SMiao Xie struct btrfs_path *path; 12400e8c36a9SMiao Xie struct btrfs_block_rsv *block_rsv; 12410e8c36a9SMiao Xie int ret; 12420e8c36a9SMiao Xie 12430e8c36a9SMiao Xie if (!delayed_node) 12440e8c36a9SMiao Xie return 0; 12450e8c36a9SMiao Xie 12460e8c36a9SMiao Xie mutex_lock(&delayed_node->mutex); 12477cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 12480e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12490e8c36a9SMiao Xie btrfs_release_delayed_node(delayed_node); 12500e8c36a9SMiao Xie return 0; 12510e8c36a9SMiao Xie } 12520e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12530e8c36a9SMiao Xie 12540e8c36a9SMiao Xie trans = btrfs_join_transaction(delayed_node->root); 12550e8c36a9SMiao Xie if (IS_ERR(trans)) { 12560e8c36a9SMiao Xie ret = PTR_ERR(trans); 12570e8c36a9SMiao Xie goto out; 12580e8c36a9SMiao Xie } 12590e8c36a9SMiao Xie 12600e8c36a9SMiao Xie path = btrfs_alloc_path(); 12610e8c36a9SMiao Xie if (!path) { 12620e8c36a9SMiao Xie ret = -ENOMEM; 12630e8c36a9SMiao Xie goto trans_out; 12640e8c36a9SMiao Xie } 12650e8c36a9SMiao Xie path->leave_spinning = 1; 12660e8c36a9SMiao Xie 12670e8c36a9SMiao Xie block_rsv = trans->block_rsv; 12682ff7e61eSJeff Mahoney trans->block_rsv = &fs_info->delayed_block_rsv; 12690e8c36a9SMiao Xie 12700e8c36a9SMiao Xie mutex_lock(&delayed_node->mutex); 12717cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) 12720e8c36a9SMiao Xie ret = __btrfs_update_delayed_inode(trans, delayed_node->root, 12730e8c36a9SMiao Xie path, delayed_node); 12740e8c36a9SMiao Xie else 12750e8c36a9SMiao Xie ret = 0; 12760e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12770e8c36a9SMiao Xie 12780e8c36a9SMiao Xie btrfs_free_path(path); 12790e8c36a9SMiao Xie trans->block_rsv = block_rsv; 12800e8c36a9SMiao Xie trans_out: 12813a45bb20SJeff Mahoney btrfs_end_transaction(trans); 12822ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(fs_info); 12830e8c36a9SMiao Xie out: 12840e8c36a9SMiao Xie btrfs_release_delayed_node(delayed_node); 12850e8c36a9SMiao Xie 12860e8c36a9SMiao Xie return ret; 12870e8c36a9SMiao Xie } 12880e8c36a9SMiao Xie 1289f48d1cf5SNikolay Borisov void btrfs_remove_delayed_node(struct btrfs_inode *inode) 129016cdcec7SMiao Xie { 129116cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 129216cdcec7SMiao Xie 1293f48d1cf5SNikolay Borisov delayed_node = READ_ONCE(inode->delayed_node); 129416cdcec7SMiao Xie if (!delayed_node) 129516cdcec7SMiao Xie return; 129616cdcec7SMiao Xie 1297f48d1cf5SNikolay Borisov inode->delayed_node = NULL; 129816cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 129916cdcec7SMiao Xie } 130016cdcec7SMiao Xie 1301de3cb945SChris Mason struct btrfs_async_delayed_work { 1302de3cb945SChris Mason struct btrfs_delayed_root *delayed_root; 1303de3cb945SChris Mason int nr; 1304d458b054SQu Wenruo struct btrfs_work work; 130516cdcec7SMiao Xie }; 130616cdcec7SMiao Xie 1307d458b054SQu Wenruo static void btrfs_async_run_delayed_root(struct btrfs_work *work) 130816cdcec7SMiao Xie { 1309de3cb945SChris Mason struct btrfs_async_delayed_work *async_work; 1310de3cb945SChris Mason struct btrfs_delayed_root *delayed_root; 131116cdcec7SMiao Xie struct btrfs_trans_handle *trans; 131216cdcec7SMiao Xie struct btrfs_path *path; 131316cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node = NULL; 131416cdcec7SMiao Xie struct btrfs_root *root; 131519fd2949SMiao Xie struct btrfs_block_rsv *block_rsv; 1316de3cb945SChris Mason int total_done = 0; 131716cdcec7SMiao Xie 1318de3cb945SChris Mason async_work = container_of(work, struct btrfs_async_delayed_work, work); 1319de3cb945SChris Mason delayed_root = async_work->delayed_root; 132016cdcec7SMiao Xie 132116cdcec7SMiao Xie path = btrfs_alloc_path(); 132216cdcec7SMiao Xie if (!path) 132316cdcec7SMiao Xie goto out; 132416cdcec7SMiao Xie 1325de3cb945SChris Mason again: 1326de3cb945SChris Mason if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND / 2) 1327de3cb945SChris Mason goto free_path; 1328de3cb945SChris Mason 1329de3cb945SChris Mason delayed_node = btrfs_first_prepared_delayed_node(delayed_root); 1330de3cb945SChris Mason if (!delayed_node) 1331de3cb945SChris Mason goto free_path; 1332de3cb945SChris Mason 1333de3cb945SChris Mason path->leave_spinning = 1; 133416cdcec7SMiao Xie root = delayed_node->root; 133516cdcec7SMiao Xie 1336ff5714ccSChris Mason trans = btrfs_join_transaction(root); 133716cdcec7SMiao Xie if (IS_ERR(trans)) 1338de3cb945SChris Mason goto release_path; 133916cdcec7SMiao Xie 134019fd2949SMiao Xie block_rsv = trans->block_rsv; 13416d668ddaSJosef Bacik trans->block_rsv = &root->fs_info->delayed_block_rsv; 134219fd2949SMiao Xie 13434ea41ce0SMiao Xie __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 134416cdcec7SMiao Xie 134519fd2949SMiao Xie trans->block_rsv = block_rsv; 13463a45bb20SJeff Mahoney btrfs_end_transaction(trans); 13472ff7e61eSJeff Mahoney btrfs_btree_balance_dirty_nodelay(root->fs_info); 1348de3cb945SChris Mason 1349de3cb945SChris Mason release_path: 1350de3cb945SChris Mason btrfs_release_path(path); 1351de3cb945SChris Mason total_done++; 1352de3cb945SChris Mason 1353de3cb945SChris Mason btrfs_release_prepared_delayed_node(delayed_node); 13542939e1a8SMaxim Patlasov if ((async_work->nr == 0 && total_done < BTRFS_DELAYED_WRITEBACK) || 13552939e1a8SMaxim Patlasov total_done < async_work->nr) 1356de3cb945SChris Mason goto again; 1357de3cb945SChris Mason 135816cdcec7SMiao Xie free_path: 135916cdcec7SMiao Xie btrfs_free_path(path); 136016cdcec7SMiao Xie out: 1361de3cb945SChris Mason wake_up(&delayed_root->wait); 1362de3cb945SChris Mason kfree(async_work); 136316cdcec7SMiao Xie } 1364de3cb945SChris Mason 136516cdcec7SMiao Xie 136616cdcec7SMiao Xie static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root, 1367a585e948SDaniel Dressler struct btrfs_fs_info *fs_info, int nr) 136816cdcec7SMiao Xie { 1369de3cb945SChris Mason struct btrfs_async_delayed_work *async_work; 137016cdcec7SMiao Xie 13712939e1a8SMaxim Patlasov if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND || 13722939e1a8SMaxim Patlasov btrfs_workqueue_normal_congested(fs_info->delayed_workers)) 137316cdcec7SMiao Xie return 0; 137416cdcec7SMiao Xie 1375de3cb945SChris Mason async_work = kmalloc(sizeof(*async_work), GFP_NOFS); 1376de3cb945SChris Mason if (!async_work) 137716cdcec7SMiao Xie return -ENOMEM; 137816cdcec7SMiao Xie 1379de3cb945SChris Mason async_work->delayed_root = delayed_root; 13809e0af237SLiu Bo btrfs_init_work(&async_work->work, btrfs_delayed_meta_helper, 13819e0af237SLiu Bo btrfs_async_run_delayed_root, NULL, NULL); 1382de3cb945SChris Mason async_work->nr = nr; 138316cdcec7SMiao Xie 1384a585e948SDaniel Dressler btrfs_queue_work(fs_info->delayed_workers, &async_work->work); 138516cdcec7SMiao Xie return 0; 138616cdcec7SMiao Xie } 138716cdcec7SMiao Xie 1388ccdf9b30SJeff Mahoney void btrfs_assert_delayed_root_empty(struct btrfs_fs_info *fs_info) 1389e999376fSChris Mason { 1390ccdf9b30SJeff Mahoney WARN_ON(btrfs_first_delayed_node(fs_info->delayed_root)); 1391e999376fSChris Mason } 1392e999376fSChris Mason 13930353808cSMiao Xie static int could_end_wait(struct btrfs_delayed_root *delayed_root, int seq) 1394de3cb945SChris Mason { 1395de3cb945SChris Mason int val = atomic_read(&delayed_root->items_seq); 1396de3cb945SChris Mason 13970353808cSMiao Xie if (val < seq || val >= seq + BTRFS_DELAYED_BATCH) 1398de3cb945SChris Mason return 1; 13990353808cSMiao Xie 14000353808cSMiao Xie if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 14010353808cSMiao Xie return 1; 14020353808cSMiao Xie 1403de3cb945SChris Mason return 0; 1404de3cb945SChris Mason } 1405de3cb945SChris Mason 14062ff7e61eSJeff Mahoney void btrfs_balance_delayed_items(struct btrfs_fs_info *fs_info) 140716cdcec7SMiao Xie { 14082ff7e61eSJeff Mahoney struct btrfs_delayed_root *delayed_root = fs_info->delayed_root; 140916cdcec7SMiao Xie 141016cdcec7SMiao Xie if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 141116cdcec7SMiao Xie return; 141216cdcec7SMiao Xie 141316cdcec7SMiao Xie if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) { 14140353808cSMiao Xie int seq; 141516cdcec7SMiao Xie int ret; 14160353808cSMiao Xie 14170353808cSMiao Xie seq = atomic_read(&delayed_root->items_seq); 1418de3cb945SChris Mason 1419a585e948SDaniel Dressler ret = btrfs_wq_run_delayed_node(delayed_root, fs_info, 0); 142016cdcec7SMiao Xie if (ret) 142116cdcec7SMiao Xie return; 142216cdcec7SMiao Xie 14230353808cSMiao Xie wait_event_interruptible(delayed_root->wait, 14240353808cSMiao Xie could_end_wait(delayed_root, seq)); 14254dd466d3SMiao Xie return; 142616cdcec7SMiao Xie } 142716cdcec7SMiao Xie 1428a585e948SDaniel Dressler btrfs_wq_run_delayed_node(delayed_root, fs_info, BTRFS_DELAYED_BATCH); 142916cdcec7SMiao Xie } 143016cdcec7SMiao Xie 143179787eaaSJeff Mahoney /* Will return 0 or -ENOMEM */ 143216cdcec7SMiao Xie int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans, 14332ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info, 14342ff7e61eSJeff Mahoney const char *name, int name_len, 14356f45d185SNikolay Borisov struct btrfs_inode *dir, 143616cdcec7SMiao Xie struct btrfs_disk_key *disk_key, u8 type, 143716cdcec7SMiao Xie u64 index) 143816cdcec7SMiao Xie { 143916cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 144016cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item; 144116cdcec7SMiao Xie struct btrfs_dir_item *dir_item; 144216cdcec7SMiao Xie int ret; 144316cdcec7SMiao Xie 14446f45d185SNikolay Borisov delayed_node = btrfs_get_or_create_delayed_node(dir); 144516cdcec7SMiao Xie if (IS_ERR(delayed_node)) 144616cdcec7SMiao Xie return PTR_ERR(delayed_node); 144716cdcec7SMiao Xie 144816cdcec7SMiao Xie delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len); 144916cdcec7SMiao Xie if (!delayed_item) { 145016cdcec7SMiao Xie ret = -ENOMEM; 145116cdcec7SMiao Xie goto release_node; 145216cdcec7SMiao Xie } 145316cdcec7SMiao Xie 14546f45d185SNikolay Borisov delayed_item->key.objectid = btrfs_ino(dir); 1455962a298fSDavid Sterba delayed_item->key.type = BTRFS_DIR_INDEX_KEY; 145616cdcec7SMiao Xie delayed_item->key.offset = index; 145716cdcec7SMiao Xie 145816cdcec7SMiao Xie dir_item = (struct btrfs_dir_item *)delayed_item->data; 145916cdcec7SMiao Xie dir_item->location = *disk_key; 14603cae210fSQu Wenruo btrfs_set_stack_dir_transid(dir_item, trans->transid); 14613cae210fSQu Wenruo btrfs_set_stack_dir_data_len(dir_item, 0); 14623cae210fSQu Wenruo btrfs_set_stack_dir_name_len(dir_item, name_len); 14633cae210fSQu Wenruo btrfs_set_stack_dir_type(dir_item, type); 146416cdcec7SMiao Xie memcpy((char *)(dir_item + 1), name, name_len); 146516cdcec7SMiao Xie 14662ff7e61eSJeff Mahoney ret = btrfs_delayed_item_reserve_metadata(trans, fs_info, delayed_item); 14678c2a3ca2SJosef Bacik /* 14688c2a3ca2SJosef Bacik * we have reserved enough space when we start a new transaction, 14698c2a3ca2SJosef Bacik * so reserving metadata failure is impossible 14708c2a3ca2SJosef Bacik */ 14718c2a3ca2SJosef Bacik BUG_ON(ret); 14728c2a3ca2SJosef Bacik 14738c2a3ca2SJosef Bacik 147416cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 147516cdcec7SMiao Xie ret = __btrfs_add_delayed_insertion_item(delayed_node, delayed_item); 147616cdcec7SMiao Xie if (unlikely(ret)) { 14772ff7e61eSJeff Mahoney btrfs_err(fs_info, 14785d163e0eSJeff 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)", 1479bdab49d7SFilipe David Borba Manana name_len, name, delayed_node->root->objectid, 1480c1c9ff7cSGeert Uytterhoeven delayed_node->inode_id, ret); 148116cdcec7SMiao Xie BUG(); 148216cdcec7SMiao Xie } 148316cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 148416cdcec7SMiao Xie 148516cdcec7SMiao Xie release_node: 148616cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 148716cdcec7SMiao Xie return ret; 148816cdcec7SMiao Xie } 148916cdcec7SMiao Xie 14902ff7e61eSJeff Mahoney static int btrfs_delete_delayed_insertion_item(struct btrfs_fs_info *fs_info, 149116cdcec7SMiao Xie struct btrfs_delayed_node *node, 149216cdcec7SMiao Xie struct btrfs_key *key) 149316cdcec7SMiao Xie { 149416cdcec7SMiao Xie struct btrfs_delayed_item *item; 149516cdcec7SMiao Xie 149616cdcec7SMiao Xie mutex_lock(&node->mutex); 149716cdcec7SMiao Xie item = __btrfs_lookup_delayed_insertion_item(node, key); 149816cdcec7SMiao Xie if (!item) { 149916cdcec7SMiao Xie mutex_unlock(&node->mutex); 150016cdcec7SMiao Xie return 1; 150116cdcec7SMiao Xie } 150216cdcec7SMiao Xie 15032ff7e61eSJeff Mahoney btrfs_delayed_item_release_metadata(fs_info, item); 150416cdcec7SMiao Xie btrfs_release_delayed_item(item); 150516cdcec7SMiao Xie mutex_unlock(&node->mutex); 150616cdcec7SMiao Xie return 0; 150716cdcec7SMiao Xie } 150816cdcec7SMiao Xie 150916cdcec7SMiao Xie int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans, 15102ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info, 1511e67bbbb9SNikolay Borisov struct btrfs_inode *dir, u64 index) 151216cdcec7SMiao Xie { 151316cdcec7SMiao Xie struct btrfs_delayed_node *node; 151416cdcec7SMiao Xie struct btrfs_delayed_item *item; 151516cdcec7SMiao Xie struct btrfs_key item_key; 151616cdcec7SMiao Xie int ret; 151716cdcec7SMiao Xie 1518e67bbbb9SNikolay Borisov node = btrfs_get_or_create_delayed_node(dir); 151916cdcec7SMiao Xie if (IS_ERR(node)) 152016cdcec7SMiao Xie return PTR_ERR(node); 152116cdcec7SMiao Xie 1522e67bbbb9SNikolay Borisov item_key.objectid = btrfs_ino(dir); 1523962a298fSDavid Sterba item_key.type = BTRFS_DIR_INDEX_KEY; 152416cdcec7SMiao Xie item_key.offset = index; 152516cdcec7SMiao Xie 15262ff7e61eSJeff Mahoney ret = btrfs_delete_delayed_insertion_item(fs_info, node, &item_key); 152716cdcec7SMiao Xie if (!ret) 152816cdcec7SMiao Xie goto end; 152916cdcec7SMiao Xie 153016cdcec7SMiao Xie item = btrfs_alloc_delayed_item(0); 153116cdcec7SMiao Xie if (!item) { 153216cdcec7SMiao Xie ret = -ENOMEM; 153316cdcec7SMiao Xie goto end; 153416cdcec7SMiao Xie } 153516cdcec7SMiao Xie 153616cdcec7SMiao Xie item->key = item_key; 153716cdcec7SMiao Xie 15382ff7e61eSJeff Mahoney ret = btrfs_delayed_item_reserve_metadata(trans, fs_info, item); 153916cdcec7SMiao Xie /* 154016cdcec7SMiao Xie * we have reserved enough space when we start a new transaction, 154116cdcec7SMiao Xie * so reserving metadata failure is impossible. 154216cdcec7SMiao Xie */ 154316cdcec7SMiao Xie BUG_ON(ret); 154416cdcec7SMiao Xie 154516cdcec7SMiao Xie mutex_lock(&node->mutex); 154616cdcec7SMiao Xie ret = __btrfs_add_delayed_deletion_item(node, item); 154716cdcec7SMiao Xie if (unlikely(ret)) { 15482ff7e61eSJeff Mahoney btrfs_err(fs_info, 15495d163e0eSJeff 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)", 15505d163e0eSJeff Mahoney index, node->root->objectid, node->inode_id, ret); 155116cdcec7SMiao Xie BUG(); 155216cdcec7SMiao Xie } 155316cdcec7SMiao Xie mutex_unlock(&node->mutex); 155416cdcec7SMiao Xie end: 155516cdcec7SMiao Xie btrfs_release_delayed_node(node); 155616cdcec7SMiao Xie return ret; 155716cdcec7SMiao Xie } 155816cdcec7SMiao Xie 1559*f5cc7b80SNikolay Borisov int btrfs_inode_delayed_dir_index_count(struct btrfs_inode *inode) 156016cdcec7SMiao Xie { 1561*f5cc7b80SNikolay Borisov struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 156216cdcec7SMiao Xie 156316cdcec7SMiao Xie if (!delayed_node) 156416cdcec7SMiao Xie return -ENOENT; 156516cdcec7SMiao Xie 156616cdcec7SMiao Xie /* 156716cdcec7SMiao Xie * Since we have held i_mutex of this directory, it is impossible that 156816cdcec7SMiao Xie * a new directory index is added into the delayed node and index_cnt 156916cdcec7SMiao Xie * is updated now. So we needn't lock the delayed node. 157016cdcec7SMiao Xie */ 15712f7e33d4SMiao Xie if (!delayed_node->index_cnt) { 15722f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 157316cdcec7SMiao Xie return -EINVAL; 15742f7e33d4SMiao Xie } 157516cdcec7SMiao Xie 1576*f5cc7b80SNikolay Borisov inode->index_cnt = delayed_node->index_cnt; 15772f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 15782f7e33d4SMiao Xie return 0; 157916cdcec7SMiao Xie } 158016cdcec7SMiao Xie 158102dbfc99SOmar Sandoval bool btrfs_readdir_get_delayed_items(struct inode *inode, 158202dbfc99SOmar Sandoval struct list_head *ins_list, 158316cdcec7SMiao Xie struct list_head *del_list) 158416cdcec7SMiao Xie { 158516cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 158616cdcec7SMiao Xie struct btrfs_delayed_item *item; 158716cdcec7SMiao Xie 1588340c6ca9SNikolay Borisov delayed_node = btrfs_get_delayed_node(BTRFS_I(inode)); 158916cdcec7SMiao Xie if (!delayed_node) 159002dbfc99SOmar Sandoval return false; 159102dbfc99SOmar Sandoval 159202dbfc99SOmar Sandoval /* 159302dbfc99SOmar Sandoval * We can only do one readdir with delayed items at a time because of 159402dbfc99SOmar Sandoval * item->readdir_list. 159502dbfc99SOmar Sandoval */ 159602dbfc99SOmar Sandoval inode_unlock_shared(inode); 159702dbfc99SOmar Sandoval inode_lock(inode); 159816cdcec7SMiao Xie 159916cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 160016cdcec7SMiao Xie item = __btrfs_first_delayed_insertion_item(delayed_node); 160116cdcec7SMiao Xie while (item) { 160216cdcec7SMiao Xie atomic_inc(&item->refs); 160316cdcec7SMiao Xie list_add_tail(&item->readdir_list, ins_list); 160416cdcec7SMiao Xie item = __btrfs_next_delayed_item(item); 160516cdcec7SMiao Xie } 160616cdcec7SMiao Xie 160716cdcec7SMiao Xie item = __btrfs_first_delayed_deletion_item(delayed_node); 160816cdcec7SMiao Xie while (item) { 160916cdcec7SMiao Xie atomic_inc(&item->refs); 161016cdcec7SMiao Xie list_add_tail(&item->readdir_list, del_list); 161116cdcec7SMiao Xie item = __btrfs_next_delayed_item(item); 161216cdcec7SMiao Xie } 161316cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 161416cdcec7SMiao Xie /* 161516cdcec7SMiao Xie * This delayed node is still cached in the btrfs inode, so refs 161616cdcec7SMiao Xie * must be > 1 now, and we needn't check it is going to be freed 161716cdcec7SMiao Xie * or not. 161816cdcec7SMiao Xie * 161916cdcec7SMiao Xie * Besides that, this function is used to read dir, we do not 162016cdcec7SMiao Xie * insert/delete delayed items in this period. So we also needn't 162116cdcec7SMiao Xie * requeue or dequeue this delayed node. 162216cdcec7SMiao Xie */ 162316cdcec7SMiao Xie atomic_dec(&delayed_node->refs); 162402dbfc99SOmar Sandoval 162502dbfc99SOmar Sandoval return true; 162616cdcec7SMiao Xie } 162716cdcec7SMiao Xie 162802dbfc99SOmar Sandoval void btrfs_readdir_put_delayed_items(struct inode *inode, 162902dbfc99SOmar Sandoval struct list_head *ins_list, 163016cdcec7SMiao Xie struct list_head *del_list) 163116cdcec7SMiao Xie { 163216cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 163316cdcec7SMiao Xie 163416cdcec7SMiao Xie list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 163516cdcec7SMiao Xie list_del(&curr->readdir_list); 163616cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 163716cdcec7SMiao Xie kfree(curr); 163816cdcec7SMiao Xie } 163916cdcec7SMiao Xie 164016cdcec7SMiao Xie list_for_each_entry_safe(curr, next, del_list, readdir_list) { 164116cdcec7SMiao Xie list_del(&curr->readdir_list); 164216cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 164316cdcec7SMiao Xie kfree(curr); 164416cdcec7SMiao Xie } 164502dbfc99SOmar Sandoval 164602dbfc99SOmar Sandoval /* 164702dbfc99SOmar Sandoval * The VFS is going to do up_read(), so we need to downgrade back to a 164802dbfc99SOmar Sandoval * read lock. 164902dbfc99SOmar Sandoval */ 165002dbfc99SOmar Sandoval downgrade_write(&inode->i_rwsem); 165116cdcec7SMiao Xie } 165216cdcec7SMiao Xie 165316cdcec7SMiao Xie int btrfs_should_delete_dir_index(struct list_head *del_list, 165416cdcec7SMiao Xie u64 index) 165516cdcec7SMiao Xie { 165616cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 165716cdcec7SMiao Xie int ret; 165816cdcec7SMiao Xie 165916cdcec7SMiao Xie if (list_empty(del_list)) 166016cdcec7SMiao Xie return 0; 166116cdcec7SMiao Xie 166216cdcec7SMiao Xie list_for_each_entry_safe(curr, next, del_list, readdir_list) { 166316cdcec7SMiao Xie if (curr->key.offset > index) 166416cdcec7SMiao Xie break; 166516cdcec7SMiao Xie 166616cdcec7SMiao Xie list_del(&curr->readdir_list); 166716cdcec7SMiao Xie ret = (curr->key.offset == index); 166816cdcec7SMiao Xie 166916cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 167016cdcec7SMiao Xie kfree(curr); 167116cdcec7SMiao Xie 167216cdcec7SMiao Xie if (ret) 167316cdcec7SMiao Xie return 1; 167416cdcec7SMiao Xie else 167516cdcec7SMiao Xie continue; 167616cdcec7SMiao Xie } 167716cdcec7SMiao Xie return 0; 167816cdcec7SMiao Xie } 167916cdcec7SMiao Xie 168016cdcec7SMiao Xie /* 168116cdcec7SMiao Xie * btrfs_readdir_delayed_dir_index - read dir info stored in the delayed tree 168216cdcec7SMiao Xie * 168316cdcec7SMiao Xie */ 16849cdda8d3SAl Viro int btrfs_readdir_delayed_dir_index(struct dir_context *ctx, 1685d2fbb2b5SJeff Mahoney struct list_head *ins_list) 168616cdcec7SMiao Xie { 168716cdcec7SMiao Xie struct btrfs_dir_item *di; 168816cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 168916cdcec7SMiao Xie struct btrfs_key location; 169016cdcec7SMiao Xie char *name; 169116cdcec7SMiao Xie int name_len; 169216cdcec7SMiao Xie int over = 0; 169316cdcec7SMiao Xie unsigned char d_type; 169416cdcec7SMiao Xie 169516cdcec7SMiao Xie if (list_empty(ins_list)) 169616cdcec7SMiao Xie return 0; 169716cdcec7SMiao Xie 169816cdcec7SMiao Xie /* 169916cdcec7SMiao Xie * Changing the data of the delayed item is impossible. So 170016cdcec7SMiao Xie * we needn't lock them. And we have held i_mutex of the 170116cdcec7SMiao Xie * directory, nobody can delete any directory indexes now. 170216cdcec7SMiao Xie */ 170316cdcec7SMiao Xie list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 170416cdcec7SMiao Xie list_del(&curr->readdir_list); 170516cdcec7SMiao Xie 17069cdda8d3SAl Viro if (curr->key.offset < ctx->pos) { 170716cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 170816cdcec7SMiao Xie kfree(curr); 170916cdcec7SMiao Xie continue; 171016cdcec7SMiao Xie } 171116cdcec7SMiao Xie 17129cdda8d3SAl Viro ctx->pos = curr->key.offset; 171316cdcec7SMiao Xie 171416cdcec7SMiao Xie di = (struct btrfs_dir_item *)curr->data; 171516cdcec7SMiao Xie name = (char *)(di + 1); 17163cae210fSQu Wenruo name_len = btrfs_stack_dir_name_len(di); 171716cdcec7SMiao Xie 171816cdcec7SMiao Xie d_type = btrfs_filetype_table[di->type]; 171916cdcec7SMiao Xie btrfs_disk_key_to_cpu(&location, &di->location); 172016cdcec7SMiao Xie 17219cdda8d3SAl Viro over = !dir_emit(ctx, name, name_len, 172216cdcec7SMiao Xie location.objectid, d_type); 172316cdcec7SMiao Xie 172416cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 172516cdcec7SMiao Xie kfree(curr); 172616cdcec7SMiao Xie 172716cdcec7SMiao Xie if (over) 172816cdcec7SMiao Xie return 1; 172916cdcec7SMiao Xie } 173016cdcec7SMiao Xie return 0; 173116cdcec7SMiao Xie } 173216cdcec7SMiao Xie 173316cdcec7SMiao Xie static void fill_stack_inode_item(struct btrfs_trans_handle *trans, 173416cdcec7SMiao Xie struct btrfs_inode_item *inode_item, 173516cdcec7SMiao Xie struct inode *inode) 173616cdcec7SMiao Xie { 17372f2f43d3SEric W. Biederman btrfs_set_stack_inode_uid(inode_item, i_uid_read(inode)); 17382f2f43d3SEric W. Biederman btrfs_set_stack_inode_gid(inode_item, i_gid_read(inode)); 173916cdcec7SMiao Xie btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size); 174016cdcec7SMiao Xie btrfs_set_stack_inode_mode(inode_item, inode->i_mode); 174116cdcec7SMiao Xie btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink); 174216cdcec7SMiao Xie btrfs_set_stack_inode_nbytes(inode_item, inode_get_bytes(inode)); 174316cdcec7SMiao Xie btrfs_set_stack_inode_generation(inode_item, 174416cdcec7SMiao Xie BTRFS_I(inode)->generation); 17450c4d2d95SJosef Bacik btrfs_set_stack_inode_sequence(inode_item, inode->i_version); 174616cdcec7SMiao Xie btrfs_set_stack_inode_transid(inode_item, trans->transid); 174716cdcec7SMiao Xie btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev); 174816cdcec7SMiao Xie btrfs_set_stack_inode_flags(inode_item, BTRFS_I(inode)->flags); 1749ff5714ccSChris Mason btrfs_set_stack_inode_block_group(inode_item, 0); 175016cdcec7SMiao Xie 1751a937b979SDavid Sterba btrfs_set_stack_timespec_sec(&inode_item->atime, 175216cdcec7SMiao Xie inode->i_atime.tv_sec); 1753a937b979SDavid Sterba btrfs_set_stack_timespec_nsec(&inode_item->atime, 175416cdcec7SMiao Xie inode->i_atime.tv_nsec); 175516cdcec7SMiao Xie 1756a937b979SDavid Sterba btrfs_set_stack_timespec_sec(&inode_item->mtime, 175716cdcec7SMiao Xie inode->i_mtime.tv_sec); 1758a937b979SDavid Sterba btrfs_set_stack_timespec_nsec(&inode_item->mtime, 175916cdcec7SMiao Xie inode->i_mtime.tv_nsec); 176016cdcec7SMiao Xie 1761a937b979SDavid Sterba btrfs_set_stack_timespec_sec(&inode_item->ctime, 176216cdcec7SMiao Xie inode->i_ctime.tv_sec); 1763a937b979SDavid Sterba btrfs_set_stack_timespec_nsec(&inode_item->ctime, 176416cdcec7SMiao Xie inode->i_ctime.tv_nsec); 17659cc97d64Schandan r 17669cc97d64Schandan r btrfs_set_stack_timespec_sec(&inode_item->otime, 17679cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_sec); 17689cc97d64Schandan r btrfs_set_stack_timespec_nsec(&inode_item->otime, 17699cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_nsec); 177016cdcec7SMiao Xie } 177116cdcec7SMiao Xie 17722f7e33d4SMiao Xie int btrfs_fill_inode(struct inode *inode, u32 *rdev) 17732f7e33d4SMiao Xie { 17742f7e33d4SMiao Xie struct btrfs_delayed_node *delayed_node; 17752f7e33d4SMiao Xie struct btrfs_inode_item *inode_item; 17762f7e33d4SMiao Xie 1777340c6ca9SNikolay Borisov delayed_node = btrfs_get_delayed_node(BTRFS_I(inode)); 17782f7e33d4SMiao Xie if (!delayed_node) 17792f7e33d4SMiao Xie return -ENOENT; 17802f7e33d4SMiao Xie 17812f7e33d4SMiao Xie mutex_lock(&delayed_node->mutex); 17827cf35d91SMiao Xie if (!test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 17832f7e33d4SMiao Xie mutex_unlock(&delayed_node->mutex); 17842f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 17852f7e33d4SMiao Xie return -ENOENT; 17862f7e33d4SMiao Xie } 17872f7e33d4SMiao Xie 17882f7e33d4SMiao Xie inode_item = &delayed_node->inode_item; 17892f7e33d4SMiao Xie 17902f2f43d3SEric W. Biederman i_uid_write(inode, btrfs_stack_inode_uid(inode_item)); 17912f2f43d3SEric W. Biederman i_gid_write(inode, btrfs_stack_inode_gid(inode_item)); 17922f7e33d4SMiao Xie btrfs_i_size_write(inode, btrfs_stack_inode_size(inode_item)); 17932f7e33d4SMiao Xie inode->i_mode = btrfs_stack_inode_mode(inode_item); 1794bfe86848SMiklos Szeredi set_nlink(inode, btrfs_stack_inode_nlink(inode_item)); 17952f7e33d4SMiao Xie inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item)); 17962f7e33d4SMiao Xie BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item); 17976e17d30bSYang Dongsheng BTRFS_I(inode)->last_trans = btrfs_stack_inode_transid(inode_item); 17986e17d30bSYang Dongsheng 17990c4d2d95SJosef Bacik inode->i_version = btrfs_stack_inode_sequence(inode_item); 18002f7e33d4SMiao Xie inode->i_rdev = 0; 18012f7e33d4SMiao Xie *rdev = btrfs_stack_inode_rdev(inode_item); 18022f7e33d4SMiao Xie BTRFS_I(inode)->flags = btrfs_stack_inode_flags(inode_item); 18032f7e33d4SMiao Xie 1804a937b979SDavid Sterba inode->i_atime.tv_sec = btrfs_stack_timespec_sec(&inode_item->atime); 1805a937b979SDavid Sterba inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->atime); 18062f7e33d4SMiao Xie 1807a937b979SDavid Sterba inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(&inode_item->mtime); 1808a937b979SDavid Sterba inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->mtime); 18092f7e33d4SMiao Xie 1810a937b979SDavid Sterba inode->i_ctime.tv_sec = btrfs_stack_timespec_sec(&inode_item->ctime); 1811a937b979SDavid Sterba inode->i_ctime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->ctime); 18122f7e33d4SMiao Xie 18139cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_sec = 18149cc97d64Schandan r btrfs_stack_timespec_sec(&inode_item->otime); 18159cc97d64Schandan r BTRFS_I(inode)->i_otime.tv_nsec = 18169cc97d64Schandan r btrfs_stack_timespec_nsec(&inode_item->otime); 18179cc97d64Schandan r 18182f7e33d4SMiao Xie inode->i_generation = BTRFS_I(inode)->generation; 18192f7e33d4SMiao Xie BTRFS_I(inode)->index_cnt = (u64)-1; 18202f7e33d4SMiao Xie 18212f7e33d4SMiao Xie mutex_unlock(&delayed_node->mutex); 18222f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 18232f7e33d4SMiao Xie return 0; 18242f7e33d4SMiao Xie } 18252f7e33d4SMiao Xie 182616cdcec7SMiao Xie int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans, 182716cdcec7SMiao Xie struct btrfs_root *root, struct inode *inode) 182816cdcec7SMiao Xie { 182916cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 1830aa0467d8SDavid Sterba int ret = 0; 183116cdcec7SMiao Xie 1832e5517a7bSNikolay Borisov delayed_node = btrfs_get_or_create_delayed_node(BTRFS_I(inode)); 183316cdcec7SMiao Xie if (IS_ERR(delayed_node)) 183416cdcec7SMiao Xie return PTR_ERR(delayed_node); 183516cdcec7SMiao Xie 183616cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 18377cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 183816cdcec7SMiao Xie fill_stack_inode_item(trans, &delayed_node->inode_item, inode); 183916cdcec7SMiao Xie goto release_node; 184016cdcec7SMiao Xie } 184116cdcec7SMiao Xie 1842fcabdd1cSNikolay Borisov ret = btrfs_delayed_inode_reserve_metadata(trans, root, BTRFS_I(inode), 18437fd2ae21SJosef Bacik delayed_node); 1844c06a0e12SJosef Bacik if (ret) 1845c06a0e12SJosef Bacik goto release_node; 184616cdcec7SMiao Xie 184716cdcec7SMiao Xie fill_stack_inode_item(trans, &delayed_node->inode_item, inode); 18487cf35d91SMiao Xie set_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags); 184916cdcec7SMiao Xie delayed_node->count++; 185016cdcec7SMiao Xie atomic_inc(&root->fs_info->delayed_root->items); 185116cdcec7SMiao Xie release_node: 185216cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 185316cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 185416cdcec7SMiao Xie return ret; 185516cdcec7SMiao Xie } 185616cdcec7SMiao Xie 1857e07222c7SNikolay Borisov int btrfs_delayed_delete_inode_ref(struct btrfs_inode *inode) 185867de1176SMiao Xie { 1859e07222c7SNikolay Borisov struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb); 186067de1176SMiao Xie struct btrfs_delayed_node *delayed_node; 186167de1176SMiao Xie 18626f896054SChris Mason /* 18636f896054SChris Mason * we don't do delayed inode updates during log recovery because it 18646f896054SChris Mason * leads to enospc problems. This means we also can't do 18656f896054SChris Mason * delayed inode refs 18666f896054SChris Mason */ 18670b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 18686f896054SChris Mason return -EAGAIN; 18696f896054SChris Mason 1870e07222c7SNikolay Borisov delayed_node = btrfs_get_or_create_delayed_node(inode); 187167de1176SMiao Xie if (IS_ERR(delayed_node)) 187267de1176SMiao Xie return PTR_ERR(delayed_node); 187367de1176SMiao Xie 187467de1176SMiao Xie /* 187567de1176SMiao Xie * We don't reserve space for inode ref deletion is because: 187667de1176SMiao Xie * - We ONLY do async inode ref deletion for the inode who has only 187767de1176SMiao Xie * one link(i_nlink == 1), it means there is only one inode ref. 187867de1176SMiao Xie * And in most case, the inode ref and the inode item are in the 187967de1176SMiao Xie * same leaf, and we will deal with them at the same time. 188067de1176SMiao Xie * Since we are sure we will reserve the space for the inode item, 188167de1176SMiao Xie * it is unnecessary to reserve space for inode ref deletion. 188267de1176SMiao Xie * - If the inode ref and the inode item are not in the same leaf, 188367de1176SMiao Xie * We also needn't worry about enospc problem, because we reserve 188467de1176SMiao Xie * much more space for the inode update than it needs. 188567de1176SMiao Xie * - At the worst, we can steal some space from the global reservation. 188667de1176SMiao Xie * It is very rare. 188767de1176SMiao Xie */ 188867de1176SMiao Xie mutex_lock(&delayed_node->mutex); 188967de1176SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) 189067de1176SMiao Xie goto release_node; 189167de1176SMiao Xie 189267de1176SMiao Xie set_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags); 189367de1176SMiao Xie delayed_node->count++; 18940b246afaSJeff Mahoney atomic_inc(&fs_info->delayed_root->items); 189567de1176SMiao Xie release_node: 189667de1176SMiao Xie mutex_unlock(&delayed_node->mutex); 189767de1176SMiao Xie btrfs_release_delayed_node(delayed_node); 189867de1176SMiao Xie return 0; 189967de1176SMiao Xie } 190067de1176SMiao Xie 190116cdcec7SMiao Xie static void __btrfs_kill_delayed_node(struct btrfs_delayed_node *delayed_node) 190216cdcec7SMiao Xie { 190316cdcec7SMiao Xie struct btrfs_root *root = delayed_node->root; 19042ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 190516cdcec7SMiao Xie struct btrfs_delayed_item *curr_item, *prev_item; 190616cdcec7SMiao Xie 190716cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 190816cdcec7SMiao Xie curr_item = __btrfs_first_delayed_insertion_item(delayed_node); 190916cdcec7SMiao Xie while (curr_item) { 19102ff7e61eSJeff Mahoney btrfs_delayed_item_release_metadata(fs_info, curr_item); 191116cdcec7SMiao Xie prev_item = curr_item; 191216cdcec7SMiao Xie curr_item = __btrfs_next_delayed_item(prev_item); 191316cdcec7SMiao Xie btrfs_release_delayed_item(prev_item); 191416cdcec7SMiao Xie } 191516cdcec7SMiao Xie 191616cdcec7SMiao Xie curr_item = __btrfs_first_delayed_deletion_item(delayed_node); 191716cdcec7SMiao Xie while (curr_item) { 19182ff7e61eSJeff Mahoney btrfs_delayed_item_release_metadata(fs_info, curr_item); 191916cdcec7SMiao Xie prev_item = curr_item; 192016cdcec7SMiao Xie curr_item = __btrfs_next_delayed_item(prev_item); 192116cdcec7SMiao Xie btrfs_release_delayed_item(prev_item); 192216cdcec7SMiao Xie } 192316cdcec7SMiao Xie 192467de1176SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_DEL_IREF, &delayed_node->flags)) 192567de1176SMiao Xie btrfs_release_delayed_iref(delayed_node); 192667de1176SMiao Xie 19277cf35d91SMiao Xie if (test_bit(BTRFS_DELAYED_NODE_INODE_DIRTY, &delayed_node->flags)) { 19282ff7e61eSJeff Mahoney btrfs_delayed_inode_release_metadata(fs_info, delayed_node); 192916cdcec7SMiao Xie btrfs_release_delayed_inode(delayed_node); 193016cdcec7SMiao Xie } 193116cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 193216cdcec7SMiao Xie } 193316cdcec7SMiao Xie 19344ccb5c72SNikolay Borisov void btrfs_kill_delayed_inode_items(struct btrfs_inode *inode) 193516cdcec7SMiao Xie { 193616cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 193716cdcec7SMiao Xie 19384ccb5c72SNikolay Borisov delayed_node = btrfs_get_delayed_node(inode); 193916cdcec7SMiao Xie if (!delayed_node) 194016cdcec7SMiao Xie return; 194116cdcec7SMiao Xie 194216cdcec7SMiao Xie __btrfs_kill_delayed_node(delayed_node); 194316cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 194416cdcec7SMiao Xie } 194516cdcec7SMiao Xie 194616cdcec7SMiao Xie void btrfs_kill_all_delayed_nodes(struct btrfs_root *root) 194716cdcec7SMiao Xie { 194816cdcec7SMiao Xie u64 inode_id = 0; 194916cdcec7SMiao Xie struct btrfs_delayed_node *delayed_nodes[8]; 195016cdcec7SMiao Xie int i, n; 195116cdcec7SMiao Xie 195216cdcec7SMiao Xie while (1) { 195316cdcec7SMiao Xie spin_lock(&root->inode_lock); 195416cdcec7SMiao Xie n = radix_tree_gang_lookup(&root->delayed_nodes_tree, 195516cdcec7SMiao Xie (void **)delayed_nodes, inode_id, 195616cdcec7SMiao Xie ARRAY_SIZE(delayed_nodes)); 195716cdcec7SMiao Xie if (!n) { 195816cdcec7SMiao Xie spin_unlock(&root->inode_lock); 195916cdcec7SMiao Xie break; 196016cdcec7SMiao Xie } 196116cdcec7SMiao Xie 196216cdcec7SMiao Xie inode_id = delayed_nodes[n - 1]->inode_id + 1; 196316cdcec7SMiao Xie 196416cdcec7SMiao Xie for (i = 0; i < n; i++) 196516cdcec7SMiao Xie atomic_inc(&delayed_nodes[i]->refs); 196616cdcec7SMiao Xie spin_unlock(&root->inode_lock); 196716cdcec7SMiao Xie 196816cdcec7SMiao Xie for (i = 0; i < n; i++) { 196916cdcec7SMiao Xie __btrfs_kill_delayed_node(delayed_nodes[i]); 197016cdcec7SMiao Xie btrfs_release_delayed_node(delayed_nodes[i]); 197116cdcec7SMiao Xie } 197216cdcec7SMiao Xie } 197316cdcec7SMiao Xie } 197467cde344SMiao Xie 1975ccdf9b30SJeff Mahoney void btrfs_destroy_delayed_inodes(struct btrfs_fs_info *fs_info) 197667cde344SMiao Xie { 197767cde344SMiao Xie struct btrfs_delayed_node *curr_node, *prev_node; 197867cde344SMiao Xie 1979ccdf9b30SJeff Mahoney curr_node = btrfs_first_delayed_node(fs_info->delayed_root); 198067cde344SMiao Xie while (curr_node) { 198167cde344SMiao Xie __btrfs_kill_delayed_node(curr_node); 198267cde344SMiao Xie 198367cde344SMiao Xie prev_node = curr_node; 198467cde344SMiao Xie curr_node = btrfs_next_delayed_node(curr_node); 198567cde344SMiao Xie btrfs_release_delayed_node(prev_node); 198667cde344SMiao Xie } 198767cde344SMiao Xie } 198867cde344SMiao Xie 1989