16cbd5570SChris Mason /* 26cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 36cbd5570SChris Mason * 46cbd5570SChris Mason * This program is free software; you can redistribute it and/or 56cbd5570SChris Mason * modify it under the terms of the GNU General Public 66cbd5570SChris Mason * License v2 as published by the Free Software Foundation. 76cbd5570SChris Mason * 86cbd5570SChris Mason * This program is distributed in the hope that it will be useful, 96cbd5570SChris Mason * but WITHOUT ANY WARRANTY; without even the implied warranty of 106cbd5570SChris Mason * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 116cbd5570SChris Mason * General Public License for more details. 126cbd5570SChris Mason * 136cbd5570SChris Mason * You should have received a copy of the GNU General Public 146cbd5570SChris Mason * License along with this program; if not, write to the 156cbd5570SChris Mason * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 166cbd5570SChris Mason * Boston, MA 021110-1307, USA. 176cbd5570SChris Mason */ 186cbd5570SChris Mason 1979154b1bSChris Mason #include <linux/fs.h> 2034088780SChris Mason #include <linux/sched.h> 21d3c2fdcfSChris Mason #include <linux/writeback.h> 225f39d397SChris Mason #include <linux/pagemap.h> 2379154b1bSChris Mason #include "ctree.h" 2479154b1bSChris Mason #include "disk-io.h" 2579154b1bSChris Mason #include "transaction.h" 26925baeddSChris Mason #include "locking.h" 2731153d81SYan Zheng #include "ref-cache.h" 28e02119d5SChris Mason #include "tree-log.h" 2979154b1bSChris Mason 3078fae27eSChris Mason static int total_trans = 0; 312c90e5d6SChris Mason extern struct kmem_cache *btrfs_trans_handle_cachep; 322c90e5d6SChris Mason extern struct kmem_cache *btrfs_transaction_cachep; 332c90e5d6SChris Mason 340f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 350f7d52f4SChris Mason 3680b6794dSChris Mason static noinline void put_transaction(struct btrfs_transaction *transaction) 3779154b1bSChris Mason { 382c90e5d6SChris Mason WARN_ON(transaction->use_count == 0); 3979154b1bSChris Mason transaction->use_count--; 4078fae27eSChris Mason if (transaction->use_count == 0) { 4178fae27eSChris Mason WARN_ON(total_trans == 0); 4278fae27eSChris Mason total_trans--; 438fd17795SChris Mason list_del_init(&transaction->list); 442c90e5d6SChris Mason memset(transaction, 0, sizeof(*transaction)); 452c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 4679154b1bSChris Mason } 4778fae27eSChris Mason } 4879154b1bSChris Mason 4980b6794dSChris Mason static noinline int join_transaction(struct btrfs_root *root) 5079154b1bSChris Mason { 5179154b1bSChris Mason struct btrfs_transaction *cur_trans; 5279154b1bSChris Mason cur_trans = root->fs_info->running_transaction; 5379154b1bSChris Mason if (!cur_trans) { 542c90e5d6SChris Mason cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, 552c90e5d6SChris Mason GFP_NOFS); 5678fae27eSChris Mason total_trans++; 5779154b1bSChris Mason BUG_ON(!cur_trans); 580f7d52f4SChris Mason root->fs_info->generation++; 59e18e4809SChris Mason root->fs_info->last_alloc = 0; 604529ba49SChris Mason root->fs_info->last_data_alloc = 0; 61e02119d5SChris Mason root->fs_info->last_log_alloc = 0; 6215ee9bc7SJosef Bacik cur_trans->num_writers = 1; 6315ee9bc7SJosef Bacik cur_trans->num_joined = 0; 640f7d52f4SChris Mason cur_trans->transid = root->fs_info->generation; 6579154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 6679154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 6779154b1bSChris Mason cur_trans->in_commit = 0; 68f9295749SChris Mason cur_trans->blocked = 0; 69d5719762SChris Mason cur_trans->use_count = 1; 7079154b1bSChris Mason cur_trans->commit_done = 0; 7108607c1bSChris Mason cur_trans->start_time = get_seconds(); 723063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 738fd17795SChris Mason list_add_tail(&cur_trans->list, &root->fs_info->trans_list); 74d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 755f39d397SChris Mason root->fs_info->btree_inode->i_mapping, 765f39d397SChris Mason GFP_NOFS); 7748ec2cf8SChris Mason spin_lock(&root->fs_info->new_trans_lock); 7848ec2cf8SChris Mason root->fs_info->running_transaction = cur_trans; 7948ec2cf8SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 8015ee9bc7SJosef Bacik } else { 8179154b1bSChris Mason cur_trans->num_writers++; 8215ee9bc7SJosef Bacik cur_trans->num_joined++; 8315ee9bc7SJosef Bacik } 8415ee9bc7SJosef Bacik 8579154b1bSChris Mason return 0; 8679154b1bSChris Mason } 8779154b1bSChris Mason 88e02119d5SChris Mason noinline int btrfs_record_root_in_trans(struct btrfs_root *root) 896702ed49SChris Mason { 90f321e491SYan Zheng struct btrfs_dirty_root *dirty; 916702ed49SChris Mason u64 running_trans_id = root->fs_info->running_transaction->transid; 926702ed49SChris Mason if (root->ref_cows && root->last_trans < running_trans_id) { 936702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 946702ed49SChris Mason if (root->root_item.refs != 0) { 956702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 966702ed49SChris Mason (unsigned long)root->root_key.objectid, 976702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 9831153d81SYan Zheng 9931153d81SYan Zheng dirty = kmalloc(sizeof(*dirty), GFP_NOFS); 10031153d81SYan Zheng BUG_ON(!dirty); 10131153d81SYan Zheng dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS); 10231153d81SYan Zheng BUG_ON(!dirty->root); 10331153d81SYan Zheng dirty->latest_root = root; 10431153d81SYan Zheng INIT_LIST_HEAD(&dirty->list); 10531153d81SYan Zheng 106925baeddSChris Mason root->commit_root = btrfs_root_node(root); 10731153d81SYan Zheng 10831153d81SYan Zheng memcpy(dirty->root, root, sizeof(*root)); 10931153d81SYan Zheng spin_lock_init(&dirty->root->node_lock); 110bcc63abbSYan spin_lock_init(&dirty->root->list_lock); 11131153d81SYan Zheng mutex_init(&dirty->root->objectid_mutex); 1125b21f2edSZheng Yan mutex_init(&dirty->root->log_mutex); 113bcc63abbSYan INIT_LIST_HEAD(&dirty->root->dead_list); 11431153d81SYan Zheng dirty->root->node = root->commit_root; 11531153d81SYan Zheng dirty->root->commit_root = NULL; 116bcc63abbSYan 117bcc63abbSYan spin_lock(&root->list_lock); 118bcc63abbSYan list_add(&dirty->root->dead_list, &root->dead_list); 119bcc63abbSYan spin_unlock(&root->list_lock); 120bcc63abbSYan 121bcc63abbSYan root->dirty_root = dirty; 1226702ed49SChris Mason } else { 1236702ed49SChris Mason WARN_ON(1); 1246702ed49SChris Mason } 1256702ed49SChris Mason root->last_trans = running_trans_id; 1266702ed49SChris Mason } 1276702ed49SChris Mason return 0; 1286702ed49SChris Mason } 1296702ed49SChris Mason 13037d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 13179154b1bSChris Mason { 132f9295749SChris Mason struct btrfs_transaction *cur_trans; 13379154b1bSChris Mason 134f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 13537d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 136f9295749SChris Mason DEFINE_WAIT(wait); 137f9295749SChris Mason cur_trans->use_count++; 138f9295749SChris Mason while(1) { 139f9295749SChris Mason prepare_to_wait(&root->fs_info->transaction_wait, &wait, 140f9295749SChris Mason TASK_UNINTERRUPTIBLE); 141f9295749SChris Mason if (cur_trans->blocked) { 142f9295749SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 143f9295749SChris Mason schedule(); 144f9295749SChris Mason mutex_lock(&root->fs_info->trans_mutex); 145f9295749SChris Mason finish_wait(&root->fs_info->transaction_wait, 146f9295749SChris Mason &wait); 147f9295749SChris Mason } else { 148f9295749SChris Mason finish_wait(&root->fs_info->transaction_wait, 149f9295749SChris Mason &wait); 150f9295749SChris Mason break; 151f9295749SChris Mason } 152f9295749SChris Mason } 153f9295749SChris Mason put_transaction(cur_trans); 154f9295749SChris Mason } 15537d1aeeeSChris Mason } 15637d1aeeeSChris Mason 157e02119d5SChris Mason static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 1589ca9ee09SSage Weil int num_blocks, int wait) 15937d1aeeeSChris Mason { 16037d1aeeeSChris Mason struct btrfs_trans_handle *h = 16137d1aeeeSChris Mason kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 16237d1aeeeSChris Mason int ret; 16337d1aeeeSChris Mason 16437d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 1654bef0848SChris Mason if (!root->fs_info->log_root_recovering && 1664bef0848SChris Mason ((wait == 1 && !root->fs_info->open_ioctl_trans) || wait == 2)) 16737d1aeeeSChris Mason wait_current_trans(root); 16879154b1bSChris Mason ret = join_transaction(root); 16979154b1bSChris Mason BUG_ON(ret); 1700f7d52f4SChris Mason 171e02119d5SChris Mason btrfs_record_root_in_trans(root); 1726702ed49SChris Mason h->transid = root->fs_info->running_transaction->transid; 17379154b1bSChris Mason h->transaction = root->fs_info->running_transaction; 17479154b1bSChris Mason h->blocks_reserved = num_blocks; 17579154b1bSChris Mason h->blocks_used = 0; 17631f3c99bSChris Mason h->block_group = NULL; 17726b8003fSChris Mason h->alloc_exclude_nr = 0; 17826b8003fSChris Mason h->alloc_exclude_start = 0; 17979154b1bSChris Mason root->fs_info->running_transaction->use_count++; 18079154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 18179154b1bSChris Mason return h; 18279154b1bSChris Mason } 18379154b1bSChris Mason 184f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 185f9295749SChris Mason int num_blocks) 186f9295749SChris Mason { 1879ca9ee09SSage Weil return start_transaction(root, num_blocks, 1); 188f9295749SChris Mason } 189f9295749SChris Mason struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root, 190f9295749SChris Mason int num_blocks) 191f9295749SChris Mason { 1929ca9ee09SSage Weil return start_transaction(root, num_blocks, 0); 193f9295749SChris Mason } 194f9295749SChris Mason 1959ca9ee09SSage Weil struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r, 1969ca9ee09SSage Weil int num_blocks) 1979ca9ee09SSage Weil { 1989ca9ee09SSage Weil return start_transaction(r, num_blocks, 2); 1999ca9ee09SSage Weil } 2009ca9ee09SSage Weil 2019ca9ee09SSage Weil 20289ce8a63SChris Mason static noinline int wait_for_commit(struct btrfs_root *root, 20389ce8a63SChris Mason struct btrfs_transaction *commit) 20489ce8a63SChris Mason { 20589ce8a63SChris Mason DEFINE_WAIT(wait); 20689ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 20789ce8a63SChris Mason while(!commit->commit_done) { 20889ce8a63SChris Mason prepare_to_wait(&commit->commit_wait, &wait, 20989ce8a63SChris Mason TASK_UNINTERRUPTIBLE); 21089ce8a63SChris Mason if (commit->commit_done) 21189ce8a63SChris Mason break; 21289ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 21389ce8a63SChris Mason schedule(); 21489ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 21589ce8a63SChris Mason } 21689ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 21789ce8a63SChris Mason finish_wait(&commit->commit_wait, &wait); 21889ce8a63SChris Mason return 0; 21989ce8a63SChris Mason } 22089ce8a63SChris Mason 22137d1aeeeSChris Mason static void throttle_on_drops(struct btrfs_root *root) 222ab78c84dSChris Mason { 223ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 2242dd3e67bSChris Mason int harder_count = 0; 225ab78c84dSChris Mason 2262dd3e67bSChris Mason harder: 227ab78c84dSChris Mason if (atomic_read(&info->throttles)) { 228ab78c84dSChris Mason DEFINE_WAIT(wait); 229ab78c84dSChris Mason int thr; 230ab78c84dSChris Mason thr = atomic_read(&info->throttle_gen); 231ab78c84dSChris Mason 232ab78c84dSChris Mason do { 233ab78c84dSChris Mason prepare_to_wait(&info->transaction_throttle, 234ab78c84dSChris Mason &wait, TASK_UNINTERRUPTIBLE); 235ab78c84dSChris Mason if (!atomic_read(&info->throttles)) { 236ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 237ab78c84dSChris Mason break; 238ab78c84dSChris Mason } 239ab78c84dSChris Mason schedule(); 240ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 241ab78c84dSChris Mason } while (thr == atomic_read(&info->throttle_gen)); 2422dd3e67bSChris Mason harder_count++; 2432dd3e67bSChris Mason 2442dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 && 2452dd3e67bSChris Mason harder_count < 2) 2462dd3e67bSChris Mason goto harder; 2472dd3e67bSChris Mason 2482dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 && 2492dd3e67bSChris Mason harder_count < 10) 2502dd3e67bSChris Mason goto harder; 2512dd3e67bSChris Mason 2522dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 && 2532dd3e67bSChris Mason harder_count < 20) 2542dd3e67bSChris Mason goto harder; 255ab78c84dSChris Mason } 256ab78c84dSChris Mason } 257ab78c84dSChris Mason 25837d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 25937d1aeeeSChris Mason { 26037d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 2619ca9ee09SSage Weil if (!root->fs_info->open_ioctl_trans) 26237d1aeeeSChris Mason wait_current_trans(root); 26337d1aeeeSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 26437d1aeeeSChris Mason 26537d1aeeeSChris Mason throttle_on_drops(root); 26637d1aeeeSChris Mason } 26737d1aeeeSChris Mason 26889ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 26989ce8a63SChris Mason struct btrfs_root *root, int throttle) 27079154b1bSChris Mason { 27179154b1bSChris Mason struct btrfs_transaction *cur_trans; 272ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 273d6e4a428SChris Mason 274ab78c84dSChris Mason mutex_lock(&info->trans_mutex); 275ab78c84dSChris Mason cur_trans = info->running_transaction; 276ccd467d6SChris Mason WARN_ON(cur_trans != trans->transaction); 277d5719762SChris Mason WARN_ON(cur_trans->num_writers < 1); 278ccd467d6SChris Mason cur_trans->num_writers--; 27989ce8a63SChris Mason 28079154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 28179154b1bSChris Mason wake_up(&cur_trans->writer_wait); 28279154b1bSChris Mason put_transaction(cur_trans); 283ab78c84dSChris Mason mutex_unlock(&info->trans_mutex); 284d6025579SChris Mason memset(trans, 0, sizeof(*trans)); 2852c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 286ab78c84dSChris Mason 287ab78c84dSChris Mason if (throttle) 28837d1aeeeSChris Mason throttle_on_drops(root); 289ab78c84dSChris Mason 29079154b1bSChris Mason return 0; 29179154b1bSChris Mason } 29279154b1bSChris Mason 29389ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 29489ce8a63SChris Mason struct btrfs_root *root) 29589ce8a63SChris Mason { 29689ce8a63SChris Mason return __btrfs_end_transaction(trans, root, 0); 29789ce8a63SChris Mason } 29889ce8a63SChris Mason 29989ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 30089ce8a63SChris Mason struct btrfs_root *root) 30189ce8a63SChris Mason { 30289ce8a63SChris Mason return __btrfs_end_transaction(trans, root, 1); 30389ce8a63SChris Mason } 30489ce8a63SChris Mason 30579154b1bSChris Mason 306d0c803c4SChris Mason int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 307d0c803c4SChris Mason struct extent_io_tree *dirty_pages) 30879154b1bSChris Mason { 3097c4452b9SChris Mason int ret; 310777e6bd7SChris Mason int err = 0; 3117c4452b9SChris Mason int werr = 0; 3127c4452b9SChris Mason struct page *page; 3137c4452b9SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 314777e6bd7SChris Mason u64 start = 0; 3155f39d397SChris Mason u64 end; 3165f39d397SChris Mason unsigned long index; 3177c4452b9SChris Mason 3187c4452b9SChris Mason while(1) { 319777e6bd7SChris Mason ret = find_first_extent_bit(dirty_pages, start, &start, &end, 3205f39d397SChris Mason EXTENT_DIRTY); 3215f39d397SChris Mason if (ret) 3227c4452b9SChris Mason break; 3235f39d397SChris Mason while(start <= end) { 324777e6bd7SChris Mason cond_resched(); 325777e6bd7SChris Mason 3265f39d397SChris Mason index = start >> PAGE_CACHE_SHIFT; 32735ebb934SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 3284bef0848SChris Mason page = find_get_page(btree_inode->i_mapping, index); 3297c4452b9SChris Mason if (!page) 3307c4452b9SChris Mason continue; 3314bef0848SChris Mason 3324bef0848SChris Mason btree_lock_page_hook(page); 3334bef0848SChris Mason if (!page->mapping) { 3344bef0848SChris Mason unlock_page(page); 3354bef0848SChris Mason page_cache_release(page); 3364bef0848SChris Mason continue; 3374bef0848SChris Mason } 3384bef0848SChris Mason 3396702ed49SChris Mason if (PageWriteback(page)) { 3406702ed49SChris Mason if (PageDirty(page)) 3416702ed49SChris Mason wait_on_page_writeback(page); 3426702ed49SChris Mason else { 3436702ed49SChris Mason unlock_page(page); 3446702ed49SChris Mason page_cache_release(page); 3456702ed49SChris Mason continue; 3466702ed49SChris Mason } 3476702ed49SChris Mason } 3487c4452b9SChris Mason err = write_one_page(page, 0); 3497c4452b9SChris Mason if (err) 3507c4452b9SChris Mason werr = err; 3517c4452b9SChris Mason page_cache_release(page); 3527c4452b9SChris Mason } 3537c4452b9SChris Mason } 354777e6bd7SChris Mason while(1) { 355777e6bd7SChris Mason ret = find_first_extent_bit(dirty_pages, 0, &start, &end, 356777e6bd7SChris Mason EXTENT_DIRTY); 357777e6bd7SChris Mason if (ret) 358777e6bd7SChris Mason break; 359777e6bd7SChris Mason 360777e6bd7SChris Mason clear_extent_dirty(dirty_pages, start, end, GFP_NOFS); 361777e6bd7SChris Mason while(start <= end) { 362777e6bd7SChris Mason index = start >> PAGE_CACHE_SHIFT; 363777e6bd7SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 364777e6bd7SChris Mason page = find_get_page(btree_inode->i_mapping, index); 365777e6bd7SChris Mason if (!page) 366777e6bd7SChris Mason continue; 367777e6bd7SChris Mason if (PageDirty(page)) { 3684bef0848SChris Mason btree_lock_page_hook(page); 3694bef0848SChris Mason wait_on_page_writeback(page); 370777e6bd7SChris Mason err = write_one_page(page, 0); 371777e6bd7SChris Mason if (err) 372777e6bd7SChris Mason werr = err; 373777e6bd7SChris Mason } 374777e6bd7SChris Mason wait_on_page_writeback(page); 375777e6bd7SChris Mason page_cache_release(page); 376777e6bd7SChris Mason cond_resched(); 377777e6bd7SChris Mason } 378777e6bd7SChris Mason } 3797c4452b9SChris Mason if (err) 3807c4452b9SChris Mason werr = err; 3817c4452b9SChris Mason return werr; 38279154b1bSChris Mason } 38379154b1bSChris Mason 384d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 385d0c803c4SChris Mason struct btrfs_root *root) 386d0c803c4SChris Mason { 387d0c803c4SChris Mason if (!trans || !trans->transaction) { 388d0c803c4SChris Mason struct inode *btree_inode; 389d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 390d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 391d0c803c4SChris Mason } 392d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 393d0c803c4SChris Mason &trans->transaction->dirty_pages); 394d0c803c4SChris Mason } 395d0c803c4SChris Mason 3960b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 39779154b1bSChris Mason struct btrfs_root *root) 39879154b1bSChris Mason { 39979154b1bSChris Mason int ret; 4000b86a832SChris Mason u64 old_root_bytenr; 4010b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 40279154b1bSChris Mason 4030b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 40479154b1bSChris Mason while(1) { 4050b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 4060b86a832SChris Mason if (old_root_bytenr == root->node->start) 40779154b1bSChris Mason break; 4080b86a832SChris Mason btrfs_set_root_bytenr(&root->root_item, 4090b86a832SChris Mason root->node->start); 4100b86a832SChris Mason btrfs_set_root_level(&root->root_item, 4110b86a832SChris Mason btrfs_header_level(root->node)); 41279154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 4130b86a832SChris Mason &root->root_key, 4140b86a832SChris Mason &root->root_item); 41579154b1bSChris Mason BUG_ON(ret); 4160b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 4170b86a832SChris Mason } 4180b86a832SChris Mason return 0; 4190b86a832SChris Mason } 4200b86a832SChris Mason 4210b86a832SChris Mason int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans, 4220b86a832SChris Mason struct btrfs_root *root) 4230b86a832SChris Mason { 4240b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 4250b86a832SChris Mason struct list_head *next; 4260b86a832SChris Mason 4270b86a832SChris Mason while(!list_empty(&fs_info->dirty_cowonly_roots)) { 4280b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 4290b86a832SChris Mason list_del_init(next); 4300b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 4310b86a832SChris Mason update_cowonly_root(trans, root); 43279154b1bSChris Mason } 43379154b1bSChris Mason return 0; 43479154b1bSChris Mason } 43579154b1bSChris Mason 436b48652c1SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root, struct btrfs_root *latest) 4375eda7b5eSChris Mason { 438f321e491SYan Zheng struct btrfs_dirty_root *dirty; 4395eda7b5eSChris Mason 4405eda7b5eSChris Mason dirty = kmalloc(sizeof(*dirty), GFP_NOFS); 4415eda7b5eSChris Mason if (!dirty) 4425eda7b5eSChris Mason return -ENOMEM; 4435eda7b5eSChris Mason dirty->root = root; 4445ce14bbcSChris Mason dirty->latest_root = latest; 445b48652c1SYan Zheng 446b48652c1SYan Zheng mutex_lock(&root->fs_info->trans_mutex); 447b48652c1SYan Zheng list_add(&dirty->list, &latest->fs_info->dead_roots); 448b48652c1SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 4495eda7b5eSChris Mason return 0; 4505eda7b5eSChris Mason } 4515eda7b5eSChris Mason 45280b6794dSChris Mason static noinline int add_dirty_roots(struct btrfs_trans_handle *trans, 45335b7e476SChris Mason struct radix_tree_root *radix, 45435b7e476SChris Mason struct list_head *list) 4550f7d52f4SChris Mason { 456f321e491SYan Zheng struct btrfs_dirty_root *dirty; 4570f7d52f4SChris Mason struct btrfs_root *gang[8]; 4580f7d52f4SChris Mason struct btrfs_root *root; 4590f7d52f4SChris Mason int i; 4600f7d52f4SChris Mason int ret; 46154aa1f4dSChris Mason int err = 0; 4625eda7b5eSChris Mason u32 refs; 46354aa1f4dSChris Mason 4640f7d52f4SChris Mason while(1) { 4650f7d52f4SChris Mason ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0, 4660f7d52f4SChris Mason ARRAY_SIZE(gang), 4670f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 4680f7d52f4SChris Mason if (ret == 0) 4690f7d52f4SChris Mason break; 4700f7d52f4SChris Mason for (i = 0; i < ret; i++) { 4710f7d52f4SChris Mason root = gang[i]; 4722619ba1fSChris Mason radix_tree_tag_clear(radix, 4732619ba1fSChris Mason (unsigned long)root->root_key.objectid, 4740f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 47531153d81SYan Zheng 47631153d81SYan Zheng BUG_ON(!root->ref_tree); 477017e5369SChris Mason dirty = root->dirty_root; 47831153d81SYan Zheng 479e02119d5SChris Mason btrfs_free_log(trans, root); 4801a40e23bSZheng Yan btrfs_free_reloc_root(root); 481e02119d5SChris Mason 4820f7d52f4SChris Mason if (root->commit_root == root->node) { 483db94535dSChris Mason WARN_ON(root->node->start != 484db94535dSChris Mason btrfs_root_bytenr(&root->root_item)); 48531153d81SYan Zheng 4865f39d397SChris Mason free_extent_buffer(root->commit_root); 4870f7d52f4SChris Mason root->commit_root = NULL; 4887ea394f1SYan Zheng root->dirty_root = NULL; 48931153d81SYan Zheng 490bcc63abbSYan spin_lock(&root->list_lock); 491bcc63abbSYan list_del_init(&dirty->root->dead_list); 492bcc63abbSYan spin_unlock(&root->list_lock); 493bcc63abbSYan 49431153d81SYan Zheng kfree(dirty->root); 49531153d81SYan Zheng kfree(dirty); 49658176a96SJosef Bacik 49758176a96SJosef Bacik /* make sure to update the root on disk 49858176a96SJosef Bacik * so we get any updates to the block used 49958176a96SJosef Bacik * counts 50058176a96SJosef Bacik */ 50158176a96SJosef Bacik err = btrfs_update_root(trans, 50258176a96SJosef Bacik root->fs_info->tree_root, 50358176a96SJosef Bacik &root->root_key, 50458176a96SJosef Bacik &root->root_item); 5050f7d52f4SChris Mason continue; 5060f7d52f4SChris Mason } 5079f3a7427SChris Mason 5089f3a7427SChris Mason memset(&root->root_item.drop_progress, 0, 5099f3a7427SChris Mason sizeof(struct btrfs_disk_key)); 5109f3a7427SChris Mason root->root_item.drop_level = 0; 5110f7d52f4SChris Mason root->commit_root = NULL; 5127ea394f1SYan Zheng root->dirty_root = NULL; 5130f7d52f4SChris Mason root->root_key.offset = root->fs_info->generation; 514db94535dSChris Mason btrfs_set_root_bytenr(&root->root_item, 515db94535dSChris Mason root->node->start); 516db94535dSChris Mason btrfs_set_root_level(&root->root_item, 517db94535dSChris Mason btrfs_header_level(root->node)); 5180f7d52f4SChris Mason err = btrfs_insert_root(trans, root->fs_info->tree_root, 5190f7d52f4SChris Mason &root->root_key, 5200f7d52f4SChris Mason &root->root_item); 52154aa1f4dSChris Mason if (err) 52254aa1f4dSChris Mason break; 5239f3a7427SChris Mason 5249f3a7427SChris Mason refs = btrfs_root_refs(&dirty->root->root_item); 5259f3a7427SChris Mason btrfs_set_root_refs(&dirty->root->root_item, refs - 1); 5265eda7b5eSChris Mason err = btrfs_update_root(trans, root->fs_info->tree_root, 5279f3a7427SChris Mason &dirty->root->root_key, 5289f3a7427SChris Mason &dirty->root->root_item); 5295eda7b5eSChris Mason 5305eda7b5eSChris Mason BUG_ON(err); 5319f3a7427SChris Mason if (refs == 1) { 5320f7d52f4SChris Mason list_add(&dirty->list, list); 5339f3a7427SChris Mason } else { 5349f3a7427SChris Mason WARN_ON(1); 53531153d81SYan Zheng free_extent_buffer(dirty->root->node); 5369f3a7427SChris Mason kfree(dirty->root); 5375eda7b5eSChris Mason kfree(dirty); 5380f7d52f4SChris Mason } 5390f7d52f4SChris Mason } 5409f3a7427SChris Mason } 54154aa1f4dSChris Mason return err; 5420f7d52f4SChris Mason } 5430f7d52f4SChris Mason 544e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 545e9d0b13bSChris Mason { 546e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 547e9d0b13bSChris Mason int ret; 548e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 549d3c2fdcfSChris Mason unsigned long nr; 550e9d0b13bSChris Mason 551a2135011SChris Mason smp_mb(); 552e9d0b13bSChris Mason if (root->defrag_running) 553e9d0b13bSChris Mason return 0; 554e9d0b13bSChris Mason trans = btrfs_start_transaction(root, 1); 5556b80053dSChris Mason while (1) { 556e9d0b13bSChris Mason root->defrag_running = 1; 557e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 558d3c2fdcfSChris Mason nr = trans->blocks_used; 559e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 560d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 561e9d0b13bSChris Mason cond_resched(); 562e9d0b13bSChris Mason 563e9d0b13bSChris Mason trans = btrfs_start_transaction(root, 1); 5643f157a2fSChris Mason if (root->fs_info->closing || ret != -EAGAIN) 565e9d0b13bSChris Mason break; 566e9d0b13bSChris Mason } 567e9d0b13bSChris Mason root->defrag_running = 0; 568a2135011SChris Mason smp_mb(); 569e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 570e9d0b13bSChris Mason return 0; 571e9d0b13bSChris Mason } 572e9d0b13bSChris Mason 57380b6794dSChris Mason static noinline int drop_dirty_roots(struct btrfs_root *tree_root, 57435b7e476SChris Mason struct list_head *list) 5750f7d52f4SChris Mason { 576f321e491SYan Zheng struct btrfs_dirty_root *dirty; 5770f7d52f4SChris Mason struct btrfs_trans_handle *trans; 578d3c2fdcfSChris Mason unsigned long nr; 579db94535dSChris Mason u64 num_bytes; 580db94535dSChris Mason u64 bytes_used; 581bcc63abbSYan u64 max_useless; 58254aa1f4dSChris Mason int ret = 0; 5839f3a7427SChris Mason int err; 5849f3a7427SChris Mason 5850f7d52f4SChris Mason while(!list_empty(list)) { 58658176a96SJosef Bacik struct btrfs_root *root; 58758176a96SJosef Bacik 588f321e491SYan Zheng dirty = list_entry(list->prev, struct btrfs_dirty_root, list); 5890f7d52f4SChris Mason list_del_init(&dirty->list); 5905eda7b5eSChris Mason 591db94535dSChris Mason num_bytes = btrfs_root_used(&dirty->root->root_item); 59258176a96SJosef Bacik root = dirty->latest_root; 593a2135011SChris Mason atomic_inc(&root->fs_info->throttles); 59458176a96SJosef Bacik 5959f3a7427SChris Mason while(1) { 5960f7d52f4SChris Mason trans = btrfs_start_transaction(tree_root, 1); 5975b21f2edSZheng Yan mutex_lock(&root->fs_info->drop_mutex); 5989f3a7427SChris Mason ret = btrfs_drop_snapshot(trans, dirty->root); 5999f3a7427SChris Mason if (ret != -EAGAIN) { 6009f3a7427SChris Mason break; 6019f3a7427SChris Mason } 6025b21f2edSZheng Yan mutex_unlock(&root->fs_info->drop_mutex); 60358176a96SJosef Bacik 6049f3a7427SChris Mason err = btrfs_update_root(trans, 6059f3a7427SChris Mason tree_root, 6069f3a7427SChris Mason &dirty->root->root_key, 6079f3a7427SChris Mason &dirty->root->root_item); 6089f3a7427SChris Mason if (err) 6099f3a7427SChris Mason ret = err; 610d3c2fdcfSChris Mason nr = trans->blocks_used; 611017e5369SChris Mason ret = btrfs_end_transaction(trans, tree_root); 6120f7d52f4SChris Mason BUG_ON(ret); 613a2135011SChris Mason 614d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 6154dc11904SChris Mason cond_resched(); 6169f3a7427SChris Mason } 6179f3a7427SChris Mason BUG_ON(ret); 618a2135011SChris Mason atomic_dec(&root->fs_info->throttles); 619017e5369SChris Mason wake_up(&root->fs_info->transaction_throttle); 62058176a96SJosef Bacik 621a2135011SChris Mason mutex_lock(&root->fs_info->alloc_mutex); 622db94535dSChris Mason num_bytes -= btrfs_root_used(&dirty->root->root_item); 623db94535dSChris Mason bytes_used = btrfs_root_used(&root->root_item); 624db94535dSChris Mason if (num_bytes) { 625e02119d5SChris Mason btrfs_record_root_in_trans(root); 6265f39d397SChris Mason btrfs_set_root_used(&root->root_item, 627db94535dSChris Mason bytes_used - num_bytes); 62858176a96SJosef Bacik } 629a2135011SChris Mason mutex_unlock(&root->fs_info->alloc_mutex); 630a2135011SChris Mason 6319f3a7427SChris Mason ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key); 63258176a96SJosef Bacik if (ret) { 63358176a96SJosef Bacik BUG(); 63454aa1f4dSChris Mason break; 63558176a96SJosef Bacik } 636a2135011SChris Mason mutex_unlock(&root->fs_info->drop_mutex); 637a2135011SChris Mason 638bcc63abbSYan spin_lock(&root->list_lock); 639bcc63abbSYan list_del_init(&dirty->root->dead_list); 640bcc63abbSYan if (!list_empty(&root->dead_list)) { 641bcc63abbSYan struct btrfs_root *oldest; 642bcc63abbSYan oldest = list_entry(root->dead_list.prev, 643bcc63abbSYan struct btrfs_root, dead_list); 644bcc63abbSYan max_useless = oldest->root_key.offset - 1; 645bcc63abbSYan } else { 646bcc63abbSYan max_useless = root->root_key.offset - 1; 647bcc63abbSYan } 648bcc63abbSYan spin_unlock(&root->list_lock); 649bcc63abbSYan 650d3c2fdcfSChris Mason nr = trans->blocks_used; 6510f7d52f4SChris Mason ret = btrfs_end_transaction(trans, tree_root); 6520f7d52f4SChris Mason BUG_ON(ret); 6535eda7b5eSChris Mason 654e4657689SZheng Yan ret = btrfs_remove_leaf_refs(root, max_useless, 0); 655bcc63abbSYan BUG_ON(ret); 656bcc63abbSYan 657f510cfecSChris Mason free_extent_buffer(dirty->root->node); 6585eda7b5eSChris Mason kfree(dirty->root); 6590f7d52f4SChris Mason kfree(dirty); 660d3c2fdcfSChris Mason 661d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 6624dc11904SChris Mason cond_resched(); 6630f7d52f4SChris Mason } 66454aa1f4dSChris Mason return ret; 6650f7d52f4SChris Mason } 6660f7d52f4SChris Mason 66780b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 6683063d29fSChris Mason struct btrfs_fs_info *fs_info, 6693063d29fSChris Mason struct btrfs_pending_snapshot *pending) 6703063d29fSChris Mason { 6713063d29fSChris Mason struct btrfs_key key; 67280b6794dSChris Mason struct btrfs_root_item *new_root_item; 6733063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 6743063d29fSChris Mason struct btrfs_root *root = pending->root; 6753063d29fSChris Mason struct extent_buffer *tmp; 676925baeddSChris Mason struct extent_buffer *old; 6773063d29fSChris Mason int ret; 6783b96362cSSven Wegener int namelen; 6793063d29fSChris Mason u64 objectid; 6803063d29fSChris Mason 68180b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 68280b6794dSChris Mason if (!new_root_item) { 68380b6794dSChris Mason ret = -ENOMEM; 68480b6794dSChris Mason goto fail; 68580b6794dSChris Mason } 6863063d29fSChris Mason ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid); 6873063d29fSChris Mason if (ret) 6883063d29fSChris Mason goto fail; 6893063d29fSChris Mason 69080b6794dSChris Mason memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 6913063d29fSChris Mason 6923063d29fSChris Mason key.objectid = objectid; 6935b21f2edSZheng Yan key.offset = trans->transid; 6943063d29fSChris Mason btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); 6953063d29fSChris Mason 696925baeddSChris Mason old = btrfs_lock_root_node(root); 69765b51a00SChris Mason btrfs_cow_block(trans, root, old, NULL, 0, &old, 0); 6983063d29fSChris Mason 699925baeddSChris Mason btrfs_copy_root(trans, root, old, &tmp, objectid); 700925baeddSChris Mason btrfs_tree_unlock(old); 701925baeddSChris Mason free_extent_buffer(old); 7023063d29fSChris Mason 70380b6794dSChris Mason btrfs_set_root_bytenr(new_root_item, tmp->start); 70480b6794dSChris Mason btrfs_set_root_level(new_root_item, btrfs_header_level(tmp)); 7053063d29fSChris Mason ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key, 70680b6794dSChris Mason new_root_item); 707925baeddSChris Mason btrfs_tree_unlock(tmp); 7083063d29fSChris Mason free_extent_buffer(tmp); 7093063d29fSChris Mason if (ret) 7103063d29fSChris Mason goto fail; 7113063d29fSChris Mason 7123063d29fSChris Mason /* 7133063d29fSChris Mason * insert the directory item 7143063d29fSChris Mason */ 7153063d29fSChris Mason key.offset = (u64)-1; 7163b96362cSSven Wegener namelen = strlen(pending->name); 7173063d29fSChris Mason ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root, 7183b96362cSSven Wegener pending->name, namelen, 7193063d29fSChris Mason root->fs_info->sb->s_root->d_inode->i_ino, 720aec7477bSJosef Bacik &key, BTRFS_FT_DIR, 0); 7213063d29fSChris Mason 7223063d29fSChris Mason if (ret) 7233063d29fSChris Mason goto fail; 7243063d29fSChris Mason 7253063d29fSChris Mason ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root, 7263063d29fSChris Mason pending->name, strlen(pending->name), objectid, 727aec7477bSJosef Bacik root->fs_info->sb->s_root->d_inode->i_ino, 0); 7283b96362cSSven Wegener 7293b96362cSSven Wegener /* Invalidate existing dcache entry for new snapshot. */ 7303b96362cSSven Wegener btrfs_invalidate_dcache_root(root, pending->name, namelen); 7313b96362cSSven Wegener 7323063d29fSChris Mason fail: 73380b6794dSChris Mason kfree(new_root_item); 7343063d29fSChris Mason return ret; 7353063d29fSChris Mason } 7363063d29fSChris Mason 73780b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 7383063d29fSChris Mason struct btrfs_fs_info *fs_info) 7393063d29fSChris Mason { 7403063d29fSChris Mason struct btrfs_pending_snapshot *pending; 7413063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 7423063d29fSChris Mason int ret; 7433063d29fSChris Mason 7443063d29fSChris Mason while(!list_empty(head)) { 7453063d29fSChris Mason pending = list_entry(head->next, 7463063d29fSChris Mason struct btrfs_pending_snapshot, list); 7473063d29fSChris Mason ret = create_pending_snapshot(trans, fs_info, pending); 7483063d29fSChris Mason BUG_ON(ret); 7493063d29fSChris Mason list_del(&pending->list); 7503063d29fSChris Mason kfree(pending->name); 7513063d29fSChris Mason kfree(pending); 7523063d29fSChris Mason } 753dc17ff8fSChris Mason return 0; 754dc17ff8fSChris Mason } 755dc17ff8fSChris Mason 75679154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 75779154b1bSChris Mason struct btrfs_root *root) 75879154b1bSChris Mason { 75915ee9bc7SJosef Bacik unsigned long joined = 0; 76015ee9bc7SJosef Bacik unsigned long timeout = 1; 76179154b1bSChris Mason struct btrfs_transaction *cur_trans; 7628fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 7630b86a832SChris Mason struct btrfs_root *chunk_root = root->fs_info->chunk_root; 7640f7d52f4SChris Mason struct list_head dirty_fs_roots; 765d1310b2eSChris Mason struct extent_io_tree *pinned_copy; 76679154b1bSChris Mason DEFINE_WAIT(wait); 76715ee9bc7SJosef Bacik int ret; 76879154b1bSChris Mason 7690f7d52f4SChris Mason INIT_LIST_HEAD(&dirty_fs_roots); 77079154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 77179154b1bSChris Mason if (trans->transaction->in_commit) { 77279154b1bSChris Mason cur_trans = trans->transaction; 77379154b1bSChris Mason trans->transaction->use_count++; 774ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 77579154b1bSChris Mason btrfs_end_transaction(trans, root); 776ccd467d6SChris Mason 77779154b1bSChris Mason ret = wait_for_commit(root, cur_trans); 77879154b1bSChris Mason BUG_ON(ret); 77915ee9bc7SJosef Bacik 78015ee9bc7SJosef Bacik mutex_lock(&root->fs_info->trans_mutex); 78179154b1bSChris Mason put_transaction(cur_trans); 78215ee9bc7SJosef Bacik mutex_unlock(&root->fs_info->trans_mutex); 78315ee9bc7SJosef Bacik 78479154b1bSChris Mason return 0; 78579154b1bSChris Mason } 7864313b399SChris Mason 7874313b399SChris Mason pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS); 7884313b399SChris Mason if (!pinned_copy) 7894313b399SChris Mason return -ENOMEM; 7904313b399SChris Mason 791d1310b2eSChris Mason extent_io_tree_init(pinned_copy, 7924313b399SChris Mason root->fs_info->btree_inode->i_mapping, GFP_NOFS); 7934313b399SChris Mason 7942c90e5d6SChris Mason trans->transaction->in_commit = 1; 795f9295749SChris Mason trans->transaction->blocked = 1; 796ccd467d6SChris Mason cur_trans = trans->transaction; 797ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 798ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 799ccd467d6SChris Mason struct btrfs_transaction, list); 800ccd467d6SChris Mason if (!prev_trans->commit_done) { 801ccd467d6SChris Mason prev_trans->use_count++; 802ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 803ccd467d6SChris Mason 804ccd467d6SChris Mason wait_for_commit(root, prev_trans); 805ccd467d6SChris Mason 806ccd467d6SChris Mason mutex_lock(&root->fs_info->trans_mutex); 80715ee9bc7SJosef Bacik put_transaction(prev_trans); 808ccd467d6SChris Mason } 809ccd467d6SChris Mason } 81015ee9bc7SJosef Bacik 81115ee9bc7SJosef Bacik do { 8127ea394f1SYan Zheng int snap_pending = 0; 81315ee9bc7SJosef Bacik joined = cur_trans->num_joined; 8147ea394f1SYan Zheng if (!list_empty(&trans->transaction->pending_snapshots)) 8157ea394f1SYan Zheng snap_pending = 1; 8167ea394f1SYan Zheng 8172c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 81815ee9bc7SJosef Bacik prepare_to_wait(&cur_trans->writer_wait, &wait, 81979154b1bSChris Mason TASK_UNINTERRUPTIBLE); 82015ee9bc7SJosef Bacik 82115ee9bc7SJosef Bacik if (cur_trans->num_writers > 1) 82215ee9bc7SJosef Bacik timeout = MAX_SCHEDULE_TIMEOUT; 82315ee9bc7SJosef Bacik else 82415ee9bc7SJosef Bacik timeout = 1; 82515ee9bc7SJosef Bacik 82679154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 82715ee9bc7SJosef Bacik 8287ea394f1SYan Zheng if (snap_pending) { 8297ea394f1SYan Zheng ret = btrfs_wait_ordered_extents(root, 1); 8307ea394f1SYan Zheng BUG_ON(ret); 8317ea394f1SYan Zheng } 8327ea394f1SYan Zheng 83315ee9bc7SJosef Bacik schedule_timeout(timeout); 83415ee9bc7SJosef Bacik 83579154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 83615ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 83715ee9bc7SJosef Bacik } while (cur_trans->num_writers > 1 || 83815ee9bc7SJosef Bacik (cur_trans->num_joined != joined)); 83915ee9bc7SJosef Bacik 8403063d29fSChris Mason ret = create_pending_snapshots(trans, root->fs_info); 8413063d29fSChris Mason BUG_ON(ret); 8423063d29fSChris Mason 8432c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 844dc17ff8fSChris Mason 845e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 846e02119d5SChris Mason * various roots consistent with each other. Every pointer 847e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 848e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 849e02119d5SChris Mason * the tree logging code from jumping in and changing any 850e02119d5SChris Mason * of the trees. 851e02119d5SChris Mason * 852e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 853e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 854e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 855e02119d5SChris Mason * from now until after the super is written, we avoid races 856e02119d5SChris Mason * with the tree-log code. 857e02119d5SChris Mason */ 858e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 8591a40e23bSZheng Yan /* 8601a40e23bSZheng Yan * keep tree reloc code from adding new reloc trees 8611a40e23bSZheng Yan */ 8621a40e23bSZheng Yan mutex_lock(&root->fs_info->tree_reloc_mutex); 8631a40e23bSZheng Yan 864e02119d5SChris Mason 86554aa1f4dSChris Mason ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix, 86654aa1f4dSChris Mason &dirty_fs_roots); 86754aa1f4dSChris Mason BUG_ON(ret); 86854aa1f4dSChris Mason 869e02119d5SChris Mason /* add_dirty_roots gets rid of all the tree log roots, it is now 870e02119d5SChris Mason * safe to free the root of tree log roots 871e02119d5SChris Mason */ 872e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 873e02119d5SChris Mason 8741a40e23bSZheng Yan btrfs_free_reloc_mappings(root); 8751a40e23bSZheng Yan 87679154b1bSChris Mason ret = btrfs_commit_tree_roots(trans, root); 87779154b1bSChris Mason BUG_ON(ret); 87854aa1f4dSChris Mason 87978fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 880cee36a03SChris Mason spin_lock(&root->fs_info->new_trans_lock); 88178fae27eSChris Mason root->fs_info->running_transaction = NULL; 882cee36a03SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 8834b52dff6SChris Mason btrfs_set_super_generation(&root->fs_info->super_copy, 8844b52dff6SChris Mason cur_trans->transid); 8854b52dff6SChris Mason btrfs_set_super_root(&root->fs_info->super_copy, 886db94535dSChris Mason root->fs_info->tree_root->node->start); 887db94535dSChris Mason btrfs_set_super_root_level(&root->fs_info->super_copy, 888db94535dSChris Mason btrfs_header_level(root->fs_info->tree_root->node)); 8895f39d397SChris Mason 8900b86a832SChris Mason btrfs_set_super_chunk_root(&root->fs_info->super_copy, 8910b86a832SChris Mason chunk_root->node->start); 8920b86a832SChris Mason btrfs_set_super_chunk_root_level(&root->fs_info->super_copy, 8930b86a832SChris Mason btrfs_header_level(chunk_root->node)); 894e02119d5SChris Mason 895e02119d5SChris Mason if (!root->fs_info->log_root_recovering) { 896e02119d5SChris Mason btrfs_set_super_log_root(&root->fs_info->super_copy, 0); 897e02119d5SChris Mason btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0); 898e02119d5SChris Mason } 899e02119d5SChris Mason 900a061fc8dSChris Mason memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy, 9014b52dff6SChris Mason sizeof(root->fs_info->super_copy)); 902ccd467d6SChris Mason 9034313b399SChris Mason btrfs_copy_pinned(root, pinned_copy); 904ccd467d6SChris Mason 905f9295749SChris Mason trans->transaction->blocked = 0; 906e6dcd2dcSChris Mason wake_up(&root->fs_info->transaction_throttle); 907f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 908e6dcd2dcSChris Mason 90978fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 91079154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 91179154b1bSChris Mason BUG_ON(ret); 91279154b1bSChris Mason write_ctree_super(trans, root); 9134313b399SChris Mason 914e02119d5SChris Mason /* 915e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 916e02119d5SChris Mason * to go about their business 917e02119d5SChris Mason */ 918e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 919e02119d5SChris Mason 9204313b399SChris Mason btrfs_finish_extent_commit(trans, root, pinned_copy); 9214313b399SChris Mason kfree(pinned_copy); 9224313b399SChris Mason 9231a40e23bSZheng Yan btrfs_drop_dead_reloc_roots(root); 9241a40e23bSZheng Yan mutex_unlock(&root->fs_info->tree_reloc_mutex); 9251a40e23bSZheng Yan 9261a40e23bSZheng Yan mutex_lock(&root->fs_info->trans_mutex); 9271a40e23bSZheng Yan 9282c90e5d6SChris Mason cur_trans->commit_done = 1; 92915ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 9302c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 93179154b1bSChris Mason put_transaction(cur_trans); 93278fae27eSChris Mason put_transaction(cur_trans); 93358176a96SJosef Bacik 934bcc63abbSYan list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots); 935facda1e7SChris Mason if (root->fs_info->closing) 936facda1e7SChris Mason list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots); 93758176a96SJosef Bacik 93878fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 9392c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 94079154b1bSChris Mason 941facda1e7SChris Mason if (root->fs_info->closing) { 9420f7d52f4SChris Mason drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots); 943facda1e7SChris Mason } 94479154b1bSChris Mason return ret; 94579154b1bSChris Mason } 94679154b1bSChris Mason 947e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 948e9d0b13bSChris Mason { 949e9d0b13bSChris Mason struct list_head dirty_roots; 950e9d0b13bSChris Mason INIT_LIST_HEAD(&dirty_roots); 951a74a4b97SChris Mason again: 952e9d0b13bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 953e9d0b13bSChris Mason list_splice_init(&root->fs_info->dead_roots, &dirty_roots); 954e9d0b13bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 955e9d0b13bSChris Mason 956e9d0b13bSChris Mason if (!list_empty(&dirty_roots)) { 957e9d0b13bSChris Mason drop_dirty_roots(root, &dirty_roots); 958a74a4b97SChris Mason goto again; 959e9d0b13bSChris Mason } 960e9d0b13bSChris Mason return 0; 961e9d0b13bSChris Mason } 962