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, 3716cdcec7SMiao Xie SLAB_RECLAIM_ACCOUNT | 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 if (delayed_node_cache) 4716cdcec7SMiao Xie kmem_cache_destroy(delayed_node_cache); 4816cdcec7SMiao Xie } 4916cdcec7SMiao Xie 5016cdcec7SMiao Xie static inline void btrfs_init_delayed_node( 5116cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 5216cdcec7SMiao Xie struct btrfs_root *root, u64 inode_id) 5316cdcec7SMiao Xie { 5416cdcec7SMiao Xie delayed_node->root = root; 5516cdcec7SMiao Xie delayed_node->inode_id = inode_id; 5616cdcec7SMiao Xie atomic_set(&delayed_node->refs, 0); 5716cdcec7SMiao Xie delayed_node->count = 0; 5816cdcec7SMiao Xie delayed_node->in_list = 0; 5916cdcec7SMiao Xie delayed_node->inode_dirty = 0; 6016cdcec7SMiao Xie delayed_node->ins_root = RB_ROOT; 6116cdcec7SMiao Xie delayed_node->del_root = RB_ROOT; 6216cdcec7SMiao Xie mutex_init(&delayed_node->mutex); 6316cdcec7SMiao Xie delayed_node->index_cnt = 0; 6416cdcec7SMiao Xie INIT_LIST_HEAD(&delayed_node->n_list); 6516cdcec7SMiao Xie INIT_LIST_HEAD(&delayed_node->p_list); 6616cdcec7SMiao Xie delayed_node->bytes_reserved = 0; 67293f7e07SLi Zefan memset(&delayed_node->inode_item, 0, sizeof(delayed_node->inode_item)); 6816cdcec7SMiao Xie } 6916cdcec7SMiao Xie 7016cdcec7SMiao Xie static inline int btrfs_is_continuous_delayed_item( 7116cdcec7SMiao Xie struct btrfs_delayed_item *item1, 7216cdcec7SMiao Xie struct btrfs_delayed_item *item2) 7316cdcec7SMiao Xie { 7416cdcec7SMiao Xie if (item1->key.type == BTRFS_DIR_INDEX_KEY && 7516cdcec7SMiao Xie item1->key.objectid == item2->key.objectid && 7616cdcec7SMiao Xie item1->key.type == item2->key.type && 7716cdcec7SMiao Xie item1->key.offset + 1 == item2->key.offset) 7816cdcec7SMiao Xie return 1; 7916cdcec7SMiao Xie return 0; 8016cdcec7SMiao Xie } 8116cdcec7SMiao Xie 8216cdcec7SMiao Xie static inline struct btrfs_delayed_root *btrfs_get_delayed_root( 8316cdcec7SMiao Xie struct btrfs_root *root) 8416cdcec7SMiao Xie { 8516cdcec7SMiao Xie return root->fs_info->delayed_root; 8616cdcec7SMiao Xie } 8716cdcec7SMiao Xie 882f7e33d4SMiao Xie static struct btrfs_delayed_node *btrfs_get_delayed_node(struct inode *inode) 892f7e33d4SMiao Xie { 902f7e33d4SMiao Xie struct btrfs_inode *btrfs_inode = BTRFS_I(inode); 912f7e33d4SMiao Xie struct btrfs_root *root = btrfs_inode->root; 922f7e33d4SMiao Xie u64 ino = btrfs_ino(inode); 932f7e33d4SMiao Xie struct btrfs_delayed_node *node; 942f7e33d4SMiao Xie 952f7e33d4SMiao Xie node = ACCESS_ONCE(btrfs_inode->delayed_node); 962f7e33d4SMiao Xie if (node) { 972f7e33d4SMiao Xie atomic_inc(&node->refs); 982f7e33d4SMiao Xie return node; 992f7e33d4SMiao Xie } 1002f7e33d4SMiao Xie 1012f7e33d4SMiao Xie spin_lock(&root->inode_lock); 1022f7e33d4SMiao Xie node = radix_tree_lookup(&root->delayed_nodes_tree, ino); 1032f7e33d4SMiao Xie if (node) { 1042f7e33d4SMiao Xie if (btrfs_inode->delayed_node) { 1052f7e33d4SMiao Xie atomic_inc(&node->refs); /* can be accessed */ 1062f7e33d4SMiao Xie BUG_ON(btrfs_inode->delayed_node != node); 1072f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 1082f7e33d4SMiao Xie return node; 1092f7e33d4SMiao Xie } 1102f7e33d4SMiao Xie btrfs_inode->delayed_node = node; 11195e94d14SRashika /* can be accessed and cached in the inode */ 11295e94d14SRashika atomic_add(2, &node->refs); 1132f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 1142f7e33d4SMiao Xie return node; 1152f7e33d4SMiao Xie } 1162f7e33d4SMiao Xie spin_unlock(&root->inode_lock); 1172f7e33d4SMiao Xie 1182f7e33d4SMiao Xie return NULL; 1192f7e33d4SMiao Xie } 1202f7e33d4SMiao Xie 12179787eaaSJeff Mahoney /* Will return either the node or PTR_ERR(-ENOMEM) */ 12216cdcec7SMiao Xie static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node( 12316cdcec7SMiao Xie struct inode *inode) 12416cdcec7SMiao Xie { 12516cdcec7SMiao Xie struct btrfs_delayed_node *node; 12616cdcec7SMiao Xie struct btrfs_inode *btrfs_inode = BTRFS_I(inode); 12716cdcec7SMiao Xie struct btrfs_root *root = btrfs_inode->root; 1280d0ca30fSChris Mason u64 ino = btrfs_ino(inode); 12916cdcec7SMiao Xie int ret; 13016cdcec7SMiao Xie 13116cdcec7SMiao Xie again: 1322f7e33d4SMiao Xie node = btrfs_get_delayed_node(inode); 1332f7e33d4SMiao Xie if (node) 13416cdcec7SMiao Xie return node; 13516cdcec7SMiao Xie 13616cdcec7SMiao Xie node = kmem_cache_alloc(delayed_node_cache, GFP_NOFS); 13716cdcec7SMiao Xie if (!node) 13816cdcec7SMiao Xie return ERR_PTR(-ENOMEM); 1390d0ca30fSChris Mason btrfs_init_delayed_node(node, root, ino); 14016cdcec7SMiao Xie 14195e94d14SRashika /* cached in the btrfs inode and can be accessed */ 14295e94d14SRashika atomic_add(2, &node->refs); 14316cdcec7SMiao Xie 14416cdcec7SMiao Xie ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM); 14516cdcec7SMiao Xie if (ret) { 14616cdcec7SMiao Xie kmem_cache_free(delayed_node_cache, node); 14716cdcec7SMiao Xie return ERR_PTR(ret); 14816cdcec7SMiao Xie } 14916cdcec7SMiao Xie 15016cdcec7SMiao Xie spin_lock(&root->inode_lock); 1510d0ca30fSChris Mason ret = radix_tree_insert(&root->delayed_nodes_tree, ino, node); 15216cdcec7SMiao Xie if (ret == -EEXIST) { 15316cdcec7SMiao Xie kmem_cache_free(delayed_node_cache, node); 15416cdcec7SMiao Xie spin_unlock(&root->inode_lock); 15516cdcec7SMiao Xie radix_tree_preload_end(); 15616cdcec7SMiao Xie goto again; 15716cdcec7SMiao Xie } 15816cdcec7SMiao Xie btrfs_inode->delayed_node = node; 15916cdcec7SMiao Xie spin_unlock(&root->inode_lock); 16016cdcec7SMiao Xie radix_tree_preload_end(); 16116cdcec7SMiao Xie 16216cdcec7SMiao Xie return node; 16316cdcec7SMiao Xie } 16416cdcec7SMiao Xie 16516cdcec7SMiao Xie /* 16616cdcec7SMiao Xie * Call it when holding delayed_node->mutex 16716cdcec7SMiao Xie * 16816cdcec7SMiao Xie * If mod = 1, add this node into the prepared list. 16916cdcec7SMiao Xie */ 17016cdcec7SMiao Xie static void btrfs_queue_delayed_node(struct btrfs_delayed_root *root, 17116cdcec7SMiao Xie struct btrfs_delayed_node *node, 17216cdcec7SMiao Xie int mod) 17316cdcec7SMiao Xie { 17416cdcec7SMiao Xie spin_lock(&root->lock); 17516cdcec7SMiao Xie if (node->in_list) { 17616cdcec7SMiao Xie if (!list_empty(&node->p_list)) 17716cdcec7SMiao Xie list_move_tail(&node->p_list, &root->prepare_list); 17816cdcec7SMiao Xie else if (mod) 17916cdcec7SMiao Xie list_add_tail(&node->p_list, &root->prepare_list); 18016cdcec7SMiao Xie } else { 18116cdcec7SMiao Xie list_add_tail(&node->n_list, &root->node_list); 18216cdcec7SMiao Xie list_add_tail(&node->p_list, &root->prepare_list); 18316cdcec7SMiao Xie atomic_inc(&node->refs); /* inserted into list */ 18416cdcec7SMiao Xie root->nodes++; 18516cdcec7SMiao Xie node->in_list = 1; 18616cdcec7SMiao Xie } 18716cdcec7SMiao Xie spin_unlock(&root->lock); 18816cdcec7SMiao Xie } 18916cdcec7SMiao Xie 19016cdcec7SMiao Xie /* Call it when holding delayed_node->mutex */ 19116cdcec7SMiao Xie static void btrfs_dequeue_delayed_node(struct btrfs_delayed_root *root, 19216cdcec7SMiao Xie struct btrfs_delayed_node *node) 19316cdcec7SMiao Xie { 19416cdcec7SMiao Xie spin_lock(&root->lock); 19516cdcec7SMiao Xie if (node->in_list) { 19616cdcec7SMiao Xie root->nodes--; 19716cdcec7SMiao Xie atomic_dec(&node->refs); /* not in the list */ 19816cdcec7SMiao Xie list_del_init(&node->n_list); 19916cdcec7SMiao Xie if (!list_empty(&node->p_list)) 20016cdcec7SMiao Xie list_del_init(&node->p_list); 20116cdcec7SMiao Xie node->in_list = 0; 20216cdcec7SMiao Xie } 20316cdcec7SMiao Xie spin_unlock(&root->lock); 20416cdcec7SMiao Xie } 20516cdcec7SMiao Xie 20648a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_first_delayed_node( 20716cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root) 20816cdcec7SMiao Xie { 20916cdcec7SMiao Xie struct list_head *p; 21016cdcec7SMiao Xie struct btrfs_delayed_node *node = NULL; 21116cdcec7SMiao Xie 21216cdcec7SMiao Xie spin_lock(&delayed_root->lock); 21316cdcec7SMiao Xie if (list_empty(&delayed_root->node_list)) 21416cdcec7SMiao Xie goto out; 21516cdcec7SMiao Xie 21616cdcec7SMiao Xie p = delayed_root->node_list.next; 21716cdcec7SMiao Xie node = list_entry(p, struct btrfs_delayed_node, n_list); 21816cdcec7SMiao Xie atomic_inc(&node->refs); 21916cdcec7SMiao Xie out: 22016cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 22116cdcec7SMiao Xie 22216cdcec7SMiao Xie return node; 22316cdcec7SMiao Xie } 22416cdcec7SMiao Xie 22548a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_next_delayed_node( 22616cdcec7SMiao Xie struct btrfs_delayed_node *node) 22716cdcec7SMiao Xie { 22816cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 22916cdcec7SMiao Xie struct list_head *p; 23016cdcec7SMiao Xie struct btrfs_delayed_node *next = NULL; 23116cdcec7SMiao Xie 23216cdcec7SMiao Xie delayed_root = node->root->fs_info->delayed_root; 23316cdcec7SMiao Xie spin_lock(&delayed_root->lock); 23416cdcec7SMiao Xie if (!node->in_list) { /* not in the list */ 23516cdcec7SMiao Xie if (list_empty(&delayed_root->node_list)) 23616cdcec7SMiao Xie goto out; 23716cdcec7SMiao Xie p = delayed_root->node_list.next; 23816cdcec7SMiao Xie } else if (list_is_last(&node->n_list, &delayed_root->node_list)) 23916cdcec7SMiao Xie goto out; 24016cdcec7SMiao Xie else 24116cdcec7SMiao Xie p = node->n_list.next; 24216cdcec7SMiao Xie 24316cdcec7SMiao Xie next = list_entry(p, struct btrfs_delayed_node, n_list); 24416cdcec7SMiao Xie atomic_inc(&next->refs); 24516cdcec7SMiao Xie out: 24616cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 24716cdcec7SMiao Xie 24816cdcec7SMiao Xie return next; 24916cdcec7SMiao Xie } 25016cdcec7SMiao Xie 25116cdcec7SMiao Xie static void __btrfs_release_delayed_node( 25216cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 25316cdcec7SMiao Xie int mod) 25416cdcec7SMiao Xie { 25516cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 25616cdcec7SMiao Xie 25716cdcec7SMiao Xie if (!delayed_node) 25816cdcec7SMiao Xie return; 25916cdcec7SMiao Xie 26016cdcec7SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 26116cdcec7SMiao Xie 26216cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 26316cdcec7SMiao Xie if (delayed_node->count) 26416cdcec7SMiao Xie btrfs_queue_delayed_node(delayed_root, delayed_node, mod); 26516cdcec7SMiao Xie else 26616cdcec7SMiao Xie btrfs_dequeue_delayed_node(delayed_root, delayed_node); 26716cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 26816cdcec7SMiao Xie 26916cdcec7SMiao Xie if (atomic_dec_and_test(&delayed_node->refs)) { 27016cdcec7SMiao Xie struct btrfs_root *root = delayed_node->root; 27116cdcec7SMiao Xie spin_lock(&root->inode_lock); 27216cdcec7SMiao Xie if (atomic_read(&delayed_node->refs) == 0) { 27316cdcec7SMiao Xie radix_tree_delete(&root->delayed_nodes_tree, 27416cdcec7SMiao Xie delayed_node->inode_id); 27516cdcec7SMiao Xie kmem_cache_free(delayed_node_cache, delayed_node); 27616cdcec7SMiao Xie } 27716cdcec7SMiao Xie spin_unlock(&root->inode_lock); 27816cdcec7SMiao Xie } 27916cdcec7SMiao Xie } 28016cdcec7SMiao Xie 28116cdcec7SMiao Xie static inline void btrfs_release_delayed_node(struct btrfs_delayed_node *node) 28216cdcec7SMiao Xie { 28316cdcec7SMiao Xie __btrfs_release_delayed_node(node, 0); 28416cdcec7SMiao Xie } 28516cdcec7SMiao Xie 28648a3b636SEric Sandeen static struct btrfs_delayed_node *btrfs_first_prepared_delayed_node( 28716cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root) 28816cdcec7SMiao Xie { 28916cdcec7SMiao Xie struct list_head *p; 29016cdcec7SMiao Xie struct btrfs_delayed_node *node = NULL; 29116cdcec7SMiao Xie 29216cdcec7SMiao Xie spin_lock(&delayed_root->lock); 29316cdcec7SMiao Xie if (list_empty(&delayed_root->prepare_list)) 29416cdcec7SMiao Xie goto out; 29516cdcec7SMiao Xie 29616cdcec7SMiao Xie p = delayed_root->prepare_list.next; 29716cdcec7SMiao Xie list_del_init(p); 29816cdcec7SMiao Xie node = list_entry(p, struct btrfs_delayed_node, p_list); 29916cdcec7SMiao Xie atomic_inc(&node->refs); 30016cdcec7SMiao Xie out: 30116cdcec7SMiao Xie spin_unlock(&delayed_root->lock); 30216cdcec7SMiao Xie 30316cdcec7SMiao Xie return node; 30416cdcec7SMiao Xie } 30516cdcec7SMiao Xie 30616cdcec7SMiao Xie static inline void btrfs_release_prepared_delayed_node( 30716cdcec7SMiao Xie struct btrfs_delayed_node *node) 30816cdcec7SMiao Xie { 30916cdcec7SMiao Xie __btrfs_release_delayed_node(node, 1); 31016cdcec7SMiao Xie } 31116cdcec7SMiao Xie 31248a3b636SEric Sandeen static struct btrfs_delayed_item *btrfs_alloc_delayed_item(u32 data_len) 31316cdcec7SMiao Xie { 31416cdcec7SMiao Xie struct btrfs_delayed_item *item; 31516cdcec7SMiao Xie item = kmalloc(sizeof(*item) + data_len, GFP_NOFS); 31616cdcec7SMiao Xie if (item) { 31716cdcec7SMiao Xie item->data_len = data_len; 31816cdcec7SMiao Xie item->ins_or_del = 0; 31916cdcec7SMiao Xie item->bytes_reserved = 0; 32016cdcec7SMiao Xie item->delayed_node = NULL; 32116cdcec7SMiao Xie atomic_set(&item->refs, 1); 32216cdcec7SMiao Xie } 32316cdcec7SMiao Xie return item; 32416cdcec7SMiao Xie } 32516cdcec7SMiao Xie 32616cdcec7SMiao Xie /* 32716cdcec7SMiao Xie * __btrfs_lookup_delayed_item - look up the delayed item by key 32816cdcec7SMiao Xie * @delayed_node: pointer to the delayed node 32916cdcec7SMiao Xie * @key: the key to look up 33016cdcec7SMiao Xie * @prev: used to store the prev item if the right item isn't found 33116cdcec7SMiao Xie * @next: used to store the next item if the right item isn't found 33216cdcec7SMiao Xie * 33316cdcec7SMiao Xie * Note: if we don't find the right item, we will return the prev item and 33416cdcec7SMiao Xie * the next item. 33516cdcec7SMiao Xie */ 33616cdcec7SMiao Xie static struct btrfs_delayed_item *__btrfs_lookup_delayed_item( 33716cdcec7SMiao Xie struct rb_root *root, 33816cdcec7SMiao Xie struct btrfs_key *key, 33916cdcec7SMiao Xie struct btrfs_delayed_item **prev, 34016cdcec7SMiao Xie struct btrfs_delayed_item **next) 34116cdcec7SMiao Xie { 34216cdcec7SMiao Xie struct rb_node *node, *prev_node = NULL; 34316cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item = NULL; 34416cdcec7SMiao Xie int ret = 0; 34516cdcec7SMiao Xie 34616cdcec7SMiao Xie node = root->rb_node; 34716cdcec7SMiao Xie 34816cdcec7SMiao Xie while (node) { 34916cdcec7SMiao Xie delayed_item = rb_entry(node, struct btrfs_delayed_item, 35016cdcec7SMiao Xie rb_node); 35116cdcec7SMiao Xie prev_node = node; 35216cdcec7SMiao Xie ret = btrfs_comp_cpu_keys(&delayed_item->key, key); 35316cdcec7SMiao Xie if (ret < 0) 35416cdcec7SMiao Xie node = node->rb_right; 35516cdcec7SMiao Xie else if (ret > 0) 35616cdcec7SMiao Xie node = node->rb_left; 35716cdcec7SMiao Xie else 35816cdcec7SMiao Xie return delayed_item; 35916cdcec7SMiao Xie } 36016cdcec7SMiao Xie 36116cdcec7SMiao Xie if (prev) { 36216cdcec7SMiao Xie if (!prev_node) 36316cdcec7SMiao Xie *prev = NULL; 36416cdcec7SMiao Xie else if (ret < 0) 36516cdcec7SMiao Xie *prev = delayed_item; 36616cdcec7SMiao Xie else if ((node = rb_prev(prev_node)) != NULL) { 36716cdcec7SMiao Xie *prev = rb_entry(node, struct btrfs_delayed_item, 36816cdcec7SMiao Xie rb_node); 36916cdcec7SMiao Xie } else 37016cdcec7SMiao Xie *prev = NULL; 37116cdcec7SMiao Xie } 37216cdcec7SMiao Xie 37316cdcec7SMiao Xie if (next) { 37416cdcec7SMiao Xie if (!prev_node) 37516cdcec7SMiao Xie *next = NULL; 37616cdcec7SMiao Xie else if (ret > 0) 37716cdcec7SMiao Xie *next = delayed_item; 37816cdcec7SMiao Xie else if ((node = rb_next(prev_node)) != NULL) { 37916cdcec7SMiao Xie *next = rb_entry(node, struct btrfs_delayed_item, 38016cdcec7SMiao Xie rb_node); 38116cdcec7SMiao Xie } else 38216cdcec7SMiao Xie *next = NULL; 38316cdcec7SMiao Xie } 38416cdcec7SMiao Xie return NULL; 38516cdcec7SMiao Xie } 38616cdcec7SMiao Xie 38748a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_lookup_delayed_insertion_item( 38816cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node, 38916cdcec7SMiao Xie struct btrfs_key *key) 39016cdcec7SMiao Xie { 39116cdcec7SMiao Xie struct btrfs_delayed_item *item; 39216cdcec7SMiao Xie 39316cdcec7SMiao Xie item = __btrfs_lookup_delayed_item(&delayed_node->ins_root, key, 39416cdcec7SMiao Xie NULL, NULL); 39516cdcec7SMiao Xie return item; 39616cdcec7SMiao Xie } 39716cdcec7SMiao Xie 39816cdcec7SMiao Xie static int __btrfs_add_delayed_item(struct btrfs_delayed_node *delayed_node, 39916cdcec7SMiao Xie struct btrfs_delayed_item *ins, 40016cdcec7SMiao Xie int action) 40116cdcec7SMiao Xie { 40216cdcec7SMiao Xie struct rb_node **p, *node; 40316cdcec7SMiao Xie struct rb_node *parent_node = NULL; 40416cdcec7SMiao Xie struct rb_root *root; 40516cdcec7SMiao Xie struct btrfs_delayed_item *item; 40616cdcec7SMiao Xie int cmp; 40716cdcec7SMiao Xie 40816cdcec7SMiao Xie if (action == BTRFS_DELAYED_INSERTION_ITEM) 40916cdcec7SMiao Xie root = &delayed_node->ins_root; 41016cdcec7SMiao Xie else if (action == BTRFS_DELAYED_DELETION_ITEM) 41116cdcec7SMiao Xie root = &delayed_node->del_root; 41216cdcec7SMiao Xie else 41316cdcec7SMiao Xie BUG(); 41416cdcec7SMiao Xie p = &root->rb_node; 41516cdcec7SMiao Xie node = &ins->rb_node; 41616cdcec7SMiao Xie 41716cdcec7SMiao Xie while (*p) { 41816cdcec7SMiao Xie parent_node = *p; 41916cdcec7SMiao Xie item = rb_entry(parent_node, struct btrfs_delayed_item, 42016cdcec7SMiao Xie rb_node); 42116cdcec7SMiao Xie 42216cdcec7SMiao Xie cmp = btrfs_comp_cpu_keys(&item->key, &ins->key); 42316cdcec7SMiao Xie if (cmp < 0) 42416cdcec7SMiao Xie p = &(*p)->rb_right; 42516cdcec7SMiao Xie else if (cmp > 0) 42616cdcec7SMiao Xie p = &(*p)->rb_left; 42716cdcec7SMiao Xie else 42816cdcec7SMiao Xie return -EEXIST; 42916cdcec7SMiao Xie } 43016cdcec7SMiao Xie 43116cdcec7SMiao Xie rb_link_node(node, parent_node, p); 43216cdcec7SMiao Xie rb_insert_color(node, root); 43316cdcec7SMiao Xie ins->delayed_node = delayed_node; 43416cdcec7SMiao Xie ins->ins_or_del = action; 43516cdcec7SMiao Xie 43616cdcec7SMiao Xie if (ins->key.type == BTRFS_DIR_INDEX_KEY && 43716cdcec7SMiao Xie action == BTRFS_DELAYED_INSERTION_ITEM && 43816cdcec7SMiao Xie ins->key.offset >= delayed_node->index_cnt) 43916cdcec7SMiao Xie delayed_node->index_cnt = ins->key.offset + 1; 44016cdcec7SMiao Xie 44116cdcec7SMiao Xie delayed_node->count++; 44216cdcec7SMiao Xie atomic_inc(&delayed_node->root->fs_info->delayed_root->items); 44316cdcec7SMiao Xie return 0; 44416cdcec7SMiao Xie } 44516cdcec7SMiao Xie 44616cdcec7SMiao Xie static int __btrfs_add_delayed_insertion_item(struct btrfs_delayed_node *node, 44716cdcec7SMiao Xie struct btrfs_delayed_item *item) 44816cdcec7SMiao Xie { 44916cdcec7SMiao Xie return __btrfs_add_delayed_item(node, item, 45016cdcec7SMiao Xie BTRFS_DELAYED_INSERTION_ITEM); 45116cdcec7SMiao Xie } 45216cdcec7SMiao Xie 45316cdcec7SMiao Xie static int __btrfs_add_delayed_deletion_item(struct btrfs_delayed_node *node, 45416cdcec7SMiao Xie struct btrfs_delayed_item *item) 45516cdcec7SMiao Xie { 45616cdcec7SMiao Xie return __btrfs_add_delayed_item(node, item, 45716cdcec7SMiao Xie BTRFS_DELAYED_DELETION_ITEM); 45816cdcec7SMiao Xie } 45916cdcec7SMiao Xie 460de3cb945SChris Mason static void finish_one_item(struct btrfs_delayed_root *delayed_root) 461de3cb945SChris Mason { 462de3cb945SChris Mason int seq = atomic_inc_return(&delayed_root->items_seq); 463de3cb945SChris Mason if ((atomic_dec_return(&delayed_root->items) < 464de3cb945SChris Mason BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0) && 465de3cb945SChris Mason waitqueue_active(&delayed_root->wait)) 466de3cb945SChris Mason wake_up(&delayed_root->wait); 467de3cb945SChris Mason } 468de3cb945SChris Mason 46916cdcec7SMiao Xie static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item) 47016cdcec7SMiao Xie { 47116cdcec7SMiao Xie struct rb_root *root; 47216cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 47316cdcec7SMiao Xie 47416cdcec7SMiao Xie delayed_root = delayed_item->delayed_node->root->fs_info->delayed_root; 47516cdcec7SMiao Xie 47616cdcec7SMiao Xie BUG_ON(!delayed_root); 47716cdcec7SMiao Xie BUG_ON(delayed_item->ins_or_del != BTRFS_DELAYED_DELETION_ITEM && 47816cdcec7SMiao Xie delayed_item->ins_or_del != BTRFS_DELAYED_INSERTION_ITEM); 47916cdcec7SMiao Xie 48016cdcec7SMiao Xie if (delayed_item->ins_or_del == BTRFS_DELAYED_INSERTION_ITEM) 48116cdcec7SMiao Xie root = &delayed_item->delayed_node->ins_root; 48216cdcec7SMiao Xie else 48316cdcec7SMiao Xie root = &delayed_item->delayed_node->del_root; 48416cdcec7SMiao Xie 48516cdcec7SMiao Xie rb_erase(&delayed_item->rb_node, root); 48616cdcec7SMiao Xie delayed_item->delayed_node->count--; 487de3cb945SChris Mason 488de3cb945SChris Mason finish_one_item(delayed_root); 48916cdcec7SMiao Xie } 49016cdcec7SMiao Xie 49116cdcec7SMiao Xie static void btrfs_release_delayed_item(struct btrfs_delayed_item *item) 49216cdcec7SMiao Xie { 49316cdcec7SMiao Xie if (item) { 49416cdcec7SMiao Xie __btrfs_remove_delayed_item(item); 49516cdcec7SMiao Xie if (atomic_dec_and_test(&item->refs)) 49616cdcec7SMiao Xie kfree(item); 49716cdcec7SMiao Xie } 49816cdcec7SMiao Xie } 49916cdcec7SMiao Xie 50048a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_first_delayed_insertion_item( 50116cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node) 50216cdcec7SMiao Xie { 50316cdcec7SMiao Xie struct rb_node *p; 50416cdcec7SMiao Xie struct btrfs_delayed_item *item = NULL; 50516cdcec7SMiao Xie 50616cdcec7SMiao Xie p = rb_first(&delayed_node->ins_root); 50716cdcec7SMiao Xie if (p) 50816cdcec7SMiao Xie item = rb_entry(p, struct btrfs_delayed_item, rb_node); 50916cdcec7SMiao Xie 51016cdcec7SMiao Xie return item; 51116cdcec7SMiao Xie } 51216cdcec7SMiao Xie 51348a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_first_delayed_deletion_item( 51416cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node) 51516cdcec7SMiao Xie { 51616cdcec7SMiao Xie struct rb_node *p; 51716cdcec7SMiao Xie struct btrfs_delayed_item *item = NULL; 51816cdcec7SMiao Xie 51916cdcec7SMiao Xie p = rb_first(&delayed_node->del_root); 52016cdcec7SMiao Xie if (p) 52116cdcec7SMiao Xie item = rb_entry(p, struct btrfs_delayed_item, rb_node); 52216cdcec7SMiao Xie 52316cdcec7SMiao Xie return item; 52416cdcec7SMiao Xie } 52516cdcec7SMiao Xie 52648a3b636SEric Sandeen static struct btrfs_delayed_item *__btrfs_next_delayed_item( 52716cdcec7SMiao Xie struct btrfs_delayed_item *item) 52816cdcec7SMiao Xie { 52916cdcec7SMiao Xie struct rb_node *p; 53016cdcec7SMiao Xie struct btrfs_delayed_item *next = NULL; 53116cdcec7SMiao Xie 53216cdcec7SMiao Xie p = rb_next(&item->rb_node); 53316cdcec7SMiao Xie if (p) 53416cdcec7SMiao Xie next = rb_entry(p, struct btrfs_delayed_item, rb_node); 53516cdcec7SMiao Xie 53616cdcec7SMiao Xie return next; 53716cdcec7SMiao Xie } 53816cdcec7SMiao Xie 53916cdcec7SMiao Xie static int btrfs_delayed_item_reserve_metadata(struct btrfs_trans_handle *trans, 54016cdcec7SMiao Xie struct btrfs_root *root, 54116cdcec7SMiao Xie struct btrfs_delayed_item *item) 54216cdcec7SMiao Xie { 54316cdcec7SMiao Xie struct btrfs_block_rsv *src_rsv; 54416cdcec7SMiao Xie struct btrfs_block_rsv *dst_rsv; 54516cdcec7SMiao Xie u64 num_bytes; 54616cdcec7SMiao Xie int ret; 54716cdcec7SMiao Xie 54816cdcec7SMiao Xie if (!trans->bytes_reserved) 54916cdcec7SMiao Xie return 0; 55016cdcec7SMiao Xie 55116cdcec7SMiao Xie src_rsv = trans->block_rsv; 5526d668ddaSJosef Bacik dst_rsv = &root->fs_info->delayed_block_rsv; 55316cdcec7SMiao Xie 55416cdcec7SMiao Xie num_bytes = btrfs_calc_trans_metadata_size(root, 1); 55516cdcec7SMiao Xie ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes); 5568c2a3ca2SJosef Bacik if (!ret) { 5578c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "delayed_item", 5588c2a3ca2SJosef Bacik item->key.objectid, 5598c2a3ca2SJosef Bacik num_bytes, 1); 56016cdcec7SMiao Xie item->bytes_reserved = num_bytes; 5618c2a3ca2SJosef Bacik } 56216cdcec7SMiao Xie 56316cdcec7SMiao Xie return ret; 56416cdcec7SMiao Xie } 56516cdcec7SMiao Xie 56616cdcec7SMiao Xie static void btrfs_delayed_item_release_metadata(struct btrfs_root *root, 56716cdcec7SMiao Xie struct btrfs_delayed_item *item) 56816cdcec7SMiao Xie { 56919fd2949SMiao Xie struct btrfs_block_rsv *rsv; 57019fd2949SMiao Xie 57116cdcec7SMiao Xie if (!item->bytes_reserved) 57216cdcec7SMiao Xie return; 57316cdcec7SMiao Xie 5746d668ddaSJosef Bacik rsv = &root->fs_info->delayed_block_rsv; 5758c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "delayed_item", 5768c2a3ca2SJosef Bacik item->key.objectid, item->bytes_reserved, 5778c2a3ca2SJosef Bacik 0); 57819fd2949SMiao Xie btrfs_block_rsv_release(root, rsv, 57916cdcec7SMiao Xie item->bytes_reserved); 58016cdcec7SMiao Xie } 58116cdcec7SMiao Xie 58216cdcec7SMiao Xie static int btrfs_delayed_inode_reserve_metadata( 58316cdcec7SMiao Xie struct btrfs_trans_handle *trans, 58416cdcec7SMiao Xie struct btrfs_root *root, 5857fd2ae21SJosef Bacik struct inode *inode, 58616cdcec7SMiao Xie struct btrfs_delayed_node *node) 58716cdcec7SMiao Xie { 58816cdcec7SMiao Xie struct btrfs_block_rsv *src_rsv; 58916cdcec7SMiao Xie struct btrfs_block_rsv *dst_rsv; 59016cdcec7SMiao Xie u64 num_bytes; 59116cdcec7SMiao Xie int ret; 5928c2a3ca2SJosef Bacik bool release = false; 59316cdcec7SMiao Xie 59416cdcec7SMiao Xie src_rsv = trans->block_rsv; 5956d668ddaSJosef Bacik dst_rsv = &root->fs_info->delayed_block_rsv; 59616cdcec7SMiao Xie 59716cdcec7SMiao Xie num_bytes = btrfs_calc_trans_metadata_size(root, 1); 598c06a0e12SJosef Bacik 599c06a0e12SJosef Bacik /* 600c06a0e12SJosef Bacik * btrfs_dirty_inode will update the inode under btrfs_join_transaction 601c06a0e12SJosef Bacik * which doesn't reserve space for speed. This is a problem since we 602c06a0e12SJosef Bacik * still need to reserve space for this update, so try to reserve the 603c06a0e12SJosef Bacik * space. 604c06a0e12SJosef Bacik * 605c06a0e12SJosef Bacik * Now if src_rsv == delalloc_block_rsv we'll let it just steal since 606c06a0e12SJosef Bacik * we're accounted for. 607c06a0e12SJosef Bacik */ 608e755d9abSChris Mason if (!src_rsv || (!trans->bytes_reserved && 60966d8f3ddSMiao Xie src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) { 61008e007d2SMiao Xie ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes, 61108e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 612c06a0e12SJosef Bacik /* 613c06a0e12SJosef Bacik * Since we're under a transaction reserve_metadata_bytes could 614c06a0e12SJosef Bacik * try to commit the transaction which will make it return 615c06a0e12SJosef Bacik * EAGAIN to make us stop the transaction we have, so return 616c06a0e12SJosef Bacik * ENOSPC instead so that btrfs_dirty_inode knows what to do. 617c06a0e12SJosef Bacik */ 618c06a0e12SJosef Bacik if (ret == -EAGAIN) 619c06a0e12SJosef Bacik ret = -ENOSPC; 6208c2a3ca2SJosef Bacik if (!ret) { 621c06a0e12SJosef Bacik node->bytes_reserved = num_bytes; 6228c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, 6238c2a3ca2SJosef Bacik "delayed_inode", 6248c2a3ca2SJosef Bacik btrfs_ino(inode), 6258c2a3ca2SJosef Bacik num_bytes, 1); 6268c2a3ca2SJosef Bacik } 627c06a0e12SJosef Bacik return ret; 62866d8f3ddSMiao Xie } else if (src_rsv->type == BTRFS_BLOCK_RSV_DELALLOC) { 6297fd2ae21SJosef Bacik spin_lock(&BTRFS_I(inode)->lock); 63072ac3c0dSJosef Bacik if (test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED, 63172ac3c0dSJosef Bacik &BTRFS_I(inode)->runtime_flags)) { 6327fd2ae21SJosef Bacik spin_unlock(&BTRFS_I(inode)->lock); 6337fd2ae21SJosef Bacik release = true; 6347fd2ae21SJosef Bacik goto migrate; 635c06a0e12SJosef Bacik } 6367fd2ae21SJosef Bacik spin_unlock(&BTRFS_I(inode)->lock); 6377fd2ae21SJosef Bacik 6387fd2ae21SJosef Bacik /* Ok we didn't have space pre-reserved. This shouldn't happen 6397fd2ae21SJosef Bacik * too often but it can happen if we do delalloc to an existing 6407fd2ae21SJosef Bacik * inode which gets dirtied because of the time update, and then 6417fd2ae21SJosef Bacik * isn't touched again until after the transaction commits and 6427fd2ae21SJosef Bacik * then we try to write out the data. First try to be nice and 6437fd2ae21SJosef Bacik * reserve something strictly for us. If not be a pain and try 6447fd2ae21SJosef Bacik * to steal from the delalloc block rsv. 6457fd2ae21SJosef Bacik */ 64608e007d2SMiao Xie ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes, 64708e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 6487fd2ae21SJosef Bacik if (!ret) 6497fd2ae21SJosef Bacik goto out; 650c06a0e12SJosef Bacik 65116cdcec7SMiao Xie ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes); 652*fae7f21cSDulshani Gunawardhana if (!WARN_ON(ret)) 6537fd2ae21SJosef Bacik goto out; 6547fd2ae21SJosef Bacik 6557fd2ae21SJosef Bacik /* 6567fd2ae21SJosef Bacik * Ok this is a problem, let's just steal from the global rsv 6577fd2ae21SJosef Bacik * since this really shouldn't happen that often. 6587fd2ae21SJosef Bacik */ 6597fd2ae21SJosef Bacik ret = btrfs_block_rsv_migrate(&root->fs_info->global_block_rsv, 6607fd2ae21SJosef Bacik dst_rsv, num_bytes); 6617fd2ae21SJosef Bacik goto out; 6627fd2ae21SJosef Bacik } 6637fd2ae21SJosef Bacik 6647fd2ae21SJosef Bacik migrate: 6657fd2ae21SJosef Bacik ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes); 6667fd2ae21SJosef Bacik 6677fd2ae21SJosef Bacik out: 6687fd2ae21SJosef Bacik /* 6697fd2ae21SJosef Bacik * Migrate only takes a reservation, it doesn't touch the size of the 6707fd2ae21SJosef Bacik * block_rsv. This is to simplify people who don't normally have things 6717fd2ae21SJosef Bacik * migrated from their block rsv. If they go to release their 6727fd2ae21SJosef Bacik * reservation, that will decrease the size as well, so if migrate 6737fd2ae21SJosef Bacik * reduced size we'd end up with a negative size. But for the 6747fd2ae21SJosef Bacik * delalloc_meta_reserved stuff we will only know to drop 1 reservation, 6757fd2ae21SJosef Bacik * but we could in fact do this reserve/migrate dance several times 6767fd2ae21SJosef Bacik * between the time we did the original reservation and we'd clean it 6777fd2ae21SJosef Bacik * up. So to take care of this, release the space for the meta 6787fd2ae21SJosef Bacik * reservation here. I think it may be time for a documentation page on 6797fd2ae21SJosef Bacik * how block rsvs. work. 6807fd2ae21SJosef Bacik */ 6818c2a3ca2SJosef Bacik if (!ret) { 6828c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "delayed_inode", 6838c2a3ca2SJosef Bacik btrfs_ino(inode), num_bytes, 1); 68416cdcec7SMiao Xie node->bytes_reserved = num_bytes; 6858c2a3ca2SJosef Bacik } 68616cdcec7SMiao Xie 6878c2a3ca2SJosef Bacik if (release) { 6888c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "delalloc", 6898c2a3ca2SJosef Bacik btrfs_ino(inode), num_bytes, 0); 6907fd2ae21SJosef Bacik btrfs_block_rsv_release(root, src_rsv, num_bytes); 6918c2a3ca2SJosef Bacik } 69216cdcec7SMiao Xie 69316cdcec7SMiao Xie return ret; 69416cdcec7SMiao Xie } 69516cdcec7SMiao Xie 69616cdcec7SMiao Xie static void btrfs_delayed_inode_release_metadata(struct btrfs_root *root, 69716cdcec7SMiao Xie struct btrfs_delayed_node *node) 69816cdcec7SMiao Xie { 69916cdcec7SMiao Xie struct btrfs_block_rsv *rsv; 70016cdcec7SMiao Xie 70116cdcec7SMiao Xie if (!node->bytes_reserved) 70216cdcec7SMiao Xie return; 70316cdcec7SMiao Xie 7046d668ddaSJosef Bacik rsv = &root->fs_info->delayed_block_rsv; 7058c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "delayed_inode", 7068c2a3ca2SJosef Bacik node->inode_id, node->bytes_reserved, 0); 70716cdcec7SMiao Xie btrfs_block_rsv_release(root, rsv, 70816cdcec7SMiao Xie node->bytes_reserved); 70916cdcec7SMiao Xie node->bytes_reserved = 0; 71016cdcec7SMiao Xie } 71116cdcec7SMiao Xie 71216cdcec7SMiao Xie /* 71316cdcec7SMiao Xie * This helper will insert some continuous items into the same leaf according 71416cdcec7SMiao Xie * to the free space of the leaf. 71516cdcec7SMiao Xie */ 716afe5fea7STsutomu Itoh static int btrfs_batch_insert_items(struct btrfs_root *root, 71716cdcec7SMiao Xie struct btrfs_path *path, 71816cdcec7SMiao Xie struct btrfs_delayed_item *item) 71916cdcec7SMiao Xie { 72016cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 72116cdcec7SMiao Xie int free_space; 72216cdcec7SMiao Xie int total_data_size = 0, total_size = 0; 72316cdcec7SMiao Xie struct extent_buffer *leaf; 72416cdcec7SMiao Xie char *data_ptr; 72516cdcec7SMiao Xie struct btrfs_key *keys; 72616cdcec7SMiao Xie u32 *data_size; 72716cdcec7SMiao Xie struct list_head head; 72816cdcec7SMiao Xie int slot; 72916cdcec7SMiao Xie int nitems; 73016cdcec7SMiao Xie int i; 73116cdcec7SMiao Xie int ret = 0; 73216cdcec7SMiao Xie 73316cdcec7SMiao Xie BUG_ON(!path->nodes[0]); 73416cdcec7SMiao Xie 73516cdcec7SMiao Xie leaf = path->nodes[0]; 73616cdcec7SMiao Xie free_space = btrfs_leaf_free_space(root, leaf); 73716cdcec7SMiao Xie INIT_LIST_HEAD(&head); 73816cdcec7SMiao Xie 73916cdcec7SMiao Xie next = item; 74017aca1c9SChris Mason nitems = 0; 74116cdcec7SMiao Xie 74216cdcec7SMiao Xie /* 74316cdcec7SMiao Xie * count the number of the continuous items that we can insert in batch 74416cdcec7SMiao Xie */ 74516cdcec7SMiao Xie while (total_size + next->data_len + sizeof(struct btrfs_item) <= 74616cdcec7SMiao Xie free_space) { 74716cdcec7SMiao Xie total_data_size += next->data_len; 74816cdcec7SMiao Xie total_size += next->data_len + sizeof(struct btrfs_item); 74916cdcec7SMiao Xie list_add_tail(&next->tree_list, &head); 75016cdcec7SMiao Xie nitems++; 75116cdcec7SMiao Xie 75216cdcec7SMiao Xie curr = next; 75316cdcec7SMiao Xie next = __btrfs_next_delayed_item(curr); 75416cdcec7SMiao Xie if (!next) 75516cdcec7SMiao Xie break; 75616cdcec7SMiao Xie 75716cdcec7SMiao Xie if (!btrfs_is_continuous_delayed_item(curr, next)) 75816cdcec7SMiao Xie break; 75916cdcec7SMiao Xie } 76016cdcec7SMiao Xie 76116cdcec7SMiao Xie if (!nitems) { 76216cdcec7SMiao Xie ret = 0; 76316cdcec7SMiao Xie goto out; 76416cdcec7SMiao Xie } 76516cdcec7SMiao Xie 76616cdcec7SMiao Xie /* 76716cdcec7SMiao Xie * we need allocate some memory space, but it might cause the task 76816cdcec7SMiao Xie * to sleep, so we set all locked nodes in the path to blocking locks 76916cdcec7SMiao Xie * first. 77016cdcec7SMiao Xie */ 77116cdcec7SMiao Xie btrfs_set_path_blocking(path); 77216cdcec7SMiao Xie 77316cdcec7SMiao Xie keys = kmalloc(sizeof(struct btrfs_key) * nitems, GFP_NOFS); 77416cdcec7SMiao Xie if (!keys) { 77516cdcec7SMiao Xie ret = -ENOMEM; 77616cdcec7SMiao Xie goto out; 77716cdcec7SMiao Xie } 77816cdcec7SMiao Xie 77916cdcec7SMiao Xie data_size = kmalloc(sizeof(u32) * nitems, GFP_NOFS); 78016cdcec7SMiao Xie if (!data_size) { 78116cdcec7SMiao Xie ret = -ENOMEM; 78216cdcec7SMiao Xie goto error; 78316cdcec7SMiao Xie } 78416cdcec7SMiao Xie 78516cdcec7SMiao Xie /* get keys of all the delayed items */ 78616cdcec7SMiao Xie i = 0; 78716cdcec7SMiao Xie list_for_each_entry(next, &head, tree_list) { 78816cdcec7SMiao Xie keys[i] = next->key; 78916cdcec7SMiao Xie data_size[i] = next->data_len; 79016cdcec7SMiao Xie i++; 79116cdcec7SMiao Xie } 79216cdcec7SMiao Xie 79316cdcec7SMiao Xie /* reset all the locked nodes in the patch to spinning locks. */ 794bd681513SChris Mason btrfs_clear_path_blocking(path, NULL, 0); 79516cdcec7SMiao Xie 79616cdcec7SMiao Xie /* insert the keys of the items */ 797afe5fea7STsutomu Itoh setup_items_for_insert(root, path, keys, data_size, 79816cdcec7SMiao Xie total_data_size, total_size, nitems); 79916cdcec7SMiao Xie 80016cdcec7SMiao Xie /* insert the dir index items */ 80116cdcec7SMiao Xie slot = path->slots[0]; 80216cdcec7SMiao Xie list_for_each_entry_safe(curr, next, &head, tree_list) { 80316cdcec7SMiao Xie data_ptr = btrfs_item_ptr(leaf, slot, char); 80416cdcec7SMiao Xie write_extent_buffer(leaf, &curr->data, 80516cdcec7SMiao Xie (unsigned long)data_ptr, 80616cdcec7SMiao Xie curr->data_len); 80716cdcec7SMiao Xie slot++; 80816cdcec7SMiao Xie 80916cdcec7SMiao Xie btrfs_delayed_item_release_metadata(root, curr); 81016cdcec7SMiao Xie 81116cdcec7SMiao Xie list_del(&curr->tree_list); 81216cdcec7SMiao Xie btrfs_release_delayed_item(curr); 81316cdcec7SMiao Xie } 81416cdcec7SMiao Xie 81516cdcec7SMiao Xie error: 81616cdcec7SMiao Xie kfree(data_size); 81716cdcec7SMiao Xie kfree(keys); 81816cdcec7SMiao Xie out: 81916cdcec7SMiao Xie return ret; 82016cdcec7SMiao Xie } 82116cdcec7SMiao Xie 82216cdcec7SMiao Xie /* 82316cdcec7SMiao Xie * This helper can just do simple insertion that needn't extend item for new 82416cdcec7SMiao Xie * data, such as directory name index insertion, inode insertion. 82516cdcec7SMiao Xie */ 82616cdcec7SMiao Xie static int btrfs_insert_delayed_item(struct btrfs_trans_handle *trans, 82716cdcec7SMiao Xie struct btrfs_root *root, 82816cdcec7SMiao Xie struct btrfs_path *path, 82916cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item) 83016cdcec7SMiao Xie { 83116cdcec7SMiao Xie struct extent_buffer *leaf; 83216cdcec7SMiao Xie char *ptr; 83316cdcec7SMiao Xie int ret; 83416cdcec7SMiao Xie 83516cdcec7SMiao Xie ret = btrfs_insert_empty_item(trans, root, path, &delayed_item->key, 83616cdcec7SMiao Xie delayed_item->data_len); 83716cdcec7SMiao Xie if (ret < 0 && ret != -EEXIST) 83816cdcec7SMiao Xie return ret; 83916cdcec7SMiao Xie 84016cdcec7SMiao Xie leaf = path->nodes[0]; 84116cdcec7SMiao Xie 84216cdcec7SMiao Xie ptr = btrfs_item_ptr(leaf, path->slots[0], char); 84316cdcec7SMiao Xie 84416cdcec7SMiao Xie write_extent_buffer(leaf, delayed_item->data, (unsigned long)ptr, 84516cdcec7SMiao Xie delayed_item->data_len); 84616cdcec7SMiao Xie btrfs_mark_buffer_dirty(leaf); 84716cdcec7SMiao Xie 84816cdcec7SMiao Xie btrfs_delayed_item_release_metadata(root, delayed_item); 84916cdcec7SMiao Xie return 0; 85016cdcec7SMiao Xie } 85116cdcec7SMiao Xie 85216cdcec7SMiao Xie /* 85316cdcec7SMiao Xie * we insert an item first, then if there are some continuous items, we try 85416cdcec7SMiao Xie * to insert those items into the same leaf. 85516cdcec7SMiao Xie */ 85616cdcec7SMiao Xie static int btrfs_insert_delayed_items(struct btrfs_trans_handle *trans, 85716cdcec7SMiao Xie struct btrfs_path *path, 85816cdcec7SMiao Xie struct btrfs_root *root, 85916cdcec7SMiao Xie struct btrfs_delayed_node *node) 86016cdcec7SMiao Xie { 86116cdcec7SMiao Xie struct btrfs_delayed_item *curr, *prev; 86216cdcec7SMiao Xie int ret = 0; 86316cdcec7SMiao Xie 86416cdcec7SMiao Xie do_again: 86516cdcec7SMiao Xie mutex_lock(&node->mutex); 86616cdcec7SMiao Xie curr = __btrfs_first_delayed_insertion_item(node); 86716cdcec7SMiao Xie if (!curr) 86816cdcec7SMiao Xie goto insert_end; 86916cdcec7SMiao Xie 87016cdcec7SMiao Xie ret = btrfs_insert_delayed_item(trans, root, path, curr); 87116cdcec7SMiao Xie if (ret < 0) { 872945d8962SChris Mason btrfs_release_path(path); 87316cdcec7SMiao Xie goto insert_end; 87416cdcec7SMiao Xie } 87516cdcec7SMiao Xie 87616cdcec7SMiao Xie prev = curr; 87716cdcec7SMiao Xie curr = __btrfs_next_delayed_item(prev); 87816cdcec7SMiao Xie if (curr && btrfs_is_continuous_delayed_item(prev, curr)) { 87916cdcec7SMiao Xie /* insert the continuous items into the same leaf */ 88016cdcec7SMiao Xie path->slots[0]++; 881afe5fea7STsutomu Itoh btrfs_batch_insert_items(root, path, curr); 88216cdcec7SMiao Xie } 88316cdcec7SMiao Xie btrfs_release_delayed_item(prev); 88416cdcec7SMiao Xie btrfs_mark_buffer_dirty(path->nodes[0]); 88516cdcec7SMiao Xie 886945d8962SChris Mason btrfs_release_path(path); 88716cdcec7SMiao Xie mutex_unlock(&node->mutex); 88816cdcec7SMiao Xie goto do_again; 88916cdcec7SMiao Xie 89016cdcec7SMiao Xie insert_end: 89116cdcec7SMiao Xie mutex_unlock(&node->mutex); 89216cdcec7SMiao Xie return ret; 89316cdcec7SMiao Xie } 89416cdcec7SMiao Xie 89516cdcec7SMiao Xie static int btrfs_batch_delete_items(struct btrfs_trans_handle *trans, 89616cdcec7SMiao Xie struct btrfs_root *root, 89716cdcec7SMiao Xie struct btrfs_path *path, 89816cdcec7SMiao Xie struct btrfs_delayed_item *item) 89916cdcec7SMiao Xie { 90016cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 90116cdcec7SMiao Xie struct extent_buffer *leaf; 90216cdcec7SMiao Xie struct btrfs_key key; 90316cdcec7SMiao Xie struct list_head head; 90416cdcec7SMiao Xie int nitems, i, last_item; 90516cdcec7SMiao Xie int ret = 0; 90616cdcec7SMiao Xie 90716cdcec7SMiao Xie BUG_ON(!path->nodes[0]); 90816cdcec7SMiao Xie 90916cdcec7SMiao Xie leaf = path->nodes[0]; 91016cdcec7SMiao Xie 91116cdcec7SMiao Xie i = path->slots[0]; 91216cdcec7SMiao Xie last_item = btrfs_header_nritems(leaf) - 1; 91316cdcec7SMiao Xie if (i > last_item) 91416cdcec7SMiao Xie return -ENOENT; /* FIXME: Is errno suitable? */ 91516cdcec7SMiao Xie 91616cdcec7SMiao Xie next = item; 91716cdcec7SMiao Xie INIT_LIST_HEAD(&head); 91816cdcec7SMiao Xie btrfs_item_key_to_cpu(leaf, &key, i); 91916cdcec7SMiao Xie nitems = 0; 92016cdcec7SMiao Xie /* 92116cdcec7SMiao Xie * count the number of the dir index items that we can delete in batch 92216cdcec7SMiao Xie */ 92316cdcec7SMiao Xie while (btrfs_comp_cpu_keys(&next->key, &key) == 0) { 92416cdcec7SMiao Xie list_add_tail(&next->tree_list, &head); 92516cdcec7SMiao Xie nitems++; 92616cdcec7SMiao Xie 92716cdcec7SMiao Xie curr = next; 92816cdcec7SMiao Xie next = __btrfs_next_delayed_item(curr); 92916cdcec7SMiao Xie if (!next) 93016cdcec7SMiao Xie break; 93116cdcec7SMiao Xie 93216cdcec7SMiao Xie if (!btrfs_is_continuous_delayed_item(curr, next)) 93316cdcec7SMiao Xie break; 93416cdcec7SMiao Xie 93516cdcec7SMiao Xie i++; 93616cdcec7SMiao Xie if (i > last_item) 93716cdcec7SMiao Xie break; 93816cdcec7SMiao Xie btrfs_item_key_to_cpu(leaf, &key, i); 93916cdcec7SMiao Xie } 94016cdcec7SMiao Xie 94116cdcec7SMiao Xie if (!nitems) 94216cdcec7SMiao Xie return 0; 94316cdcec7SMiao Xie 94416cdcec7SMiao Xie ret = btrfs_del_items(trans, root, path, path->slots[0], nitems); 94516cdcec7SMiao Xie if (ret) 94616cdcec7SMiao Xie goto out; 94716cdcec7SMiao Xie 94816cdcec7SMiao Xie list_for_each_entry_safe(curr, next, &head, tree_list) { 94916cdcec7SMiao Xie btrfs_delayed_item_release_metadata(root, curr); 95016cdcec7SMiao Xie list_del(&curr->tree_list); 95116cdcec7SMiao Xie btrfs_release_delayed_item(curr); 95216cdcec7SMiao Xie } 95316cdcec7SMiao Xie 95416cdcec7SMiao Xie out: 95516cdcec7SMiao Xie return ret; 95616cdcec7SMiao Xie } 95716cdcec7SMiao Xie 95816cdcec7SMiao Xie static int btrfs_delete_delayed_items(struct btrfs_trans_handle *trans, 95916cdcec7SMiao Xie struct btrfs_path *path, 96016cdcec7SMiao Xie struct btrfs_root *root, 96116cdcec7SMiao Xie struct btrfs_delayed_node *node) 96216cdcec7SMiao Xie { 96316cdcec7SMiao Xie struct btrfs_delayed_item *curr, *prev; 96416cdcec7SMiao Xie int ret = 0; 96516cdcec7SMiao Xie 96616cdcec7SMiao Xie do_again: 96716cdcec7SMiao Xie mutex_lock(&node->mutex); 96816cdcec7SMiao Xie curr = __btrfs_first_delayed_deletion_item(node); 96916cdcec7SMiao Xie if (!curr) 97016cdcec7SMiao Xie goto delete_fail; 97116cdcec7SMiao Xie 97216cdcec7SMiao Xie ret = btrfs_search_slot(trans, root, &curr->key, path, -1, 1); 97316cdcec7SMiao Xie if (ret < 0) 97416cdcec7SMiao Xie goto delete_fail; 97516cdcec7SMiao Xie else if (ret > 0) { 97616cdcec7SMiao Xie /* 97716cdcec7SMiao Xie * can't find the item which the node points to, so this node 97816cdcec7SMiao Xie * is invalid, just drop it. 97916cdcec7SMiao Xie */ 98016cdcec7SMiao Xie prev = curr; 98116cdcec7SMiao Xie curr = __btrfs_next_delayed_item(prev); 98216cdcec7SMiao Xie btrfs_release_delayed_item(prev); 98316cdcec7SMiao Xie ret = 0; 984945d8962SChris Mason btrfs_release_path(path); 98562095265SFengguang Wu if (curr) { 98662095265SFengguang Wu mutex_unlock(&node->mutex); 98716cdcec7SMiao Xie goto do_again; 98862095265SFengguang Wu } else 98916cdcec7SMiao Xie goto delete_fail; 99016cdcec7SMiao Xie } 99116cdcec7SMiao Xie 99216cdcec7SMiao Xie btrfs_batch_delete_items(trans, root, path, curr); 993945d8962SChris Mason btrfs_release_path(path); 99416cdcec7SMiao Xie mutex_unlock(&node->mutex); 99516cdcec7SMiao Xie goto do_again; 99616cdcec7SMiao Xie 99716cdcec7SMiao Xie delete_fail: 998945d8962SChris Mason btrfs_release_path(path); 99916cdcec7SMiao Xie mutex_unlock(&node->mutex); 100016cdcec7SMiao Xie return ret; 100116cdcec7SMiao Xie } 100216cdcec7SMiao Xie 100316cdcec7SMiao Xie static void btrfs_release_delayed_inode(struct btrfs_delayed_node *delayed_node) 100416cdcec7SMiao Xie { 100516cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 100616cdcec7SMiao Xie 100716cdcec7SMiao Xie if (delayed_node && delayed_node->inode_dirty) { 100816cdcec7SMiao Xie BUG_ON(!delayed_node->root); 100916cdcec7SMiao Xie delayed_node->inode_dirty = 0; 101016cdcec7SMiao Xie delayed_node->count--; 101116cdcec7SMiao Xie 101216cdcec7SMiao Xie delayed_root = delayed_node->root->fs_info->delayed_root; 1013de3cb945SChris Mason finish_one_item(delayed_root); 101416cdcec7SMiao Xie } 101516cdcec7SMiao Xie } 101616cdcec7SMiao Xie 10170e8c36a9SMiao Xie static int __btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 101816cdcec7SMiao Xie struct btrfs_root *root, 101916cdcec7SMiao Xie struct btrfs_path *path, 102016cdcec7SMiao Xie struct btrfs_delayed_node *node) 102116cdcec7SMiao Xie { 102216cdcec7SMiao Xie struct btrfs_key key; 102316cdcec7SMiao Xie struct btrfs_inode_item *inode_item; 102416cdcec7SMiao Xie struct extent_buffer *leaf; 102516cdcec7SMiao Xie int ret; 102616cdcec7SMiao Xie 102716cdcec7SMiao Xie key.objectid = node->inode_id; 102816cdcec7SMiao Xie btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY); 102916cdcec7SMiao Xie key.offset = 0; 10300e8c36a9SMiao Xie 103116cdcec7SMiao Xie ret = btrfs_lookup_inode(trans, root, path, &key, 1); 103216cdcec7SMiao Xie if (ret > 0) { 1033945d8962SChris Mason btrfs_release_path(path); 103416cdcec7SMiao Xie return -ENOENT; 103516cdcec7SMiao Xie } else if (ret < 0) { 103616cdcec7SMiao Xie return ret; 103716cdcec7SMiao Xie } 103816cdcec7SMiao Xie 103916cdcec7SMiao Xie btrfs_unlock_up_safe(path, 1); 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); 1046945d8962SChris Mason btrfs_release_path(path); 104716cdcec7SMiao Xie 104816cdcec7SMiao Xie btrfs_delayed_inode_release_metadata(root, node); 104916cdcec7SMiao Xie btrfs_release_delayed_inode(node); 105016cdcec7SMiao Xie 105116cdcec7SMiao Xie return 0; 105216cdcec7SMiao Xie } 105316cdcec7SMiao Xie 10540e8c36a9SMiao Xie static inline int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, 10550e8c36a9SMiao Xie struct btrfs_root *root, 10560e8c36a9SMiao Xie struct btrfs_path *path, 10570e8c36a9SMiao Xie struct btrfs_delayed_node *node) 10580e8c36a9SMiao Xie { 10590e8c36a9SMiao Xie int ret; 10600e8c36a9SMiao Xie 10610e8c36a9SMiao Xie mutex_lock(&node->mutex); 10620e8c36a9SMiao Xie if (!node->inode_dirty) { 10630e8c36a9SMiao Xie mutex_unlock(&node->mutex); 10640e8c36a9SMiao Xie return 0; 10650e8c36a9SMiao Xie } 10660e8c36a9SMiao Xie 10670e8c36a9SMiao Xie ret = __btrfs_update_delayed_inode(trans, root, path, node); 10680e8c36a9SMiao Xie mutex_unlock(&node->mutex); 10690e8c36a9SMiao Xie return ret; 10700e8c36a9SMiao Xie } 10710e8c36a9SMiao Xie 10724ea41ce0SMiao Xie static inline int 10734ea41ce0SMiao Xie __btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 10744ea41ce0SMiao Xie struct btrfs_path *path, 10754ea41ce0SMiao Xie struct btrfs_delayed_node *node) 10764ea41ce0SMiao Xie { 10774ea41ce0SMiao Xie int ret; 10784ea41ce0SMiao Xie 10794ea41ce0SMiao Xie ret = btrfs_insert_delayed_items(trans, path, node->root, node); 10804ea41ce0SMiao Xie if (ret) 10814ea41ce0SMiao Xie return ret; 10824ea41ce0SMiao Xie 10834ea41ce0SMiao Xie ret = btrfs_delete_delayed_items(trans, path, node->root, node); 10844ea41ce0SMiao Xie if (ret) 10854ea41ce0SMiao Xie return ret; 10864ea41ce0SMiao Xie 10874ea41ce0SMiao Xie ret = btrfs_update_delayed_inode(trans, node->root, path, node); 10884ea41ce0SMiao Xie return ret; 10894ea41ce0SMiao Xie } 10904ea41ce0SMiao Xie 109179787eaaSJeff Mahoney /* 109279787eaaSJeff Mahoney * Called when committing the transaction. 109379787eaaSJeff Mahoney * Returns 0 on success. 109479787eaaSJeff Mahoney * Returns < 0 on error and returns with an aborted transaction with any 109579787eaaSJeff Mahoney * outstanding delayed items cleaned up. 109679787eaaSJeff Mahoney */ 109796c3f433SJosef Bacik static int __btrfs_run_delayed_items(struct btrfs_trans_handle *trans, 109896c3f433SJosef Bacik struct btrfs_root *root, int nr) 109916cdcec7SMiao Xie { 110016cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 110116cdcec7SMiao Xie struct btrfs_delayed_node *curr_node, *prev_node; 110216cdcec7SMiao Xie struct btrfs_path *path; 110319fd2949SMiao Xie struct btrfs_block_rsv *block_rsv; 110416cdcec7SMiao Xie int ret = 0; 110596c3f433SJosef Bacik bool count = (nr > 0); 110616cdcec7SMiao Xie 110779787eaaSJeff Mahoney if (trans->aborted) 110879787eaaSJeff Mahoney return -EIO; 110979787eaaSJeff Mahoney 111016cdcec7SMiao Xie path = btrfs_alloc_path(); 111116cdcec7SMiao Xie if (!path) 111216cdcec7SMiao Xie return -ENOMEM; 111316cdcec7SMiao Xie path->leave_spinning = 1; 111416cdcec7SMiao Xie 111519fd2949SMiao Xie block_rsv = trans->block_rsv; 11166d668ddaSJosef Bacik trans->block_rsv = &root->fs_info->delayed_block_rsv; 111719fd2949SMiao Xie 111816cdcec7SMiao Xie delayed_root = btrfs_get_delayed_root(root); 111916cdcec7SMiao Xie 112016cdcec7SMiao Xie curr_node = btrfs_first_delayed_node(delayed_root); 112196c3f433SJosef Bacik while (curr_node && (!count || (count && nr--))) { 11224ea41ce0SMiao Xie ret = __btrfs_commit_inode_delayed_items(trans, path, 112316cdcec7SMiao Xie curr_node); 112416cdcec7SMiao Xie if (ret) { 112516cdcec7SMiao Xie btrfs_release_delayed_node(curr_node); 112696c3f433SJosef Bacik curr_node = NULL; 112779787eaaSJeff Mahoney btrfs_abort_transaction(trans, root, ret); 112816cdcec7SMiao Xie break; 112916cdcec7SMiao Xie } 113016cdcec7SMiao Xie 113116cdcec7SMiao Xie prev_node = curr_node; 113216cdcec7SMiao Xie curr_node = btrfs_next_delayed_node(curr_node); 113316cdcec7SMiao Xie btrfs_release_delayed_node(prev_node); 113416cdcec7SMiao Xie } 113516cdcec7SMiao Xie 113696c3f433SJosef Bacik if (curr_node) 113796c3f433SJosef Bacik btrfs_release_delayed_node(curr_node); 113816cdcec7SMiao Xie btrfs_free_path(path); 113919fd2949SMiao Xie trans->block_rsv = block_rsv; 114079787eaaSJeff Mahoney 114116cdcec7SMiao Xie return ret; 114216cdcec7SMiao Xie } 114316cdcec7SMiao Xie 114496c3f433SJosef Bacik int btrfs_run_delayed_items(struct btrfs_trans_handle *trans, 114596c3f433SJosef Bacik struct btrfs_root *root) 114696c3f433SJosef Bacik { 114796c3f433SJosef Bacik return __btrfs_run_delayed_items(trans, root, -1); 114896c3f433SJosef Bacik } 114996c3f433SJosef Bacik 115096c3f433SJosef Bacik int btrfs_run_delayed_items_nr(struct btrfs_trans_handle *trans, 115196c3f433SJosef Bacik struct btrfs_root *root, int nr) 115296c3f433SJosef Bacik { 115396c3f433SJosef Bacik return __btrfs_run_delayed_items(trans, root, nr); 115496c3f433SJosef Bacik } 115596c3f433SJosef Bacik 115616cdcec7SMiao Xie int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans, 115716cdcec7SMiao Xie struct inode *inode) 115816cdcec7SMiao Xie { 115916cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 11604ea41ce0SMiao Xie struct btrfs_path *path; 11614ea41ce0SMiao Xie struct btrfs_block_rsv *block_rsv; 116216cdcec7SMiao Xie int ret; 116316cdcec7SMiao Xie 116416cdcec7SMiao Xie if (!delayed_node) 116516cdcec7SMiao Xie return 0; 116616cdcec7SMiao Xie 116716cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 116816cdcec7SMiao Xie if (!delayed_node->count) { 116916cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 117016cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 117116cdcec7SMiao Xie return 0; 117216cdcec7SMiao Xie } 117316cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 117416cdcec7SMiao Xie 11754ea41ce0SMiao Xie path = btrfs_alloc_path(); 11763c77bd94SFilipe David Borba Manana if (!path) { 11773c77bd94SFilipe David Borba Manana btrfs_release_delayed_node(delayed_node); 11784ea41ce0SMiao Xie return -ENOMEM; 11793c77bd94SFilipe David Borba Manana } 11804ea41ce0SMiao Xie path->leave_spinning = 1; 11814ea41ce0SMiao Xie 11824ea41ce0SMiao Xie block_rsv = trans->block_rsv; 11834ea41ce0SMiao Xie trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv; 11844ea41ce0SMiao Xie 11854ea41ce0SMiao Xie ret = __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 11864ea41ce0SMiao Xie 118716cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 11884ea41ce0SMiao Xie btrfs_free_path(path); 11894ea41ce0SMiao Xie trans->block_rsv = block_rsv; 11904ea41ce0SMiao Xie 119116cdcec7SMiao Xie return ret; 119216cdcec7SMiao Xie } 119316cdcec7SMiao Xie 11940e8c36a9SMiao Xie int btrfs_commit_inode_delayed_inode(struct inode *inode) 11950e8c36a9SMiao Xie { 11960e8c36a9SMiao Xie struct btrfs_trans_handle *trans; 11970e8c36a9SMiao Xie struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 11980e8c36a9SMiao Xie struct btrfs_path *path; 11990e8c36a9SMiao Xie struct btrfs_block_rsv *block_rsv; 12000e8c36a9SMiao Xie int ret; 12010e8c36a9SMiao Xie 12020e8c36a9SMiao Xie if (!delayed_node) 12030e8c36a9SMiao Xie return 0; 12040e8c36a9SMiao Xie 12050e8c36a9SMiao Xie mutex_lock(&delayed_node->mutex); 12060e8c36a9SMiao Xie if (!delayed_node->inode_dirty) { 12070e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12080e8c36a9SMiao Xie btrfs_release_delayed_node(delayed_node); 12090e8c36a9SMiao Xie return 0; 12100e8c36a9SMiao Xie } 12110e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12120e8c36a9SMiao Xie 12130e8c36a9SMiao Xie trans = btrfs_join_transaction(delayed_node->root); 12140e8c36a9SMiao Xie if (IS_ERR(trans)) { 12150e8c36a9SMiao Xie ret = PTR_ERR(trans); 12160e8c36a9SMiao Xie goto out; 12170e8c36a9SMiao Xie } 12180e8c36a9SMiao Xie 12190e8c36a9SMiao Xie path = btrfs_alloc_path(); 12200e8c36a9SMiao Xie if (!path) { 12210e8c36a9SMiao Xie ret = -ENOMEM; 12220e8c36a9SMiao Xie goto trans_out; 12230e8c36a9SMiao Xie } 12240e8c36a9SMiao Xie path->leave_spinning = 1; 12250e8c36a9SMiao Xie 12260e8c36a9SMiao Xie block_rsv = trans->block_rsv; 12270e8c36a9SMiao Xie trans->block_rsv = &delayed_node->root->fs_info->delayed_block_rsv; 12280e8c36a9SMiao Xie 12290e8c36a9SMiao Xie mutex_lock(&delayed_node->mutex); 12300e8c36a9SMiao Xie if (delayed_node->inode_dirty) 12310e8c36a9SMiao Xie ret = __btrfs_update_delayed_inode(trans, delayed_node->root, 12320e8c36a9SMiao Xie path, delayed_node); 12330e8c36a9SMiao Xie else 12340e8c36a9SMiao Xie ret = 0; 12350e8c36a9SMiao Xie mutex_unlock(&delayed_node->mutex); 12360e8c36a9SMiao Xie 12370e8c36a9SMiao Xie btrfs_free_path(path); 12380e8c36a9SMiao Xie trans->block_rsv = block_rsv; 12390e8c36a9SMiao Xie trans_out: 12400e8c36a9SMiao Xie btrfs_end_transaction(trans, delayed_node->root); 12410e8c36a9SMiao Xie btrfs_btree_balance_dirty(delayed_node->root); 12420e8c36a9SMiao Xie out: 12430e8c36a9SMiao Xie btrfs_release_delayed_node(delayed_node); 12440e8c36a9SMiao Xie 12450e8c36a9SMiao Xie return ret; 12460e8c36a9SMiao Xie } 12470e8c36a9SMiao Xie 124816cdcec7SMiao Xie void btrfs_remove_delayed_node(struct inode *inode) 124916cdcec7SMiao Xie { 125016cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 125116cdcec7SMiao Xie 125216cdcec7SMiao Xie delayed_node = ACCESS_ONCE(BTRFS_I(inode)->delayed_node); 125316cdcec7SMiao Xie if (!delayed_node) 125416cdcec7SMiao Xie return; 125516cdcec7SMiao Xie 125616cdcec7SMiao Xie BTRFS_I(inode)->delayed_node = NULL; 125716cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 125816cdcec7SMiao Xie } 125916cdcec7SMiao Xie 1260de3cb945SChris Mason struct btrfs_async_delayed_work { 1261de3cb945SChris Mason struct btrfs_delayed_root *delayed_root; 1262de3cb945SChris Mason int nr; 126316cdcec7SMiao Xie struct btrfs_work work; 126416cdcec7SMiao Xie }; 126516cdcec7SMiao Xie 1266de3cb945SChris Mason static void btrfs_async_run_delayed_root(struct btrfs_work *work) 126716cdcec7SMiao Xie { 1268de3cb945SChris Mason struct btrfs_async_delayed_work *async_work; 1269de3cb945SChris Mason struct btrfs_delayed_root *delayed_root; 127016cdcec7SMiao Xie struct btrfs_trans_handle *trans; 127116cdcec7SMiao Xie struct btrfs_path *path; 127216cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node = NULL; 127316cdcec7SMiao Xie struct btrfs_root *root; 127419fd2949SMiao Xie struct btrfs_block_rsv *block_rsv; 1275de3cb945SChris Mason int total_done = 0; 127616cdcec7SMiao Xie 1277de3cb945SChris Mason async_work = container_of(work, struct btrfs_async_delayed_work, work); 1278de3cb945SChris Mason delayed_root = async_work->delayed_root; 127916cdcec7SMiao Xie 128016cdcec7SMiao Xie path = btrfs_alloc_path(); 128116cdcec7SMiao Xie if (!path) 128216cdcec7SMiao Xie goto out; 128316cdcec7SMiao Xie 1284de3cb945SChris Mason again: 1285de3cb945SChris Mason if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND / 2) 1286de3cb945SChris Mason goto free_path; 1287de3cb945SChris Mason 1288de3cb945SChris Mason delayed_node = btrfs_first_prepared_delayed_node(delayed_root); 1289de3cb945SChris Mason if (!delayed_node) 1290de3cb945SChris Mason goto free_path; 1291de3cb945SChris Mason 1292de3cb945SChris Mason path->leave_spinning = 1; 129316cdcec7SMiao Xie root = delayed_node->root; 129416cdcec7SMiao Xie 1295ff5714ccSChris Mason trans = btrfs_join_transaction(root); 129616cdcec7SMiao Xie if (IS_ERR(trans)) 1297de3cb945SChris Mason goto release_path; 129816cdcec7SMiao Xie 129919fd2949SMiao Xie block_rsv = trans->block_rsv; 13006d668ddaSJosef Bacik trans->block_rsv = &root->fs_info->delayed_block_rsv; 130119fd2949SMiao Xie 13024ea41ce0SMiao Xie __btrfs_commit_inode_delayed_items(trans, path, delayed_node); 130316cdcec7SMiao Xie /* 130416cdcec7SMiao Xie * Maybe new delayed items have been inserted, so we need requeue 130516cdcec7SMiao Xie * the work. Besides that, we must dequeue the empty delayed nodes 130616cdcec7SMiao Xie * to avoid the race between delayed items balance and the worker. 130716cdcec7SMiao Xie * The race like this: 130816cdcec7SMiao Xie * Task1 Worker thread 130916cdcec7SMiao Xie * count == 0, needn't requeue 131016cdcec7SMiao Xie * also needn't insert the 131116cdcec7SMiao Xie * delayed node into prepare 131216cdcec7SMiao Xie * list again. 131316cdcec7SMiao Xie * add lots of delayed items 131416cdcec7SMiao Xie * queue the delayed node 131516cdcec7SMiao Xie * already in the list, 131616cdcec7SMiao Xie * and not in the prepare 131716cdcec7SMiao Xie * list, it means the delayed 131816cdcec7SMiao Xie * node is being dealt with 131916cdcec7SMiao Xie * by the worker. 132016cdcec7SMiao Xie * do delayed items balance 132116cdcec7SMiao Xie * the delayed node is being 132216cdcec7SMiao Xie * dealt with by the worker 132316cdcec7SMiao Xie * now, just wait. 132416cdcec7SMiao Xie * the worker goto idle. 132516cdcec7SMiao Xie * Task1 will sleep until the transaction is commited. 132616cdcec7SMiao Xie */ 132716cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 1328de3cb945SChris Mason btrfs_dequeue_delayed_node(root->fs_info->delayed_root, delayed_node); 132916cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 133016cdcec7SMiao Xie 133119fd2949SMiao Xie trans->block_rsv = block_rsv; 133216cdcec7SMiao Xie btrfs_end_transaction_dmeta(trans, root); 1333b53d3f5dSLiu Bo btrfs_btree_balance_dirty_nodelay(root); 1334de3cb945SChris Mason 1335de3cb945SChris Mason release_path: 1336de3cb945SChris Mason btrfs_release_path(path); 1337de3cb945SChris Mason total_done++; 1338de3cb945SChris Mason 1339de3cb945SChris Mason btrfs_release_prepared_delayed_node(delayed_node); 1340de3cb945SChris Mason if (async_work->nr == 0 || total_done < async_work->nr) 1341de3cb945SChris Mason goto again; 1342de3cb945SChris Mason 134316cdcec7SMiao Xie free_path: 134416cdcec7SMiao Xie btrfs_free_path(path); 134516cdcec7SMiao Xie out: 1346de3cb945SChris Mason wake_up(&delayed_root->wait); 1347de3cb945SChris Mason kfree(async_work); 134816cdcec7SMiao Xie } 1349de3cb945SChris Mason 135016cdcec7SMiao Xie 135116cdcec7SMiao Xie static int btrfs_wq_run_delayed_node(struct btrfs_delayed_root *delayed_root, 1352de3cb945SChris Mason struct btrfs_root *root, int nr) 135316cdcec7SMiao Xie { 1354de3cb945SChris Mason struct btrfs_async_delayed_work *async_work; 135516cdcec7SMiao Xie 1356de3cb945SChris Mason if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 135716cdcec7SMiao Xie return 0; 135816cdcec7SMiao Xie 1359de3cb945SChris Mason async_work = kmalloc(sizeof(*async_work), GFP_NOFS); 1360de3cb945SChris Mason if (!async_work) 136116cdcec7SMiao Xie return -ENOMEM; 136216cdcec7SMiao Xie 1363de3cb945SChris Mason async_work->delayed_root = delayed_root; 1364de3cb945SChris Mason async_work->work.func = btrfs_async_run_delayed_root; 1365de3cb945SChris Mason async_work->work.flags = 0; 1366de3cb945SChris Mason async_work->nr = nr; 136716cdcec7SMiao Xie 1368de3cb945SChris Mason btrfs_queue_worker(&root->fs_info->delayed_workers, &async_work->work); 136916cdcec7SMiao Xie return 0; 137016cdcec7SMiao Xie } 137116cdcec7SMiao Xie 1372e999376fSChris Mason void btrfs_assert_delayed_root_empty(struct btrfs_root *root) 1373e999376fSChris Mason { 1374e999376fSChris Mason struct btrfs_delayed_root *delayed_root; 1375e999376fSChris Mason delayed_root = btrfs_get_delayed_root(root); 1376e999376fSChris Mason WARN_ON(btrfs_first_delayed_node(delayed_root)); 1377e999376fSChris Mason } 1378e999376fSChris Mason 1379de3cb945SChris Mason static int refs_newer(struct btrfs_delayed_root *delayed_root, 1380de3cb945SChris Mason int seq, int count) 1381de3cb945SChris Mason { 1382de3cb945SChris Mason int val = atomic_read(&delayed_root->items_seq); 1383de3cb945SChris Mason 1384de3cb945SChris Mason if (val < seq || val >= seq + count) 1385de3cb945SChris Mason return 1; 1386de3cb945SChris Mason return 0; 1387de3cb945SChris Mason } 1388de3cb945SChris Mason 138916cdcec7SMiao Xie void btrfs_balance_delayed_items(struct btrfs_root *root) 139016cdcec7SMiao Xie { 139116cdcec7SMiao Xie struct btrfs_delayed_root *delayed_root; 1392de3cb945SChris Mason int seq; 139316cdcec7SMiao Xie 139416cdcec7SMiao Xie delayed_root = btrfs_get_delayed_root(root); 139516cdcec7SMiao Xie 139616cdcec7SMiao Xie if (atomic_read(&delayed_root->items) < BTRFS_DELAYED_BACKGROUND) 139716cdcec7SMiao Xie return; 139816cdcec7SMiao Xie 1399de3cb945SChris Mason seq = atomic_read(&delayed_root->items_seq); 1400de3cb945SChris Mason 140116cdcec7SMiao Xie if (atomic_read(&delayed_root->items) >= BTRFS_DELAYED_WRITEBACK) { 140216cdcec7SMiao Xie int ret; 1403de3cb945SChris Mason DEFINE_WAIT(__wait); 1404de3cb945SChris Mason 1405de3cb945SChris Mason ret = btrfs_wq_run_delayed_node(delayed_root, root, 0); 140616cdcec7SMiao Xie if (ret) 140716cdcec7SMiao Xie return; 140816cdcec7SMiao Xie 1409de3cb945SChris Mason while (1) { 1410de3cb945SChris Mason prepare_to_wait(&delayed_root->wait, &__wait, 1411de3cb945SChris Mason TASK_INTERRUPTIBLE); 1412de3cb945SChris Mason 1413de3cb945SChris Mason if (refs_newer(delayed_root, seq, 1414de3cb945SChris Mason BTRFS_DELAYED_BATCH) || 1415de3cb945SChris Mason atomic_read(&delayed_root->items) < 1416de3cb945SChris Mason BTRFS_DELAYED_BACKGROUND) { 1417de3cb945SChris Mason break; 1418de3cb945SChris Mason } 1419de3cb945SChris Mason if (!signal_pending(current)) 1420de3cb945SChris Mason schedule(); 1421de3cb945SChris Mason else 1422de3cb945SChris Mason break; 1423de3cb945SChris Mason } 1424de3cb945SChris Mason finish_wait(&delayed_root->wait, &__wait); 142516cdcec7SMiao Xie } 142616cdcec7SMiao Xie 1427de3cb945SChris Mason btrfs_wq_run_delayed_node(delayed_root, root, BTRFS_DELAYED_BATCH); 142816cdcec7SMiao Xie } 142916cdcec7SMiao Xie 143079787eaaSJeff Mahoney /* Will return 0 or -ENOMEM */ 143116cdcec7SMiao Xie int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans, 143216cdcec7SMiao Xie struct btrfs_root *root, const char *name, 143316cdcec7SMiao Xie int name_len, struct inode *dir, 143416cdcec7SMiao Xie struct btrfs_disk_key *disk_key, u8 type, 143516cdcec7SMiao Xie u64 index) 143616cdcec7SMiao Xie { 143716cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 143816cdcec7SMiao Xie struct btrfs_delayed_item *delayed_item; 143916cdcec7SMiao Xie struct btrfs_dir_item *dir_item; 144016cdcec7SMiao Xie int ret; 144116cdcec7SMiao Xie 144216cdcec7SMiao Xie delayed_node = btrfs_get_or_create_delayed_node(dir); 144316cdcec7SMiao Xie if (IS_ERR(delayed_node)) 144416cdcec7SMiao Xie return PTR_ERR(delayed_node); 144516cdcec7SMiao Xie 144616cdcec7SMiao Xie delayed_item = btrfs_alloc_delayed_item(sizeof(*dir_item) + name_len); 144716cdcec7SMiao Xie if (!delayed_item) { 144816cdcec7SMiao Xie ret = -ENOMEM; 144916cdcec7SMiao Xie goto release_node; 145016cdcec7SMiao Xie } 145116cdcec7SMiao Xie 14520d0ca30fSChris Mason delayed_item->key.objectid = btrfs_ino(dir); 145316cdcec7SMiao Xie btrfs_set_key_type(&delayed_item->key, BTRFS_DIR_INDEX_KEY); 145416cdcec7SMiao Xie delayed_item->key.offset = index; 145516cdcec7SMiao Xie 145616cdcec7SMiao Xie dir_item = (struct btrfs_dir_item *)delayed_item->data; 145716cdcec7SMiao Xie dir_item->location = *disk_key; 14583cae210fSQu Wenruo btrfs_set_stack_dir_transid(dir_item, trans->transid); 14593cae210fSQu Wenruo btrfs_set_stack_dir_data_len(dir_item, 0); 14603cae210fSQu Wenruo btrfs_set_stack_dir_name_len(dir_item, name_len); 14613cae210fSQu Wenruo btrfs_set_stack_dir_type(dir_item, type); 146216cdcec7SMiao Xie memcpy((char *)(dir_item + 1), name, name_len); 146316cdcec7SMiao Xie 14648c2a3ca2SJosef Bacik ret = btrfs_delayed_item_reserve_metadata(trans, root, delayed_item); 14658c2a3ca2SJosef Bacik /* 14668c2a3ca2SJosef Bacik * we have reserved enough space when we start a new transaction, 14678c2a3ca2SJosef Bacik * so reserving metadata failure is impossible 14688c2a3ca2SJosef Bacik */ 14698c2a3ca2SJosef Bacik BUG_ON(ret); 14708c2a3ca2SJosef Bacik 14718c2a3ca2SJosef Bacik 147216cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 147316cdcec7SMiao Xie ret = __btrfs_add_delayed_insertion_item(delayed_node, delayed_item); 147416cdcec7SMiao Xie if (unlikely(ret)) { 1475bdab49d7SFilipe David Borba Manana printk(KERN_ERR "err add delayed dir index item(name: %.*s) " 1476bdab49d7SFilipe David Borba Manana "into the insertion tree of the delayed node" 147716cdcec7SMiao Xie "(root id: %llu, inode id: %llu, errno: %d)\n", 1478bdab49d7SFilipe David Borba Manana name_len, name, delayed_node->root->objectid, 1479c1c9ff7cSGeert Uytterhoeven delayed_node->inode_id, ret); 148016cdcec7SMiao Xie BUG(); 148116cdcec7SMiao Xie } 148216cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 148316cdcec7SMiao Xie 148416cdcec7SMiao Xie release_node: 148516cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 148616cdcec7SMiao Xie return ret; 148716cdcec7SMiao Xie } 148816cdcec7SMiao Xie 148916cdcec7SMiao Xie static int btrfs_delete_delayed_insertion_item(struct btrfs_root *root, 149016cdcec7SMiao Xie struct btrfs_delayed_node *node, 149116cdcec7SMiao Xie struct btrfs_key *key) 149216cdcec7SMiao Xie { 149316cdcec7SMiao Xie struct btrfs_delayed_item *item; 149416cdcec7SMiao Xie 149516cdcec7SMiao Xie mutex_lock(&node->mutex); 149616cdcec7SMiao Xie item = __btrfs_lookup_delayed_insertion_item(node, key); 149716cdcec7SMiao Xie if (!item) { 149816cdcec7SMiao Xie mutex_unlock(&node->mutex); 149916cdcec7SMiao Xie return 1; 150016cdcec7SMiao Xie } 150116cdcec7SMiao Xie 150216cdcec7SMiao Xie btrfs_delayed_item_release_metadata(root, item); 150316cdcec7SMiao Xie btrfs_release_delayed_item(item); 150416cdcec7SMiao Xie mutex_unlock(&node->mutex); 150516cdcec7SMiao Xie return 0; 150616cdcec7SMiao Xie } 150716cdcec7SMiao Xie 150816cdcec7SMiao Xie int btrfs_delete_delayed_dir_index(struct btrfs_trans_handle *trans, 150916cdcec7SMiao Xie struct btrfs_root *root, struct inode *dir, 151016cdcec7SMiao Xie u64 index) 151116cdcec7SMiao Xie { 151216cdcec7SMiao Xie struct btrfs_delayed_node *node; 151316cdcec7SMiao Xie struct btrfs_delayed_item *item; 151416cdcec7SMiao Xie struct btrfs_key item_key; 151516cdcec7SMiao Xie int ret; 151616cdcec7SMiao Xie 151716cdcec7SMiao Xie node = btrfs_get_or_create_delayed_node(dir); 151816cdcec7SMiao Xie if (IS_ERR(node)) 151916cdcec7SMiao Xie return PTR_ERR(node); 152016cdcec7SMiao Xie 15210d0ca30fSChris Mason item_key.objectid = btrfs_ino(dir); 152216cdcec7SMiao Xie btrfs_set_key_type(&item_key, BTRFS_DIR_INDEX_KEY); 152316cdcec7SMiao Xie item_key.offset = index; 152416cdcec7SMiao Xie 152516cdcec7SMiao Xie ret = btrfs_delete_delayed_insertion_item(root, node, &item_key); 152616cdcec7SMiao Xie if (!ret) 152716cdcec7SMiao Xie goto end; 152816cdcec7SMiao Xie 152916cdcec7SMiao Xie item = btrfs_alloc_delayed_item(0); 153016cdcec7SMiao Xie if (!item) { 153116cdcec7SMiao Xie ret = -ENOMEM; 153216cdcec7SMiao Xie goto end; 153316cdcec7SMiao Xie } 153416cdcec7SMiao Xie 153516cdcec7SMiao Xie item->key = item_key; 153616cdcec7SMiao Xie 153716cdcec7SMiao Xie ret = btrfs_delayed_item_reserve_metadata(trans, root, item); 153816cdcec7SMiao Xie /* 153916cdcec7SMiao Xie * we have reserved enough space when we start a new transaction, 154016cdcec7SMiao Xie * so reserving metadata failure is impossible. 154116cdcec7SMiao Xie */ 154216cdcec7SMiao Xie BUG_ON(ret); 154316cdcec7SMiao Xie 154416cdcec7SMiao Xie mutex_lock(&node->mutex); 154516cdcec7SMiao Xie ret = __btrfs_add_delayed_deletion_item(node, item); 154616cdcec7SMiao Xie if (unlikely(ret)) { 154716cdcec7SMiao Xie printk(KERN_ERR "err add delayed dir index item(index: %llu) " 154816cdcec7SMiao Xie "into the deletion tree of the delayed node" 154916cdcec7SMiao Xie "(root id: %llu, inode id: %llu, errno: %d)\n", 1550c1c9ff7cSGeert Uytterhoeven index, node->root->objectid, node->inode_id, 155116cdcec7SMiao Xie ret); 155216cdcec7SMiao Xie BUG(); 155316cdcec7SMiao Xie } 155416cdcec7SMiao Xie mutex_unlock(&node->mutex); 155516cdcec7SMiao Xie end: 155616cdcec7SMiao Xie btrfs_release_delayed_node(node); 155716cdcec7SMiao Xie return ret; 155816cdcec7SMiao Xie } 155916cdcec7SMiao Xie 156016cdcec7SMiao Xie int btrfs_inode_delayed_dir_index_count(struct inode *inode) 156116cdcec7SMiao Xie { 15622f7e33d4SMiao Xie struct btrfs_delayed_node *delayed_node = btrfs_get_delayed_node(inode); 156316cdcec7SMiao Xie 156416cdcec7SMiao Xie if (!delayed_node) 156516cdcec7SMiao Xie return -ENOENT; 156616cdcec7SMiao Xie 156716cdcec7SMiao Xie /* 156816cdcec7SMiao Xie * Since we have held i_mutex of this directory, it is impossible that 156916cdcec7SMiao Xie * a new directory index is added into the delayed node and index_cnt 157016cdcec7SMiao Xie * is updated now. So we needn't lock the delayed node. 157116cdcec7SMiao Xie */ 15722f7e33d4SMiao Xie if (!delayed_node->index_cnt) { 15732f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 157416cdcec7SMiao Xie return -EINVAL; 15752f7e33d4SMiao Xie } 157616cdcec7SMiao Xie 157716cdcec7SMiao Xie BTRFS_I(inode)->index_cnt = delayed_node->index_cnt; 15782f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 15792f7e33d4SMiao Xie return 0; 158016cdcec7SMiao Xie } 158116cdcec7SMiao Xie 158216cdcec7SMiao Xie void btrfs_get_delayed_items(struct inode *inode, 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 158816cdcec7SMiao Xie delayed_node = btrfs_get_delayed_node(inode); 158916cdcec7SMiao Xie if (!delayed_node) 159016cdcec7SMiao Xie return; 159116cdcec7SMiao Xie 159216cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 159316cdcec7SMiao Xie item = __btrfs_first_delayed_insertion_item(delayed_node); 159416cdcec7SMiao Xie while (item) { 159516cdcec7SMiao Xie atomic_inc(&item->refs); 159616cdcec7SMiao Xie list_add_tail(&item->readdir_list, ins_list); 159716cdcec7SMiao Xie item = __btrfs_next_delayed_item(item); 159816cdcec7SMiao Xie } 159916cdcec7SMiao Xie 160016cdcec7SMiao Xie item = __btrfs_first_delayed_deletion_item(delayed_node); 160116cdcec7SMiao Xie while (item) { 160216cdcec7SMiao Xie atomic_inc(&item->refs); 160316cdcec7SMiao Xie list_add_tail(&item->readdir_list, del_list); 160416cdcec7SMiao Xie item = __btrfs_next_delayed_item(item); 160516cdcec7SMiao Xie } 160616cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 160716cdcec7SMiao Xie /* 160816cdcec7SMiao Xie * This delayed node is still cached in the btrfs inode, so refs 160916cdcec7SMiao Xie * must be > 1 now, and we needn't check it is going to be freed 161016cdcec7SMiao Xie * or not. 161116cdcec7SMiao Xie * 161216cdcec7SMiao Xie * Besides that, this function is used to read dir, we do not 161316cdcec7SMiao Xie * insert/delete delayed items in this period. So we also needn't 161416cdcec7SMiao Xie * requeue or dequeue this delayed node. 161516cdcec7SMiao Xie */ 161616cdcec7SMiao Xie atomic_dec(&delayed_node->refs); 161716cdcec7SMiao Xie } 161816cdcec7SMiao Xie 161916cdcec7SMiao Xie void btrfs_put_delayed_items(struct list_head *ins_list, 162016cdcec7SMiao Xie struct list_head *del_list) 162116cdcec7SMiao Xie { 162216cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 162316cdcec7SMiao Xie 162416cdcec7SMiao Xie list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 162516cdcec7SMiao Xie list_del(&curr->readdir_list); 162616cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 162716cdcec7SMiao Xie kfree(curr); 162816cdcec7SMiao Xie } 162916cdcec7SMiao Xie 163016cdcec7SMiao Xie list_for_each_entry_safe(curr, next, del_list, readdir_list) { 163116cdcec7SMiao Xie list_del(&curr->readdir_list); 163216cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 163316cdcec7SMiao Xie kfree(curr); 163416cdcec7SMiao Xie } 163516cdcec7SMiao Xie } 163616cdcec7SMiao Xie 163716cdcec7SMiao Xie int btrfs_should_delete_dir_index(struct list_head *del_list, 163816cdcec7SMiao Xie u64 index) 163916cdcec7SMiao Xie { 164016cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 164116cdcec7SMiao Xie int ret; 164216cdcec7SMiao Xie 164316cdcec7SMiao Xie if (list_empty(del_list)) 164416cdcec7SMiao Xie return 0; 164516cdcec7SMiao Xie 164616cdcec7SMiao Xie list_for_each_entry_safe(curr, next, del_list, readdir_list) { 164716cdcec7SMiao Xie if (curr->key.offset > index) 164816cdcec7SMiao Xie break; 164916cdcec7SMiao Xie 165016cdcec7SMiao Xie list_del(&curr->readdir_list); 165116cdcec7SMiao Xie ret = (curr->key.offset == index); 165216cdcec7SMiao Xie 165316cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 165416cdcec7SMiao Xie kfree(curr); 165516cdcec7SMiao Xie 165616cdcec7SMiao Xie if (ret) 165716cdcec7SMiao Xie return 1; 165816cdcec7SMiao Xie else 165916cdcec7SMiao Xie continue; 166016cdcec7SMiao Xie } 166116cdcec7SMiao Xie return 0; 166216cdcec7SMiao Xie } 166316cdcec7SMiao Xie 166416cdcec7SMiao Xie /* 166516cdcec7SMiao Xie * btrfs_readdir_delayed_dir_index - read dir info stored in the delayed tree 166616cdcec7SMiao Xie * 166716cdcec7SMiao Xie */ 16689cdda8d3SAl Viro int btrfs_readdir_delayed_dir_index(struct dir_context *ctx, 166916cdcec7SMiao Xie struct list_head *ins_list) 167016cdcec7SMiao Xie { 167116cdcec7SMiao Xie struct btrfs_dir_item *di; 167216cdcec7SMiao Xie struct btrfs_delayed_item *curr, *next; 167316cdcec7SMiao Xie struct btrfs_key location; 167416cdcec7SMiao Xie char *name; 167516cdcec7SMiao Xie int name_len; 167616cdcec7SMiao Xie int over = 0; 167716cdcec7SMiao Xie unsigned char d_type; 167816cdcec7SMiao Xie 167916cdcec7SMiao Xie if (list_empty(ins_list)) 168016cdcec7SMiao Xie return 0; 168116cdcec7SMiao Xie 168216cdcec7SMiao Xie /* 168316cdcec7SMiao Xie * Changing the data of the delayed item is impossible. So 168416cdcec7SMiao Xie * we needn't lock them. And we have held i_mutex of the 168516cdcec7SMiao Xie * directory, nobody can delete any directory indexes now. 168616cdcec7SMiao Xie */ 168716cdcec7SMiao Xie list_for_each_entry_safe(curr, next, ins_list, readdir_list) { 168816cdcec7SMiao Xie list_del(&curr->readdir_list); 168916cdcec7SMiao Xie 16909cdda8d3SAl Viro if (curr->key.offset < ctx->pos) { 169116cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 169216cdcec7SMiao Xie kfree(curr); 169316cdcec7SMiao Xie continue; 169416cdcec7SMiao Xie } 169516cdcec7SMiao Xie 16969cdda8d3SAl Viro ctx->pos = curr->key.offset; 169716cdcec7SMiao Xie 169816cdcec7SMiao Xie di = (struct btrfs_dir_item *)curr->data; 169916cdcec7SMiao Xie name = (char *)(di + 1); 17003cae210fSQu Wenruo name_len = btrfs_stack_dir_name_len(di); 170116cdcec7SMiao Xie 170216cdcec7SMiao Xie d_type = btrfs_filetype_table[di->type]; 170316cdcec7SMiao Xie btrfs_disk_key_to_cpu(&location, &di->location); 170416cdcec7SMiao Xie 17059cdda8d3SAl Viro over = !dir_emit(ctx, name, name_len, 170616cdcec7SMiao Xie location.objectid, d_type); 170716cdcec7SMiao Xie 170816cdcec7SMiao Xie if (atomic_dec_and_test(&curr->refs)) 170916cdcec7SMiao Xie kfree(curr); 171016cdcec7SMiao Xie 171116cdcec7SMiao Xie if (over) 171216cdcec7SMiao Xie return 1; 171316cdcec7SMiao Xie } 171416cdcec7SMiao Xie return 0; 171516cdcec7SMiao Xie } 171616cdcec7SMiao Xie 171716cdcec7SMiao Xie static void fill_stack_inode_item(struct btrfs_trans_handle *trans, 171816cdcec7SMiao Xie struct btrfs_inode_item *inode_item, 171916cdcec7SMiao Xie struct inode *inode) 172016cdcec7SMiao Xie { 17212f2f43d3SEric W. Biederman btrfs_set_stack_inode_uid(inode_item, i_uid_read(inode)); 17222f2f43d3SEric W. Biederman btrfs_set_stack_inode_gid(inode_item, i_gid_read(inode)); 172316cdcec7SMiao Xie btrfs_set_stack_inode_size(inode_item, BTRFS_I(inode)->disk_i_size); 172416cdcec7SMiao Xie btrfs_set_stack_inode_mode(inode_item, inode->i_mode); 172516cdcec7SMiao Xie btrfs_set_stack_inode_nlink(inode_item, inode->i_nlink); 172616cdcec7SMiao Xie btrfs_set_stack_inode_nbytes(inode_item, inode_get_bytes(inode)); 172716cdcec7SMiao Xie btrfs_set_stack_inode_generation(inode_item, 172816cdcec7SMiao Xie BTRFS_I(inode)->generation); 17290c4d2d95SJosef Bacik btrfs_set_stack_inode_sequence(inode_item, inode->i_version); 173016cdcec7SMiao Xie btrfs_set_stack_inode_transid(inode_item, trans->transid); 173116cdcec7SMiao Xie btrfs_set_stack_inode_rdev(inode_item, inode->i_rdev); 173216cdcec7SMiao Xie btrfs_set_stack_inode_flags(inode_item, BTRFS_I(inode)->flags); 1733ff5714ccSChris Mason btrfs_set_stack_inode_block_group(inode_item, 0); 173416cdcec7SMiao Xie 173516cdcec7SMiao Xie btrfs_set_stack_timespec_sec(btrfs_inode_atime(inode_item), 173616cdcec7SMiao Xie inode->i_atime.tv_sec); 173716cdcec7SMiao Xie btrfs_set_stack_timespec_nsec(btrfs_inode_atime(inode_item), 173816cdcec7SMiao Xie inode->i_atime.tv_nsec); 173916cdcec7SMiao Xie 174016cdcec7SMiao Xie btrfs_set_stack_timespec_sec(btrfs_inode_mtime(inode_item), 174116cdcec7SMiao Xie inode->i_mtime.tv_sec); 174216cdcec7SMiao Xie btrfs_set_stack_timespec_nsec(btrfs_inode_mtime(inode_item), 174316cdcec7SMiao Xie inode->i_mtime.tv_nsec); 174416cdcec7SMiao Xie 174516cdcec7SMiao Xie btrfs_set_stack_timespec_sec(btrfs_inode_ctime(inode_item), 174616cdcec7SMiao Xie inode->i_ctime.tv_sec); 174716cdcec7SMiao Xie btrfs_set_stack_timespec_nsec(btrfs_inode_ctime(inode_item), 174816cdcec7SMiao Xie inode->i_ctime.tv_nsec); 174916cdcec7SMiao Xie } 175016cdcec7SMiao Xie 17512f7e33d4SMiao Xie int btrfs_fill_inode(struct inode *inode, u32 *rdev) 17522f7e33d4SMiao Xie { 17532f7e33d4SMiao Xie struct btrfs_delayed_node *delayed_node; 17542f7e33d4SMiao Xie struct btrfs_inode_item *inode_item; 17552f7e33d4SMiao Xie struct btrfs_timespec *tspec; 17562f7e33d4SMiao Xie 17572f7e33d4SMiao Xie delayed_node = btrfs_get_delayed_node(inode); 17582f7e33d4SMiao Xie if (!delayed_node) 17592f7e33d4SMiao Xie return -ENOENT; 17602f7e33d4SMiao Xie 17612f7e33d4SMiao Xie mutex_lock(&delayed_node->mutex); 17622f7e33d4SMiao Xie if (!delayed_node->inode_dirty) { 17632f7e33d4SMiao Xie mutex_unlock(&delayed_node->mutex); 17642f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 17652f7e33d4SMiao Xie return -ENOENT; 17662f7e33d4SMiao Xie } 17672f7e33d4SMiao Xie 17682f7e33d4SMiao Xie inode_item = &delayed_node->inode_item; 17692f7e33d4SMiao Xie 17702f2f43d3SEric W. Biederman i_uid_write(inode, btrfs_stack_inode_uid(inode_item)); 17712f2f43d3SEric W. Biederman i_gid_write(inode, btrfs_stack_inode_gid(inode_item)); 17722f7e33d4SMiao Xie btrfs_i_size_write(inode, btrfs_stack_inode_size(inode_item)); 17732f7e33d4SMiao Xie inode->i_mode = btrfs_stack_inode_mode(inode_item); 1774bfe86848SMiklos Szeredi set_nlink(inode, btrfs_stack_inode_nlink(inode_item)); 17752f7e33d4SMiao Xie inode_set_bytes(inode, btrfs_stack_inode_nbytes(inode_item)); 17762f7e33d4SMiao Xie BTRFS_I(inode)->generation = btrfs_stack_inode_generation(inode_item); 17770c4d2d95SJosef Bacik inode->i_version = btrfs_stack_inode_sequence(inode_item); 17782f7e33d4SMiao Xie inode->i_rdev = 0; 17792f7e33d4SMiao Xie *rdev = btrfs_stack_inode_rdev(inode_item); 17802f7e33d4SMiao Xie BTRFS_I(inode)->flags = btrfs_stack_inode_flags(inode_item); 17812f7e33d4SMiao Xie 17822f7e33d4SMiao Xie tspec = btrfs_inode_atime(inode_item); 17832f7e33d4SMiao Xie inode->i_atime.tv_sec = btrfs_stack_timespec_sec(tspec); 17842f7e33d4SMiao Xie inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(tspec); 17852f7e33d4SMiao Xie 17862f7e33d4SMiao Xie tspec = btrfs_inode_mtime(inode_item); 17872f7e33d4SMiao Xie inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(tspec); 17882f7e33d4SMiao Xie inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(tspec); 17892f7e33d4SMiao Xie 17902f7e33d4SMiao Xie tspec = btrfs_inode_ctime(inode_item); 17912f7e33d4SMiao Xie inode->i_ctime.tv_sec = btrfs_stack_timespec_sec(tspec); 17922f7e33d4SMiao Xie inode->i_ctime.tv_nsec = btrfs_stack_timespec_nsec(tspec); 17932f7e33d4SMiao Xie 17942f7e33d4SMiao Xie inode->i_generation = BTRFS_I(inode)->generation; 17952f7e33d4SMiao Xie BTRFS_I(inode)->index_cnt = (u64)-1; 17962f7e33d4SMiao Xie 17972f7e33d4SMiao Xie mutex_unlock(&delayed_node->mutex); 17982f7e33d4SMiao Xie btrfs_release_delayed_node(delayed_node); 17992f7e33d4SMiao Xie return 0; 18002f7e33d4SMiao Xie } 18012f7e33d4SMiao Xie 180216cdcec7SMiao Xie int btrfs_delayed_update_inode(struct btrfs_trans_handle *trans, 180316cdcec7SMiao Xie struct btrfs_root *root, struct inode *inode) 180416cdcec7SMiao Xie { 180516cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 1806aa0467d8SDavid Sterba int ret = 0; 180716cdcec7SMiao Xie 180816cdcec7SMiao Xie delayed_node = btrfs_get_or_create_delayed_node(inode); 180916cdcec7SMiao Xie if (IS_ERR(delayed_node)) 181016cdcec7SMiao Xie return PTR_ERR(delayed_node); 181116cdcec7SMiao Xie 181216cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 181316cdcec7SMiao Xie if (delayed_node->inode_dirty) { 181416cdcec7SMiao Xie fill_stack_inode_item(trans, &delayed_node->inode_item, inode); 181516cdcec7SMiao Xie goto release_node; 181616cdcec7SMiao Xie } 181716cdcec7SMiao Xie 18187fd2ae21SJosef Bacik ret = btrfs_delayed_inode_reserve_metadata(trans, root, inode, 18197fd2ae21SJosef Bacik delayed_node); 1820c06a0e12SJosef Bacik if (ret) 1821c06a0e12SJosef Bacik goto release_node; 182216cdcec7SMiao Xie 182316cdcec7SMiao Xie fill_stack_inode_item(trans, &delayed_node->inode_item, inode); 182416cdcec7SMiao Xie delayed_node->inode_dirty = 1; 182516cdcec7SMiao Xie delayed_node->count++; 182616cdcec7SMiao Xie atomic_inc(&root->fs_info->delayed_root->items); 182716cdcec7SMiao Xie release_node: 182816cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 182916cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 183016cdcec7SMiao Xie return ret; 183116cdcec7SMiao Xie } 183216cdcec7SMiao Xie 183316cdcec7SMiao Xie static void __btrfs_kill_delayed_node(struct btrfs_delayed_node *delayed_node) 183416cdcec7SMiao Xie { 183516cdcec7SMiao Xie struct btrfs_root *root = delayed_node->root; 183616cdcec7SMiao Xie struct btrfs_delayed_item *curr_item, *prev_item; 183716cdcec7SMiao Xie 183816cdcec7SMiao Xie mutex_lock(&delayed_node->mutex); 183916cdcec7SMiao Xie curr_item = __btrfs_first_delayed_insertion_item(delayed_node); 184016cdcec7SMiao Xie while (curr_item) { 184116cdcec7SMiao Xie btrfs_delayed_item_release_metadata(root, curr_item); 184216cdcec7SMiao Xie prev_item = curr_item; 184316cdcec7SMiao Xie curr_item = __btrfs_next_delayed_item(prev_item); 184416cdcec7SMiao Xie btrfs_release_delayed_item(prev_item); 184516cdcec7SMiao Xie } 184616cdcec7SMiao Xie 184716cdcec7SMiao Xie curr_item = __btrfs_first_delayed_deletion_item(delayed_node); 184816cdcec7SMiao Xie while (curr_item) { 184916cdcec7SMiao Xie btrfs_delayed_item_release_metadata(root, curr_item); 185016cdcec7SMiao Xie prev_item = curr_item; 185116cdcec7SMiao Xie curr_item = __btrfs_next_delayed_item(prev_item); 185216cdcec7SMiao Xie btrfs_release_delayed_item(prev_item); 185316cdcec7SMiao Xie } 185416cdcec7SMiao Xie 185516cdcec7SMiao Xie if (delayed_node->inode_dirty) { 185616cdcec7SMiao Xie btrfs_delayed_inode_release_metadata(root, delayed_node); 185716cdcec7SMiao Xie btrfs_release_delayed_inode(delayed_node); 185816cdcec7SMiao Xie } 185916cdcec7SMiao Xie mutex_unlock(&delayed_node->mutex); 186016cdcec7SMiao Xie } 186116cdcec7SMiao Xie 186216cdcec7SMiao Xie void btrfs_kill_delayed_inode_items(struct inode *inode) 186316cdcec7SMiao Xie { 186416cdcec7SMiao Xie struct btrfs_delayed_node *delayed_node; 186516cdcec7SMiao Xie 186616cdcec7SMiao Xie delayed_node = btrfs_get_delayed_node(inode); 186716cdcec7SMiao Xie if (!delayed_node) 186816cdcec7SMiao Xie return; 186916cdcec7SMiao Xie 187016cdcec7SMiao Xie __btrfs_kill_delayed_node(delayed_node); 187116cdcec7SMiao Xie btrfs_release_delayed_node(delayed_node); 187216cdcec7SMiao Xie } 187316cdcec7SMiao Xie 187416cdcec7SMiao Xie void btrfs_kill_all_delayed_nodes(struct btrfs_root *root) 187516cdcec7SMiao Xie { 187616cdcec7SMiao Xie u64 inode_id = 0; 187716cdcec7SMiao Xie struct btrfs_delayed_node *delayed_nodes[8]; 187816cdcec7SMiao Xie int i, n; 187916cdcec7SMiao Xie 188016cdcec7SMiao Xie while (1) { 188116cdcec7SMiao Xie spin_lock(&root->inode_lock); 188216cdcec7SMiao Xie n = radix_tree_gang_lookup(&root->delayed_nodes_tree, 188316cdcec7SMiao Xie (void **)delayed_nodes, inode_id, 188416cdcec7SMiao Xie ARRAY_SIZE(delayed_nodes)); 188516cdcec7SMiao Xie if (!n) { 188616cdcec7SMiao Xie spin_unlock(&root->inode_lock); 188716cdcec7SMiao Xie break; 188816cdcec7SMiao Xie } 188916cdcec7SMiao Xie 189016cdcec7SMiao Xie inode_id = delayed_nodes[n - 1]->inode_id + 1; 189116cdcec7SMiao Xie 189216cdcec7SMiao Xie for (i = 0; i < n; i++) 189316cdcec7SMiao Xie atomic_inc(&delayed_nodes[i]->refs); 189416cdcec7SMiao Xie spin_unlock(&root->inode_lock); 189516cdcec7SMiao Xie 189616cdcec7SMiao Xie for (i = 0; i < n; i++) { 189716cdcec7SMiao Xie __btrfs_kill_delayed_node(delayed_nodes[i]); 189816cdcec7SMiao Xie btrfs_release_delayed_node(delayed_nodes[i]); 189916cdcec7SMiao Xie } 190016cdcec7SMiao Xie } 190116cdcec7SMiao Xie } 190267cde344SMiao Xie 190367cde344SMiao Xie void btrfs_destroy_delayed_inodes(struct btrfs_root *root) 190467cde344SMiao Xie { 190567cde344SMiao Xie struct btrfs_delayed_root *delayed_root; 190667cde344SMiao Xie struct btrfs_delayed_node *curr_node, *prev_node; 190767cde344SMiao Xie 190867cde344SMiao Xie delayed_root = btrfs_get_delayed_root(root); 190967cde344SMiao Xie 191067cde344SMiao Xie curr_node = btrfs_first_delayed_node(delayed_root); 191167cde344SMiao Xie while (curr_node) { 191267cde344SMiao Xie __btrfs_kill_delayed_node(curr_node); 191367cde344SMiao Xie 191467cde344SMiao Xie prev_node = curr_node; 191567cde344SMiao Xie curr_node = btrfs_next_delayed_node(curr_node); 191667cde344SMiao Xie btrfs_release_delayed_node(prev_node); 191767cde344SMiao Xie } 191867cde344SMiao Xie } 191967cde344SMiao Xie 1920