Chris Mason | 6cbd557 | 2007-06-12 09:07:21 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2007 Oracle. All rights reserved. |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or |
| 5 | * modify it under the terms of the GNU General Public |
| 6 | * License v2 as published by the Free Software Foundation. |
| 7 | * |
| 8 | * This program is distributed in the hope that it will be useful, |
| 9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 11 | * General Public License for more details. |
| 12 | * |
| 13 | * You should have received a copy of the GNU General Public |
| 14 | * License along with this program; if not, write to the |
| 15 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 16 | * Boston, MA 021110-1307, USA. |
| 17 | */ |
| 18 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 19 | #include <linux/fs.h> |
Chris Mason | 3408878 | 2007-06-12 11:36:58 -0400 | [diff] [blame] | 20 | #include <linux/sched.h> |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 21 | #include <linux/writeback.h> |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 22 | #include <linux/pagemap.h> |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 23 | #include "ctree.h" |
| 24 | #include "disk-io.h" |
| 25 | #include "transaction.h" |
| 26 | |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 27 | static int total_trans = 0; |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 28 | extern struct kmem_cache *btrfs_trans_handle_cachep; |
| 29 | extern struct kmem_cache *btrfs_transaction_cachep; |
| 30 | |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 31 | static struct workqueue_struct *trans_wq; |
| 32 | |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 33 | #define BTRFS_ROOT_TRANS_TAG 0 |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 34 | #define BTRFS_ROOT_DEFRAG_TAG 1 |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 35 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 36 | static void put_transaction(struct btrfs_transaction *transaction) |
| 37 | { |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 38 | WARN_ON(transaction->use_count == 0); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 39 | transaction->use_count--; |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 40 | if (transaction->use_count == 0) { |
| 41 | WARN_ON(total_trans == 0); |
| 42 | total_trans--; |
Chris Mason | 8fd1779 | 2007-04-19 21:01:03 -0400 | [diff] [blame] | 43 | list_del_init(&transaction->list); |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 44 | memset(transaction, 0, sizeof(*transaction)); |
| 45 | kmem_cache_free(btrfs_transaction_cachep, transaction); |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 46 | } |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | static int join_transaction(struct btrfs_root *root) |
| 50 | { |
| 51 | struct btrfs_transaction *cur_trans; |
| 52 | cur_trans = root->fs_info->running_transaction; |
| 53 | if (!cur_trans) { |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 54 | cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, |
| 55 | GFP_NOFS); |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 56 | total_trans++; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 57 | BUG_ON(!cur_trans); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 58 | root->fs_info->generation++; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 59 | root->fs_info->running_transaction = cur_trans; |
Chris Mason | e18e480 | 2008-01-18 10:54:22 -0500 | [diff] [blame] | 60 | root->fs_info->last_alloc = 0; |
Chris Mason | 4529ba4 | 2008-01-31 16:45:07 -0500 | [diff] [blame^] | 61 | root->fs_info->last_data_alloc = 0; |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 62 | cur_trans->num_writers = 1; |
| 63 | cur_trans->num_joined = 0; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 64 | cur_trans->transid = root->fs_info->generation; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 65 | init_waitqueue_head(&cur_trans->writer_wait); |
| 66 | init_waitqueue_head(&cur_trans->commit_wait); |
| 67 | cur_trans->in_commit = 0; |
Chris Mason | d571976 | 2007-03-23 10:01:08 -0400 | [diff] [blame] | 68 | cur_trans->use_count = 1; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 69 | cur_trans->commit_done = 0; |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 70 | cur_trans->start_time = get_seconds(); |
Chris Mason | 3063d29 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 71 | INIT_LIST_HEAD(&cur_trans->pending_snapshots); |
Chris Mason | 8fd1779 | 2007-04-19 21:01:03 -0400 | [diff] [blame] | 72 | list_add_tail(&cur_trans->list, &root->fs_info->trans_list); |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 73 | btrfs_ordered_inode_tree_init(&cur_trans->ordered_inode_tree); |
Chris Mason | d1310b2 | 2008-01-24 16:13:08 -0500 | [diff] [blame] | 74 | extent_io_tree_init(&cur_trans->dirty_pages, |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 75 | root->fs_info->btree_inode->i_mapping, |
| 76 | GFP_NOFS); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 77 | } else { |
| 78 | cur_trans->num_writers++; |
| 79 | cur_trans->num_joined++; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 80 | } |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 81 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 82 | return 0; |
| 83 | } |
| 84 | |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 85 | static int record_root_in_trans(struct btrfs_root *root) |
| 86 | { |
| 87 | u64 running_trans_id = root->fs_info->running_transaction->transid; |
| 88 | if (root->ref_cows && root->last_trans < running_trans_id) { |
| 89 | WARN_ON(root == root->fs_info->extent_root); |
| 90 | if (root->root_item.refs != 0) { |
| 91 | radix_tree_tag_set(&root->fs_info->fs_roots_radix, |
| 92 | (unsigned long)root->root_key.objectid, |
| 93 | BTRFS_ROOT_TRANS_TAG); |
| 94 | radix_tree_tag_set(&root->fs_info->fs_roots_radix, |
| 95 | (unsigned long)root->root_key.objectid, |
| 96 | BTRFS_ROOT_DEFRAG_TAG); |
| 97 | root->commit_root = root->node; |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 98 | extent_buffer_get(root->node); |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 99 | } else { |
| 100 | WARN_ON(1); |
| 101 | } |
| 102 | root->last_trans = running_trans_id; |
| 103 | } |
| 104 | return 0; |
| 105 | } |
| 106 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 107 | struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, |
| 108 | int num_blocks) |
| 109 | { |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 110 | struct btrfs_trans_handle *h = |
| 111 | kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 112 | int ret; |
| 113 | |
| 114 | mutex_lock(&root->fs_info->trans_mutex); |
| 115 | ret = join_transaction(root); |
| 116 | BUG_ON(ret); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 117 | |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 118 | record_root_in_trans(root); |
| 119 | h->transid = root->fs_info->running_transaction->transid; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 120 | h->transaction = root->fs_info->running_transaction; |
| 121 | h->blocks_reserved = num_blocks; |
| 122 | h->blocks_used = 0; |
Chris Mason | 31f3c99 | 2007-04-30 15:25:45 -0400 | [diff] [blame] | 123 | h->block_group = NULL; |
Chris Mason | 26b8003 | 2007-08-08 20:17:12 -0400 | [diff] [blame] | 124 | h->alloc_exclude_nr = 0; |
| 125 | h->alloc_exclude_start = 0; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 126 | root->fs_info->running_transaction->use_count++; |
| 127 | mutex_unlock(&root->fs_info->trans_mutex); |
| 128 | return h; |
| 129 | } |
| 130 | |
| 131 | int btrfs_end_transaction(struct btrfs_trans_handle *trans, |
| 132 | struct btrfs_root *root) |
| 133 | { |
| 134 | struct btrfs_transaction *cur_trans; |
Chris Mason | d6e4a42 | 2007-04-06 15:37:36 -0400 | [diff] [blame] | 135 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 136 | mutex_lock(&root->fs_info->trans_mutex); |
| 137 | cur_trans = root->fs_info->running_transaction; |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 138 | WARN_ON(cur_trans != trans->transaction); |
Chris Mason | d571976 | 2007-03-23 10:01:08 -0400 | [diff] [blame] | 139 | WARN_ON(cur_trans->num_writers < 1); |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 140 | cur_trans->num_writers--; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 141 | if (waitqueue_active(&cur_trans->writer_wait)) |
| 142 | wake_up(&cur_trans->writer_wait); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 143 | put_transaction(cur_trans); |
| 144 | mutex_unlock(&root->fs_info->trans_mutex); |
Chris Mason | d602557 | 2007-03-30 14:27:56 -0400 | [diff] [blame] | 145 | memset(trans, 0, sizeof(*trans)); |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 146 | kmem_cache_free(btrfs_trans_handle_cachep, trans); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 147 | return 0; |
| 148 | } |
| 149 | |
| 150 | |
| 151 | int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, |
| 152 | struct btrfs_root *root) |
| 153 | { |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 154 | int ret; |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 155 | int err; |
| 156 | int werr = 0; |
Chris Mason | d1310b2 | 2008-01-24 16:13:08 -0500 | [diff] [blame] | 157 | struct extent_io_tree *dirty_pages; |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 158 | struct page *page; |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 159 | struct inode *btree_inode = root->fs_info->btree_inode; |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 160 | u64 start; |
| 161 | u64 end; |
| 162 | unsigned long index; |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 163 | |
| 164 | if (!trans || !trans->transaction) { |
| 165 | return filemap_write_and_wait(btree_inode->i_mapping); |
| 166 | } |
| 167 | dirty_pages = &trans->transaction->dirty_pages; |
| 168 | while(1) { |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 169 | ret = find_first_extent_bit(dirty_pages, 0, &start, &end, |
| 170 | EXTENT_DIRTY); |
| 171 | if (ret) |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 172 | break; |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 173 | clear_extent_dirty(dirty_pages, start, end, GFP_NOFS); |
| 174 | while(start <= end) { |
| 175 | index = start >> PAGE_CACHE_SHIFT; |
Chris Mason | 35ebb93 | 2007-10-30 16:56:53 -0400 | [diff] [blame] | 176 | start = (u64)(index + 1) << PAGE_CACHE_SHIFT; |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 177 | page = find_lock_page(btree_inode->i_mapping, index); |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 178 | if (!page) |
| 179 | continue; |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 180 | if (PageWriteback(page)) { |
| 181 | if (PageDirty(page)) |
| 182 | wait_on_page_writeback(page); |
| 183 | else { |
| 184 | unlock_page(page); |
| 185 | page_cache_release(page); |
| 186 | continue; |
| 187 | } |
| 188 | } |
Chris Mason | 7c4452b | 2007-04-28 09:29:35 -0400 | [diff] [blame] | 189 | err = write_one_page(page, 0); |
| 190 | if (err) |
| 191 | werr = err; |
| 192 | page_cache_release(page); |
| 193 | } |
| 194 | } |
| 195 | err = filemap_fdatawait(btree_inode->i_mapping); |
| 196 | if (err) |
| 197 | werr = err; |
| 198 | return werr; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | int btrfs_commit_tree_roots(struct btrfs_trans_handle *trans, |
| 202 | struct btrfs_root *root) |
| 203 | { |
| 204 | int ret; |
| 205 | u64 old_extent_block; |
| 206 | struct btrfs_fs_info *fs_info = root->fs_info; |
| 207 | struct btrfs_root *tree_root = fs_info->tree_root; |
| 208 | struct btrfs_root *extent_root = fs_info->extent_root; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 209 | |
Chris Mason | 9078a3e | 2007-04-26 16:46:15 -0400 | [diff] [blame] | 210 | btrfs_write_dirty_block_groups(trans, extent_root); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 211 | while(1) { |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 212 | old_extent_block = btrfs_root_bytenr(&extent_root->root_item); |
| 213 | if (old_extent_block == extent_root->node->start) |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 214 | break; |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 215 | btrfs_set_root_bytenr(&extent_root->root_item, |
| 216 | extent_root->node->start); |
| 217 | btrfs_set_root_level(&extent_root->root_item, |
| 218 | btrfs_header_level(extent_root->node)); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 219 | ret = btrfs_update_root(trans, tree_root, |
| 220 | &extent_root->root_key, |
| 221 | &extent_root->root_item); |
| 222 | BUG_ON(ret); |
Chris Mason | 9078a3e | 2007-04-26 16:46:15 -0400 | [diff] [blame] | 223 | btrfs_write_dirty_block_groups(trans, extent_root); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 224 | } |
| 225 | return 0; |
| 226 | } |
| 227 | |
| 228 | static int wait_for_commit(struct btrfs_root *root, |
| 229 | struct btrfs_transaction *commit) |
| 230 | { |
| 231 | DEFINE_WAIT(wait); |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 232 | mutex_lock(&root->fs_info->trans_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 233 | while(!commit->commit_done) { |
| 234 | prepare_to_wait(&commit->commit_wait, &wait, |
| 235 | TASK_UNINTERRUPTIBLE); |
| 236 | if (commit->commit_done) |
| 237 | break; |
| 238 | mutex_unlock(&root->fs_info->trans_mutex); |
| 239 | schedule(); |
| 240 | mutex_lock(&root->fs_info->trans_mutex); |
| 241 | } |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 242 | mutex_unlock(&root->fs_info->trans_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 243 | finish_wait(&commit->commit_wait, &wait); |
| 244 | return 0; |
| 245 | } |
| 246 | |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 247 | struct dirty_root { |
| 248 | struct list_head list; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 249 | struct btrfs_root *root; |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 250 | struct btrfs_root *latest_root; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 251 | }; |
| 252 | |
Chris Mason | 5ce14bb | 2007-09-11 11:15:39 -0400 | [diff] [blame] | 253 | int btrfs_add_dead_root(struct btrfs_root *root, |
| 254 | struct btrfs_root *latest, |
| 255 | struct list_head *dead_list) |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 256 | { |
| 257 | struct dirty_root *dirty; |
| 258 | |
| 259 | dirty = kmalloc(sizeof(*dirty), GFP_NOFS); |
| 260 | if (!dirty) |
| 261 | return -ENOMEM; |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 262 | dirty->root = root; |
Chris Mason | 5ce14bb | 2007-09-11 11:15:39 -0400 | [diff] [blame] | 263 | dirty->latest_root = latest; |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 264 | list_add(&dirty->list, dead_list); |
| 265 | return 0; |
| 266 | } |
| 267 | |
Chris Mason | 35b7e47 | 2007-05-02 15:53:43 -0400 | [diff] [blame] | 268 | static int add_dirty_roots(struct btrfs_trans_handle *trans, |
| 269 | struct radix_tree_root *radix, |
| 270 | struct list_head *list) |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 271 | { |
| 272 | struct dirty_root *dirty; |
| 273 | struct btrfs_root *gang[8]; |
| 274 | struct btrfs_root *root; |
| 275 | int i; |
| 276 | int ret; |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 277 | int err = 0; |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 278 | u32 refs; |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 279 | |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 280 | while(1) { |
| 281 | ret = radix_tree_gang_lookup_tag(radix, (void **)gang, 0, |
| 282 | ARRAY_SIZE(gang), |
| 283 | BTRFS_ROOT_TRANS_TAG); |
| 284 | if (ret == 0) |
| 285 | break; |
| 286 | for (i = 0; i < ret; i++) { |
| 287 | root = gang[i]; |
Chris Mason | 2619ba1 | 2007-04-10 16:58:11 -0400 | [diff] [blame] | 288 | radix_tree_tag_clear(radix, |
| 289 | (unsigned long)root->root_key.objectid, |
| 290 | BTRFS_ROOT_TRANS_TAG); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 291 | if (root->commit_root == root->node) { |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 292 | WARN_ON(root->node->start != |
| 293 | btrfs_root_bytenr(&root->root_item)); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 294 | free_extent_buffer(root->commit_root); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 295 | root->commit_root = NULL; |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 296 | |
| 297 | /* make sure to update the root on disk |
| 298 | * so we get any updates to the block used |
| 299 | * counts |
| 300 | */ |
| 301 | err = btrfs_update_root(trans, |
| 302 | root->fs_info->tree_root, |
| 303 | &root->root_key, |
| 304 | &root->root_item); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 305 | continue; |
| 306 | } |
| 307 | dirty = kmalloc(sizeof(*dirty), GFP_NOFS); |
| 308 | BUG_ON(!dirty); |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 309 | dirty->root = kmalloc(sizeof(*dirty->root), GFP_NOFS); |
| 310 | BUG_ON(!dirty->root); |
| 311 | |
| 312 | memset(&root->root_item.drop_progress, 0, |
| 313 | sizeof(struct btrfs_disk_key)); |
| 314 | root->root_item.drop_level = 0; |
| 315 | |
| 316 | memcpy(dirty->root, root, sizeof(*root)); |
| 317 | dirty->root->node = root->commit_root; |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 318 | dirty->latest_root = root; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 319 | root->commit_root = NULL; |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 320 | |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 321 | root->root_key.offset = root->fs_info->generation; |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 322 | btrfs_set_root_bytenr(&root->root_item, |
| 323 | root->node->start); |
| 324 | btrfs_set_root_level(&root->root_item, |
| 325 | btrfs_header_level(root->node)); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 326 | err = btrfs_insert_root(trans, root->fs_info->tree_root, |
| 327 | &root->root_key, |
| 328 | &root->root_item); |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 329 | if (err) |
| 330 | break; |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 331 | |
| 332 | refs = btrfs_root_refs(&dirty->root->root_item); |
| 333 | btrfs_set_root_refs(&dirty->root->root_item, refs - 1); |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 334 | err = btrfs_update_root(trans, root->fs_info->tree_root, |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 335 | &dirty->root->root_key, |
| 336 | &dirty->root->root_item); |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 337 | |
| 338 | BUG_ON(err); |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 339 | if (refs == 1) { |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 340 | list_add(&dirty->list, list); |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 341 | } else { |
| 342 | WARN_ON(1); |
| 343 | kfree(dirty->root); |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 344 | kfree(dirty); |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 345 | } |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 346 | } |
| 347 | } |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 348 | return err; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 349 | } |
| 350 | |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 351 | int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) |
| 352 | { |
| 353 | struct btrfs_fs_info *info = root->fs_info; |
| 354 | int ret; |
| 355 | struct btrfs_trans_handle *trans; |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 356 | unsigned long nr; |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 357 | |
| 358 | if (root->defrag_running) |
| 359 | return 0; |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 360 | trans = btrfs_start_transaction(root, 1); |
Chris Mason | 6b80053 | 2007-10-15 16:17:34 -0400 | [diff] [blame] | 361 | while (1) { |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 362 | root->defrag_running = 1; |
| 363 | ret = btrfs_defrag_leaves(trans, root, cacheonly); |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 364 | nr = trans->blocks_used; |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 365 | btrfs_end_transaction(trans, root); |
| 366 | mutex_unlock(&info->fs_mutex); |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 367 | btrfs_btree_balance_dirty(info->tree_root, nr); |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 368 | cond_resched(); |
| 369 | |
| 370 | mutex_lock(&info->fs_mutex); |
| 371 | trans = btrfs_start_transaction(root, 1); |
| 372 | if (ret != -EAGAIN) |
| 373 | break; |
| 374 | } |
| 375 | root->defrag_running = 0; |
| 376 | radix_tree_tag_clear(&info->fs_roots_radix, |
| 377 | (unsigned long)root->root_key.objectid, |
| 378 | BTRFS_ROOT_DEFRAG_TAG); |
| 379 | btrfs_end_transaction(trans, root); |
| 380 | return 0; |
| 381 | } |
| 382 | |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 383 | int btrfs_defrag_dirty_roots(struct btrfs_fs_info *info) |
| 384 | { |
| 385 | struct btrfs_root *gang[1]; |
| 386 | struct btrfs_root *root; |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 387 | int i; |
| 388 | int ret; |
| 389 | int err = 0; |
| 390 | u64 last = 0; |
| 391 | |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 392 | while(1) { |
| 393 | ret = radix_tree_gang_lookup_tag(&info->fs_roots_radix, |
| 394 | (void **)gang, last, |
| 395 | ARRAY_SIZE(gang), |
| 396 | BTRFS_ROOT_DEFRAG_TAG); |
| 397 | if (ret == 0) |
| 398 | break; |
| 399 | for (i = 0; i < ret; i++) { |
| 400 | root = gang[i]; |
| 401 | last = root->root_key.objectid + 1; |
Chris Mason | f510cfe | 2007-10-15 16:14:48 -0400 | [diff] [blame] | 402 | btrfs_defrag_root(root, 1); |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 403 | } |
| 404 | } |
Chris Mason | 6b80053 | 2007-10-15 16:17:34 -0400 | [diff] [blame] | 405 | btrfs_defrag_root(info->extent_root, 1); |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 406 | return err; |
| 407 | } |
| 408 | |
Chris Mason | 35b7e47 | 2007-05-02 15:53:43 -0400 | [diff] [blame] | 409 | static int drop_dirty_roots(struct btrfs_root *tree_root, |
| 410 | struct list_head *list) |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 411 | { |
| 412 | struct dirty_root *dirty; |
| 413 | struct btrfs_trans_handle *trans; |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 414 | unsigned long nr; |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 415 | u64 num_bytes; |
| 416 | u64 bytes_used; |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 417 | int ret = 0; |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 418 | int err; |
| 419 | |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 420 | while(!list_empty(list)) { |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 421 | struct btrfs_root *root; |
| 422 | |
Chris Mason | facda1e | 2007-06-08 18:11:48 -0400 | [diff] [blame] | 423 | mutex_lock(&tree_root->fs_info->fs_mutex); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 424 | dirty = list_entry(list->next, struct dirty_root, list); |
| 425 | list_del_init(&dirty->list); |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 426 | |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 427 | num_bytes = btrfs_root_used(&dirty->root->root_item); |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 428 | root = dirty->latest_root; |
Chris Mason | e2008b6 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 429 | root->fs_info->throttles++; |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 430 | |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 431 | while(1) { |
| 432 | trans = btrfs_start_transaction(tree_root, 1); |
| 433 | ret = btrfs_drop_snapshot(trans, dirty->root); |
| 434 | if (ret != -EAGAIN) { |
| 435 | break; |
| 436 | } |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 437 | |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 438 | err = btrfs_update_root(trans, |
| 439 | tree_root, |
| 440 | &dirty->root->root_key, |
| 441 | &dirty->root->root_item); |
| 442 | if (err) |
| 443 | ret = err; |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 444 | nr = trans->blocks_used; |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 445 | ret = btrfs_end_transaction(trans, tree_root); |
| 446 | BUG_ON(ret); |
Chris Mason | f4468e9 | 2007-08-08 10:08:58 -0400 | [diff] [blame] | 447 | mutex_unlock(&tree_root->fs_info->fs_mutex); |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 448 | btrfs_btree_balance_dirty(tree_root, nr); |
Chris Mason | 4dc11904 | 2007-10-15 16:18:14 -0400 | [diff] [blame] | 449 | cond_resched(); |
Chris Mason | f4468e9 | 2007-08-08 10:08:58 -0400 | [diff] [blame] | 450 | mutex_lock(&tree_root->fs_info->fs_mutex); |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 451 | } |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 452 | BUG_ON(ret); |
Chris Mason | e2008b6 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 453 | root->fs_info->throttles--; |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 454 | |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 455 | num_bytes -= btrfs_root_used(&dirty->root->root_item); |
| 456 | bytes_used = btrfs_root_used(&root->root_item); |
| 457 | if (num_bytes) { |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 458 | record_root_in_trans(root); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 459 | btrfs_set_root_used(&root->root_item, |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 460 | bytes_used - num_bytes); |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 461 | } |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 462 | ret = btrfs_del_root(trans, tree_root, &dirty->root->root_key); |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 463 | if (ret) { |
| 464 | BUG(); |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 465 | break; |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 466 | } |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 467 | nr = trans->blocks_used; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 468 | ret = btrfs_end_transaction(trans, tree_root); |
| 469 | BUG_ON(ret); |
Chris Mason | 5eda7b5 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 470 | |
Chris Mason | f510cfe | 2007-10-15 16:14:48 -0400 | [diff] [blame] | 471 | free_extent_buffer(dirty->root->node); |
Chris Mason | 9f3a742 | 2007-08-07 15:52:19 -0400 | [diff] [blame] | 472 | kfree(dirty->root); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 473 | kfree(dirty); |
Chris Mason | facda1e | 2007-06-08 18:11:48 -0400 | [diff] [blame] | 474 | mutex_unlock(&tree_root->fs_info->fs_mutex); |
Chris Mason | d3c2fdcf | 2007-09-17 10:58:06 -0400 | [diff] [blame] | 475 | |
| 476 | btrfs_btree_balance_dirty(tree_root, nr); |
Chris Mason | 4dc11904 | 2007-10-15 16:18:14 -0400 | [diff] [blame] | 477 | cond_resched(); |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 478 | } |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 479 | return ret; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 480 | } |
| 481 | |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 482 | int btrfs_write_ordered_inodes(struct btrfs_trans_handle *trans, |
| 483 | struct btrfs_root *root) |
| 484 | { |
| 485 | struct btrfs_transaction *cur_trans = trans->transaction; |
| 486 | struct inode *inode; |
| 487 | u64 root_objectid = 0; |
| 488 | u64 objectid = 0; |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 489 | int ret; |
| 490 | |
Chris Mason | e2008b6 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 491 | root->fs_info->throttles++; |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 492 | while(1) { |
| 493 | ret = btrfs_find_first_ordered_inode( |
| 494 | &cur_trans->ordered_inode_tree, |
Chris Mason | 4d5e74b | 2008-01-16 16:09:22 -0500 | [diff] [blame] | 495 | &root_objectid, &objectid, &inode); |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 496 | if (!ret) |
| 497 | break; |
| 498 | |
| 499 | mutex_unlock(&root->fs_info->trans_mutex); |
| 500 | mutex_unlock(&root->fs_info->fs_mutex); |
Chris Mason | 4d5e74b | 2008-01-16 16:09:22 -0500 | [diff] [blame] | 501 | |
| 502 | if (S_ISREG(inode->i_mode)) |
| 503 | filemap_fdatawrite(inode->i_mapping); |
| 504 | iput(inode); |
| 505 | |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 506 | mutex_lock(&root->fs_info->fs_mutex); |
| 507 | mutex_lock(&root->fs_info->trans_mutex); |
| 508 | } |
| 509 | while(1) { |
| 510 | root_objectid = 0; |
| 511 | objectid = 0; |
| 512 | ret = btrfs_find_del_first_ordered_inode( |
| 513 | &cur_trans->ordered_inode_tree, |
Chris Mason | 4d5e74b | 2008-01-16 16:09:22 -0500 | [diff] [blame] | 514 | &root_objectid, &objectid, &inode); |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 515 | if (!ret) |
| 516 | break; |
| 517 | mutex_unlock(&root->fs_info->trans_mutex); |
| 518 | mutex_unlock(&root->fs_info->fs_mutex); |
Chris Mason | 4d5e74b | 2008-01-16 16:09:22 -0500 | [diff] [blame] | 519 | |
| 520 | if (S_ISREG(inode->i_mode)) |
| 521 | filemap_write_and_wait(inode->i_mapping); |
| 522 | atomic_dec(&inode->i_count); |
| 523 | iput(inode); |
| 524 | |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 525 | mutex_lock(&root->fs_info->fs_mutex); |
| 526 | mutex_lock(&root->fs_info->trans_mutex); |
| 527 | } |
Chris Mason | e2008b6 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 528 | root->fs_info->throttles--; |
Chris Mason | 3063d29 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 529 | return 0; |
| 530 | } |
| 531 | |
| 532 | static int create_pending_snapshot(struct btrfs_trans_handle *trans, |
| 533 | struct btrfs_fs_info *fs_info, |
| 534 | struct btrfs_pending_snapshot *pending) |
| 535 | { |
| 536 | struct btrfs_key key; |
| 537 | struct btrfs_root_item new_root_item; |
| 538 | struct btrfs_root *tree_root = fs_info->tree_root; |
| 539 | struct btrfs_root *root = pending->root; |
| 540 | struct extent_buffer *tmp; |
| 541 | int ret; |
| 542 | u64 objectid; |
| 543 | |
| 544 | ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid); |
| 545 | if (ret) |
| 546 | goto fail; |
| 547 | |
| 548 | memcpy(&new_root_item, &root->root_item, sizeof(new_root_item)); |
| 549 | |
| 550 | key.objectid = objectid; |
| 551 | key.offset = 1; |
| 552 | btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); |
| 553 | |
| 554 | extent_buffer_get(root->node); |
| 555 | btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp); |
| 556 | free_extent_buffer(tmp); |
| 557 | |
| 558 | btrfs_copy_root(trans, root, root->node, &tmp, objectid); |
| 559 | |
| 560 | btrfs_set_root_bytenr(&new_root_item, tmp->start); |
| 561 | btrfs_set_root_level(&new_root_item, btrfs_header_level(tmp)); |
| 562 | ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key, |
| 563 | &new_root_item); |
| 564 | free_extent_buffer(tmp); |
| 565 | if (ret) |
| 566 | goto fail; |
| 567 | |
| 568 | /* |
| 569 | * insert the directory item |
| 570 | */ |
| 571 | key.offset = (u64)-1; |
| 572 | ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root, |
| 573 | pending->name, strlen(pending->name), |
| 574 | root->fs_info->sb->s_root->d_inode->i_ino, |
| 575 | &key, BTRFS_FT_DIR); |
| 576 | |
| 577 | if (ret) |
| 578 | goto fail; |
| 579 | |
| 580 | ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root, |
| 581 | pending->name, strlen(pending->name), objectid, |
| 582 | root->fs_info->sb->s_root->d_inode->i_ino); |
| 583 | fail: |
| 584 | return ret; |
| 585 | } |
| 586 | |
| 587 | static int create_pending_snapshots(struct btrfs_trans_handle *trans, |
| 588 | struct btrfs_fs_info *fs_info) |
| 589 | { |
| 590 | struct btrfs_pending_snapshot *pending; |
| 591 | struct list_head *head = &trans->transaction->pending_snapshots; |
| 592 | int ret; |
| 593 | |
| 594 | while(!list_empty(head)) { |
| 595 | pending = list_entry(head->next, |
| 596 | struct btrfs_pending_snapshot, list); |
| 597 | ret = create_pending_snapshot(trans, fs_info, pending); |
| 598 | BUG_ON(ret); |
| 599 | list_del(&pending->list); |
| 600 | kfree(pending->name); |
| 601 | kfree(pending); |
| 602 | } |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 603 | return 0; |
| 604 | } |
| 605 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 606 | int btrfs_commit_transaction(struct btrfs_trans_handle *trans, |
| 607 | struct btrfs_root *root) |
| 608 | { |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 609 | unsigned long joined = 0; |
| 610 | unsigned long timeout = 1; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 611 | struct btrfs_transaction *cur_trans; |
Chris Mason | 8fd1779 | 2007-04-19 21:01:03 -0400 | [diff] [blame] | 612 | struct btrfs_transaction *prev_trans = NULL; |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 613 | struct list_head dirty_fs_roots; |
Chris Mason | d1310b2 | 2008-01-24 16:13:08 -0500 | [diff] [blame] | 614 | struct extent_io_tree *pinned_copy; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 615 | DEFINE_WAIT(wait); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 616 | int ret; |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 617 | |
Chris Mason | 0f7d52f | 2007-04-09 10:42:37 -0400 | [diff] [blame] | 618 | INIT_LIST_HEAD(&dirty_fs_roots); |
Chris Mason | d6e4a42 | 2007-04-06 15:37:36 -0400 | [diff] [blame] | 619 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 620 | mutex_lock(&root->fs_info->trans_mutex); |
| 621 | if (trans->transaction->in_commit) { |
| 622 | cur_trans = trans->transaction; |
| 623 | trans->transaction->use_count++; |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 624 | mutex_unlock(&root->fs_info->trans_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 625 | btrfs_end_transaction(trans, root); |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 626 | |
| 627 | mutex_unlock(&root->fs_info->fs_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 628 | ret = wait_for_commit(root, cur_trans); |
| 629 | BUG_ON(ret); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 630 | |
| 631 | mutex_lock(&root->fs_info->trans_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 632 | put_transaction(cur_trans); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 633 | mutex_unlock(&root->fs_info->trans_mutex); |
| 634 | |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 635 | mutex_lock(&root->fs_info->fs_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 636 | return 0; |
| 637 | } |
Chris Mason | 4313b39 | 2008-01-03 09:08:48 -0500 | [diff] [blame] | 638 | |
| 639 | pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS); |
| 640 | if (!pinned_copy) |
| 641 | return -ENOMEM; |
| 642 | |
Chris Mason | d1310b2 | 2008-01-24 16:13:08 -0500 | [diff] [blame] | 643 | extent_io_tree_init(pinned_copy, |
Chris Mason | 4313b39 | 2008-01-03 09:08:48 -0500 | [diff] [blame] | 644 | root->fs_info->btree_inode->i_mapping, GFP_NOFS); |
| 645 | |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 646 | trans->transaction->in_commit = 1; |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 647 | cur_trans = trans->transaction; |
| 648 | if (cur_trans->list.prev != &root->fs_info->trans_list) { |
| 649 | prev_trans = list_entry(cur_trans->list.prev, |
| 650 | struct btrfs_transaction, list); |
| 651 | if (!prev_trans->commit_done) { |
| 652 | prev_trans->use_count++; |
| 653 | mutex_unlock(&root->fs_info->fs_mutex); |
| 654 | mutex_unlock(&root->fs_info->trans_mutex); |
| 655 | |
| 656 | wait_for_commit(root, prev_trans); |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 657 | |
| 658 | mutex_lock(&root->fs_info->fs_mutex); |
| 659 | mutex_lock(&root->fs_info->trans_mutex); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 660 | put_transaction(prev_trans); |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 661 | } |
| 662 | } |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 663 | |
| 664 | do { |
| 665 | joined = cur_trans->num_joined; |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 666 | WARN_ON(cur_trans != trans->transaction); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 667 | prepare_to_wait(&cur_trans->writer_wait, &wait, |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 668 | TASK_UNINTERRUPTIBLE); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 669 | |
| 670 | if (cur_trans->num_writers > 1) |
| 671 | timeout = MAX_SCHEDULE_TIMEOUT; |
| 672 | else |
| 673 | timeout = 1; |
| 674 | |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 675 | mutex_unlock(&root->fs_info->fs_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 676 | mutex_unlock(&root->fs_info->trans_mutex); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 677 | |
| 678 | schedule_timeout(timeout); |
| 679 | |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 680 | mutex_lock(&root->fs_info->fs_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 681 | mutex_lock(&root->fs_info->trans_mutex); |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 682 | finish_wait(&cur_trans->writer_wait, &wait); |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 683 | ret = btrfs_write_ordered_inodes(trans, root); |
| 684 | |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 685 | } while (cur_trans->num_writers > 1 || |
| 686 | (cur_trans->num_joined != joined)); |
| 687 | |
Chris Mason | 3063d29 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 688 | ret = create_pending_snapshots(trans, root->fs_info); |
| 689 | BUG_ON(ret); |
| 690 | |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 691 | WARN_ON(cur_trans != trans->transaction); |
Chris Mason | dc17ff8 | 2008-01-08 15:46:30 -0500 | [diff] [blame] | 692 | |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 693 | ret = add_dirty_roots(trans, &root->fs_info->fs_roots_radix, |
| 694 | &dirty_fs_roots); |
| 695 | BUG_ON(ret); |
| 696 | |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 697 | ret = btrfs_commit_tree_roots(trans, root); |
| 698 | BUG_ON(ret); |
Chris Mason | 54aa1f4 | 2007-06-22 14:16:25 -0400 | [diff] [blame] | 699 | |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 700 | cur_trans = root->fs_info->running_transaction; |
Chris Mason | cee36a0 | 2008-01-15 08:40:48 -0500 | [diff] [blame] | 701 | spin_lock(&root->fs_info->new_trans_lock); |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 702 | root->fs_info->running_transaction = NULL; |
Chris Mason | cee36a0 | 2008-01-15 08:40:48 -0500 | [diff] [blame] | 703 | spin_unlock(&root->fs_info->new_trans_lock); |
Chris Mason | 4b52dff | 2007-06-26 10:06:50 -0400 | [diff] [blame] | 704 | btrfs_set_super_generation(&root->fs_info->super_copy, |
| 705 | cur_trans->transid); |
| 706 | btrfs_set_super_root(&root->fs_info->super_copy, |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 707 | root->fs_info->tree_root->node->start); |
| 708 | btrfs_set_super_root_level(&root->fs_info->super_copy, |
| 709 | btrfs_header_level(root->fs_info->tree_root->node)); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 710 | |
| 711 | write_extent_buffer(root->fs_info->sb_buffer, |
| 712 | &root->fs_info->super_copy, 0, |
| 713 | sizeof(root->fs_info->super_copy)); |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 714 | |
Chris Mason | 4313b39 | 2008-01-03 09:08:48 -0500 | [diff] [blame] | 715 | btrfs_copy_pinned(root, pinned_copy); |
Chris Mason | ccd467d | 2007-06-28 15:57:36 -0400 | [diff] [blame] | 716 | |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 717 | mutex_unlock(&root->fs_info->trans_mutex); |
Chris Mason | 8fd1779 | 2007-04-19 21:01:03 -0400 | [diff] [blame] | 718 | mutex_unlock(&root->fs_info->fs_mutex); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 719 | ret = btrfs_write_and_wait_transaction(trans, root); |
| 720 | BUG_ON(ret); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 721 | write_ctree_super(trans, root); |
Chris Mason | 4313b39 | 2008-01-03 09:08:48 -0500 | [diff] [blame] | 722 | |
Chris Mason | 8fd1779 | 2007-04-19 21:01:03 -0400 | [diff] [blame] | 723 | mutex_lock(&root->fs_info->fs_mutex); |
Chris Mason | 4313b39 | 2008-01-03 09:08:48 -0500 | [diff] [blame] | 724 | btrfs_finish_extent_commit(trans, root, pinned_copy); |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 725 | mutex_lock(&root->fs_info->trans_mutex); |
Chris Mason | 4313b39 | 2008-01-03 09:08:48 -0500 | [diff] [blame] | 726 | |
| 727 | kfree(pinned_copy); |
| 728 | |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 729 | cur_trans->commit_done = 1; |
Josef Bacik | 15ee9bc | 2007-08-10 16:22:09 -0400 | [diff] [blame] | 730 | root->fs_info->last_trans_committed = cur_trans->transid; |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 731 | wake_up(&cur_trans->commit_wait); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 732 | put_transaction(cur_trans); |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 733 | put_transaction(cur_trans); |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 734 | |
Chris Mason | facda1e | 2007-06-08 18:11:48 -0400 | [diff] [blame] | 735 | if (root->fs_info->closing) |
| 736 | list_splice_init(&root->fs_info->dead_roots, &dirty_fs_roots); |
| 737 | else |
| 738 | list_splice_init(&dirty_fs_roots, &root->fs_info->dead_roots); |
Josef Bacik | 58176a9 | 2007-08-29 15:47:34 -0400 | [diff] [blame] | 739 | |
Chris Mason | 78fae27 | 2007-03-25 11:35:08 -0400 | [diff] [blame] | 740 | mutex_unlock(&root->fs_info->trans_mutex); |
Chris Mason | 2c90e5d | 2007-04-02 10:50:19 -0400 | [diff] [blame] | 741 | kmem_cache_free(btrfs_trans_handle_cachep, trans); |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 742 | |
Chris Mason | facda1e | 2007-06-08 18:11:48 -0400 | [diff] [blame] | 743 | if (root->fs_info->closing) { |
| 744 | mutex_unlock(&root->fs_info->fs_mutex); |
| 745 | drop_dirty_roots(root->fs_info->tree_root, &dirty_fs_roots); |
| 746 | mutex_lock(&root->fs_info->fs_mutex); |
| 747 | } |
Chris Mason | 79154b1 | 2007-03-22 15:59:16 -0400 | [diff] [blame] | 748 | return ret; |
| 749 | } |
| 750 | |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 751 | int btrfs_clean_old_snapshots(struct btrfs_root *root) |
| 752 | { |
| 753 | struct list_head dirty_roots; |
| 754 | INIT_LIST_HEAD(&dirty_roots); |
| 755 | |
| 756 | mutex_lock(&root->fs_info->trans_mutex); |
| 757 | list_splice_init(&root->fs_info->dead_roots, &dirty_roots); |
| 758 | mutex_unlock(&root->fs_info->trans_mutex); |
| 759 | |
| 760 | if (!list_empty(&dirty_roots)) { |
| 761 | drop_dirty_roots(root, &dirty_roots); |
| 762 | } |
| 763 | return 0; |
| 764 | } |
Chris Mason | 6da6aba | 2007-12-18 16:15:09 -0500 | [diff] [blame] | 765 | #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18) |
| 766 | void btrfs_transaction_cleaner(void *p) |
| 767 | #else |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 768 | void btrfs_transaction_cleaner(struct work_struct *work) |
Chris Mason | 6da6aba | 2007-12-18 16:15:09 -0500 | [diff] [blame] | 769 | #endif |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 770 | { |
Chris Mason | 6da6aba | 2007-12-18 16:15:09 -0500 | [diff] [blame] | 771 | #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18) |
| 772 | struct btrfs_fs_info *fs_info = p; |
| 773 | #else |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 774 | struct btrfs_fs_info *fs_info = container_of(work, |
| 775 | struct btrfs_fs_info, |
| 776 | trans_work.work); |
| 777 | |
Chris Mason | 6da6aba | 2007-12-18 16:15:09 -0500 | [diff] [blame] | 778 | #endif |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 779 | struct btrfs_root *root = fs_info->tree_root; |
| 780 | struct btrfs_transaction *cur; |
| 781 | struct btrfs_trans_handle *trans; |
| 782 | unsigned long now; |
| 783 | unsigned long delay = HZ * 30; |
| 784 | int ret; |
| 785 | |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 786 | mutex_lock(&root->fs_info->fs_mutex); |
| 787 | mutex_lock(&root->fs_info->trans_mutex); |
| 788 | cur = root->fs_info->running_transaction; |
| 789 | if (!cur) { |
| 790 | mutex_unlock(&root->fs_info->trans_mutex); |
| 791 | goto out; |
| 792 | } |
| 793 | now = get_seconds(); |
| 794 | if (now < cur->start_time || now - cur->start_time < 30) { |
| 795 | mutex_unlock(&root->fs_info->trans_mutex); |
| 796 | delay = HZ * 5; |
| 797 | goto out; |
| 798 | } |
| 799 | mutex_unlock(&root->fs_info->trans_mutex); |
Chris Mason | 6702ed4 | 2007-08-07 16:15:09 -0400 | [diff] [blame] | 800 | btrfs_defrag_dirty_roots(root->fs_info); |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 801 | trans = btrfs_start_transaction(root, 1); |
| 802 | ret = btrfs_commit_transaction(trans, root); |
| 803 | out: |
| 804 | mutex_unlock(&root->fs_info->fs_mutex); |
Chris Mason | e9d0b13 | 2007-08-10 14:06:19 -0400 | [diff] [blame] | 805 | btrfs_clean_old_snapshots(root); |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 806 | btrfs_transaction_queue_work(root, delay); |
| 807 | } |
| 808 | |
| 809 | void btrfs_transaction_queue_work(struct btrfs_root *root, int delay) |
| 810 | { |
| 811 | queue_delayed_work(trans_wq, &root->fs_info->trans_work, delay); |
| 812 | } |
| 813 | |
| 814 | void btrfs_transaction_flush_work(struct btrfs_root *root) |
| 815 | { |
| 816 | cancel_rearming_delayed_workqueue(trans_wq, &root->fs_info->trans_work); |
| 817 | flush_workqueue(trans_wq); |
| 818 | } |
| 819 | |
| 820 | void __init btrfs_init_transaction_sys(void) |
| 821 | { |
| 822 | trans_wq = create_workqueue("btrfs"); |
| 823 | } |
| 824 | |
Christian Hesse | 17636e0 | 2007-12-11 09:25:06 -0500 | [diff] [blame] | 825 | void btrfs_exit_transaction_sys(void) |
Chris Mason | 08607c1 | 2007-06-08 15:33:54 -0400 | [diff] [blame] | 826 | { |
| 827 | destroy_workqueue(trans_wq); |
| 828 | } |
| 829 | |