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" 2879154b1bSChris Mason 2978fae27eSChris Mason static int total_trans = 0; 302c90e5d6SChris Mason extern struct kmem_cache *btrfs_trans_handle_cachep; 312c90e5d6SChris Mason extern struct kmem_cache *btrfs_transaction_cachep; 322c90e5d6SChris Mason 330f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 340f7d52f4SChris Mason 3580b6794dSChris Mason static noinline void put_transaction(struct btrfs_transaction *transaction) 3679154b1bSChris Mason { 372c90e5d6SChris Mason WARN_ON(transaction->use_count == 0); 3879154b1bSChris Mason transaction->use_count--; 3978fae27eSChris Mason if (transaction->use_count == 0) { 4078fae27eSChris Mason WARN_ON(total_trans == 0); 4178fae27eSChris Mason total_trans--; 428fd17795SChris Mason list_del_init(&transaction->list); 432c90e5d6SChris Mason memset(transaction, 0, sizeof(*transaction)); 442c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 4579154b1bSChris Mason } 4678fae27eSChris Mason } 4779154b1bSChris Mason 4880b6794dSChris Mason static noinline int join_transaction(struct btrfs_root *root) 4979154b1bSChris Mason { 5079154b1bSChris Mason struct btrfs_transaction *cur_trans; 5179154b1bSChris Mason cur_trans = root->fs_info->running_transaction; 5279154b1bSChris Mason if (!cur_trans) { 532c90e5d6SChris Mason cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, 542c90e5d6SChris Mason GFP_NOFS); 5578fae27eSChris Mason total_trans++; 5679154b1bSChris Mason BUG_ON(!cur_trans); 570f7d52f4SChris Mason root->fs_info->generation++; 58e18e4809SChris Mason root->fs_info->last_alloc = 0; 594529ba49SChris Mason root->fs_info->last_data_alloc = 0; 6015ee9bc7SJosef Bacik cur_trans->num_writers = 1; 6115ee9bc7SJosef Bacik cur_trans->num_joined = 0; 620f7d52f4SChris Mason cur_trans->transid = root->fs_info->generation; 6379154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 6479154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 6579154b1bSChris Mason cur_trans->in_commit = 0; 66f9295749SChris Mason cur_trans->blocked = 0; 67d5719762SChris Mason cur_trans->use_count = 1; 6879154b1bSChris Mason cur_trans->commit_done = 0; 6908607c1bSChris Mason cur_trans->start_time = get_seconds(); 703063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 718fd17795SChris Mason list_add_tail(&cur_trans->list, &root->fs_info->trans_list); 72d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 735f39d397SChris Mason root->fs_info->btree_inode->i_mapping, 745f39d397SChris Mason GFP_NOFS); 7548ec2cf8SChris Mason spin_lock(&root->fs_info->new_trans_lock); 7648ec2cf8SChris Mason root->fs_info->running_transaction = cur_trans; 7748ec2cf8SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 7815ee9bc7SJosef Bacik } else { 7979154b1bSChris Mason cur_trans->num_writers++; 8015ee9bc7SJosef Bacik cur_trans->num_joined++; 8115ee9bc7SJosef Bacik } 8215ee9bc7SJosef Bacik 8379154b1bSChris Mason return 0; 8479154b1bSChris Mason } 8579154b1bSChris Mason 8680b6794dSChris Mason static noinline int record_root_in_trans(struct btrfs_root *root) 876702ed49SChris Mason { 88f321e491SYan Zheng struct btrfs_dirty_root *dirty; 896702ed49SChris Mason u64 running_trans_id = root->fs_info->running_transaction->transid; 906702ed49SChris Mason if (root->ref_cows && root->last_trans < running_trans_id) { 916702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 926702ed49SChris Mason if (root->root_item.refs != 0) { 936702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 946702ed49SChris Mason (unsigned long)root->root_key.objectid, 956702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 9631153d81SYan Zheng 9731153d81SYan Zheng dirty = kmalloc(sizeof(*dirty), GFP_NOFS); 9831153d81SYan Zheng BUG_ON(!dirty); 9931153d81SYan Zheng dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS); 10031153d81SYan Zheng BUG_ON(!dirty->root); 10131153d81SYan Zheng dirty->latest_root = root; 10231153d81SYan Zheng INIT_LIST_HEAD(&dirty->list); 10331153d81SYan Zheng 104925baeddSChris Mason root->commit_root = btrfs_root_node(root); 10531153d81SYan Zheng 10631153d81SYan Zheng memcpy(dirty->root, root, sizeof(*root)); 10731153d81SYan Zheng spin_lock_init(&dirty->root->node_lock); 108bcc63abbSYan spin_lock_init(&dirty->root->list_lock); 10931153d81SYan Zheng mutex_init(&dirty->root->objectid_mutex); 110bcc63abbSYan INIT_LIST_HEAD(&dirty->root->dead_list); 11131153d81SYan Zheng dirty->root->node = root->commit_root; 11231153d81SYan Zheng dirty->root->commit_root = NULL; 113bcc63abbSYan 114bcc63abbSYan spin_lock(&root->list_lock); 115bcc63abbSYan list_add(&dirty->root->dead_list, &root->dead_list); 116bcc63abbSYan spin_unlock(&root->list_lock); 117bcc63abbSYan 118bcc63abbSYan root->dirty_root = dirty; 1196702ed49SChris Mason } else { 1206702ed49SChris Mason WARN_ON(1); 1216702ed49SChris Mason } 1226702ed49SChris Mason root->last_trans = running_trans_id; 1236702ed49SChris Mason } 1246702ed49SChris Mason return 0; 1256702ed49SChris Mason } 1266702ed49SChris Mason 12737d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 12879154b1bSChris Mason { 129f9295749SChris Mason struct btrfs_transaction *cur_trans; 13079154b1bSChris Mason 131f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 13237d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 133f9295749SChris Mason DEFINE_WAIT(wait); 134f9295749SChris Mason cur_trans->use_count++; 135f9295749SChris Mason while(1) { 136f9295749SChris Mason prepare_to_wait(&root->fs_info->transaction_wait, &wait, 137f9295749SChris Mason TASK_UNINTERRUPTIBLE); 138f9295749SChris Mason if (cur_trans->blocked) { 139f9295749SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 140f9295749SChris Mason schedule(); 141f9295749SChris Mason mutex_lock(&root->fs_info->trans_mutex); 142f9295749SChris Mason finish_wait(&root->fs_info->transaction_wait, 143f9295749SChris Mason &wait); 144f9295749SChris Mason } else { 145f9295749SChris Mason finish_wait(&root->fs_info->transaction_wait, 146f9295749SChris Mason &wait); 147f9295749SChris Mason break; 148f9295749SChris Mason } 149f9295749SChris Mason } 150f9295749SChris Mason put_transaction(cur_trans); 151f9295749SChris Mason } 15237d1aeeeSChris Mason } 15337d1aeeeSChris Mason 15437d1aeeeSChris Mason struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 1559ca9ee09SSage Weil int num_blocks, int wait) 15637d1aeeeSChris Mason { 15737d1aeeeSChris Mason struct btrfs_trans_handle *h = 15837d1aeeeSChris Mason kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 15937d1aeeeSChris Mason int ret; 16037d1aeeeSChris Mason 16137d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 1629ca9ee09SSage Weil if ((wait == 1 && !root->fs_info->open_ioctl_trans) || wait == 2) 16337d1aeeeSChris Mason wait_current_trans(root); 16479154b1bSChris Mason ret = join_transaction(root); 16579154b1bSChris Mason BUG_ON(ret); 1660f7d52f4SChris Mason 1676702ed49SChris Mason record_root_in_trans(root); 1686702ed49SChris Mason h->transid = root->fs_info->running_transaction->transid; 16979154b1bSChris Mason h->transaction = root->fs_info->running_transaction; 17079154b1bSChris Mason h->blocks_reserved = num_blocks; 17179154b1bSChris Mason h->blocks_used = 0; 17231f3c99bSChris Mason h->block_group = NULL; 17326b8003fSChris Mason h->alloc_exclude_nr = 0; 17426b8003fSChris Mason h->alloc_exclude_start = 0; 17579154b1bSChris Mason root->fs_info->running_transaction->use_count++; 17679154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 17779154b1bSChris Mason return h; 17879154b1bSChris Mason } 17979154b1bSChris Mason 180f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 181f9295749SChris Mason int num_blocks) 182f9295749SChris Mason { 1839ca9ee09SSage Weil return start_transaction(root, num_blocks, 1); 184f9295749SChris Mason } 185f9295749SChris Mason struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root, 186f9295749SChris Mason int num_blocks) 187f9295749SChris Mason { 1889ca9ee09SSage Weil return start_transaction(root, num_blocks, 0); 189f9295749SChris Mason } 190f9295749SChris Mason 1919ca9ee09SSage Weil struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r, 1929ca9ee09SSage Weil int num_blocks) 1939ca9ee09SSage Weil { 1949ca9ee09SSage Weil return start_transaction(r, num_blocks, 2); 1959ca9ee09SSage Weil } 1969ca9ee09SSage Weil 1979ca9ee09SSage Weil 19889ce8a63SChris Mason static noinline int wait_for_commit(struct btrfs_root *root, 19989ce8a63SChris Mason struct btrfs_transaction *commit) 20089ce8a63SChris Mason { 20189ce8a63SChris Mason DEFINE_WAIT(wait); 20289ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 20389ce8a63SChris Mason while(!commit->commit_done) { 20489ce8a63SChris Mason prepare_to_wait(&commit->commit_wait, &wait, 20589ce8a63SChris Mason TASK_UNINTERRUPTIBLE); 20689ce8a63SChris Mason if (commit->commit_done) 20789ce8a63SChris Mason break; 20889ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 20989ce8a63SChris Mason schedule(); 21089ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 21189ce8a63SChris Mason } 21289ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 21389ce8a63SChris Mason finish_wait(&commit->commit_wait, &wait); 21489ce8a63SChris Mason return 0; 21589ce8a63SChris Mason } 21689ce8a63SChris Mason 21737d1aeeeSChris Mason static void throttle_on_drops(struct btrfs_root *root) 218ab78c84dSChris Mason { 219ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 2202dd3e67bSChris Mason int harder_count = 0; 221ab78c84dSChris Mason 2222dd3e67bSChris Mason harder: 223ab78c84dSChris Mason if (atomic_read(&info->throttles)) { 224ab78c84dSChris Mason DEFINE_WAIT(wait); 225ab78c84dSChris Mason int thr; 226ab78c84dSChris Mason thr = atomic_read(&info->throttle_gen); 227ab78c84dSChris Mason 228ab78c84dSChris Mason do { 229ab78c84dSChris Mason prepare_to_wait(&info->transaction_throttle, 230ab78c84dSChris Mason &wait, TASK_UNINTERRUPTIBLE); 231ab78c84dSChris Mason if (!atomic_read(&info->throttles)) { 232ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 233ab78c84dSChris Mason break; 234ab78c84dSChris Mason } 235ab78c84dSChris Mason schedule(); 236ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 237ab78c84dSChris Mason } while (thr == atomic_read(&info->throttle_gen)); 2382dd3e67bSChris Mason harder_count++; 2392dd3e67bSChris Mason 2402dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 && 2412dd3e67bSChris Mason harder_count < 2) 2422dd3e67bSChris Mason goto harder; 2432dd3e67bSChris Mason 2442dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 && 2452dd3e67bSChris Mason harder_count < 10) 2462dd3e67bSChris Mason goto harder; 2472dd3e67bSChris Mason 2482dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 && 2492dd3e67bSChris Mason harder_count < 20) 2502dd3e67bSChris Mason goto harder; 251ab78c84dSChris Mason } 252ab78c84dSChris Mason } 253ab78c84dSChris Mason 25437d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 25537d1aeeeSChris Mason { 25637d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 2579ca9ee09SSage Weil if (!root->fs_info->open_ioctl_trans) 25837d1aeeeSChris Mason wait_current_trans(root); 25937d1aeeeSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 26037d1aeeeSChris Mason 26137d1aeeeSChris Mason throttle_on_drops(root); 26237d1aeeeSChris Mason } 26337d1aeeeSChris Mason 26489ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 26589ce8a63SChris Mason struct btrfs_root *root, int throttle) 26679154b1bSChris Mason { 26779154b1bSChris Mason struct btrfs_transaction *cur_trans; 268ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 269d6e4a428SChris Mason 270ab78c84dSChris Mason mutex_lock(&info->trans_mutex); 271ab78c84dSChris Mason cur_trans = info->running_transaction; 272ccd467d6SChris Mason WARN_ON(cur_trans != trans->transaction); 273d5719762SChris Mason WARN_ON(cur_trans->num_writers < 1); 274ccd467d6SChris Mason cur_trans->num_writers--; 27589ce8a63SChris Mason 27679154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 27779154b1bSChris Mason wake_up(&cur_trans->writer_wait); 27879154b1bSChris Mason put_transaction(cur_trans); 279ab78c84dSChris Mason mutex_unlock(&info->trans_mutex); 280d6025579SChris Mason memset(trans, 0, sizeof(*trans)); 2812c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 282ab78c84dSChris Mason 283ab78c84dSChris Mason if (throttle) 28437d1aeeeSChris Mason throttle_on_drops(root); 285ab78c84dSChris Mason 28679154b1bSChris Mason return 0; 28779154b1bSChris Mason } 28879154b1bSChris Mason 28989ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 29089ce8a63SChris Mason struct btrfs_root *root) 29189ce8a63SChris Mason { 29289ce8a63SChris Mason return __btrfs_end_transaction(trans, root, 0); 29389ce8a63SChris Mason } 29489ce8a63SChris Mason 29589ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 29689ce8a63SChris Mason struct btrfs_root *root) 29789ce8a63SChris Mason { 29889ce8a63SChris Mason return __btrfs_end_transaction(trans, root, 1); 29989ce8a63SChris Mason } 30089ce8a63SChris Mason 30179154b1bSChris Mason 30279154b1bSChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 30379154b1bSChris Mason struct btrfs_root *root) 30479154b1bSChris Mason { 3057c4452b9SChris Mason int ret; 3067c4452b9SChris Mason int err; 3077c4452b9SChris Mason int werr = 0; 308d1310b2eSChris Mason struct extent_io_tree *dirty_pages; 3097c4452b9SChris Mason struct page *page; 3107c4452b9SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 3115f39d397SChris Mason u64 start; 3125f39d397SChris Mason u64 end; 3135f39d397SChris Mason unsigned long index; 3147c4452b9SChris Mason 3157c4452b9SChris Mason if (!trans || !trans->transaction) { 3167c4452b9SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 3177c4452b9SChris Mason } 3187c4452b9SChris Mason dirty_pages = &trans->transaction->dirty_pages; 3197c4452b9SChris Mason while(1) { 3205f39d397SChris Mason ret = find_first_extent_bit(dirty_pages, 0, &start, &end, 3215f39d397SChris Mason EXTENT_DIRTY); 3225f39d397SChris Mason if (ret) 3237c4452b9SChris Mason break; 3245f39d397SChris Mason clear_extent_dirty(dirty_pages, start, end, GFP_NOFS); 3255f39d397SChris Mason while(start <= end) { 3265f39d397SChris Mason index = start >> PAGE_CACHE_SHIFT; 32735ebb934SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 3285f39d397SChris Mason page = find_lock_page(btree_inode->i_mapping, index); 3297c4452b9SChris Mason if (!page) 3307c4452b9SChris Mason continue; 3316702ed49SChris Mason if (PageWriteback(page)) { 3326702ed49SChris Mason if (PageDirty(page)) 3336702ed49SChris Mason wait_on_page_writeback(page); 3346702ed49SChris Mason else { 3356702ed49SChris Mason unlock_page(page); 3366702ed49SChris Mason page_cache_release(page); 3376702ed49SChris Mason continue; 3386702ed49SChris Mason } 3396702ed49SChris Mason } 3407c4452b9SChris Mason err = write_one_page(page, 0); 3417c4452b9SChris Mason if (err) 3427c4452b9SChris Mason werr = err; 3437c4452b9SChris Mason page_cache_release(page); 3447c4452b9SChris Mason } 3457c4452b9SChris Mason } 3467c4452b9SChris Mason err = filemap_fdatawait(btree_inode->i_mapping); 3477c4452b9SChris Mason if (err) 3487c4452b9SChris Mason werr = err; 3497c4452b9SChris Mason return werr; 35079154b1bSChris Mason } 35179154b1bSChris Mason 3520b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 35379154b1bSChris Mason struct btrfs_root *root) 35479154b1bSChris Mason { 35579154b1bSChris Mason int ret; 3560b86a832SChris Mason u64 old_root_bytenr; 3570b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 35879154b1bSChris Mason 3590b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 36079154b1bSChris Mason while(1) { 3610b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 3620b86a832SChris Mason if (old_root_bytenr == root->node->start) 36379154b1bSChris Mason break; 3640b86a832SChris Mason btrfs_set_root_bytenr(&root->root_item, 3650b86a832SChris Mason root->node->start); 3660b86a832SChris Mason btrfs_set_root_level(&root->root_item, 3670b86a832SChris Mason btrfs_header_level(root->node)); 36879154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 3690b86a832SChris Mason &root->root_key, 3700b86a832SChris Mason &root->root_item); 37179154b1bSChris Mason BUG_ON(ret); 3720b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 3730b86a832SChris Mason } 3740b86a832SChris Mason return 0; 3750b86a832SChris Mason } 3760b86a832SChris Mason 3770b86a832SChris Mason int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans, 3780b86a832SChris Mason struct btrfs_root *root) 3790b86a832SChris Mason { 3800b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 3810b86a832SChris Mason struct list_head *next; 3820b86a832SChris Mason 3830b86a832SChris Mason while(!list_empty(&fs_info->dirty_cowonly_roots)) { 3840b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 3850b86a832SChris Mason list_del_init(next); 3860b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 3870b86a832SChris Mason update_cowonly_root(trans, root); 38879154b1bSChris Mason } 38979154b1bSChris Mason return 0; 39079154b1bSChris Mason } 39179154b1bSChris Mason 392b48652c1SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root, struct btrfs_root *latest) 3935eda7b5eSChris Mason { 394f321e491SYan Zheng struct btrfs_dirty_root *dirty; 3955eda7b5eSChris Mason 3965eda7b5eSChris Mason dirty = kmalloc(sizeof(*dirty), GFP_NOFS); 3975eda7b5eSChris Mason if (!dirty) 3985eda7b5eSChris Mason return -ENOMEM; 3995eda7b5eSChris Mason dirty->root = root; 4005ce14bbcSChris Mason dirty->latest_root = latest; 401b48652c1SYan Zheng 402b48652c1SYan Zheng mutex_lock(&root->fs_info->trans_mutex); 403b48652c1SYan Zheng list_add(&dirty->list, &latest->fs_info->dead_roots); 404b48652c1SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 4055eda7b5eSChris Mason return 0; 4065eda7b5eSChris Mason } 4075eda7b5eSChris Mason 40880b6794dSChris Mason static noinline int add_dirty_roots(struct btrfs_trans_handle *trans, 40935b7e476SChris Mason struct radix_tree_root *radix, 41035b7e476SChris Mason struct list_head *list) 4110f7d52f4SChris Mason { 412f321e491SYan Zheng struct btrfs_dirty_root *dirty; 4130f7d52f4SChris Mason struct btrfs_root *gang[8]; 4140f7d52f4SChris Mason struct btrfs_root *root; 4150f7d52f4SChris Mason int i; 4160f7d52f4SChris Mason int ret; 41754aa1f4dSChris Mason int err = 0; 4185eda7b5eSChris Mason u32 refs; 41954aa1f4dSChris Mason 4200f7d52f4SChris Mason while(1) { 4210f7d52f4SChris Mason ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0, 4220f7d52f4SChris Mason ARRAY_SIZE(gang), 4230f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 4240f7d52f4SChris Mason if (ret == 0) 4250f7d52f4SChris Mason break; 4260f7d52f4SChris Mason for (i = 0; i < ret; i++) { 4270f7d52f4SChris Mason root = gang[i]; 4282619ba1fSChris Mason radix_tree_tag_clear(radix, 4292619ba1fSChris Mason (unsigned long)root->root_key.objectid, 4300f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 43131153d81SYan Zheng 43231153d81SYan Zheng BUG_ON(!root->ref_tree); 433017e5369SChris Mason dirty = root->dirty_root; 43431153d81SYan Zheng 4350f7d52f4SChris Mason if (root->commit_root == root->node) { 436db94535dSChris Mason WARN_ON(root->node->start != 437db94535dSChris Mason btrfs_root_bytenr(&root->root_item)); 43831153d81SYan Zheng 4395f39d397SChris Mason free_extent_buffer(root->commit_root); 4400f7d52f4SChris Mason root->commit_root = NULL; 44131153d81SYan Zheng 442bcc63abbSYan spin_lock(&root->list_lock); 443bcc63abbSYan list_del_init(&dirty->root->dead_list); 444bcc63abbSYan spin_unlock(&root->list_lock); 445bcc63abbSYan 44631153d81SYan Zheng kfree(dirty->root); 44731153d81SYan Zheng kfree(dirty); 44858176a96SJosef Bacik 44958176a96SJosef Bacik /* make sure to update the root on disk 45058176a96SJosef Bacik * so we get any updates to the block used 45158176a96SJosef Bacik * counts 45258176a96SJosef Bacik */ 45358176a96SJosef Bacik err = btrfs_update_root(trans, 45458176a96SJosef Bacik root->fs_info->tree_root, 45558176a96SJosef Bacik &root->root_key, 45658176a96SJosef Bacik &root->root_item); 4570f7d52f4SChris Mason continue; 4580f7d52f4SChris Mason } 4599f3a7427SChris Mason 4609f3a7427SChris Mason memset(&root->root_item.drop_progress, 0, 4619f3a7427SChris Mason sizeof(struct btrfs_disk_key)); 4629f3a7427SChris Mason root->root_item.drop_level = 0; 4630f7d52f4SChris Mason root->commit_root = NULL; 4640f7d52f4SChris Mason root->root_key.offset = root->fs_info->generation; 465db94535dSChris Mason btrfs_set_root_bytenr(&root->root_item, 466db94535dSChris Mason root->node->start); 467db94535dSChris Mason btrfs_set_root_level(&root->root_item, 468db94535dSChris Mason btrfs_header_level(root->node)); 4690f7d52f4SChris Mason err = btrfs_insert_root(trans, root->fs_info->tree_root, 4700f7d52f4SChris Mason &root->root_key, 4710f7d52f4SChris Mason &root->root_item); 47254aa1f4dSChris Mason if (err) 47354aa1f4dSChris Mason break; 4749f3a7427SChris Mason 4759f3a7427SChris Mason refs = btrfs_root_refs(&dirty->root->root_item); 4769f3a7427SChris Mason btrfs_set_root_refs(&dirty->root->root_item, refs - 1); 4775eda7b5eSChris Mason err = btrfs_update_root(trans, root->fs_info->tree_root, 4789f3a7427SChris Mason &dirty->root->root_key, 4799f3a7427SChris Mason &dirty->root->root_item); 4805eda7b5eSChris Mason 4815eda7b5eSChris Mason BUG_ON(err); 4829f3a7427SChris Mason if (refs == 1) { 4830f7d52f4SChris Mason list_add(&dirty->list, list); 4849f3a7427SChris Mason } else { 4859f3a7427SChris Mason WARN_ON(1); 48631153d81SYan Zheng free_extent_buffer(dirty->root->node); 4879f3a7427SChris Mason kfree(dirty->root); 4885eda7b5eSChris Mason kfree(dirty); 4890f7d52f4SChris Mason } 4900f7d52f4SChris Mason } 4919f3a7427SChris Mason } 49254aa1f4dSChris Mason return err; 4930f7d52f4SChris Mason } 4940f7d52f4SChris Mason 495e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 496e9d0b13bSChris Mason { 497e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 498e9d0b13bSChris Mason int ret; 499e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 500d3c2fdcfSChris Mason unsigned long nr; 501e9d0b13bSChris Mason 502a2135011SChris Mason smp_mb(); 503e9d0b13bSChris Mason if (root->defrag_running) 504e9d0b13bSChris Mason return 0; 505e9d0b13bSChris Mason trans = btrfs_start_transaction(root, 1); 5066b80053dSChris Mason while (1) { 507e9d0b13bSChris Mason root->defrag_running = 1; 508e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 509d3c2fdcfSChris Mason nr = trans->blocks_used; 510e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 511d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 512e9d0b13bSChris Mason cond_resched(); 513e9d0b13bSChris Mason 514e9d0b13bSChris Mason trans = btrfs_start_transaction(root, 1); 5153f157a2fSChris Mason if (root->fs_info->closing || ret != -EAGAIN) 516e9d0b13bSChris Mason break; 517e9d0b13bSChris Mason } 518e9d0b13bSChris Mason root->defrag_running = 0; 519a2135011SChris Mason smp_mb(); 520e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 521e9d0b13bSChris Mason return 0; 522e9d0b13bSChris Mason } 523e9d0b13bSChris Mason 52480b6794dSChris Mason static noinline int drop_dirty_roots(struct btrfs_root *tree_root, 52535b7e476SChris Mason struct list_head *list) 5260f7d52f4SChris Mason { 527f321e491SYan Zheng struct btrfs_dirty_root *dirty; 5280f7d52f4SChris Mason struct btrfs_trans_handle *trans; 529d3c2fdcfSChris Mason unsigned long nr; 530db94535dSChris Mason u64 num_bytes; 531db94535dSChris Mason u64 bytes_used; 532bcc63abbSYan u64 max_useless; 53354aa1f4dSChris Mason int ret = 0; 5349f3a7427SChris Mason int err; 5359f3a7427SChris Mason 5360f7d52f4SChris Mason while(!list_empty(list)) { 53758176a96SJosef Bacik struct btrfs_root *root; 53858176a96SJosef Bacik 539f321e491SYan Zheng dirty = list_entry(list->prev, struct btrfs_dirty_root, list); 5400f7d52f4SChris Mason list_del_init(&dirty->list); 5415eda7b5eSChris Mason 542db94535dSChris Mason num_bytes = btrfs_root_used(&dirty->root->root_item); 54358176a96SJosef Bacik root = dirty->latest_root; 544a2135011SChris Mason atomic_inc(&root->fs_info->throttles); 54558176a96SJosef Bacik 546a2135011SChris Mason mutex_lock(&root->fs_info->drop_mutex); 5479f3a7427SChris Mason while(1) { 5480f7d52f4SChris Mason trans = btrfs_start_transaction(tree_root, 1); 5499f3a7427SChris Mason ret = btrfs_drop_snapshot(trans, dirty->root); 5509f3a7427SChris Mason if (ret != -EAGAIN) { 5519f3a7427SChris Mason break; 5529f3a7427SChris Mason } 55358176a96SJosef Bacik 5549f3a7427SChris Mason err = btrfs_update_root(trans, 5559f3a7427SChris Mason tree_root, 5569f3a7427SChris Mason &dirty->root->root_key, 5579f3a7427SChris Mason &dirty->root->root_item); 5589f3a7427SChris Mason if (err) 5599f3a7427SChris Mason ret = err; 560d3c2fdcfSChris Mason nr = trans->blocks_used; 561017e5369SChris Mason ret = btrfs_end_transaction(trans, tree_root); 5620f7d52f4SChris Mason BUG_ON(ret); 563a2135011SChris Mason 564a2135011SChris Mason mutex_unlock(&root->fs_info->drop_mutex); 565d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 5664dc11904SChris Mason cond_resched(); 567a2135011SChris Mason mutex_lock(&root->fs_info->drop_mutex); 5689f3a7427SChris Mason } 5699f3a7427SChris Mason BUG_ON(ret); 570a2135011SChris Mason atomic_dec(&root->fs_info->throttles); 571017e5369SChris Mason wake_up(&root->fs_info->transaction_throttle); 57258176a96SJosef Bacik 573a2135011SChris Mason mutex_lock(&root->fs_info->alloc_mutex); 574db94535dSChris Mason num_bytes -= btrfs_root_used(&dirty->root->root_item); 575db94535dSChris Mason bytes_used = btrfs_root_used(&root->root_item); 576db94535dSChris Mason if (num_bytes) { 57758176a96SJosef Bacik record_root_in_trans(root); 5785f39d397SChris Mason btrfs_set_root_used(&root->root_item, 579db94535dSChris Mason bytes_used - num_bytes); 58058176a96SJosef Bacik } 581a2135011SChris Mason mutex_unlock(&root->fs_info->alloc_mutex); 582a2135011SChris Mason 5839f3a7427SChris Mason ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key); 58458176a96SJosef Bacik if (ret) { 58558176a96SJosef Bacik BUG(); 58654aa1f4dSChris Mason break; 58758176a96SJosef Bacik } 588a2135011SChris Mason mutex_unlock(&root->fs_info->drop_mutex); 589a2135011SChris Mason 590bcc63abbSYan spin_lock(&root->list_lock); 591bcc63abbSYan list_del_init(&dirty->root->dead_list); 592bcc63abbSYan if (!list_empty(&root->dead_list)) { 593bcc63abbSYan struct btrfs_root *oldest; 594bcc63abbSYan oldest = list_entry(root->dead_list.prev, 595bcc63abbSYan struct btrfs_root, dead_list); 596bcc63abbSYan max_useless = oldest->root_key.offset - 1; 597bcc63abbSYan } else { 598bcc63abbSYan max_useless = root->root_key.offset - 1; 599bcc63abbSYan } 600bcc63abbSYan spin_unlock(&root->list_lock); 601bcc63abbSYan 602d3c2fdcfSChris Mason nr = trans->blocks_used; 6030f7d52f4SChris Mason ret = btrfs_end_transaction(trans, tree_root); 6040f7d52f4SChris Mason BUG_ON(ret); 6055eda7b5eSChris Mason 606bcc63abbSYan ret = btrfs_remove_leaf_refs(root, max_useless); 607bcc63abbSYan BUG_ON(ret); 608bcc63abbSYan 609f510cfecSChris Mason free_extent_buffer(dirty->root->node); 6105eda7b5eSChris Mason kfree(dirty->root); 6110f7d52f4SChris Mason kfree(dirty); 612d3c2fdcfSChris Mason 613d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 6144dc11904SChris Mason cond_resched(); 6150f7d52f4SChris Mason } 61654aa1f4dSChris Mason return ret; 6170f7d52f4SChris Mason } 6180f7d52f4SChris Mason 61980b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 6203063d29fSChris Mason struct btrfs_fs_info *fs_info, 6213063d29fSChris Mason struct btrfs_pending_snapshot *pending) 6223063d29fSChris Mason { 6233063d29fSChris Mason struct btrfs_key key; 62480b6794dSChris Mason struct btrfs_root_item *new_root_item; 6253063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 6263063d29fSChris Mason struct btrfs_root *root = pending->root; 6273063d29fSChris Mason struct extent_buffer *tmp; 628925baeddSChris Mason struct extent_buffer *old; 6293063d29fSChris Mason int ret; 6303b96362cSSven Wegener int namelen; 6313063d29fSChris Mason u64 objectid; 6323063d29fSChris Mason 63380b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 63480b6794dSChris Mason if (!new_root_item) { 63580b6794dSChris Mason ret = -ENOMEM; 63680b6794dSChris Mason goto fail; 63780b6794dSChris Mason } 6383063d29fSChris Mason ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid); 6393063d29fSChris Mason if (ret) 6403063d29fSChris Mason goto fail; 6413063d29fSChris Mason 64280b6794dSChris Mason memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 6433063d29fSChris Mason 6443063d29fSChris Mason key.objectid = objectid; 6453063d29fSChris Mason key.offset = 1; 6463063d29fSChris Mason btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); 6473063d29fSChris Mason 648925baeddSChris Mason old = btrfs_lock_root_node(root); 64965b51a00SChris Mason btrfs_cow_block(trans, root, old, NULL, 0, &old, 0); 6503063d29fSChris Mason 651925baeddSChris Mason btrfs_copy_root(trans, root, old, &tmp, objectid); 652925baeddSChris Mason btrfs_tree_unlock(old); 653925baeddSChris Mason free_extent_buffer(old); 6543063d29fSChris Mason 65580b6794dSChris Mason btrfs_set_root_bytenr(new_root_item, tmp->start); 65680b6794dSChris Mason btrfs_set_root_level(new_root_item, btrfs_header_level(tmp)); 6573063d29fSChris Mason ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key, 65880b6794dSChris Mason new_root_item); 659925baeddSChris Mason btrfs_tree_unlock(tmp); 6603063d29fSChris Mason free_extent_buffer(tmp); 6613063d29fSChris Mason if (ret) 6623063d29fSChris Mason goto fail; 6633063d29fSChris Mason 6643063d29fSChris Mason /* 6653063d29fSChris Mason * insert the directory item 6663063d29fSChris Mason */ 6673063d29fSChris Mason key.offset = (u64)-1; 6683b96362cSSven Wegener namelen = strlen(pending->name); 6693063d29fSChris Mason ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root, 6703b96362cSSven Wegener pending->name, namelen, 6713063d29fSChris Mason root->fs_info->sb->s_root->d_inode->i_ino, 672aec7477bSJosef Bacik &key, BTRFS_FT_DIR, 0); 6733063d29fSChris Mason 6743063d29fSChris Mason if (ret) 6753063d29fSChris Mason goto fail; 6763063d29fSChris Mason 6773063d29fSChris Mason ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root, 6783063d29fSChris Mason pending->name, strlen(pending->name), objectid, 679aec7477bSJosef Bacik root->fs_info->sb->s_root->d_inode->i_ino, 0); 6803b96362cSSven Wegener 6813b96362cSSven Wegener /* Invalidate existing dcache entry for new snapshot. */ 6823b96362cSSven Wegener btrfs_invalidate_dcache_root(root, pending->name, namelen); 6833b96362cSSven Wegener 6843063d29fSChris Mason fail: 68580b6794dSChris Mason kfree(new_root_item); 6863063d29fSChris Mason return ret; 6873063d29fSChris Mason } 6883063d29fSChris Mason 68980b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 6903063d29fSChris Mason struct btrfs_fs_info *fs_info) 6913063d29fSChris Mason { 6923063d29fSChris Mason struct btrfs_pending_snapshot *pending; 6933063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 6943063d29fSChris Mason int ret; 6953063d29fSChris Mason 6963063d29fSChris Mason while(!list_empty(head)) { 6973063d29fSChris Mason pending = list_entry(head->next, 6983063d29fSChris Mason struct btrfs_pending_snapshot, list); 6993063d29fSChris Mason ret = create_pending_snapshot(trans, fs_info, pending); 7003063d29fSChris Mason BUG_ON(ret); 7013063d29fSChris Mason list_del(&pending->list); 7023063d29fSChris Mason kfree(pending->name); 7033063d29fSChris Mason kfree(pending); 7043063d29fSChris Mason } 705dc17ff8fSChris Mason return 0; 706dc17ff8fSChris Mason } 707dc17ff8fSChris Mason 70879154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 70979154b1bSChris Mason struct btrfs_root *root) 71079154b1bSChris Mason { 71115ee9bc7SJosef Bacik unsigned long joined = 0; 71215ee9bc7SJosef Bacik unsigned long timeout = 1; 71379154b1bSChris Mason struct btrfs_transaction *cur_trans; 7148fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 7150b86a832SChris Mason struct btrfs_root *chunk_root = root->fs_info->chunk_root; 7160f7d52f4SChris Mason struct list_head dirty_fs_roots; 717d1310b2eSChris Mason struct extent_io_tree *pinned_copy; 71879154b1bSChris Mason DEFINE_WAIT(wait); 71915ee9bc7SJosef Bacik int ret; 72079154b1bSChris Mason 7210f7d52f4SChris Mason INIT_LIST_HEAD(&dirty_fs_roots); 722d6e4a428SChris Mason 72379154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 72479154b1bSChris Mason if (trans->transaction->in_commit) { 72579154b1bSChris Mason cur_trans = trans->transaction; 72679154b1bSChris Mason trans->transaction->use_count++; 727ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 72879154b1bSChris Mason btrfs_end_transaction(trans, root); 729ccd467d6SChris Mason 73079154b1bSChris Mason ret = wait_for_commit(root, cur_trans); 73179154b1bSChris Mason BUG_ON(ret); 73215ee9bc7SJosef Bacik 73315ee9bc7SJosef Bacik mutex_lock(&root->fs_info->trans_mutex); 73479154b1bSChris Mason put_transaction(cur_trans); 73515ee9bc7SJosef Bacik mutex_unlock(&root->fs_info->trans_mutex); 73615ee9bc7SJosef Bacik 73779154b1bSChris Mason return 0; 73879154b1bSChris Mason } 7394313b399SChris Mason 7404313b399SChris Mason pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS); 7414313b399SChris Mason if (!pinned_copy) 7424313b399SChris Mason return -ENOMEM; 7434313b399SChris Mason 744d1310b2eSChris Mason extent_io_tree_init(pinned_copy, 7454313b399SChris Mason root->fs_info->btree_inode->i_mapping, GFP_NOFS); 7464313b399SChris Mason 7472c90e5d6SChris Mason trans->transaction->in_commit = 1; 748f9295749SChris Mason trans->transaction->blocked = 1; 749ccd467d6SChris Mason cur_trans = trans->transaction; 750ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 751ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 752ccd467d6SChris Mason struct btrfs_transaction, list); 753ccd467d6SChris Mason if (!prev_trans->commit_done) { 754ccd467d6SChris Mason prev_trans->use_count++; 755ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 756ccd467d6SChris Mason 757ccd467d6SChris Mason wait_for_commit(root, prev_trans); 758ccd467d6SChris Mason 759ccd467d6SChris Mason mutex_lock(&root->fs_info->trans_mutex); 76015ee9bc7SJosef Bacik put_transaction(prev_trans); 761ccd467d6SChris Mason } 762ccd467d6SChris Mason } 76315ee9bc7SJosef Bacik 76415ee9bc7SJosef Bacik do { 76515ee9bc7SJosef Bacik joined = cur_trans->num_joined; 7662c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 76715ee9bc7SJosef Bacik prepare_to_wait(&cur_trans->writer_wait, &wait, 76879154b1bSChris Mason TASK_UNINTERRUPTIBLE); 76915ee9bc7SJosef Bacik 77015ee9bc7SJosef Bacik if (cur_trans->num_writers > 1) 77115ee9bc7SJosef Bacik timeout = MAX_SCHEDULE_TIMEOUT; 77215ee9bc7SJosef Bacik else 77315ee9bc7SJosef Bacik timeout = 1; 77415ee9bc7SJosef Bacik 77579154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 77615ee9bc7SJosef Bacik 77715ee9bc7SJosef Bacik schedule_timeout(timeout); 77815ee9bc7SJosef Bacik 77979154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 78015ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 78115ee9bc7SJosef Bacik } while (cur_trans->num_writers > 1 || 78215ee9bc7SJosef Bacik (cur_trans->num_joined != joined)); 78315ee9bc7SJosef Bacik 7843063d29fSChris Mason ret = create_pending_snapshots(trans, root->fs_info); 7853063d29fSChris Mason BUG_ON(ret); 7863063d29fSChris Mason 7872c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 788dc17ff8fSChris Mason 78954aa1f4dSChris Mason ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix, 79054aa1f4dSChris Mason &dirty_fs_roots); 79154aa1f4dSChris Mason BUG_ON(ret); 79254aa1f4dSChris Mason 79379154b1bSChris Mason ret = btrfs_commit_tree_roots(trans, root); 79479154b1bSChris Mason BUG_ON(ret); 79554aa1f4dSChris Mason 79678fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 797cee36a03SChris Mason spin_lock(&root->fs_info->new_trans_lock); 79878fae27eSChris Mason root->fs_info->running_transaction = NULL; 799cee36a03SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 8004b52dff6SChris Mason btrfs_set_super_generation(&root->fs_info->super_copy, 8014b52dff6SChris Mason cur_trans->transid); 8024b52dff6SChris Mason btrfs_set_super_root(&root->fs_info->super_copy, 803db94535dSChris Mason root->fs_info->tree_root->node->start); 804db94535dSChris Mason btrfs_set_super_root_level(&root->fs_info->super_copy, 805db94535dSChris Mason btrfs_header_level(root->fs_info->tree_root->node)); 8065f39d397SChris Mason 8070b86a832SChris Mason btrfs_set_super_chunk_root(&root->fs_info->super_copy, 8080b86a832SChris Mason chunk_root->node->start); 8090b86a832SChris Mason btrfs_set_super_chunk_root_level(&root->fs_info->super_copy, 8100b86a832SChris Mason btrfs_header_level(chunk_root->node)); 811a061fc8dSChris Mason memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy, 8124b52dff6SChris Mason sizeof(root->fs_info->super_copy)); 813ccd467d6SChris Mason 8144313b399SChris Mason btrfs_copy_pinned(root, pinned_copy); 815ccd467d6SChris Mason 816f9295749SChris Mason trans->transaction->blocked = 0; 817e6dcd2dcSChris Mason wake_up(&root->fs_info->transaction_throttle); 818f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 819e6dcd2dcSChris Mason 82078fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 82179154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 82279154b1bSChris Mason BUG_ON(ret); 82379154b1bSChris Mason write_ctree_super(trans, root); 8244313b399SChris Mason 8254313b399SChris Mason btrfs_finish_extent_commit(trans, root, pinned_copy); 82678fae27eSChris Mason mutex_lock(&root->fs_info->trans_mutex); 8274313b399SChris Mason 8284313b399SChris Mason kfree(pinned_copy); 8294313b399SChris Mason 8302c90e5d6SChris Mason cur_trans->commit_done = 1; 83115ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 8322c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 83379154b1bSChris Mason put_transaction(cur_trans); 83478fae27eSChris Mason put_transaction(cur_trans); 83558176a96SJosef Bacik 836bcc63abbSYan list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots); 837facda1e7SChris Mason if (root->fs_info->closing) 838facda1e7SChris Mason list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots); 83958176a96SJosef Bacik 84078fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 8412c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 84279154b1bSChris Mason 843facda1e7SChris Mason if (root->fs_info->closing) { 8440f7d52f4SChris Mason drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots); 845facda1e7SChris Mason } 84679154b1bSChris Mason return ret; 84779154b1bSChris Mason } 84879154b1bSChris Mason 849e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 850e9d0b13bSChris Mason { 851e9d0b13bSChris Mason struct list_head dirty_roots; 852e9d0b13bSChris Mason INIT_LIST_HEAD(&dirty_roots); 853a74a4b97SChris Mason again: 854e9d0b13bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 855e9d0b13bSChris Mason list_splice_init(&root->fs_info->dead_roots, &dirty_roots); 856e9d0b13bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 857e9d0b13bSChris Mason 858e9d0b13bSChris Mason if (!list_empty(&dirty_roots)) { 859e9d0b13bSChris Mason drop_dirty_roots(root, &dirty_roots); 860a74a4b97SChris Mason goto again; 861e9d0b13bSChris Mason } 862e9d0b13bSChris Mason return 0; 863e9d0b13bSChris Mason } 864