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 49d352ac68SChris Mason /* 50d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 51d352ac68SChris Mason */ 5280b6794dSChris Mason static noinline int join_transaction(struct btrfs_root *root) 5379154b1bSChris Mason { 5479154b1bSChris Mason struct btrfs_transaction *cur_trans; 5579154b1bSChris Mason cur_trans = root->fs_info->running_transaction; 5679154b1bSChris Mason if (!cur_trans) { 572c90e5d6SChris Mason cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, 582c90e5d6SChris Mason GFP_NOFS); 5978fae27eSChris Mason total_trans++; 6079154b1bSChris Mason BUG_ON(!cur_trans); 610f7d52f4SChris Mason root->fs_info->generation++; 62e18e4809SChris Mason root->fs_info->last_alloc = 0; 634529ba49SChris Mason root->fs_info->last_data_alloc = 0; 6415ee9bc7SJosef Bacik cur_trans->num_writers = 1; 6515ee9bc7SJosef Bacik cur_trans->num_joined = 0; 660f7d52f4SChris Mason cur_trans->transid = root->fs_info->generation; 6779154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 6879154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 6979154b1bSChris Mason cur_trans->in_commit = 0; 70f9295749SChris Mason cur_trans->blocked = 0; 71d5719762SChris Mason cur_trans->use_count = 1; 7279154b1bSChris Mason cur_trans->commit_done = 0; 7308607c1bSChris Mason cur_trans->start_time = get_seconds(); 743063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 758fd17795SChris Mason list_add_tail(&cur_trans->list, &root->fs_info->trans_list); 76d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 775f39d397SChris Mason root->fs_info->btree_inode->i_mapping, 785f39d397SChris Mason GFP_NOFS); 7948ec2cf8SChris Mason spin_lock(&root->fs_info->new_trans_lock); 8048ec2cf8SChris Mason root->fs_info->running_transaction = cur_trans; 8148ec2cf8SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 8215ee9bc7SJosef Bacik } else { 8379154b1bSChris Mason cur_trans->num_writers++; 8415ee9bc7SJosef Bacik cur_trans->num_joined++; 8515ee9bc7SJosef Bacik } 8615ee9bc7SJosef Bacik 8779154b1bSChris Mason return 0; 8879154b1bSChris Mason } 8979154b1bSChris Mason 90d352ac68SChris Mason /* 91d352ac68SChris Mason * this does all the record keeping required to make sure that a 92d352ac68SChris Mason * reference counted root is properly recorded in a given transaction. 93d352ac68SChris Mason * This is required to make sure the old root from before we joined the transaction 94d352ac68SChris Mason * is deleted when the transaction commits 95d352ac68SChris Mason */ 96e02119d5SChris Mason noinline int btrfs_record_root_in_trans(struct btrfs_root *root) 976702ed49SChris Mason { 98f321e491SYan Zheng struct btrfs_dirty_root *dirty; 996702ed49SChris Mason u64 running_trans_id = root->fs_info->running_transaction->transid; 1006702ed49SChris Mason if (root->ref_cows && root->last_trans < running_trans_id) { 1016702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 1026702ed49SChris Mason if (root->root_item.refs != 0) { 1036702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 1046702ed49SChris Mason (unsigned long)root->root_key.objectid, 1056702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 10631153d81SYan Zheng 10731153d81SYan Zheng dirty = kmalloc(sizeof(*dirty), GFP_NOFS); 10831153d81SYan Zheng BUG_ON(!dirty); 10931153d81SYan Zheng dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS); 11031153d81SYan Zheng BUG_ON(!dirty->root); 11131153d81SYan Zheng dirty->latest_root = root; 11231153d81SYan Zheng INIT_LIST_HEAD(&dirty->list); 11331153d81SYan Zheng 114925baeddSChris Mason root->commit_root = btrfs_root_node(root); 11531153d81SYan Zheng 11631153d81SYan Zheng memcpy(dirty->root, root, sizeof(*root)); 11731153d81SYan Zheng spin_lock_init(&dirty->root->node_lock); 118bcc63abbSYan spin_lock_init(&dirty->root->list_lock); 11931153d81SYan Zheng mutex_init(&dirty->root->objectid_mutex); 1205b21f2edSZheng Yan mutex_init(&dirty->root->log_mutex); 121bcc63abbSYan INIT_LIST_HEAD(&dirty->root->dead_list); 12231153d81SYan Zheng dirty->root->node = root->commit_root; 12331153d81SYan Zheng dirty->root->commit_root = NULL; 124bcc63abbSYan 125bcc63abbSYan spin_lock(&root->list_lock); 126bcc63abbSYan list_add(&dirty->root->dead_list, &root->dead_list); 127bcc63abbSYan spin_unlock(&root->list_lock); 128bcc63abbSYan 129bcc63abbSYan root->dirty_root = dirty; 1306702ed49SChris Mason } else { 1316702ed49SChris Mason WARN_ON(1); 1326702ed49SChris Mason } 1336702ed49SChris Mason root->last_trans = running_trans_id; 1346702ed49SChris Mason } 1356702ed49SChris Mason return 0; 1366702ed49SChris Mason } 1376702ed49SChris Mason 138d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 139d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 140d352ac68SChris Mason * transaction might not be fully on disk. 141d352ac68SChris Mason */ 14237d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 14379154b1bSChris Mason { 144f9295749SChris Mason struct btrfs_transaction *cur_trans; 14579154b1bSChris Mason 146f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 14737d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 148f9295749SChris Mason DEFINE_WAIT(wait); 149f9295749SChris Mason cur_trans->use_count++; 150f9295749SChris Mason while(1) { 151f9295749SChris Mason prepare_to_wait(&root->fs_info->transaction_wait, &wait, 152f9295749SChris Mason TASK_UNINTERRUPTIBLE); 153f9295749SChris Mason if (cur_trans->blocked) { 154f9295749SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 155f9295749SChris Mason schedule(); 156f9295749SChris Mason mutex_lock(&root->fs_info->trans_mutex); 157f9295749SChris Mason finish_wait(&root->fs_info->transaction_wait, 158f9295749SChris Mason &wait); 159f9295749SChris Mason } else { 160f9295749SChris Mason finish_wait(&root->fs_info->transaction_wait, 161f9295749SChris Mason &wait); 162f9295749SChris Mason break; 163f9295749SChris Mason } 164f9295749SChris Mason } 165f9295749SChris Mason put_transaction(cur_trans); 166f9295749SChris Mason } 16737d1aeeeSChris Mason } 16837d1aeeeSChris Mason 169e02119d5SChris Mason static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 1709ca9ee09SSage Weil int num_blocks, int wait) 17137d1aeeeSChris Mason { 17237d1aeeeSChris Mason struct btrfs_trans_handle *h = 17337d1aeeeSChris Mason kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 17437d1aeeeSChris Mason int ret; 17537d1aeeeSChris Mason 17637d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 1774bef0848SChris Mason if (!root->fs_info->log_root_recovering && 1784bef0848SChris Mason ((wait == 1 && !root->fs_info->open_ioctl_trans) || wait == 2)) 17937d1aeeeSChris Mason wait_current_trans(root); 18079154b1bSChris Mason ret = join_transaction(root); 18179154b1bSChris Mason BUG_ON(ret); 1820f7d52f4SChris Mason 183e02119d5SChris Mason btrfs_record_root_in_trans(root); 1846702ed49SChris Mason h->transid = root->fs_info->running_transaction->transid; 18579154b1bSChris Mason h->transaction = root->fs_info->running_transaction; 18679154b1bSChris Mason h->blocks_reserved = num_blocks; 18779154b1bSChris Mason h->blocks_used = 0; 18831f3c99bSChris Mason h->block_group = NULL; 18926b8003fSChris Mason h->alloc_exclude_nr = 0; 19026b8003fSChris Mason h->alloc_exclude_start = 0; 19179154b1bSChris Mason root->fs_info->running_transaction->use_count++; 19279154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 19379154b1bSChris Mason return h; 19479154b1bSChris Mason } 19579154b1bSChris Mason 196f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 197f9295749SChris Mason int num_blocks) 198f9295749SChris Mason { 1999ca9ee09SSage Weil return start_transaction(root, num_blocks, 1); 200f9295749SChris Mason } 201f9295749SChris Mason struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root, 202f9295749SChris Mason int num_blocks) 203f9295749SChris Mason { 2049ca9ee09SSage Weil return start_transaction(root, num_blocks, 0); 205f9295749SChris Mason } 206f9295749SChris Mason 2079ca9ee09SSage Weil struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r, 2089ca9ee09SSage Weil int num_blocks) 2099ca9ee09SSage Weil { 2109ca9ee09SSage Weil return start_transaction(r, num_blocks, 2); 2119ca9ee09SSage Weil } 2129ca9ee09SSage Weil 213d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 21489ce8a63SChris Mason static noinline int wait_for_commit(struct btrfs_root *root, 21589ce8a63SChris Mason struct btrfs_transaction *commit) 21689ce8a63SChris Mason { 21789ce8a63SChris Mason DEFINE_WAIT(wait); 21889ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 21989ce8a63SChris Mason while(!commit->commit_done) { 22089ce8a63SChris Mason prepare_to_wait(&commit->commit_wait, &wait, 22189ce8a63SChris Mason TASK_UNINTERRUPTIBLE); 22289ce8a63SChris Mason if (commit->commit_done) 22389ce8a63SChris Mason break; 22489ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 22589ce8a63SChris Mason schedule(); 22689ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 22789ce8a63SChris Mason } 22889ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 22989ce8a63SChris Mason finish_wait(&commit->commit_wait, &wait); 23089ce8a63SChris Mason return 0; 23189ce8a63SChris Mason } 23289ce8a63SChris Mason 233d352ac68SChris Mason /* 234d352ac68SChris Mason * rate limit against the drop_snapshot code. This helps to slow down new operations 235d352ac68SChris Mason * if the drop_snapshot code isn't able to keep up. 236d352ac68SChris Mason */ 23737d1aeeeSChris Mason static void throttle_on_drops(struct btrfs_root *root) 238ab78c84dSChris Mason { 239ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 2402dd3e67bSChris Mason int harder_count = 0; 241ab78c84dSChris Mason 2422dd3e67bSChris Mason harder: 243ab78c84dSChris Mason if (atomic_read(&info->throttles)) { 244ab78c84dSChris Mason DEFINE_WAIT(wait); 245ab78c84dSChris Mason int thr; 246ab78c84dSChris Mason thr = atomic_read(&info->throttle_gen); 247ab78c84dSChris Mason 248ab78c84dSChris Mason do { 249ab78c84dSChris Mason prepare_to_wait(&info->transaction_throttle, 250ab78c84dSChris Mason &wait, TASK_UNINTERRUPTIBLE); 251ab78c84dSChris Mason if (!atomic_read(&info->throttles)) { 252ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 253ab78c84dSChris Mason break; 254ab78c84dSChris Mason } 255ab78c84dSChris Mason schedule(); 256ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 257ab78c84dSChris Mason } while (thr == atomic_read(&info->throttle_gen)); 2582dd3e67bSChris Mason harder_count++; 2592dd3e67bSChris Mason 2602dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 && 2612dd3e67bSChris Mason harder_count < 2) 2622dd3e67bSChris Mason goto harder; 2632dd3e67bSChris Mason 2642dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 && 2652dd3e67bSChris Mason harder_count < 10) 2662dd3e67bSChris Mason goto harder; 2672dd3e67bSChris Mason 2682dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 && 2692dd3e67bSChris Mason harder_count < 20) 2702dd3e67bSChris Mason goto harder; 271ab78c84dSChris Mason } 272ab78c84dSChris Mason } 273ab78c84dSChris Mason 27437d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 27537d1aeeeSChris Mason { 27637d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 2779ca9ee09SSage Weil if (!root->fs_info->open_ioctl_trans) 27837d1aeeeSChris Mason wait_current_trans(root); 27937d1aeeeSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 28037d1aeeeSChris Mason 28137d1aeeeSChris Mason throttle_on_drops(root); 28237d1aeeeSChris Mason } 28337d1aeeeSChris Mason 28489ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 28589ce8a63SChris Mason struct btrfs_root *root, int throttle) 28679154b1bSChris Mason { 28779154b1bSChris Mason struct btrfs_transaction *cur_trans; 288ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 289d6e4a428SChris Mason 290ab78c84dSChris Mason mutex_lock(&info->trans_mutex); 291ab78c84dSChris Mason cur_trans = info->running_transaction; 292ccd467d6SChris Mason WARN_ON(cur_trans != trans->transaction); 293d5719762SChris Mason WARN_ON(cur_trans->num_writers < 1); 294ccd467d6SChris Mason cur_trans->num_writers--; 29589ce8a63SChris Mason 29679154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 29779154b1bSChris Mason wake_up(&cur_trans->writer_wait); 29879154b1bSChris Mason put_transaction(cur_trans); 299ab78c84dSChris Mason mutex_unlock(&info->trans_mutex); 300d6025579SChris Mason memset(trans, 0, sizeof(*trans)); 3012c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 302ab78c84dSChris Mason 303ab78c84dSChris Mason if (throttle) 30437d1aeeeSChris Mason throttle_on_drops(root); 305ab78c84dSChris Mason 30679154b1bSChris Mason return 0; 30779154b1bSChris Mason } 30879154b1bSChris Mason 30989ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 31089ce8a63SChris Mason struct btrfs_root *root) 31189ce8a63SChris Mason { 31289ce8a63SChris Mason return __btrfs_end_transaction(trans, root, 0); 31389ce8a63SChris Mason } 31489ce8a63SChris Mason 31589ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 31689ce8a63SChris Mason struct btrfs_root *root) 31789ce8a63SChris Mason { 31889ce8a63SChris Mason return __btrfs_end_transaction(trans, root, 1); 31989ce8a63SChris Mason } 32089ce8a63SChris Mason 321d352ac68SChris Mason /* 322d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 323d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 324d352ac68SChris Mason * those extents are on disk for transaction or log commit 325d352ac68SChris Mason */ 326d0c803c4SChris Mason int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 327d0c803c4SChris Mason struct extent_io_tree *dirty_pages) 32879154b1bSChris Mason { 3297c4452b9SChris Mason int ret; 330777e6bd7SChris Mason int err = 0; 3317c4452b9SChris Mason int werr = 0; 3327c4452b9SChris Mason struct page *page; 3337c4452b9SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 334777e6bd7SChris Mason u64 start = 0; 3355f39d397SChris Mason u64 end; 3365f39d397SChris Mason unsigned long index; 3377c4452b9SChris Mason 3387c4452b9SChris Mason while(1) { 339777e6bd7SChris Mason ret = find_first_extent_bit(dirty_pages, start, &start, &end, 3405f39d397SChris Mason EXTENT_DIRTY); 3415f39d397SChris Mason if (ret) 3427c4452b9SChris Mason break; 3435f39d397SChris Mason while(start <= end) { 344777e6bd7SChris Mason cond_resched(); 345777e6bd7SChris Mason 3465f39d397SChris Mason index = start >> PAGE_CACHE_SHIFT; 34735ebb934SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 3484bef0848SChris Mason page = find_get_page(btree_inode->i_mapping, index); 3497c4452b9SChris Mason if (!page) 3507c4452b9SChris Mason continue; 3514bef0848SChris Mason 3524bef0848SChris Mason btree_lock_page_hook(page); 3534bef0848SChris Mason if (!page->mapping) { 3544bef0848SChris Mason unlock_page(page); 3554bef0848SChris Mason page_cache_release(page); 3564bef0848SChris Mason continue; 3574bef0848SChris Mason } 3584bef0848SChris Mason 3596702ed49SChris Mason if (PageWriteback(page)) { 3606702ed49SChris Mason if (PageDirty(page)) 3616702ed49SChris Mason wait_on_page_writeback(page); 3626702ed49SChris Mason else { 3636702ed49SChris Mason unlock_page(page); 3646702ed49SChris Mason page_cache_release(page); 3656702ed49SChris Mason continue; 3666702ed49SChris Mason } 3676702ed49SChris Mason } 3687c4452b9SChris Mason err = write_one_page(page, 0); 3697c4452b9SChris Mason if (err) 3707c4452b9SChris Mason werr = err; 3717c4452b9SChris Mason page_cache_release(page); 3727c4452b9SChris Mason } 3737c4452b9SChris Mason } 374777e6bd7SChris Mason while(1) { 375777e6bd7SChris Mason ret = find_first_extent_bit(dirty_pages, 0, &start, &end, 376777e6bd7SChris Mason EXTENT_DIRTY); 377777e6bd7SChris Mason if (ret) 378777e6bd7SChris Mason break; 379777e6bd7SChris Mason 380777e6bd7SChris Mason clear_extent_dirty(dirty_pages, start, end, GFP_NOFS); 381777e6bd7SChris Mason while(start <= end) { 382777e6bd7SChris Mason index = start >> PAGE_CACHE_SHIFT; 383777e6bd7SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 384777e6bd7SChris Mason page = find_get_page(btree_inode->i_mapping, index); 385777e6bd7SChris Mason if (!page) 386777e6bd7SChris Mason continue; 387777e6bd7SChris Mason if (PageDirty(page)) { 3884bef0848SChris Mason btree_lock_page_hook(page); 3894bef0848SChris Mason wait_on_page_writeback(page); 390777e6bd7SChris Mason err = write_one_page(page, 0); 391777e6bd7SChris Mason if (err) 392777e6bd7SChris Mason werr = err; 393777e6bd7SChris Mason } 394777e6bd7SChris Mason wait_on_page_writeback(page); 395777e6bd7SChris Mason page_cache_release(page); 396777e6bd7SChris Mason cond_resched(); 397777e6bd7SChris Mason } 398777e6bd7SChris Mason } 3997c4452b9SChris Mason if (err) 4007c4452b9SChris Mason werr = err; 4017c4452b9SChris Mason return werr; 40279154b1bSChris Mason } 40379154b1bSChris Mason 404d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 405d0c803c4SChris Mason struct btrfs_root *root) 406d0c803c4SChris Mason { 407d0c803c4SChris Mason if (!trans || !trans->transaction) { 408d0c803c4SChris Mason struct inode *btree_inode; 409d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 410d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 411d0c803c4SChris Mason } 412d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 413d0c803c4SChris Mason &trans->transaction->dirty_pages); 414d0c803c4SChris Mason } 415d0c803c4SChris Mason 416d352ac68SChris Mason /* 417d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 418d352ac68SChris Mason * 419d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 420d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 421d352ac68SChris Mason * allocation tree. 422d352ac68SChris Mason * 423d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 424d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 425d352ac68SChris Mason */ 4260b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 42779154b1bSChris Mason struct btrfs_root *root) 42879154b1bSChris Mason { 42979154b1bSChris Mason int ret; 4300b86a832SChris Mason u64 old_root_bytenr; 4310b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 43279154b1bSChris Mason 4330b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 43479154b1bSChris Mason while(1) { 4350b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 4360b86a832SChris Mason if (old_root_bytenr == root->node->start) 43779154b1bSChris Mason break; 4380b86a832SChris Mason btrfs_set_root_bytenr(&root->root_item, 4390b86a832SChris Mason root->node->start); 4400b86a832SChris Mason btrfs_set_root_level(&root->root_item, 4410b86a832SChris Mason btrfs_header_level(root->node)); 44284234f3aSYan Zheng btrfs_set_root_generation(&root->root_item, trans->transid); 44379154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 4440b86a832SChris Mason &root->root_key, 4450b86a832SChris Mason &root->root_item); 44679154b1bSChris Mason BUG_ON(ret); 4470b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 4480b86a832SChris Mason } 4490b86a832SChris Mason return 0; 4500b86a832SChris Mason } 4510b86a832SChris Mason 452d352ac68SChris Mason /* 453d352ac68SChris Mason * update all the cowonly tree roots on disk 454d352ac68SChris Mason */ 4550b86a832SChris Mason int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans, 4560b86a832SChris Mason struct btrfs_root *root) 4570b86a832SChris Mason { 4580b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 4590b86a832SChris Mason struct list_head *next; 46084234f3aSYan Zheng struct extent_buffer *eb; 46184234f3aSYan Zheng 46284234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 46384234f3aSYan Zheng btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb, 0); 46484234f3aSYan Zheng btrfs_tree_unlock(eb); 46584234f3aSYan Zheng free_extent_buffer(eb); 4660b86a832SChris Mason 4670b86a832SChris Mason while(!list_empty(&fs_info->dirty_cowonly_roots)) { 4680b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 4690b86a832SChris Mason list_del_init(next); 4700b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 4710b86a832SChris Mason update_cowonly_root(trans, root); 47279154b1bSChris Mason } 47379154b1bSChris Mason return 0; 47479154b1bSChris Mason } 47579154b1bSChris Mason 476d352ac68SChris Mason /* 477d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 478d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 479d352ac68SChris Mason * be deleted 480d352ac68SChris Mason */ 481b48652c1SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root, struct btrfs_root *latest) 4825eda7b5eSChris Mason { 483f321e491SYan Zheng struct btrfs_dirty_root *dirty; 4845eda7b5eSChris Mason 4855eda7b5eSChris Mason dirty = kmalloc(sizeof(*dirty), GFP_NOFS); 4865eda7b5eSChris Mason if (!dirty) 4875eda7b5eSChris Mason return -ENOMEM; 4885eda7b5eSChris Mason dirty->root = root; 4895ce14bbcSChris Mason dirty->latest_root = latest; 490b48652c1SYan Zheng 491b48652c1SYan Zheng mutex_lock(&root->fs_info->trans_mutex); 492b48652c1SYan Zheng list_add(&dirty->list, &latest->fs_info->dead_roots); 493b48652c1SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 4945eda7b5eSChris Mason return 0; 4955eda7b5eSChris Mason } 4965eda7b5eSChris Mason 497d352ac68SChris Mason /* 498d352ac68SChris Mason * at transaction commit time we need to schedule the old roots for 499d352ac68SChris Mason * deletion via btrfs_drop_snapshot. This runs through all the 500d352ac68SChris Mason * reference counted roots that were modified in the current 501d352ac68SChris Mason * transaction and puts them into the drop list 502d352ac68SChris Mason */ 50380b6794dSChris Mason static noinline int add_dirty_roots(struct btrfs_trans_handle *trans, 50435b7e476SChris Mason struct radix_tree_root *radix, 50535b7e476SChris Mason struct list_head *list) 5060f7d52f4SChris Mason { 507f321e491SYan Zheng struct btrfs_dirty_root *dirty; 5080f7d52f4SChris Mason struct btrfs_root *gang[8]; 5090f7d52f4SChris Mason struct btrfs_root *root; 5100f7d52f4SChris Mason int i; 5110f7d52f4SChris Mason int ret; 51254aa1f4dSChris Mason int err = 0; 5135eda7b5eSChris Mason u32 refs; 51454aa1f4dSChris Mason 5150f7d52f4SChris Mason while(1) { 5160f7d52f4SChris Mason ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0, 5170f7d52f4SChris Mason ARRAY_SIZE(gang), 5180f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 5190f7d52f4SChris Mason if (ret == 0) 5200f7d52f4SChris Mason break; 5210f7d52f4SChris Mason for (i = 0; i < ret; i++) { 5220f7d52f4SChris Mason root = gang[i]; 5232619ba1fSChris Mason radix_tree_tag_clear(radix, 5242619ba1fSChris Mason (unsigned long)root->root_key.objectid, 5250f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 52631153d81SYan Zheng 52731153d81SYan Zheng BUG_ON(!root->ref_tree); 528017e5369SChris Mason dirty = root->dirty_root; 52931153d81SYan Zheng 530e02119d5SChris Mason btrfs_free_log(trans, root); 531f82d02d9SYan Zheng btrfs_free_reloc_root(trans, root); 532e02119d5SChris Mason 5330f7d52f4SChris Mason if (root->commit_root == root->node) { 534db94535dSChris Mason WARN_ON(root->node->start != 535db94535dSChris Mason btrfs_root_bytenr(&root->root_item)); 53631153d81SYan Zheng 5375f39d397SChris Mason free_extent_buffer(root->commit_root); 5380f7d52f4SChris Mason root->commit_root = NULL; 5397ea394f1SYan Zheng root->dirty_root = NULL; 54031153d81SYan Zheng 541bcc63abbSYan spin_lock(&root->list_lock); 542bcc63abbSYan list_del_init(&dirty->root->dead_list); 543bcc63abbSYan spin_unlock(&root->list_lock); 544bcc63abbSYan 54531153d81SYan Zheng kfree(dirty->root); 54631153d81SYan Zheng kfree(dirty); 54758176a96SJosef Bacik 54858176a96SJosef Bacik /* make sure to update the root on disk 54958176a96SJosef Bacik * so we get any updates to the block used 55058176a96SJosef Bacik * counts 55158176a96SJosef Bacik */ 55258176a96SJosef Bacik err = btrfs_update_root(trans, 55358176a96SJosef Bacik root->fs_info->tree_root, 55458176a96SJosef Bacik &root->root_key, 55558176a96SJosef Bacik &root->root_item); 5560f7d52f4SChris Mason continue; 5570f7d52f4SChris Mason } 5589f3a7427SChris Mason 5599f3a7427SChris Mason memset(&root->root_item.drop_progress, 0, 5609f3a7427SChris Mason sizeof(struct btrfs_disk_key)); 5619f3a7427SChris Mason root->root_item.drop_level = 0; 5620f7d52f4SChris Mason root->commit_root = NULL; 5637ea394f1SYan Zheng root->dirty_root = NULL; 5640f7d52f4SChris Mason root->root_key.offset = root->fs_info->generation; 565db94535dSChris Mason btrfs_set_root_bytenr(&root->root_item, 566db94535dSChris Mason root->node->start); 567db94535dSChris Mason btrfs_set_root_level(&root->root_item, 568db94535dSChris Mason btrfs_header_level(root->node)); 56984234f3aSYan Zheng btrfs_set_root_generation(&root->root_item, 57084234f3aSYan Zheng root->root_key.offset); 57184234f3aSYan Zheng 5720f7d52f4SChris Mason err = btrfs_insert_root(trans, root->fs_info->tree_root, 5730f7d52f4SChris Mason &root->root_key, 5740f7d52f4SChris Mason &root->root_item); 57554aa1f4dSChris Mason if (err) 57654aa1f4dSChris Mason break; 5779f3a7427SChris Mason 5789f3a7427SChris Mason refs = btrfs_root_refs(&dirty->root->root_item); 5799f3a7427SChris Mason btrfs_set_root_refs(&dirty->root->root_item, refs - 1); 5805eda7b5eSChris Mason err = btrfs_update_root(trans, root->fs_info->tree_root, 5819f3a7427SChris Mason &dirty->root->root_key, 5829f3a7427SChris Mason &dirty->root->root_item); 5835eda7b5eSChris Mason 5845eda7b5eSChris Mason BUG_ON(err); 5859f3a7427SChris Mason if (refs == 1) { 5860f7d52f4SChris Mason list_add(&dirty->list, list); 5879f3a7427SChris Mason } else { 5889f3a7427SChris Mason WARN_ON(1); 58931153d81SYan Zheng free_extent_buffer(dirty->root->node); 5909f3a7427SChris Mason kfree(dirty->root); 5915eda7b5eSChris Mason kfree(dirty); 5920f7d52f4SChris Mason } 5930f7d52f4SChris Mason } 5949f3a7427SChris Mason } 59554aa1f4dSChris Mason return err; 5960f7d52f4SChris Mason } 5970f7d52f4SChris Mason 598d352ac68SChris Mason /* 599d352ac68SChris Mason * defrag a given btree. If cacheonly == 1, this won't read from the disk, 600d352ac68SChris Mason * otherwise every leaf in the btree is read and defragged. 601d352ac68SChris Mason */ 602e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 603e9d0b13bSChris Mason { 604e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 605e9d0b13bSChris Mason int ret; 606e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 607d3c2fdcfSChris Mason unsigned long nr; 608e9d0b13bSChris Mason 609a2135011SChris Mason smp_mb(); 610e9d0b13bSChris Mason if (root->defrag_running) 611e9d0b13bSChris Mason return 0; 612e9d0b13bSChris Mason trans = btrfs_start_transaction(root, 1); 6136b80053dSChris Mason while (1) { 614e9d0b13bSChris Mason root->defrag_running = 1; 615e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 616d3c2fdcfSChris Mason nr = trans->blocks_used; 617e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 618d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 619e9d0b13bSChris Mason cond_resched(); 620e9d0b13bSChris Mason 621e9d0b13bSChris Mason trans = btrfs_start_transaction(root, 1); 6223f157a2fSChris Mason if (root->fs_info->closing || ret != -EAGAIN) 623e9d0b13bSChris Mason break; 624e9d0b13bSChris Mason } 625e9d0b13bSChris Mason root->defrag_running = 0; 626a2135011SChris Mason smp_mb(); 627e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 628e9d0b13bSChris Mason return 0; 629e9d0b13bSChris Mason } 630e9d0b13bSChris Mason 631d352ac68SChris Mason /* 632d352ac68SChris Mason * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on 633d352ac68SChris Mason * all of them 634d352ac68SChris Mason */ 63580b6794dSChris Mason static noinline int drop_dirty_roots(struct btrfs_root *tree_root, 63635b7e476SChris Mason struct list_head *list) 6370f7d52f4SChris Mason { 638f321e491SYan Zheng struct btrfs_dirty_root *dirty; 6390f7d52f4SChris Mason struct btrfs_trans_handle *trans; 640d3c2fdcfSChris Mason unsigned long nr; 641db94535dSChris Mason u64 num_bytes; 642db94535dSChris Mason u64 bytes_used; 643bcc63abbSYan u64 max_useless; 64454aa1f4dSChris Mason int ret = 0; 6459f3a7427SChris Mason int err; 6469f3a7427SChris Mason 6470f7d52f4SChris Mason while(!list_empty(list)) { 64858176a96SJosef Bacik struct btrfs_root *root; 64958176a96SJosef Bacik 650f321e491SYan Zheng dirty = list_entry(list->prev, struct btrfs_dirty_root, list); 6510f7d52f4SChris Mason list_del_init(&dirty->list); 6525eda7b5eSChris Mason 653db94535dSChris Mason num_bytes = btrfs_root_used(&dirty->root->root_item); 65458176a96SJosef Bacik root = dirty->latest_root; 655a2135011SChris Mason atomic_inc(&root->fs_info->throttles); 65658176a96SJosef Bacik 6579f3a7427SChris Mason while(1) { 6580f7d52f4SChris Mason trans = btrfs_start_transaction(tree_root, 1); 6595b21f2edSZheng Yan mutex_lock(&root->fs_info->drop_mutex); 6609f3a7427SChris Mason ret = btrfs_drop_snapshot(trans, dirty->root); 6619f3a7427SChris Mason if (ret != -EAGAIN) { 6629f3a7427SChris Mason break; 6639f3a7427SChris Mason } 6645b21f2edSZheng Yan mutex_unlock(&root->fs_info->drop_mutex); 66558176a96SJosef Bacik 6669f3a7427SChris Mason err = btrfs_update_root(trans, 6679f3a7427SChris Mason tree_root, 6689f3a7427SChris Mason &dirty->root->root_key, 6699f3a7427SChris Mason &dirty->root->root_item); 6709f3a7427SChris Mason if (err) 6719f3a7427SChris Mason ret = err; 672d3c2fdcfSChris Mason nr = trans->blocks_used; 673017e5369SChris Mason ret = btrfs_end_transaction(trans, tree_root); 6740f7d52f4SChris Mason BUG_ON(ret); 675a2135011SChris Mason 676d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 6774dc11904SChris Mason cond_resched(); 6789f3a7427SChris Mason } 6799f3a7427SChris Mason BUG_ON(ret); 680a2135011SChris Mason atomic_dec(&root->fs_info->throttles); 681017e5369SChris Mason wake_up(&root->fs_info->transaction_throttle); 68258176a96SJosef Bacik 683db94535dSChris Mason num_bytes -= btrfs_root_used(&dirty->root->root_item); 684db94535dSChris Mason bytes_used = btrfs_root_used(&root->root_item); 685db94535dSChris Mason if (num_bytes) { 686e02119d5SChris Mason btrfs_record_root_in_trans(root); 6875f39d397SChris Mason btrfs_set_root_used(&root->root_item, 688db94535dSChris Mason bytes_used - num_bytes); 68958176a96SJosef Bacik } 690a2135011SChris Mason 6919f3a7427SChris Mason ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key); 69258176a96SJosef Bacik if (ret) { 69358176a96SJosef Bacik BUG(); 69454aa1f4dSChris Mason break; 69558176a96SJosef Bacik } 696a2135011SChris Mason mutex_unlock(&root->fs_info->drop_mutex); 697a2135011SChris Mason 698bcc63abbSYan spin_lock(&root->list_lock); 699bcc63abbSYan list_del_init(&dirty->root->dead_list); 700bcc63abbSYan if (!list_empty(&root->dead_list)) { 701bcc63abbSYan struct btrfs_root *oldest; 702bcc63abbSYan oldest = list_entry(root->dead_list.prev, 703bcc63abbSYan struct btrfs_root, dead_list); 704bcc63abbSYan max_useless = oldest->root_key.offset - 1; 705bcc63abbSYan } else { 706bcc63abbSYan max_useless = root->root_key.offset - 1; 707bcc63abbSYan } 708bcc63abbSYan spin_unlock(&root->list_lock); 709bcc63abbSYan 710d3c2fdcfSChris Mason nr = trans->blocks_used; 7110f7d52f4SChris Mason ret = btrfs_end_transaction(trans, tree_root); 7120f7d52f4SChris Mason BUG_ON(ret); 7135eda7b5eSChris Mason 714e4657689SZheng Yan ret = btrfs_remove_leaf_refs(root, max_useless, 0); 715bcc63abbSYan BUG_ON(ret); 716bcc63abbSYan 717f510cfecSChris Mason free_extent_buffer(dirty->root->node); 7185eda7b5eSChris Mason kfree(dirty->root); 7190f7d52f4SChris Mason kfree(dirty); 720d3c2fdcfSChris Mason 721d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 7224dc11904SChris Mason cond_resched(); 7230f7d52f4SChris Mason } 72454aa1f4dSChris Mason return ret; 7250f7d52f4SChris Mason } 7260f7d52f4SChris Mason 727d352ac68SChris Mason /* 728d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 729d352ac68SChris Mason * transaction commit. This does the actual creation 730d352ac68SChris Mason */ 73180b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 7323063d29fSChris Mason struct btrfs_fs_info *fs_info, 7333063d29fSChris Mason struct btrfs_pending_snapshot *pending) 7343063d29fSChris Mason { 7353063d29fSChris Mason struct btrfs_key key; 73680b6794dSChris Mason struct btrfs_root_item *new_root_item; 7373063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 7383063d29fSChris Mason struct btrfs_root *root = pending->root; 7393063d29fSChris Mason struct extent_buffer *tmp; 740925baeddSChris Mason struct extent_buffer *old; 7413063d29fSChris Mason int ret; 7423b96362cSSven Wegener int namelen; 7433063d29fSChris Mason u64 objectid; 7443063d29fSChris Mason 74580b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 74680b6794dSChris Mason if (!new_root_item) { 74780b6794dSChris Mason ret = -ENOMEM; 74880b6794dSChris Mason goto fail; 74980b6794dSChris Mason } 7503063d29fSChris Mason ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid); 7513063d29fSChris Mason if (ret) 7523063d29fSChris Mason goto fail; 7533063d29fSChris Mason 75480b6794dSChris Mason memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 7553063d29fSChris Mason 7563063d29fSChris Mason key.objectid = objectid; 7575b21f2edSZheng Yan key.offset = trans->transid; 7583063d29fSChris Mason btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); 7593063d29fSChris Mason 760925baeddSChris Mason old = btrfs_lock_root_node(root); 76165b51a00SChris Mason btrfs_cow_block(trans, root, old, NULL, 0, &old, 0); 7623063d29fSChris Mason 763925baeddSChris Mason btrfs_copy_root(trans, root, old, &tmp, objectid); 764925baeddSChris Mason btrfs_tree_unlock(old); 765925baeddSChris Mason free_extent_buffer(old); 7663063d29fSChris Mason 76780b6794dSChris Mason btrfs_set_root_bytenr(new_root_item, tmp->start); 76880b6794dSChris Mason btrfs_set_root_level(new_root_item, btrfs_header_level(tmp)); 76984234f3aSYan Zheng btrfs_set_root_generation(new_root_item, trans->transid); 7703063d29fSChris Mason ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key, 77180b6794dSChris Mason new_root_item); 772925baeddSChris Mason btrfs_tree_unlock(tmp); 7733063d29fSChris Mason free_extent_buffer(tmp); 7743063d29fSChris Mason if (ret) 7753063d29fSChris Mason goto fail; 7763063d29fSChris Mason 7773063d29fSChris Mason /* 7783063d29fSChris Mason * insert the directory item 7793063d29fSChris Mason */ 7803063d29fSChris Mason key.offset = (u64)-1; 7813b96362cSSven Wegener namelen = strlen(pending->name); 7823063d29fSChris Mason ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root, 7833b96362cSSven Wegener pending->name, namelen, 7843063d29fSChris Mason root->fs_info->sb->s_root->d_inode->i_ino, 785aec7477bSJosef Bacik &key, BTRFS_FT_DIR, 0); 7863063d29fSChris Mason 7873063d29fSChris Mason if (ret) 7883063d29fSChris Mason goto fail; 7893063d29fSChris Mason 7903063d29fSChris Mason ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root, 7913063d29fSChris Mason pending->name, strlen(pending->name), objectid, 792aec7477bSJosef Bacik root->fs_info->sb->s_root->d_inode->i_ino, 0); 7933b96362cSSven Wegener 7943b96362cSSven Wegener /* Invalidate existing dcache entry for new snapshot. */ 7953b96362cSSven Wegener btrfs_invalidate_dcache_root(root, pending->name, namelen); 7963b96362cSSven Wegener 7973063d29fSChris Mason fail: 79880b6794dSChris Mason kfree(new_root_item); 7993063d29fSChris Mason return ret; 8003063d29fSChris Mason } 8013063d29fSChris Mason 802d352ac68SChris Mason /* 803d352ac68SChris Mason * create all the snapshots we've scheduled for creation 804d352ac68SChris Mason */ 80580b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 8063063d29fSChris Mason struct btrfs_fs_info *fs_info) 8073063d29fSChris Mason { 8083063d29fSChris Mason struct btrfs_pending_snapshot *pending; 8093063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 8103063d29fSChris Mason int ret; 8113063d29fSChris Mason 8123063d29fSChris Mason while(!list_empty(head)) { 8133063d29fSChris Mason pending = list_entry(head->next, 8143063d29fSChris Mason struct btrfs_pending_snapshot, list); 8153063d29fSChris Mason ret = create_pending_snapshot(trans, fs_info, pending); 8163063d29fSChris Mason BUG_ON(ret); 8173063d29fSChris Mason list_del(&pending->list); 8183063d29fSChris Mason kfree(pending->name); 8193063d29fSChris Mason kfree(pending); 8203063d29fSChris Mason } 821dc17ff8fSChris Mason return 0; 822dc17ff8fSChris Mason } 823dc17ff8fSChris Mason 82479154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 82579154b1bSChris Mason struct btrfs_root *root) 82679154b1bSChris Mason { 82715ee9bc7SJosef Bacik unsigned long joined = 0; 82815ee9bc7SJosef Bacik unsigned long timeout = 1; 82979154b1bSChris Mason struct btrfs_transaction *cur_trans; 8308fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 8310b86a832SChris Mason struct btrfs_root *chunk_root = root->fs_info->chunk_root; 8320f7d52f4SChris Mason struct list_head dirty_fs_roots; 833d1310b2eSChris Mason struct extent_io_tree *pinned_copy; 83479154b1bSChris Mason DEFINE_WAIT(wait); 83515ee9bc7SJosef Bacik int ret; 83679154b1bSChris Mason 8370f7d52f4SChris Mason INIT_LIST_HEAD(&dirty_fs_roots); 83879154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 83979154b1bSChris Mason if (trans->transaction->in_commit) { 84079154b1bSChris Mason cur_trans = trans->transaction; 84179154b1bSChris Mason trans->transaction->use_count++; 842ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 84379154b1bSChris Mason btrfs_end_transaction(trans, root); 844ccd467d6SChris Mason 84579154b1bSChris Mason ret = wait_for_commit(root, cur_trans); 84679154b1bSChris Mason BUG_ON(ret); 84715ee9bc7SJosef Bacik 84815ee9bc7SJosef Bacik mutex_lock(&root->fs_info->trans_mutex); 84979154b1bSChris Mason put_transaction(cur_trans); 85015ee9bc7SJosef Bacik mutex_unlock(&root->fs_info->trans_mutex); 85115ee9bc7SJosef Bacik 85279154b1bSChris Mason return 0; 85379154b1bSChris Mason } 8544313b399SChris Mason 8554313b399SChris Mason pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS); 8564313b399SChris Mason if (!pinned_copy) 8574313b399SChris Mason return -ENOMEM; 8584313b399SChris Mason 859d1310b2eSChris Mason extent_io_tree_init(pinned_copy, 8604313b399SChris Mason root->fs_info->btree_inode->i_mapping, GFP_NOFS); 8614313b399SChris Mason 8622c90e5d6SChris Mason trans->transaction->in_commit = 1; 863f9295749SChris Mason trans->transaction->blocked = 1; 864ccd467d6SChris Mason cur_trans = trans->transaction; 865ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 866ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 867ccd467d6SChris Mason struct btrfs_transaction, list); 868ccd467d6SChris Mason if (!prev_trans->commit_done) { 869ccd467d6SChris Mason prev_trans->use_count++; 870ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 871ccd467d6SChris Mason 872ccd467d6SChris Mason wait_for_commit(root, prev_trans); 873ccd467d6SChris Mason 874ccd467d6SChris Mason mutex_lock(&root->fs_info->trans_mutex); 87515ee9bc7SJosef Bacik put_transaction(prev_trans); 876ccd467d6SChris Mason } 877ccd467d6SChris Mason } 87815ee9bc7SJosef Bacik 87915ee9bc7SJosef Bacik do { 8807ea394f1SYan Zheng int snap_pending = 0; 88115ee9bc7SJosef Bacik joined = cur_trans->num_joined; 8827ea394f1SYan Zheng if (!list_empty(&trans->transaction->pending_snapshots)) 8837ea394f1SYan Zheng snap_pending = 1; 8847ea394f1SYan Zheng 8852c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 88615ee9bc7SJosef Bacik prepare_to_wait(&cur_trans->writer_wait, &wait, 88779154b1bSChris Mason TASK_UNINTERRUPTIBLE); 88815ee9bc7SJosef Bacik 88915ee9bc7SJosef Bacik if (cur_trans->num_writers > 1) 89015ee9bc7SJosef Bacik timeout = MAX_SCHEDULE_TIMEOUT; 89115ee9bc7SJosef Bacik else 89215ee9bc7SJosef Bacik timeout = 1; 89315ee9bc7SJosef Bacik 89479154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 89515ee9bc7SJosef Bacik 8967ea394f1SYan Zheng if (snap_pending) { 8977ea394f1SYan Zheng ret = btrfs_wait_ordered_extents(root, 1); 8987ea394f1SYan Zheng BUG_ON(ret); 8997ea394f1SYan Zheng } 9007ea394f1SYan Zheng 90115ee9bc7SJosef Bacik schedule_timeout(timeout); 90215ee9bc7SJosef Bacik 90379154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 90415ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 90515ee9bc7SJosef Bacik } while (cur_trans->num_writers > 1 || 90615ee9bc7SJosef Bacik (cur_trans->num_joined != joined)); 90715ee9bc7SJosef Bacik 9083063d29fSChris Mason ret = create_pending_snapshots(trans, root->fs_info); 9093063d29fSChris Mason BUG_ON(ret); 9103063d29fSChris Mason 9112c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 912dc17ff8fSChris Mason 913e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 914e02119d5SChris Mason * various roots consistent with each other. Every pointer 915e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 916e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 917e02119d5SChris Mason * the tree logging code from jumping in and changing any 918e02119d5SChris Mason * of the trees. 919e02119d5SChris Mason * 920e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 921e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 922e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 923e02119d5SChris Mason * from now until after the super is written, we avoid races 924e02119d5SChris Mason * with the tree-log code. 925e02119d5SChris Mason */ 926e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 9271a40e23bSZheng Yan /* 9281a40e23bSZheng Yan * keep tree reloc code from adding new reloc trees 9291a40e23bSZheng Yan */ 9301a40e23bSZheng Yan mutex_lock(&root->fs_info->tree_reloc_mutex); 9311a40e23bSZheng Yan 932e02119d5SChris Mason 93354aa1f4dSChris Mason ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix, 93454aa1f4dSChris Mason &dirty_fs_roots); 93554aa1f4dSChris Mason BUG_ON(ret); 93654aa1f4dSChris Mason 937e02119d5SChris Mason /* add_dirty_roots gets rid of all the tree log roots, it is now 938e02119d5SChris Mason * safe to free the root of tree log roots 939e02119d5SChris Mason */ 940e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 941e02119d5SChris Mason 94279154b1bSChris Mason ret = btrfs_commit_tree_roots(trans, root); 94379154b1bSChris Mason BUG_ON(ret); 94454aa1f4dSChris Mason 94578fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 946cee36a03SChris Mason spin_lock(&root->fs_info->new_trans_lock); 94778fae27eSChris Mason root->fs_info->running_transaction = NULL; 948cee36a03SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 9494b52dff6SChris Mason btrfs_set_super_generation(&root->fs_info->super_copy, 9504b52dff6SChris Mason cur_trans->transid); 9514b52dff6SChris Mason btrfs_set_super_root(&root->fs_info->super_copy, 952db94535dSChris Mason root->fs_info->tree_root->node->start); 953db94535dSChris Mason btrfs_set_super_root_level(&root->fs_info->super_copy, 954db94535dSChris Mason btrfs_header_level(root->fs_info->tree_root->node)); 9555f39d397SChris Mason 9560b86a832SChris Mason btrfs_set_super_chunk_root(&root->fs_info->super_copy, 9570b86a832SChris Mason chunk_root->node->start); 9580b86a832SChris Mason btrfs_set_super_chunk_root_level(&root->fs_info->super_copy, 9590b86a832SChris Mason btrfs_header_level(chunk_root->node)); 96084234f3aSYan Zheng btrfs_set_super_chunk_root_generation(&root->fs_info->super_copy, 96184234f3aSYan Zheng btrfs_header_generation(chunk_root->node)); 962e02119d5SChris Mason 963e02119d5SChris Mason if (!root->fs_info->log_root_recovering) { 964e02119d5SChris Mason btrfs_set_super_log_root(&root->fs_info->super_copy, 0); 965e02119d5SChris Mason btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0); 966e02119d5SChris Mason } 967e02119d5SChris Mason 968a061fc8dSChris Mason memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy, 9694b52dff6SChris Mason sizeof(root->fs_info->super_copy)); 970ccd467d6SChris Mason 9714313b399SChris Mason btrfs_copy_pinned(root, pinned_copy); 972ccd467d6SChris Mason 973f9295749SChris Mason trans->transaction->blocked = 0; 974e6dcd2dcSChris Mason wake_up(&root->fs_info->transaction_throttle); 975f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 976e6dcd2dcSChris Mason 97778fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 97879154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 97979154b1bSChris Mason BUG_ON(ret); 98079154b1bSChris Mason write_ctree_super(trans, root); 9814313b399SChris Mason 982e02119d5SChris Mason /* 983e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 984e02119d5SChris Mason * to go about their business 985e02119d5SChris Mason */ 986e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 987e02119d5SChris Mason 9884313b399SChris Mason btrfs_finish_extent_commit(trans, root, pinned_copy); 9894313b399SChris Mason kfree(pinned_copy); 9904313b399SChris Mason 9911a40e23bSZheng Yan btrfs_drop_dead_reloc_roots(root); 9921a40e23bSZheng Yan mutex_unlock(&root->fs_info->tree_reloc_mutex); 9931a40e23bSZheng Yan 9941a40e23bSZheng Yan mutex_lock(&root->fs_info->trans_mutex); 9951a40e23bSZheng Yan 9962c90e5d6SChris Mason cur_trans->commit_done = 1; 99715ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 9982c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 99979154b1bSChris Mason put_transaction(cur_trans); 100078fae27eSChris Mason put_transaction(cur_trans); 100158176a96SJosef Bacik 1002bcc63abbSYan list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots); 1003facda1e7SChris Mason if (root->fs_info->closing) 1004facda1e7SChris Mason list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots); 100558176a96SJosef Bacik 100678fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 10072c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 100879154b1bSChris Mason 1009facda1e7SChris Mason if (root->fs_info->closing) { 10100f7d52f4SChris Mason drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots); 1011facda1e7SChris Mason } 101279154b1bSChris Mason return ret; 101379154b1bSChris Mason } 101479154b1bSChris Mason 1015d352ac68SChris Mason /* 1016d352ac68SChris Mason * interface function to delete all the snapshots we have scheduled for deletion 1017d352ac68SChris Mason */ 1018e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 1019e9d0b13bSChris Mason { 1020e9d0b13bSChris Mason struct list_head dirty_roots; 1021e9d0b13bSChris Mason INIT_LIST_HEAD(&dirty_roots); 1022a74a4b97SChris Mason again: 1023e9d0b13bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 1024e9d0b13bSChris Mason list_splice_init(&root->fs_info->dead_roots, &dirty_roots); 1025e9d0b13bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 1026e9d0b13bSChris Mason 1027e9d0b13bSChris Mason if (!list_empty(&dirty_roots)) { 1028e9d0b13bSChris Mason drop_dirty_roots(root, &dirty_roots); 1029a74a4b97SChris Mason goto again; 1030e9d0b13bSChris Mason } 1031e9d0b13bSChris Mason return 0; 1032e9d0b13bSChris Mason } 1033