blob: 22443fac9408da17ca065f38b23e7025e63cefd9 [file] [log] [blame]
Chris Mason6cbd5572007-06-12 09:07:21 -04001/*
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 Masone20d96d2007-03-22 12:13:20 -040019#include <linux/fs.h>
Chris Masond98237b2007-03-28 13:57:48 -040020#include <linux/blkdev.h>
Chris Mason87cbda52007-03-28 19:44:27 -040021#include <linux/scatterlist.h>
Chris Mason22b0ebd2007-03-30 08:47:31 -040022#include <linux/swap.h>
Chris Mason0f7d52f2007-04-09 10:42:37 -040023#include <linux/radix-tree.h>
Chris Mason35b7e472007-05-02 15:53:43 -040024#include <linux/writeback.h>
Chris Masond3977122009-01-05 21:25:51 -050025#include <linux/buffer_head.h>
Chris Masonce9adaa2008-04-09 16:28:12 -040026#include <linux/workqueue.h>
Chris Masona74a4b92008-06-25 16:01:31 -040027#include <linux/kthread.h>
Chris Mason4b4e25f2008-11-20 10:22:27 -050028#include <linux/freezer.h>
David Woodhouse163e7832009-04-19 13:02:41 +010029#include <linux/crc32c.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Chris Mason784b4e22010-11-21 22:20:49 -050031#include <linux/migrate.h>
David Sterba7a36dde2011-05-06 15:33:15 +020032#include <linux/ratelimit.h>
Stefan Behrens6463fe52013-04-19 15:08:05 +000033#include <linux/uuid.h>
Stefan Behrens803b2f52013-08-15 17:11:21 +020034#include <linux/semaphore.h>
David Sterba7e75bf32011-03-18 22:56:43 +000035#include <asm/unaligned.h>
Chris Masoneb60cea2007-02-02 09:18:22 -050036#include "ctree.h"
37#include "disk-io.h"
Chris Masone089f052007-03-16 16:20:31 -040038#include "transaction.h"
Chris Mason0f7d52f2007-04-09 10:42:37 -040039#include "btrfs_inode.h"
Chris Mason0b86a832008-03-24 15:01:56 -040040#include "volumes.h"
Chris Masondb945352007-10-15 16:15:53 -040041#include "print-tree.h"
Chris Mason8b712842008-06-11 16:50:36 -040042#include "async-thread.h"
Chris Mason925baed2008-06-25 16:01:30 -040043#include "locking.h"
Chris Masone02119d2008-09-05 16:13:11 -040044#include "tree-log.h"
Chris Masonfa9c0d792009-04-03 09:47:43 -040045#include "free-space-cache.h"
Li Zefan581bb052011-04-20 10:06:11 +080046#include "inode-map.h"
Stefan Behrens21adbd52011-11-09 13:44:05 +010047#include "check-integrity.h"
Josef Bacik606686e2012-06-04 14:03:51 -040048#include "rcu-string.h"
Stefan Behrens8dabb742012-11-06 13:15:27 +010049#include "dev-replace.h"
David Woodhouse53b381b2013-01-29 18:40:14 -050050#include "raid56.h"
Chris Masoneb60cea2007-02-02 09:18:22 -050051
Josef Bacikde0022b2012-09-25 14:25:58 -040052#ifdef CONFIG_X86
53#include <asm/cpufeature.h>
54#endif
55
Chris Masond1310b22008-01-24 16:13:08 -050056static struct extent_io_ops btree_extent_io_ops;
Chris Mason8b712842008-06-11 16:50:36 -040057static void end_workqueue_fn(struct btrfs_work *work);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -040058static void free_fs_root(struct btrfs_root *root);
David Sterbafcd1f0652012-03-06 00:06:18 +010059static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
liuboacce9522011-01-06 19:30:25 +080060 int read_only);
Josef Bacik569e0f32013-02-13 11:09:14 -050061static void btrfs_destroy_ordered_operations(struct btrfs_transaction *t,
62 struct btrfs_root *root);
Jeff Mahoney143bede2012-03-01 14:56:26 +010063static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
liuboacce9522011-01-06 19:30:25 +080064static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
65 struct btrfs_root *root);
Jeff Mahoney143bede2012-03-01 14:56:26 +010066static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
liuboacce9522011-01-06 19:30:25 +080067static int btrfs_destroy_marked_extents(struct btrfs_root *root,
68 struct extent_io_tree *dirty_pages,
69 int mark);
70static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
71 struct extent_io_tree *pinned_extents);
Eric Sandeen48a3b632013-04-25 20:41:01 +000072static int btrfs_cleanup_transaction(struct btrfs_root *root);
73static void btrfs_error_commit_super(struct btrfs_root *root);
Chris Masonce9adaa2008-04-09 16:28:12 -040074
Chris Masond352ac62008-09-29 15:18:18 -040075/*
76 * end_io_wq structs are used to do processing in task context when an IO is
77 * complete. This is used during reads to verify checksums, and it is used
78 * by writes to insert metadata for new file extents after IO is complete.
79 */
Chris Masonce9adaa2008-04-09 16:28:12 -040080struct end_io_wq {
81 struct bio *bio;
82 bio_end_io_t *end_io;
83 void *private;
84 struct btrfs_fs_info *info;
85 int error;
Chris Mason22c59942008-04-09 16:28:12 -040086 int metadata;
Chris Masonce9adaa2008-04-09 16:28:12 -040087 struct list_head list;
Chris Mason8b712842008-06-11 16:50:36 -040088 struct btrfs_work work;
Chris Masonce9adaa2008-04-09 16:28:12 -040089};
Chris Mason0da54682007-11-07 21:08:01 -050090
Chris Masond352ac62008-09-29 15:18:18 -040091/*
92 * async submit bios are used to offload expensive checksumming
93 * onto the worker threads. They checksum file and metadata bios
94 * just before they are sent down the IO stack.
95 */
Chris Mason44b8bd72008-04-16 11:14:51 -040096struct async_submit_bio {
97 struct inode *inode;
98 struct bio *bio;
99 struct list_head list;
Chris Mason4a69a412008-11-06 22:03:00 -0500100 extent_submit_bio_hook_t *submit_bio_start;
101 extent_submit_bio_hook_t *submit_bio_done;
Chris Mason44b8bd72008-04-16 11:14:51 -0400102 int rw;
103 int mirror_num;
Chris Masonc8b97812008-10-29 14:49:59 -0400104 unsigned long bio_flags;
Chris Masoneaf25d92010-05-25 09:48:28 -0400105 /*
106 * bio_offset is optional, can be used if the pages in the bio
107 * can't tell us where in the file the bio should go
108 */
109 u64 bio_offset;
Chris Mason8b712842008-06-11 16:50:36 -0400110 struct btrfs_work work;
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100111 int error;
Chris Mason44b8bd72008-04-16 11:14:51 -0400112};
113
Chris Mason85d4e462011-07-26 16:11:19 -0400114/*
115 * Lockdep class keys for extent_buffer->lock's in this root. For a given
116 * eb, the lockdep key is determined by the btrfs_root it belongs to and
117 * the level the eb occupies in the tree.
Chris Mason4008c042009-02-12 14:09:45 -0500118 *
Chris Mason85d4e462011-07-26 16:11:19 -0400119 * Different roots are used for different purposes and may nest inside each
120 * other and they require separate keysets. As lockdep keys should be
121 * static, assign keysets according to the purpose of the root as indicated
122 * by btrfs_root->objectid. This ensures that all special purpose roots
123 * have separate keysets.
Chris Mason4008c042009-02-12 14:09:45 -0500124 *
Chris Mason85d4e462011-07-26 16:11:19 -0400125 * Lock-nesting across peer nodes is always done with the immediate parent
126 * node locked thus preventing deadlock. As lockdep doesn't know this, use
127 * subclass to avoid triggering lockdep warning in such cases.
Chris Mason4008c042009-02-12 14:09:45 -0500128 *
Chris Mason85d4e462011-07-26 16:11:19 -0400129 * The key is set by the readpage_end_io_hook after the buffer has passed
130 * csum validation but before the pages are unlocked. It is also set by
131 * btrfs_init_new_buffer on freshly allocated blocks.
132 *
133 * We also add a check to make sure the highest level of the tree is the
134 * same as our lockdep setup here. If BTRFS_MAX_LEVEL changes, this code
135 * needs update as well.
Chris Mason4008c042009-02-12 14:09:45 -0500136 */
137#ifdef CONFIG_DEBUG_LOCK_ALLOC
138# if BTRFS_MAX_LEVEL != 8
139# error
140# endif
Chris Mason85d4e462011-07-26 16:11:19 -0400141
142static struct btrfs_lockdep_keyset {
143 u64 id; /* root objectid */
144 const char *name_stem; /* lock name stem */
145 char names[BTRFS_MAX_LEVEL + 1][20];
146 struct lock_class_key keys[BTRFS_MAX_LEVEL + 1];
147} btrfs_lockdep_keysets[] = {
148 { .id = BTRFS_ROOT_TREE_OBJECTID, .name_stem = "root" },
149 { .id = BTRFS_EXTENT_TREE_OBJECTID, .name_stem = "extent" },
150 { .id = BTRFS_CHUNK_TREE_OBJECTID, .name_stem = "chunk" },
151 { .id = BTRFS_DEV_TREE_OBJECTID, .name_stem = "dev" },
152 { .id = BTRFS_FS_TREE_OBJECTID, .name_stem = "fs" },
153 { .id = BTRFS_CSUM_TREE_OBJECTID, .name_stem = "csum" },
David Sterba60b62972013-04-30 17:29:29 +0000154 { .id = BTRFS_QUOTA_TREE_OBJECTID, .name_stem = "quota" },
Chris Mason85d4e462011-07-26 16:11:19 -0400155 { .id = BTRFS_TREE_LOG_OBJECTID, .name_stem = "log" },
156 { .id = BTRFS_TREE_RELOC_OBJECTID, .name_stem = "treloc" },
157 { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, .name_stem = "dreloc" },
David Sterba13fd8da2013-09-03 18:28:57 +0200158 { .id = BTRFS_UUID_TREE_OBJECTID, .name_stem = "uuid" },
Chris Mason85d4e462011-07-26 16:11:19 -0400159 { .id = 0, .name_stem = "tree" },
Chris Mason4008c042009-02-12 14:09:45 -0500160};
Chris Mason85d4e462011-07-26 16:11:19 -0400161
162void __init btrfs_init_lockdep(void)
163{
164 int i, j;
165
166 /* initialize lockdep class names */
167 for (i = 0; i < ARRAY_SIZE(btrfs_lockdep_keysets); i++) {
168 struct btrfs_lockdep_keyset *ks = &btrfs_lockdep_keysets[i];
169
170 for (j = 0; j < ARRAY_SIZE(ks->names); j++)
171 snprintf(ks->names[j], sizeof(ks->names[j]),
172 "btrfs-%s-%02d", ks->name_stem, j);
173 }
174}
175
176void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
177 int level)
178{
179 struct btrfs_lockdep_keyset *ks;
180
181 BUG_ON(level >= ARRAY_SIZE(ks->keys));
182
183 /* find the matching keyset, id 0 is the default entry */
184 for (ks = btrfs_lockdep_keysets; ks->id; ks++)
185 if (ks->id == objectid)
186 break;
187
188 lockdep_set_class_and_name(&eb->lock,
189 &ks->keys[level], ks->names[level]);
190}
191
Chris Mason4008c042009-02-12 14:09:45 -0500192#endif
193
Chris Masond352ac62008-09-29 15:18:18 -0400194/*
195 * extents on the btree inode are pretty simple, there's one extent
196 * that covers the entire device
197 */
Christoph Hellwigb2950862008-12-02 09:54:17 -0500198static struct extent_map *btree_get_extent(struct inode *inode,
David Sterba306e16c2011-04-19 14:29:38 +0200199 struct page *page, size_t pg_offset, u64 start, u64 len,
Christoph Hellwigb2950862008-12-02 09:54:17 -0500200 int create)
Chris Mason5f39d392007-10-15 16:14:19 -0400201{
202 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
203 struct extent_map *em;
204 int ret;
Chris Masond98237b2007-03-28 13:57:48 -0400205
Chris Mason890871b2009-09-02 16:24:52 -0400206 read_lock(&em_tree->lock);
Chris Masond1310b22008-01-24 16:13:08 -0500207 em = lookup_extent_mapping(em_tree, start, len);
Chris Masona061fc82008-05-07 11:43:44 -0400208 if (em) {
209 em->bdev =
210 BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
Chris Mason890871b2009-09-02 16:24:52 -0400211 read_unlock(&em_tree->lock);
Chris Mason5f39d392007-10-15 16:14:19 -0400212 goto out;
Chris Masona061fc82008-05-07 11:43:44 -0400213 }
Chris Mason890871b2009-09-02 16:24:52 -0400214 read_unlock(&em_tree->lock);
Chris Mason7b13b7b2008-04-18 10:29:50 -0400215
David Sterba172ddd62011-04-21 00:48:27 +0200216 em = alloc_extent_map();
Chris Mason5f39d392007-10-15 16:14:19 -0400217 if (!em) {
218 em = ERR_PTR(-ENOMEM);
219 goto out;
220 }
221 em->start = 0;
Chris Mason0afbaf82008-04-18 14:17:20 -0400222 em->len = (u64)-1;
Chris Masonc8b97812008-10-29 14:49:59 -0400223 em->block_len = (u64)-1;
Chris Mason5f39d392007-10-15 16:14:19 -0400224 em->block_start = 0;
Chris Masona061fc82008-05-07 11:43:44 -0400225 em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
Chris Masond1310b22008-01-24 16:13:08 -0500226
Chris Mason890871b2009-09-02 16:24:52 -0400227 write_lock(&em_tree->lock);
Josef Bacik09a2a8f92013-04-05 16:51:15 -0400228 ret = add_extent_mapping(em_tree, em, 0);
Chris Mason5f39d392007-10-15 16:14:19 -0400229 if (ret == -EEXIST) {
230 free_extent_map(em);
Chris Mason7b13b7b2008-04-18 10:29:50 -0400231 em = lookup_extent_mapping(em_tree, start, len);
Tsutomu Itohb4f359a2012-09-13 03:32:54 -0600232 if (!em)
Tsutomu Itoh0433f202012-09-13 03:32:32 -0600233 em = ERR_PTR(-EIO);
Chris Mason5f39d392007-10-15 16:14:19 -0400234 } else if (ret) {
Chris Mason7b13b7b2008-04-18 10:29:50 -0400235 free_extent_map(em);
Tsutomu Itoh0433f202012-09-13 03:32:32 -0600236 em = ERR_PTR(ret);
Chris Mason5f39d392007-10-15 16:14:19 -0400237 }
Chris Mason890871b2009-09-02 16:24:52 -0400238 write_unlock(&em_tree->lock);
Chris Mason7b13b7b2008-04-18 10:29:50 -0400239
Chris Mason5f39d392007-10-15 16:14:19 -0400240out:
241 return em;
242}
243
Liu Bob0496682013-03-14 14:57:45 +0000244u32 btrfs_csum_data(char *data, u32 seed, size_t len)
Chris Mason19c00dd2007-10-15 16:19:22 -0400245{
David Woodhouse163e7832009-04-19 13:02:41 +0100246 return crc32c(seed, data, len);
Chris Mason19c00dd2007-10-15 16:19:22 -0400247}
248
249void btrfs_csum_final(u32 crc, char *result)
250{
David Sterba7e75bf32011-03-18 22:56:43 +0000251 put_unaligned_le32(~crc, result);
Chris Mason19c00dd2007-10-15 16:19:22 -0400252}
253
Chris Masond352ac62008-09-29 15:18:18 -0400254/*
255 * compute the csum for a btree block, and either verify it or write it
256 * into the csum field of the block.
257 */
Chris Mason19c00dd2007-10-15 16:19:22 -0400258static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
259 int verify)
260{
David Sterba6c417612011-04-13 15:41:04 +0200261 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
Josef Bacik607d4322008-12-02 07:17:45 -0500262 char *result = NULL;
Chris Mason19c00dd2007-10-15 16:19:22 -0400263 unsigned long len;
264 unsigned long cur_len;
265 unsigned long offset = BTRFS_CSUM_SIZE;
Chris Mason19c00dd2007-10-15 16:19:22 -0400266 char *kaddr;
267 unsigned long map_start;
268 unsigned long map_len;
269 int err;
270 u32 crc = ~(u32)0;
Josef Bacik607d4322008-12-02 07:17:45 -0500271 unsigned long inline_result;
Chris Mason19c00dd2007-10-15 16:19:22 -0400272
273 len = buf->len - offset;
Chris Masond3977122009-01-05 21:25:51 -0500274 while (len > 0) {
Chris Mason19c00dd2007-10-15 16:19:22 -0400275 err = map_private_extent_buffer(buf, offset, 32,
Chris Masona6591712011-07-19 12:04:14 -0400276 &kaddr, &map_start, &map_len);
Chris Masond3977122009-01-05 21:25:51 -0500277 if (err)
Chris Mason19c00dd2007-10-15 16:19:22 -0400278 return 1;
Chris Mason19c00dd2007-10-15 16:19:22 -0400279 cur_len = min(len, map_len - (offset - map_start));
Liu Bob0496682013-03-14 14:57:45 +0000280 crc = btrfs_csum_data(kaddr + offset - map_start,
Chris Mason19c00dd2007-10-15 16:19:22 -0400281 crc, cur_len);
282 len -= cur_len;
283 offset += cur_len;
Chris Mason19c00dd2007-10-15 16:19:22 -0400284 }
Josef Bacik607d4322008-12-02 07:17:45 -0500285 if (csum_size > sizeof(inline_result)) {
286 result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
287 if (!result)
288 return 1;
289 } else {
290 result = (char *)&inline_result;
291 }
292
Chris Mason19c00dd2007-10-15 16:19:22 -0400293 btrfs_csum_final(crc, result);
294
295 if (verify) {
Josef Bacik607d4322008-12-02 07:17:45 -0500296 if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
Chris Masone4204de2008-01-08 15:46:27 -0500297 u32 val;
298 u32 found = 0;
Josef Bacik607d4322008-12-02 07:17:45 -0500299 memcpy(&found, result, csum_size);
Chris Masone4204de2008-01-08 15:46:27 -0500300
Josef Bacik607d4322008-12-02 07:17:45 -0500301 read_extent_buffer(buf, &val, 0, csum_size);
David Sterba7a36dde2011-05-06 15:33:15 +0200302 printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
Chris Mason193f2842009-04-27 07:29:05 -0400303 "failed on %llu wanted %X found %X "
304 "level %d\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200305 root->fs_info->sb->s_id, buf->start,
306 val, found, btrfs_header_level(buf));
Josef Bacik607d4322008-12-02 07:17:45 -0500307 if (result != (char *)&inline_result)
308 kfree(result);
Chris Mason19c00dd2007-10-15 16:19:22 -0400309 return 1;
310 }
311 } else {
Josef Bacik607d4322008-12-02 07:17:45 -0500312 write_extent_buffer(buf, result, 0, csum_size);
Chris Mason19c00dd2007-10-15 16:19:22 -0400313 }
Josef Bacik607d4322008-12-02 07:17:45 -0500314 if (result != (char *)&inline_result)
315 kfree(result);
Chris Mason19c00dd2007-10-15 16:19:22 -0400316 return 0;
317}
318
Chris Masond352ac62008-09-29 15:18:18 -0400319/*
320 * we can't consider a given block up to date unless the transid of the
321 * block matches the transid in the parent node's pointer. This is how we
322 * detect blocks that either didn't get written at all or got written
323 * in the wrong place.
324 */
Chris Mason1259ab72008-05-12 13:39:03 -0400325static int verify_parent_transid(struct extent_io_tree *io_tree,
Chris Masonb9fab912012-05-06 07:23:47 -0400326 struct extent_buffer *eb, u64 parent_transid,
327 int atomic)
Chris Mason1259ab72008-05-12 13:39:03 -0400328{
Josef Bacik2ac55d42010-02-03 19:33:23 +0000329 struct extent_state *cached_state = NULL;
Chris Mason1259ab72008-05-12 13:39:03 -0400330 int ret;
331
332 if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
333 return 0;
334
Chris Masonb9fab912012-05-06 07:23:47 -0400335 if (atomic)
336 return -EAGAIN;
337
Josef Bacik2ac55d42010-02-03 19:33:23 +0000338 lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
Jeff Mahoneyd0082372012-03-01 14:57:19 +0100339 0, &cached_state);
Josef Bacik0b32f4b2012-03-13 09:38:00 -0400340 if (extent_buffer_uptodate(eb) &&
Chris Mason1259ab72008-05-12 13:39:03 -0400341 btrfs_header_generation(eb) == parent_transid) {
342 ret = 0;
343 goto out;
344 }
David Sterba7a36dde2011-05-06 15:33:15 +0200345 printk_ratelimited("parent transid verify failed on %llu wanted %llu "
Chris Mason193f2842009-04-27 07:29:05 -0400346 "found %llu\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200347 eb->start, parent_transid, btrfs_header_generation(eb));
Chris Mason1259ab72008-05-12 13:39:03 -0400348 ret = 1;
Josef Bacik0b32f4b2012-03-13 09:38:00 -0400349 clear_extent_buffer_uptodate(eb);
Chris Mason33958dc2008-07-30 10:29:12 -0400350out:
Josef Bacik2ac55d42010-02-03 19:33:23 +0000351 unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
352 &cached_state, GFP_NOFS);
Chris Mason1259ab72008-05-12 13:39:03 -0400353 return ret;
Chris Mason1259ab72008-05-12 13:39:03 -0400354}
355
Chris Masond352ac62008-09-29 15:18:18 -0400356/*
David Sterba1104a882013-03-06 15:57:46 +0100357 * Return 0 if the superblock checksum type matches the checksum value of that
358 * algorithm. Pass the raw disk superblock data.
359 */
360static int btrfs_check_super_csum(char *raw_disk_sb)
361{
362 struct btrfs_super_block *disk_sb =
363 (struct btrfs_super_block *)raw_disk_sb;
364 u16 csum_type = btrfs_super_csum_type(disk_sb);
365 int ret = 0;
366
367 if (csum_type == BTRFS_CSUM_TYPE_CRC32) {
368 u32 crc = ~(u32)0;
369 const int csum_size = sizeof(crc);
370 char result[csum_size];
371
372 /*
373 * The super_block structure does not span the whole
374 * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space
375 * is filled with zeros and is included in the checkum.
376 */
377 crc = btrfs_csum_data(raw_disk_sb + BTRFS_CSUM_SIZE,
378 crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
379 btrfs_csum_final(crc, result);
380
381 if (memcmp(raw_disk_sb, result, csum_size))
382 ret = 1;
Chris Mason667e7d92013-05-07 11:00:13 -0400383
384 if (ret && btrfs_super_generation(disk_sb) < 10) {
385 printk(KERN_WARNING "btrfs: super block crcs don't match, older mkfs detected\n");
386 ret = 0;
387 }
David Sterba1104a882013-03-06 15:57:46 +0100388 }
389
390 if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) {
391 printk(KERN_ERR "btrfs: unsupported checksum algorithm %u\n",
392 csum_type);
393 ret = 1;
394 }
395
396 return ret;
397}
398
399/*
Chris Masond352ac62008-09-29 15:18:18 -0400400 * helper to read a given tree block, doing retries as required when
401 * the checksums don't match and we have alternate mirrors to try.
402 */
Chris Masonf1885912008-04-09 16:28:12 -0400403static int btree_read_extent_buffer_pages(struct btrfs_root *root,
404 struct extent_buffer *eb,
Chris Masonca7a79a2008-05-12 12:59:19 -0400405 u64 start, u64 parent_transid)
Chris Masonf1885912008-04-09 16:28:12 -0400406{
407 struct extent_io_tree *io_tree;
Josef Bacikea466792012-03-26 21:57:36 -0400408 int failed = 0;
Chris Masonf1885912008-04-09 16:28:12 -0400409 int ret;
410 int num_copies = 0;
411 int mirror_num = 0;
Josef Bacikea466792012-03-26 21:57:36 -0400412 int failed_mirror = 0;
Chris Masonf1885912008-04-09 16:28:12 -0400413
Josef Bacika826d6d2011-03-16 13:42:43 -0400414 clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
Chris Masonf1885912008-04-09 16:28:12 -0400415 io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
416 while (1) {
Arne Jansenbb82ab82011-06-10 14:06:53 +0200417 ret = read_extent_buffer_pages(io_tree, eb, start,
418 WAIT_COMPLETE,
Chris Masonf1885912008-04-09 16:28:12 -0400419 btree_get_extent, mirror_num);
Stefan Behrens256dd1b2012-08-10 08:58:21 -0600420 if (!ret) {
421 if (!verify_parent_transid(io_tree, eb,
Chris Masonb9fab912012-05-06 07:23:47 -0400422 parent_transid, 0))
Stefan Behrens256dd1b2012-08-10 08:58:21 -0600423 break;
424 else
425 ret = -EIO;
426 }
Chris Masond3977122009-01-05 21:25:51 -0500427
Josef Bacika826d6d2011-03-16 13:42:43 -0400428 /*
429 * This buffer's crc is fine, but its contents are corrupted, so
430 * there is no reason to read the other copies, they won't be
431 * any less wrong.
432 */
433 if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
Josef Bacikea466792012-03-26 21:57:36 -0400434 break;
435
Stefan Behrens5d964052012-11-05 14:59:07 +0100436 num_copies = btrfs_num_copies(root->fs_info,
Chris Masonf1885912008-04-09 16:28:12 -0400437 eb->start, eb->len);
Chris Mason42352982008-04-28 16:40:52 -0400438 if (num_copies == 1)
Josef Bacikea466792012-03-26 21:57:36 -0400439 break;
Chris Mason42352982008-04-28 16:40:52 -0400440
Josef Bacik5cf1ab52012-04-16 09:42:26 -0400441 if (!failed_mirror) {
442 failed = 1;
443 failed_mirror = eb->read_mirror;
444 }
445
Chris Masonf1885912008-04-09 16:28:12 -0400446 mirror_num++;
Josef Bacikea466792012-03-26 21:57:36 -0400447 if (mirror_num == failed_mirror)
448 mirror_num++;
449
Chris Mason42352982008-04-28 16:40:52 -0400450 if (mirror_num > num_copies)
Josef Bacikea466792012-03-26 21:57:36 -0400451 break;
Chris Masonf1885912008-04-09 16:28:12 -0400452 }
Josef Bacikea466792012-03-26 21:57:36 -0400453
Stefan Behrensc0901582012-07-10 07:30:17 -0600454 if (failed && !ret && failed_mirror)
Josef Bacikea466792012-03-26 21:57:36 -0400455 repair_eb_io_failure(root, eb, failed_mirror);
456
457 return ret;
Chris Masonf1885912008-04-09 16:28:12 -0400458}
Chris Mason19c00dd2007-10-15 16:19:22 -0400459
Chris Masond352ac62008-09-29 15:18:18 -0400460/*
Chris Masond3977122009-01-05 21:25:51 -0500461 * checksum a dirty tree block before IO. This has extra checks to make sure
462 * we only fill in the checksum field in the first page of a multi-page block
Chris Masond352ac62008-09-29 15:18:18 -0400463 */
Chris Masond3977122009-01-05 21:25:51 -0500464
Christoph Hellwigb2950862008-12-02 09:54:17 -0500465static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
Chris Mason19c00dd2007-10-15 16:19:22 -0400466{
Chris Masond1310b22008-01-24 16:13:08 -0500467 struct extent_io_tree *tree;
Miao Xie4eee4fa2012-12-21 09:17:45 +0000468 u64 start = page_offset(page);
Chris Mason19c00dd2007-10-15 16:19:22 -0400469 u64 found_start;
Chris Mason19c00dd2007-10-15 16:19:22 -0400470 struct extent_buffer *eb;
Chris Masonf1885912008-04-09 16:28:12 -0400471
Chris Masond1310b22008-01-24 16:13:08 -0500472 tree = &BTRFS_I(page->mapping->host)->io_tree;
Chris Mason19c00dd2007-10-15 16:19:22 -0400473
Josef Bacik4f2de97a2012-03-07 16:20:05 -0500474 eb = (struct extent_buffer *)page->private;
475 if (page != eb->pages[0])
476 return 0;
Chris Mason19c00dd2007-10-15 16:19:22 -0400477 found_start = btrfs_header_bytenr(eb);
478 if (found_start != start) {
Chris Mason55c69072008-01-09 15:55:33 -0500479 WARN_ON(1);
Josef Bacik4f2de97a2012-03-07 16:20:05 -0500480 return 0;
Chris Mason55c69072008-01-09 15:55:33 -0500481 }
Chris Mason55c69072008-01-09 15:55:33 -0500482 if (!PageUptodate(page)) {
Chris Mason55c69072008-01-09 15:55:33 -0500483 WARN_ON(1);
Josef Bacik4f2de97a2012-03-07 16:20:05 -0500484 return 0;
Chris Mason19c00dd2007-10-15 16:19:22 -0400485 }
Chris Mason19c00dd2007-10-15 16:19:22 -0400486 csum_tree_block(root, eb, 0);
Chris Mason19c00dd2007-10-15 16:19:22 -0400487 return 0;
488}
489
Yan Zheng2b820322008-11-17 21:11:30 -0500490static int check_tree_block_fsid(struct btrfs_root *root,
491 struct extent_buffer *eb)
492{
493 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
494 u8 fsid[BTRFS_UUID_SIZE];
495 int ret = 1;
496
Ross Kirk0a4e5582013-09-24 10:12:38 +0100497 read_extent_buffer(eb, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
Yan Zheng2b820322008-11-17 21:11:30 -0500498 while (fs_devices) {
499 if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
500 ret = 0;
501 break;
502 }
503 fs_devices = fs_devices->seed;
504 }
505 return ret;
506}
507
Josef Bacika826d6d2011-03-16 13:42:43 -0400508#define CORRUPT(reason, eb, root, slot) \
509 printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu," \
510 "root=%llu, slot=%d\n", reason, \
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200511 btrfs_header_bytenr(eb), root->objectid, slot)
Josef Bacika826d6d2011-03-16 13:42:43 -0400512
513static noinline int check_leaf(struct btrfs_root *root,
514 struct extent_buffer *leaf)
515{
516 struct btrfs_key key;
517 struct btrfs_key leaf_key;
518 u32 nritems = btrfs_header_nritems(leaf);
519 int slot;
520
521 if (nritems == 0)
522 return 0;
523
524 /* Check the 0 item */
525 if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
526 BTRFS_LEAF_DATA_SIZE(root)) {
527 CORRUPT("invalid item offset size pair", leaf, root, 0);
528 return -EIO;
529 }
530
531 /*
532 * Check to make sure each items keys are in the correct order and their
533 * offsets make sense. We only have to loop through nritems-1 because
534 * we check the current slot against the next slot, which verifies the
535 * next slot's offset+size makes sense and that the current's slot
536 * offset is correct.
537 */
538 for (slot = 0; slot < nritems - 1; slot++) {
539 btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
540 btrfs_item_key_to_cpu(leaf, &key, slot + 1);
541
542 /* Make sure the keys are in the right order */
543 if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
544 CORRUPT("bad key order", leaf, root, slot);
545 return -EIO;
546 }
547
548 /*
549 * Make sure the offset and ends are right, remember that the
550 * item data starts at the end of the leaf and grows towards the
551 * front.
552 */
553 if (btrfs_item_offset_nr(leaf, slot) !=
554 btrfs_item_end_nr(leaf, slot + 1)) {
555 CORRUPT("slot offset bad", leaf, root, slot);
556 return -EIO;
557 }
558
559 /*
560 * Check to make sure that we don't point outside of the leaf,
561 * just incase all the items are consistent to eachother, but
562 * all point outside of the leaf.
563 */
564 if (btrfs_item_end_nr(leaf, slot) >
565 BTRFS_LEAF_DATA_SIZE(root)) {
566 CORRUPT("slot end outside of leaf", leaf, root, slot);
567 return -EIO;
568 }
569 }
570
571 return 0;
572}
573
Miao Xiefacc8a222013-07-25 19:22:34 +0800574static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
575 u64 phy_offset, struct page *page,
576 u64 start, u64 end, int mirror)
Chris Masonce9adaa2008-04-09 16:28:12 -0400577{
578 struct extent_io_tree *tree;
579 u64 found_start;
580 int found_level;
Chris Masonce9adaa2008-04-09 16:28:12 -0400581 struct extent_buffer *eb;
582 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
Chris Masonf1885912008-04-09 16:28:12 -0400583 int ret = 0;
Chris Mason727011e2010-08-06 13:21:20 -0400584 int reads_done;
Chris Masonce9adaa2008-04-09 16:28:12 -0400585
Chris Masonce9adaa2008-04-09 16:28:12 -0400586 if (!page->private)
587 goto out;
Chris Masond3977122009-01-05 21:25:51 -0500588
Chris Mason727011e2010-08-06 13:21:20 -0400589 tree = &BTRFS_I(page->mapping->host)->io_tree;
Josef Bacik4f2de97a2012-03-07 16:20:05 -0500590 eb = (struct extent_buffer *)page->private;
Chris Masond3977122009-01-05 21:25:51 -0500591
Josef Bacik0b32f4b2012-03-13 09:38:00 -0400592 /* the pending IO might have been the only thing that kept this buffer
593 * in memory. Make sure we have a ref for all this other checks
594 */
595 extent_buffer_get(eb);
596
597 reads_done = atomic_dec_and_test(&eb->io_pages);
Chris Mason727011e2010-08-06 13:21:20 -0400598 if (!reads_done)
599 goto err;
Chris Masonf1885912008-04-09 16:28:12 -0400600
Josef Bacik5cf1ab52012-04-16 09:42:26 -0400601 eb->read_mirror = mirror;
Josef Bacikea466792012-03-26 21:57:36 -0400602 if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
603 ret = -EIO;
604 goto err;
605 }
606
Chris Masonce9adaa2008-04-09 16:28:12 -0400607 found_start = btrfs_header_bytenr(eb);
Chris Mason727011e2010-08-06 13:21:20 -0400608 if (found_start != eb->start) {
David Sterba7a36dde2011-05-06 15:33:15 +0200609 printk_ratelimited(KERN_INFO "btrfs bad tree block start "
Chris Mason193f2842009-04-27 07:29:05 -0400610 "%llu %llu\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200611 found_start, eb->start);
Chris Masonf1885912008-04-09 16:28:12 -0400612 ret = -EIO;
Chris Masonce9adaa2008-04-09 16:28:12 -0400613 goto err;
614 }
Yan Zheng2b820322008-11-17 21:11:30 -0500615 if (check_tree_block_fsid(root, eb)) {
David Sterba7a36dde2011-05-06 15:33:15 +0200616 printk_ratelimited(KERN_INFO "btrfs bad fsid on block %llu\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200617 eb->start);
Chris Mason1259ab72008-05-12 13:39:03 -0400618 ret = -EIO;
619 goto err;
620 }
Chris Masonce9adaa2008-04-09 16:28:12 -0400621 found_level = btrfs_header_level(eb);
Josef Bacik1c24c3c2013-04-23 11:30:14 -0400622 if (found_level >= BTRFS_MAX_LEVEL) {
623 btrfs_info(root->fs_info, "bad tree block level %d\n",
624 (int)btrfs_header_level(eb));
625 ret = -EIO;
626 goto err;
627 }
Chris Masonce9adaa2008-04-09 16:28:12 -0400628
Chris Mason85d4e462011-07-26 16:11:19 -0400629 btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
630 eb, found_level);
Chris Mason4008c042009-02-12 14:09:45 -0500631
Chris Masonce9adaa2008-04-09 16:28:12 -0400632 ret = csum_tree_block(root, eb, 1);
Josef Bacika826d6d2011-03-16 13:42:43 -0400633 if (ret) {
Chris Masonf1885912008-04-09 16:28:12 -0400634 ret = -EIO;
Josef Bacika826d6d2011-03-16 13:42:43 -0400635 goto err;
636 }
637
638 /*
639 * If this is a leaf block and it is corrupt, set the corrupt bit so
640 * that we don't try and read the other copies of this block, just
641 * return -EIO.
642 */
643 if (found_level == 0 && check_leaf(root, eb)) {
644 set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
645 ret = -EIO;
646 }
Chris Masonce9adaa2008-04-09 16:28:12 -0400647
Josef Bacik0b32f4b2012-03-13 09:38:00 -0400648 if (!ret)
649 set_extent_buffer_uptodate(eb);
Chris Masonce9adaa2008-04-09 16:28:12 -0400650err:
Josef Bacik79fb65a2013-04-20 10:18:27 -0400651 if (reads_done &&
652 test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
Arne Jansen4bb31e92011-06-10 13:55:54 +0200653 btree_readahead_hook(root, eb, eb->start, ret);
Arne Jansen4bb31e92011-06-10 13:55:54 +0200654
David Woodhouse53b381b2013-01-29 18:40:14 -0500655 if (ret) {
656 /*
657 * our io error hook is going to dec the io pages
658 * again, we have to make sure it has something
659 * to decrement
660 */
661 atomic_inc(&eb->io_pages);
Josef Bacik0b32f4b2012-03-13 09:38:00 -0400662 clear_extent_buffer_uptodate(eb);
David Woodhouse53b381b2013-01-29 18:40:14 -0500663 }
Josef Bacik0b32f4b2012-03-13 09:38:00 -0400664 free_extent_buffer(eb);
Chris Masonce9adaa2008-04-09 16:28:12 -0400665out:
Chris Masonf1885912008-04-09 16:28:12 -0400666 return ret;
Chris Masonce9adaa2008-04-09 16:28:12 -0400667}
668
Josef Bacikea466792012-03-26 21:57:36 -0400669static int btree_io_failed_hook(struct page *page, int failed_mirror)
Arne Jansen4bb31e92011-06-10 13:55:54 +0200670{
Arne Jansen4bb31e92011-06-10 13:55:54 +0200671 struct extent_buffer *eb;
672 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
673
Josef Bacik4f2de97a2012-03-07 16:20:05 -0500674 eb = (struct extent_buffer *)page->private;
Josef Bacikea466792012-03-26 21:57:36 -0400675 set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
Josef Bacik5cf1ab52012-04-16 09:42:26 -0400676 eb->read_mirror = failed_mirror;
David Woodhouse53b381b2013-01-29 18:40:14 -0500677 atomic_dec(&eb->io_pages);
Josef Bacikea466792012-03-26 21:57:36 -0400678 if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
Arne Jansen4bb31e92011-06-10 13:55:54 +0200679 btree_readahead_hook(root, eb, eb->start, -EIO);
Arne Jansen4bb31e92011-06-10 13:55:54 +0200680 return -EIO; /* we fixed nothing */
681}
682
Chris Masonce9adaa2008-04-09 16:28:12 -0400683static void end_workqueue_bio(struct bio *bio, int err)
Chris Masonce9adaa2008-04-09 16:28:12 -0400684{
685 struct end_io_wq *end_io_wq = bio->bi_private;
686 struct btrfs_fs_info *fs_info;
Chris Masonce9adaa2008-04-09 16:28:12 -0400687
Chris Masonce9adaa2008-04-09 16:28:12 -0400688 fs_info = end_io_wq->info;
Chris Masonce9adaa2008-04-09 16:28:12 -0400689 end_io_wq->error = err;
Chris Mason8b712842008-06-11 16:50:36 -0400690 end_io_wq->work.func = end_workqueue_fn;
691 end_io_wq->work.flags = 0;
Chris Masond20f7042008-12-08 16:58:54 -0500692
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +0200693 if (bio->bi_rw & REQ_WRITE) {
David Woodhouse53b381b2013-01-29 18:40:14 -0500694 if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA)
Chris Masoncad321a2008-12-17 14:51:42 -0500695 btrfs_queue_worker(&fs_info->endio_meta_write_workers,
696 &end_io_wq->work);
David Woodhouse53b381b2013-01-29 18:40:14 -0500697 else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE)
Josef Bacik0cb59c92010-07-02 12:14:14 -0400698 btrfs_queue_worker(&fs_info->endio_freespace_worker,
699 &end_io_wq->work);
David Woodhouse53b381b2013-01-29 18:40:14 -0500700 else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
701 btrfs_queue_worker(&fs_info->endio_raid56_workers,
702 &end_io_wq->work);
Chris Masoncad321a2008-12-17 14:51:42 -0500703 else
704 btrfs_queue_worker(&fs_info->endio_write_workers,
705 &end_io_wq->work);
Chris Masond20f7042008-12-08 16:58:54 -0500706 } else {
David Woodhouse53b381b2013-01-29 18:40:14 -0500707 if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
708 btrfs_queue_worker(&fs_info->endio_raid56_workers,
709 &end_io_wq->work);
710 else if (end_io_wq->metadata)
Chris Masond20f7042008-12-08 16:58:54 -0500711 btrfs_queue_worker(&fs_info->endio_meta_workers,
712 &end_io_wq->work);
713 else
714 btrfs_queue_worker(&fs_info->endio_workers,
715 &end_io_wq->work);
716 }
Chris Masonce9adaa2008-04-09 16:28:12 -0400717}
718
Josef Bacik0cb59c92010-07-02 12:14:14 -0400719/*
720 * For the metadata arg you want
721 *
722 * 0 - if data
723 * 1 - if normal metadta
724 * 2 - if writing to the free space cache area
David Woodhouse53b381b2013-01-29 18:40:14 -0500725 * 3 - raid parity work
Josef Bacik0cb59c92010-07-02 12:14:14 -0400726 */
Chris Mason22c59942008-04-09 16:28:12 -0400727int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
728 int metadata)
Chris Mason0b86a832008-03-24 15:01:56 -0400729{
Chris Masonce9adaa2008-04-09 16:28:12 -0400730 struct end_io_wq *end_io_wq;
Chris Masonce9adaa2008-04-09 16:28:12 -0400731 end_io_wq = kmalloc(sizeof(*end_io_wq), GFP_NOFS);
732 if (!end_io_wq)
733 return -ENOMEM;
734
735 end_io_wq->private = bio->bi_private;
736 end_io_wq->end_io = bio->bi_end_io;
Chris Mason22c59942008-04-09 16:28:12 -0400737 end_io_wq->info = info;
Chris Masonce9adaa2008-04-09 16:28:12 -0400738 end_io_wq->error = 0;
739 end_io_wq->bio = bio;
Chris Mason22c59942008-04-09 16:28:12 -0400740 end_io_wq->metadata = metadata;
Chris Masonce9adaa2008-04-09 16:28:12 -0400741
742 bio->bi_private = end_io_wq;
743 bio->bi_end_io = end_workqueue_bio;
Chris Mason22c59942008-04-09 16:28:12 -0400744 return 0;
745}
746
Chris Masonb64a2852008-08-20 13:39:41 -0400747unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
Chris Mason4854ddd2008-08-15 15:34:17 -0400748{
749 unsigned long limit = min_t(unsigned long,
750 info->workers.max_workers,
751 info->fs_devices->open_devices);
752 return 256 * limit;
753}
754
Chris Mason4a69a412008-11-06 22:03:00 -0500755static void run_one_async_start(struct btrfs_work *work)
756{
Chris Mason4a69a412008-11-06 22:03:00 -0500757 struct async_submit_bio *async;
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100758 int ret;
Chris Mason4a69a412008-11-06 22:03:00 -0500759
760 async = container_of(work, struct async_submit_bio, work);
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100761 ret = async->submit_bio_start(async->inode, async->rw, async->bio,
762 async->mirror_num, async->bio_flags,
763 async->bio_offset);
764 if (ret)
765 async->error = ret;
Chris Mason4a69a412008-11-06 22:03:00 -0500766}
767
768static void run_one_async_done(struct btrfs_work *work)
Chris Mason8b712842008-06-11 16:50:36 -0400769{
770 struct btrfs_fs_info *fs_info;
771 struct async_submit_bio *async;
Chris Mason4854ddd2008-08-15 15:34:17 -0400772 int limit;
Chris Mason8b712842008-06-11 16:50:36 -0400773
774 async = container_of(work, struct async_submit_bio, work);
775 fs_info = BTRFS_I(async->inode)->root->fs_info;
Chris Mason4854ddd2008-08-15 15:34:17 -0400776
Chris Masonb64a2852008-08-20 13:39:41 -0400777 limit = btrfs_async_submit_limit(fs_info);
Chris Mason4854ddd2008-08-15 15:34:17 -0400778 limit = limit * 2 / 3;
779
Josef Bacik66657b32012-08-01 15:36:24 -0400780 if (atomic_dec_return(&fs_info->nr_async_submits) < limit &&
Chris Masonb64a2852008-08-20 13:39:41 -0400781 waitqueue_active(&fs_info->async_submit_wait))
Chris Mason4854ddd2008-08-15 15:34:17 -0400782 wake_up(&fs_info->async_submit_wait);
783
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100784 /* If an error occured we just want to clean up the bio and move on */
785 if (async->error) {
786 bio_endio(async->bio, async->error);
787 return;
788 }
789
Chris Mason4a69a412008-11-06 22:03:00 -0500790 async->submit_bio_done(async->inode, async->rw, async->bio,
Chris Masoneaf25d92010-05-25 09:48:28 -0400791 async->mirror_num, async->bio_flags,
792 async->bio_offset);
Chris Mason4a69a412008-11-06 22:03:00 -0500793}
794
795static void run_one_async_free(struct btrfs_work *work)
796{
797 struct async_submit_bio *async;
798
799 async = container_of(work, struct async_submit_bio, work);
Chris Mason8b712842008-06-11 16:50:36 -0400800 kfree(async);
801}
802
Chris Mason44b8bd72008-04-16 11:14:51 -0400803int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
804 int rw, struct bio *bio, int mirror_num,
Chris Masonc8b97812008-10-29 14:49:59 -0400805 unsigned long bio_flags,
Chris Masoneaf25d92010-05-25 09:48:28 -0400806 u64 bio_offset,
Chris Mason4a69a412008-11-06 22:03:00 -0500807 extent_submit_bio_hook_t *submit_bio_start,
808 extent_submit_bio_hook_t *submit_bio_done)
Chris Mason44b8bd72008-04-16 11:14:51 -0400809{
810 struct async_submit_bio *async;
811
812 async = kmalloc(sizeof(*async), GFP_NOFS);
813 if (!async)
814 return -ENOMEM;
815
816 async->inode = inode;
817 async->rw = rw;
818 async->bio = bio;
819 async->mirror_num = mirror_num;
Chris Mason4a69a412008-11-06 22:03:00 -0500820 async->submit_bio_start = submit_bio_start;
821 async->submit_bio_done = submit_bio_done;
822
823 async->work.func = run_one_async_start;
824 async->work.ordered_func = run_one_async_done;
825 async->work.ordered_free = run_one_async_free;
826
Chris Mason8b712842008-06-11 16:50:36 -0400827 async->work.flags = 0;
Chris Masonc8b97812008-10-29 14:49:59 -0400828 async->bio_flags = bio_flags;
Chris Masoneaf25d92010-05-25 09:48:28 -0400829 async->bio_offset = bio_offset;
Chris Mason8c8bee12008-09-29 11:19:10 -0400830
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100831 async->error = 0;
832
Chris Masoncb03c742008-05-15 16:15:45 -0400833 atomic_inc(&fs_info->nr_async_submits);
Chris Masond313d7a2009-04-20 15:50:09 -0400834
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +0200835 if (rw & REQ_SYNC)
Chris Masond313d7a2009-04-20 15:50:09 -0400836 btrfs_set_work_high_prio(&async->work);
837
Chris Mason8b712842008-06-11 16:50:36 -0400838 btrfs_queue_worker(&fs_info->workers, &async->work);
Chris Mason9473f162008-08-28 06:15:24 -0400839
Chris Masond3977122009-01-05 21:25:51 -0500840 while (atomic_read(&fs_info->async_submit_draining) &&
Chris Mason771ed682008-11-06 22:02:51 -0500841 atomic_read(&fs_info->nr_async_submits)) {
842 wait_event(fs_info->async_submit_wait,
843 (atomic_read(&fs_info->nr_async_submits) == 0));
844 }
845
Chris Mason44b8bd72008-04-16 11:14:51 -0400846 return 0;
847}
848
Chris Masonce3ed712008-09-23 13:14:12 -0400849static int btree_csum_one_bio(struct bio *bio)
850{
851 struct bio_vec *bvec = bio->bi_io_vec;
852 int bio_index = 0;
853 struct btrfs_root *root;
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100854 int ret = 0;
Chris Masonce3ed712008-09-23 13:14:12 -0400855
856 WARN_ON(bio->bi_vcnt <= 0);
Chris Masond3977122009-01-05 21:25:51 -0500857 while (bio_index < bio->bi_vcnt) {
Chris Masonce3ed712008-09-23 13:14:12 -0400858 root = BTRFS_I(bvec->bv_page->mapping->host)->root;
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100859 ret = csum_dirty_buffer(root, bvec->bv_page);
860 if (ret)
861 break;
Chris Masonce3ed712008-09-23 13:14:12 -0400862 bio_index++;
863 bvec++;
864 }
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100865 return ret;
Chris Masonce3ed712008-09-23 13:14:12 -0400866}
867
Chris Mason4a69a412008-11-06 22:03:00 -0500868static int __btree_submit_bio_start(struct inode *inode, int rw,
869 struct bio *bio, int mirror_num,
Chris Masoneaf25d92010-05-25 09:48:28 -0400870 unsigned long bio_flags,
871 u64 bio_offset)
Chris Mason22c59942008-04-09 16:28:12 -0400872{
Chris Mason8b712842008-06-11 16:50:36 -0400873 /*
874 * when we're called for a write, we're already in the async
Chris Mason5443be42008-08-15 15:34:16 -0400875 * submission context. Just jump into btrfs_map_bio
Chris Mason8b712842008-06-11 16:50:36 -0400876 */
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100877 return btree_csum_one_bio(bio);
Chris Mason4a69a412008-11-06 22:03:00 -0500878}
Chris Mason22c59942008-04-09 16:28:12 -0400879
Chris Mason4a69a412008-11-06 22:03:00 -0500880static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
Chris Masoneaf25d92010-05-25 09:48:28 -0400881 int mirror_num, unsigned long bio_flags,
882 u64 bio_offset)
Chris Mason4a69a412008-11-06 22:03:00 -0500883{
Stefan Behrens61891922012-11-05 18:51:52 +0100884 int ret;
885
Chris Mason8b712842008-06-11 16:50:36 -0400886 /*
Chris Mason4a69a412008-11-06 22:03:00 -0500887 * when we're called for a write, we're already in the async
888 * submission context. Just jump into btrfs_map_bio
Chris Mason8b712842008-06-11 16:50:36 -0400889 */
Stefan Behrens61891922012-11-05 18:51:52 +0100890 ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
891 if (ret)
892 bio_endio(bio, ret);
893 return ret;
Chris Mason0b86a832008-03-24 15:01:56 -0400894}
895
Josef Bacikde0022b2012-09-25 14:25:58 -0400896static int check_async_write(struct inode *inode, unsigned long bio_flags)
897{
898 if (bio_flags & EXTENT_BIO_TREE_LOG)
899 return 0;
900#ifdef CONFIG_X86
901 if (cpu_has_xmm4_2)
902 return 0;
903#endif
904 return 1;
905}
906
Chris Mason44b8bd72008-04-16 11:14:51 -0400907static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
Chris Masoneaf25d92010-05-25 09:48:28 -0400908 int mirror_num, unsigned long bio_flags,
909 u64 bio_offset)
Chris Mason44b8bd72008-04-16 11:14:51 -0400910{
Josef Bacikde0022b2012-09-25 14:25:58 -0400911 int async = check_async_write(inode, bio_flags);
Chris Masoncad321a2008-12-17 14:51:42 -0500912 int ret;
913
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +0200914 if (!(rw & REQ_WRITE)) {
Chris Mason4a69a412008-11-06 22:03:00 -0500915 /*
916 * called for a read, do the setup so that checksum validation
917 * can happen in the async kernel threads
918 */
Chris Masonf3f266a2012-03-23 10:22:46 -0400919 ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
920 bio, 1);
Chris Mason1d4284b2012-03-28 20:31:37 -0400921 if (ret)
Stefan Behrens61891922012-11-05 18:51:52 +0100922 goto out_w_error;
923 ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
924 mirror_num, 0);
Josef Bacikde0022b2012-09-25 14:25:58 -0400925 } else if (!async) {
926 ret = btree_csum_one_bio(bio);
927 if (ret)
Stefan Behrens61891922012-11-05 18:51:52 +0100928 goto out_w_error;
929 ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
930 mirror_num, 0);
931 } else {
932 /*
933 * kthread helpers are used to submit writes so that
934 * checksumming can happen in parallel across all CPUs
935 */
936 ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
937 inode, rw, bio, mirror_num, 0,
938 bio_offset,
939 __btree_submit_bio_start,
940 __btree_submit_bio_done);
Chris Mason44b8bd72008-04-16 11:14:51 -0400941 }
Chris Masond313d7a2009-04-20 15:50:09 -0400942
Stefan Behrens61891922012-11-05 18:51:52 +0100943 if (ret) {
944out_w_error:
945 bio_endio(bio, ret);
946 }
947 return ret;
Chris Mason44b8bd72008-04-16 11:14:51 -0400948}
949
Jan Beulich3dd14622010-12-07 14:54:09 +0000950#ifdef CONFIG_MIGRATION
Chris Mason784b4e22010-11-21 22:20:49 -0500951static int btree_migratepage(struct address_space *mapping,
Mel Gormana6bc32b2012-01-12 17:19:43 -0800952 struct page *newpage, struct page *page,
953 enum migrate_mode mode)
Chris Mason784b4e22010-11-21 22:20:49 -0500954{
955 /*
956 * we can't safely write a btree page from here,
957 * we haven't done the locking hook
958 */
959 if (PageDirty(page))
960 return -EAGAIN;
961 /*
962 * Buffers may be managed in a filesystem specific way.
963 * We must have no buffers or drop them.
964 */
965 if (page_has_private(page) &&
966 !try_to_release_page(page, GFP_KERNEL))
967 return -EAGAIN;
Mel Gormana6bc32b2012-01-12 17:19:43 -0800968 return migrate_page(mapping, newpage, page, mode);
Chris Mason784b4e22010-11-21 22:20:49 -0500969}
Jan Beulich3dd14622010-12-07 14:54:09 +0000970#endif
Chris Mason784b4e22010-11-21 22:20:49 -0500971
Chris Mason0da54682007-11-07 21:08:01 -0500972
973static int btree_writepages(struct address_space *mapping,
974 struct writeback_control *wbc)
975{
Chris Masond1310b22008-01-24 16:13:08 -0500976 struct extent_io_tree *tree;
Miao Xiee2d84522013-01-29 10:09:20 +0000977 struct btrfs_fs_info *fs_info;
978 int ret;
979
Chris Masond1310b22008-01-24 16:13:08 -0500980 tree = &BTRFS_I(mapping->host)->io_tree;
Chris Masond8d5f3e2007-12-11 12:42:00 -0500981 if (wbc->sync_mode == WB_SYNC_NONE) {
Chris Mason448d6402007-11-27 07:52:01 -0800982
983 if (wbc->for_kupdate)
984 return 0;
985
Miao Xiee2d84522013-01-29 10:09:20 +0000986 fs_info = BTRFS_I(mapping->host)->root->fs_info;
Chris Masonb9473432009-03-13 11:00:37 -0400987 /* this is a bit racy, but that's ok */
Miao Xiee2d84522013-01-29 10:09:20 +0000988 ret = percpu_counter_compare(&fs_info->dirty_metadata_bytes,
989 BTRFS_DIRTY_METADATA_THRESH);
990 if (ret < 0)
Chris Mason793955b2007-11-26 16:34:41 -0800991 return 0;
Chris Mason793955b2007-11-26 16:34:41 -0800992 }
Josef Bacik0b32f4b2012-03-13 09:38:00 -0400993 return btree_write_cache_pages(mapping, wbc);
Chris Mason0da54682007-11-07 21:08:01 -0500994}
995
Christoph Hellwigb2950862008-12-02 09:54:17 -0500996static int btree_readpage(struct file *file, struct page *page)
Chris Mason5f39d392007-10-15 16:14:19 -0400997{
Chris Masond1310b22008-01-24 16:13:08 -0500998 struct extent_io_tree *tree;
999 tree = &BTRFS_I(page->mapping->host)->io_tree;
Jan Schmidt8ddc7d92011-06-13 20:02:58 +02001000 return extent_read_full_page(tree, page, btree_get_extent, 0);
Chris Mason5f39d392007-10-15 16:14:19 -04001001}
1002
Chris Mason70dec802008-01-29 09:59:12 -05001003static int btree_releasepage(struct page *page, gfp_t gfp_flags)
Chris Mason5f39d392007-10-15 16:14:19 -04001004{
Chris Mason98509cfc2008-09-11 15:51:43 -04001005 if (PageWriteback(page) || PageDirty(page))
Chris Masond3977122009-01-05 21:25:51 -05001006 return 0;
David Sterba0c4e5382012-01-26 15:01:12 -05001007
David Sterbaf7a52a42013-04-26 14:56:29 +00001008 return try_release_extent_buffer(page);
Chris Masone20d96d2007-03-22 12:13:20 -04001009}
Chris Mason123abc82007-03-14 14:14:43 -04001010
Lukas Czernerd47992f2013-05-21 23:17:23 -04001011static void btree_invalidatepage(struct page *page, unsigned int offset,
1012 unsigned int length)
Chris Masond98237b2007-03-28 13:57:48 -04001013{
Chris Masond1310b22008-01-24 16:13:08 -05001014 struct extent_io_tree *tree;
1015 tree = &BTRFS_I(page->mapping->host)->io_tree;
Chris Mason5f39d392007-10-15 16:14:19 -04001016 extent_invalidatepage(tree, page, offset);
1017 btree_releasepage(page, GFP_NOFS);
Chris Mason9ad6b7b2008-04-18 16:11:30 -04001018 if (PagePrivate(page)) {
Chris Masond3977122009-01-05 21:25:51 -05001019 printk(KERN_WARNING "btrfs warning page private not zero "
1020 "on page %llu\n", (unsigned long long)page_offset(page));
Chris Mason9ad6b7b2008-04-18 16:11:30 -04001021 ClearPagePrivate(page);
1022 set_page_private(page, 0);
1023 page_cache_release(page);
1024 }
Chris Masond98237b2007-03-28 13:57:48 -04001025}
1026
Josef Bacik0b32f4b2012-03-13 09:38:00 -04001027static int btree_set_page_dirty(struct page *page)
1028{
Josef Bacikbb146eb2012-10-15 13:30:43 -04001029#ifdef DEBUG
Josef Bacik0b32f4b2012-03-13 09:38:00 -04001030 struct extent_buffer *eb;
1031
1032 BUG_ON(!PagePrivate(page));
1033 eb = (struct extent_buffer *)page->private;
1034 BUG_ON(!eb);
1035 BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
1036 BUG_ON(!atomic_read(&eb->refs));
1037 btrfs_assert_tree_locked(eb);
Josef Bacikbb146eb2012-10-15 13:30:43 -04001038#endif
Josef Bacik0b32f4b2012-03-13 09:38:00 -04001039 return __set_page_dirty_nobuffers(page);
1040}
1041
Alexey Dobriyan7f094102009-09-21 17:01:10 -07001042static const struct address_space_operations btree_aops = {
Chris Masond98237b2007-03-28 13:57:48 -04001043 .readpage = btree_readpage,
Chris Mason0da54682007-11-07 21:08:01 -05001044 .writepages = btree_writepages,
Chris Mason5f39d392007-10-15 16:14:19 -04001045 .releasepage = btree_releasepage,
1046 .invalidatepage = btree_invalidatepage,
Chris Mason5a92bc82010-11-29 09:49:11 -05001047#ifdef CONFIG_MIGRATION
Chris Mason784b4e22010-11-21 22:20:49 -05001048 .migratepage = btree_migratepage,
Chris Mason5a92bc82010-11-29 09:49:11 -05001049#endif
Josef Bacik0b32f4b2012-03-13 09:38:00 -04001050 .set_page_dirty = btree_set_page_dirty,
Chris Masond98237b2007-03-28 13:57:48 -04001051};
1052
Chris Masonca7a79a2008-05-12 12:59:19 -04001053int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1054 u64 parent_transid)
Chris Mason090d1872007-05-01 08:53:32 -04001055{
Chris Mason5f39d392007-10-15 16:14:19 -04001056 struct extent_buffer *buf = NULL;
1057 struct inode *btree_inode = root->fs_info->btree_inode;
Chris Masonde428b62007-05-18 13:28:27 -04001058 int ret = 0;
Chris Mason090d1872007-05-01 08:53:32 -04001059
Chris Masondb945352007-10-15 16:15:53 -04001060 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
Chris Mason5f39d392007-10-15 16:14:19 -04001061 if (!buf)
Chris Mason090d1872007-05-01 08:53:32 -04001062 return 0;
Chris Masond1310b22008-01-24 16:13:08 -05001063 read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
Arne Jansenbb82ab82011-06-10 14:06:53 +02001064 buf, 0, WAIT_NONE, btree_get_extent, 0);
Chris Mason5f39d392007-10-15 16:14:19 -04001065 free_extent_buffer(buf);
Chris Masonde428b62007-05-18 13:28:27 -04001066 return ret;
Chris Mason090d1872007-05-01 08:53:32 -04001067}
1068
Arne Jansenab0fff02011-05-23 14:25:41 +02001069int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1070 int mirror_num, struct extent_buffer **eb)
1071{
1072 struct extent_buffer *buf = NULL;
1073 struct inode *btree_inode = root->fs_info->btree_inode;
1074 struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
1075 int ret;
1076
1077 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1078 if (!buf)
1079 return 0;
1080
1081 set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);
1082
1083 ret = read_extent_buffer_pages(io_tree, buf, 0, WAIT_PAGE_LOCK,
1084 btree_get_extent, mirror_num);
1085 if (ret) {
1086 free_extent_buffer(buf);
1087 return ret;
1088 }
1089
1090 if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
1091 free_extent_buffer(buf);
1092 return -EIO;
Josef Bacik0b32f4b2012-03-13 09:38:00 -04001093 } else if (extent_buffer_uptodate(buf)) {
Arne Jansenab0fff02011-05-23 14:25:41 +02001094 *eb = buf;
1095 } else {
1096 free_extent_buffer(buf);
1097 }
1098 return 0;
1099}
1100
Chris Mason0999df52008-04-01 13:48:14 -04001101struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
1102 u64 bytenr, u32 blocksize)
1103{
1104 struct inode *btree_inode = root->fs_info->btree_inode;
1105 struct extent_buffer *eb;
Chandra Seetharaman452c75c2013-10-07 10:45:25 -05001106 eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree, bytenr);
Chris Mason0999df52008-04-01 13:48:14 -04001107 return eb;
1108}
1109
1110struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
1111 u64 bytenr, u32 blocksize)
1112{
1113 struct inode *btree_inode = root->fs_info->btree_inode;
1114 struct extent_buffer *eb;
1115
1116 eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
Chris Mason727011e2010-08-06 13:21:20 -04001117 bytenr, blocksize);
Chris Mason0999df52008-04-01 13:48:14 -04001118 return eb;
1119}
1120
1121
Chris Masone02119d2008-09-05 16:13:11 -04001122int btrfs_write_tree_block(struct extent_buffer *buf)
1123{
Chris Mason727011e2010-08-06 13:21:20 -04001124 return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
Christoph Hellwig8aa38c32009-10-01 12:58:30 -04001125 buf->start + buf->len - 1);
Chris Masone02119d2008-09-05 16:13:11 -04001126}
1127
1128int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
1129{
Chris Mason727011e2010-08-06 13:21:20 -04001130 return filemap_fdatawait_range(buf->pages[0]->mapping,
Christoph Hellwig8aa38c32009-10-01 12:58:30 -04001131 buf->start, buf->start + buf->len - 1);
Chris Masone02119d2008-09-05 16:13:11 -04001132}
1133
Chris Masondb945352007-10-15 16:15:53 -04001134struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
Chris Masonca7a79a2008-05-12 12:59:19 -04001135 u32 blocksize, u64 parent_transid)
Chris Masone20d96d2007-03-22 12:13:20 -04001136{
Chris Mason5f39d392007-10-15 16:14:19 -04001137 struct extent_buffer *buf = NULL;
Chris Mason19c00dd2007-10-15 16:19:22 -04001138 int ret;
1139
Chris Masondb945352007-10-15 16:15:53 -04001140 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
Chris Mason5f39d392007-10-15 16:14:19 -04001141 if (!buf)
1142 return NULL;
Chris Masone4204de2008-01-08 15:46:27 -05001143
Chris Masonca7a79a2008-05-12 12:59:19 -04001144 ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
Filipe David Borba Manana0f0fe8f2013-07-31 00:39:56 +01001145 if (ret) {
1146 free_extent_buffer(buf);
1147 return NULL;
1148 }
Chris Mason5f39d392007-10-15 16:14:19 -04001149 return buf;
Chris Masonce9adaa2008-04-09 16:28:12 -04001150
Chris Masoneb60cea2007-02-02 09:18:22 -05001151}
1152
Jeff Mahoneyd5c13f92012-03-01 14:56:27 +01001153void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1154 struct extent_buffer *buf)
Chris Masoned2ff2c2007-03-01 18:59:40 -05001155{
Miao Xiee2d84522013-01-29 10:09:20 +00001156 struct btrfs_fs_info *fs_info = root->fs_info;
1157
Chris Mason55c69072008-01-09 15:55:33 -05001158 if (btrfs_header_generation(buf) ==
Miao Xiee2d84522013-01-29 10:09:20 +00001159 fs_info->running_transaction->transid) {
Chris Masonb9447ef2009-03-09 11:45:38 -04001160 btrfs_assert_tree_locked(buf);
Chris Masonb4ce94d2009-02-04 09:25:08 -05001161
Chris Masonb9473432009-03-13 11:00:37 -04001162 if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
Miao Xiee2d84522013-01-29 10:09:20 +00001163 __percpu_counter_add(&fs_info->dirty_metadata_bytes,
1164 -buf->len,
1165 fs_info->dirty_metadata_batch);
Josef Baciked7b63e2012-10-15 13:33:54 -04001166 /* ugh, clear_extent_buffer_dirty needs to lock the page */
1167 btrfs_set_lock_blocking(buf);
1168 clear_extent_buffer_dirty(buf);
1169 }
Chris Mason925baed2008-06-25 16:01:30 -04001170 }
Chris Mason5f39d392007-10-15 16:14:19 -04001171}
1172
Jeff Mahoney143bede2012-03-01 14:56:26 +01001173static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
1174 u32 stripesize, struct btrfs_root *root,
1175 struct btrfs_fs_info *fs_info,
1176 u64 objectid)
Chris Masond97e63b2007-02-20 16:40:44 -05001177{
Chris Masoncfaa7292007-02-21 17:04:57 -05001178 root->node = NULL;
Chris Masona28ec192007-03-06 20:08:01 -05001179 root->commit_root = NULL;
Chris Masondb945352007-10-15 16:15:53 -04001180 root->sectorsize = sectorsize;
1181 root->nodesize = nodesize;
1182 root->leafsize = leafsize;
Chris Mason87ee04e2007-11-30 11:30:34 -05001183 root->stripesize = stripesize;
Chris Mason123abc82007-03-14 14:14:43 -04001184 root->ref_cows = 0;
Chris Mason0b86a832008-03-24 15:01:56 -04001185 root->track_dirty = 0;
Yan, Zhengc71bf092009-11-12 09:34:40 +00001186 root->in_radix = 0;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001187 root->orphan_item_inserted = 0;
1188 root->orphan_cleanup_state = 0;
Chris Mason0b86a832008-03-24 15:01:56 -04001189
Chris Mason0f7d52f2007-04-09 10:42:37 -04001190 root->objectid = objectid;
1191 root->last_trans = 0;
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001192 root->highest_objectid = 0;
Miao Xieeb73c1b2013-05-15 07:48:22 +00001193 root->nr_delalloc_inodes = 0;
Miao Xie199c2a92013-05-15 07:48:23 +00001194 root->nr_ordered_extents = 0;
Josef Bacik58176a92007-08-29 15:47:34 -04001195 root->name = NULL;
Eric Paris6bef4d32010-02-23 19:43:04 +00001196 root->inode_tree = RB_ROOT;
Miao Xie16cdcec2011-04-22 18:12:22 +08001197 INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
Yan, Zhengf0486c62010-05-16 10:46:25 -04001198 root->block_rsv = NULL;
Yan, Zhengd68fc572010-05-16 10:49:58 -04001199 root->orphan_block_rsv = NULL;
Chris Mason0b86a832008-03-24 15:01:56 -04001200
1201 INIT_LIST_HEAD(&root->dirty_list);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001202 INIT_LIST_HEAD(&root->root_list);
Miao Xieeb73c1b2013-05-15 07:48:22 +00001203 INIT_LIST_HEAD(&root->delalloc_inodes);
1204 INIT_LIST_HEAD(&root->delalloc_root);
Miao Xie199c2a92013-05-15 07:48:23 +00001205 INIT_LIST_HEAD(&root->ordered_extents);
1206 INIT_LIST_HEAD(&root->ordered_root);
Josef Bacik2ab28f32012-10-12 15:27:49 -04001207 INIT_LIST_HEAD(&root->logged_list[0]);
1208 INIT_LIST_HEAD(&root->logged_list[1]);
Yan, Zhengd68fc572010-05-16 10:49:58 -04001209 spin_lock_init(&root->orphan_lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001210 spin_lock_init(&root->inode_lock);
Miao Xieeb73c1b2013-05-15 07:48:22 +00001211 spin_lock_init(&root->delalloc_lock);
Miao Xie199c2a92013-05-15 07:48:23 +00001212 spin_lock_init(&root->ordered_extent_lock);
Yan, Zhengf0486c62010-05-16 10:46:25 -04001213 spin_lock_init(&root->accounting_lock);
Josef Bacik2ab28f32012-10-12 15:27:49 -04001214 spin_lock_init(&root->log_extents_lock[0]);
1215 spin_lock_init(&root->log_extents_lock[1]);
Chris Masona2135012008-06-25 16:01:30 -04001216 mutex_init(&root->objectid_mutex);
Chris Masone02119d2008-09-05 16:13:11 -04001217 mutex_init(&root->log_mutex);
Yan Zheng7237f1832009-01-21 12:54:03 -05001218 init_waitqueue_head(&root->log_writer_wait);
1219 init_waitqueue_head(&root->log_commit_wait[0]);
1220 init_waitqueue_head(&root->log_commit_wait[1]);
1221 atomic_set(&root->log_commit[0], 0);
1222 atomic_set(&root->log_commit[1], 0);
1223 atomic_set(&root->log_writers, 0);
Miao Xie2ecb7922012-09-06 04:04:27 -06001224 atomic_set(&root->log_batch, 0);
Josef Bacik8a35d952012-05-23 14:26:42 -04001225 atomic_set(&root->orphan_inodes, 0);
Miao Xieb0feb9d2013-05-15 07:48:20 +00001226 atomic_set(&root->refs, 1);
Yan Zheng7237f1832009-01-21 12:54:03 -05001227 root->log_transid = 0;
Chris Mason257c62e2009-10-13 13:21:08 -04001228 root->last_log_commit = 0;
Josef Bacik06ea65a2013-09-19 16:07:01 -04001229 if (fs_info)
1230 extent_io_tree_init(&root->dirty_log_pages,
1231 fs_info->btree_inode->i_mapping);
Chris Mason017e5362008-07-28 15:32:51 -04001232
Chris Mason3768f362007-03-13 16:47:54 -04001233 memset(&root->root_key, 0, sizeof(root->root_key));
1234 memset(&root->root_item, 0, sizeof(root->root_item));
Chris Mason6702ed42007-08-07 16:15:09 -04001235 memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
Josef Bacik58176a92007-08-29 15:47:34 -04001236 memset(&root->root_kobj, 0, sizeof(root->root_kobj));
Josef Bacik06ea65a2013-09-19 16:07:01 -04001237 if (fs_info)
1238 root->defrag_trans_start = fs_info->generation;
1239 else
1240 root->defrag_trans_start = 0;
Josef Bacik58176a92007-08-29 15:47:34 -04001241 init_completion(&root->kobj_unregister);
Chris Mason6702ed42007-08-07 16:15:09 -04001242 root->defrag_running = 0;
Chris Mason4d775672007-04-20 20:23:12 -04001243 root->root_key.objectid = objectid;
Al Viro0ee5dc62011-07-07 15:44:25 -04001244 root->anon_dev = 0;
Alexander Block8ea05e32012-07-25 17:35:53 +02001245
Anand Jain5f3ab902012-12-07 09:28:54 +00001246 spin_lock_init(&root->root_item_lock);
Chris Mason3768f362007-03-13 16:47:54 -04001247}
1248
Al Virof84a8bd2011-11-17 15:57:57 -05001249static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
Al Viro6f07e422011-11-17 00:46:16 -05001250{
1251 struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
1252 if (root)
1253 root->fs_info = fs_info;
1254 return root;
1255}
1256
Josef Bacik06ea65a2013-09-19 16:07:01 -04001257#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1258/* Should only be used by the testing infrastructure */
1259struct btrfs_root *btrfs_alloc_dummy_root(void)
1260{
1261 struct btrfs_root *root;
1262
1263 root = btrfs_alloc_root(NULL);
1264 if (!root)
1265 return ERR_PTR(-ENOMEM);
1266 __setup_root(4096, 4096, 4096, 4096, root, NULL, 1);
1267 root->dummy_root = 1;
1268
1269 return root;
1270}
1271#endif
1272
Arne Jansen20897f52011-09-13 12:44:20 +02001273struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
1274 struct btrfs_fs_info *fs_info,
1275 u64 objectid)
1276{
1277 struct extent_buffer *leaf;
1278 struct btrfs_root *tree_root = fs_info->tree_root;
1279 struct btrfs_root *root;
1280 struct btrfs_key key;
1281 int ret = 0;
1282 u64 bytenr;
Stefan Behrens6463fe52013-04-19 15:08:05 +00001283 uuid_le uuid;
Arne Jansen20897f52011-09-13 12:44:20 +02001284
1285 root = btrfs_alloc_root(fs_info);
1286 if (!root)
1287 return ERR_PTR(-ENOMEM);
1288
1289 __setup_root(tree_root->nodesize, tree_root->leafsize,
1290 tree_root->sectorsize, tree_root->stripesize,
1291 root, fs_info, objectid);
1292 root->root_key.objectid = objectid;
1293 root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1294 root->root_key.offset = 0;
1295
1296 leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
1297 0, objectid, NULL, 0, 0, 0);
1298 if (IS_ERR(leaf)) {
1299 ret = PTR_ERR(leaf);
Tsutomu Itoh1dd05682013-03-21 04:32:32 +00001300 leaf = NULL;
Arne Jansen20897f52011-09-13 12:44:20 +02001301 goto fail;
1302 }
1303
1304 bytenr = leaf->start;
1305 memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1306 btrfs_set_header_bytenr(leaf, leaf->start);
1307 btrfs_set_header_generation(leaf, trans->transid);
1308 btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1309 btrfs_set_header_owner(leaf, objectid);
1310 root->node = leaf;
1311
Ross Kirk0a4e5582013-09-24 10:12:38 +01001312 write_extent_buffer(leaf, fs_info->fsid, btrfs_header_fsid(),
Arne Jansen20897f52011-09-13 12:44:20 +02001313 BTRFS_FSID_SIZE);
1314 write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
Geert Uytterhoevenb308bc22013-08-20 13:20:15 +02001315 btrfs_header_chunk_tree_uuid(leaf),
Arne Jansen20897f52011-09-13 12:44:20 +02001316 BTRFS_UUID_SIZE);
1317 btrfs_mark_buffer_dirty(leaf);
1318
1319 root->commit_root = btrfs_root_node(root);
1320 root->track_dirty = 1;
1321
1322
1323 root->root_item.flags = 0;
1324 root->root_item.byte_limit = 0;
1325 btrfs_set_root_bytenr(&root->root_item, leaf->start);
1326 btrfs_set_root_generation(&root->root_item, trans->transid);
1327 btrfs_set_root_level(&root->root_item, 0);
1328 btrfs_set_root_refs(&root->root_item, 1);
1329 btrfs_set_root_used(&root->root_item, leaf->len);
1330 btrfs_set_root_last_snapshot(&root->root_item, 0);
1331 btrfs_set_root_dirid(&root->root_item, 0);
Stefan Behrens6463fe52013-04-19 15:08:05 +00001332 uuid_le_gen(&uuid);
1333 memcpy(root->root_item.uuid, uuid.b, BTRFS_UUID_SIZE);
Arne Jansen20897f52011-09-13 12:44:20 +02001334 root->root_item.drop_level = 0;
1335
1336 key.objectid = objectid;
1337 key.type = BTRFS_ROOT_ITEM_KEY;
1338 key.offset = 0;
1339 ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
1340 if (ret)
1341 goto fail;
1342
1343 btrfs_tree_unlock(leaf);
1344
Arne Jansen20897f52011-09-13 12:44:20 +02001345 return root;
Tsutomu Itoh1dd05682013-03-21 04:32:32 +00001346
1347fail:
1348 if (leaf) {
1349 btrfs_tree_unlock(leaf);
1350 free_extent_buffer(leaf);
1351 }
1352 kfree(root);
1353
1354 return ERR_PTR(ret);
Arne Jansen20897f52011-09-13 12:44:20 +02001355}
1356
Yan Zheng7237f1832009-01-21 12:54:03 -05001357static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
1358 struct btrfs_fs_info *fs_info)
Chris Mason0f7d52f2007-04-09 10:42:37 -04001359{
1360 struct btrfs_root *root;
1361 struct btrfs_root *tree_root = fs_info->tree_root;
Yan Zheng7237f1832009-01-21 12:54:03 -05001362 struct extent_buffer *leaf;
Chris Masone02119d2008-09-05 16:13:11 -04001363
Al Viro6f07e422011-11-17 00:46:16 -05001364 root = btrfs_alloc_root(fs_info);
Chris Masone02119d2008-09-05 16:13:11 -04001365 if (!root)
Yan Zheng7237f1832009-01-21 12:54:03 -05001366 return ERR_PTR(-ENOMEM);
Chris Masone02119d2008-09-05 16:13:11 -04001367
1368 __setup_root(tree_root->nodesize, tree_root->leafsize,
1369 tree_root->sectorsize, tree_root->stripesize,
1370 root, fs_info, BTRFS_TREE_LOG_OBJECTID);
1371
1372 root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
1373 root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1374 root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
Yan Zheng7237f1832009-01-21 12:54:03 -05001375 /*
1376 * log trees do not get reference counted because they go away
1377 * before a real commit is actually done. They do store pointers
1378 * to file data extents, and those reference counts still get
1379 * updated (along with back refs to the log tree).
1380 */
Chris Masone02119d2008-09-05 16:13:11 -04001381 root->ref_cows = 0;
1382
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001383 leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
Arne Jansen66d7e7f2011-09-12 15:26:38 +02001384 BTRFS_TREE_LOG_OBJECTID, NULL,
Jan Schmidt5581a512012-05-16 17:04:52 +02001385 0, 0, 0);
Yan Zheng7237f1832009-01-21 12:54:03 -05001386 if (IS_ERR(leaf)) {
1387 kfree(root);
1388 return ERR_CAST(leaf);
1389 }
Chris Masone02119d2008-09-05 16:13:11 -04001390
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001391 memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1392 btrfs_set_header_bytenr(leaf, leaf->start);
1393 btrfs_set_header_generation(leaf, trans->transid);
1394 btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1395 btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
Yan Zheng7237f1832009-01-21 12:54:03 -05001396 root->node = leaf;
Chris Masone02119d2008-09-05 16:13:11 -04001397
1398 write_extent_buffer(root->node, root->fs_info->fsid,
Ross Kirk0a4e5582013-09-24 10:12:38 +01001399 btrfs_header_fsid(), BTRFS_FSID_SIZE);
Chris Masone02119d2008-09-05 16:13:11 -04001400 btrfs_mark_buffer_dirty(root->node);
1401 btrfs_tree_unlock(root->node);
Yan Zheng7237f1832009-01-21 12:54:03 -05001402 return root;
1403}
1404
1405int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
1406 struct btrfs_fs_info *fs_info)
1407{
1408 struct btrfs_root *log_root;
1409
1410 log_root = alloc_log_tree(trans, fs_info);
1411 if (IS_ERR(log_root))
1412 return PTR_ERR(log_root);
1413 WARN_ON(fs_info->log_root_tree);
1414 fs_info->log_root_tree = log_root;
1415 return 0;
1416}
1417
1418int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
1419 struct btrfs_root *root)
1420{
1421 struct btrfs_root *log_root;
1422 struct btrfs_inode_item *inode_item;
1423
1424 log_root = alloc_log_tree(trans, root->fs_info);
1425 if (IS_ERR(log_root))
1426 return PTR_ERR(log_root);
1427
1428 log_root->last_trans = trans->transid;
1429 log_root->root_key.offset = root->root_key.objectid;
1430
1431 inode_item = &log_root->root_item.inode;
Qu Wenruo3cae2102013-07-16 11:19:18 +08001432 btrfs_set_stack_inode_generation(inode_item, 1);
1433 btrfs_set_stack_inode_size(inode_item, 3);
1434 btrfs_set_stack_inode_nlink(inode_item, 1);
1435 btrfs_set_stack_inode_nbytes(inode_item, root->leafsize);
1436 btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
Yan Zheng7237f1832009-01-21 12:54:03 -05001437
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001438 btrfs_set_root_node(&log_root->root_item, log_root->node);
Yan Zheng7237f1832009-01-21 12:54:03 -05001439
1440 WARN_ON(root->log_root);
1441 root->log_root = log_root;
1442 root->log_transid = 0;
Chris Mason257c62e2009-10-13 13:21:08 -04001443 root->last_log_commit = 0;
Chris Masone02119d2008-09-05 16:13:11 -04001444 return 0;
1445}
1446
Stefan Behrens35a36212013-08-14 18:12:25 +02001447static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
1448 struct btrfs_key *key)
Chris Masone02119d2008-09-05 16:13:11 -04001449{
1450 struct btrfs_root *root;
1451 struct btrfs_fs_info *fs_info = tree_root->fs_info;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001452 struct btrfs_path *path;
Yan Zheng84234f32008-10-29 14:49:05 -04001453 u64 generation;
Chris Masondb945352007-10-15 16:15:53 -04001454 u32 blocksize;
Miao Xiecb517ea2013-05-15 07:48:19 +00001455 int ret;
1456
1457 path = btrfs_alloc_path();
1458 if (!path)
1459 return ERR_PTR(-ENOMEM);
Chris Mason0f7d52f2007-04-09 10:42:37 -04001460
Al Viro6f07e422011-11-17 00:46:16 -05001461 root = btrfs_alloc_root(fs_info);
Miao Xiecb517ea2013-05-15 07:48:19 +00001462 if (!root) {
1463 ret = -ENOMEM;
1464 goto alloc_fail;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001465 }
1466
Chris Masondb945352007-10-15 16:15:53 -04001467 __setup_root(tree_root->nodesize, tree_root->leafsize,
Chris Mason87ee04e2007-11-30 11:30:34 -05001468 tree_root->sectorsize, tree_root->stripesize,
Miao Xiecb517ea2013-05-15 07:48:19 +00001469 root, fs_info, key->objectid);
Chris Mason0f7d52f2007-04-09 10:42:37 -04001470
Miao Xiecb517ea2013-05-15 07:48:19 +00001471 ret = btrfs_find_root(tree_root, key, path,
1472 &root->root_item, &root->root_key);
Chris Mason0f7d52f2007-04-09 10:42:37 -04001473 if (ret) {
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001474 if (ret > 0)
1475 ret = -ENOENT;
Miao Xiecb517ea2013-05-15 07:48:19 +00001476 goto find_fail;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001477 }
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001478
Yan Zheng84234f32008-10-29 14:49:05 -04001479 generation = btrfs_root_generation(&root->root_item);
Chris Masondb945352007-10-15 16:15:53 -04001480 blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
1481 root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
Yan Zheng84234f32008-10-29 14:49:05 -04001482 blocksize, generation);
Miao Xiecb517ea2013-05-15 07:48:19 +00001483 if (!root->node) {
1484 ret = -ENOMEM;
1485 goto find_fail;
1486 } else if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
1487 ret = -EIO;
1488 goto read_fail;
Josef Bacik416bc652013-04-23 14:17:42 -04001489 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001490 root->commit_root = btrfs_root_node(root);
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001491out:
Miao Xiecb517ea2013-05-15 07:48:19 +00001492 btrfs_free_path(path);
1493 return root;
1494
1495read_fail:
1496 free_extent_buffer(root->node);
1497find_fail:
1498 kfree(root);
1499alloc_fail:
1500 root = ERR_PTR(ret);
1501 goto out;
1502}
1503
1504struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,
1505 struct btrfs_key *location)
1506{
1507 struct btrfs_root *root;
1508
1509 root = btrfs_read_tree_root(tree_root, location);
1510 if (IS_ERR(root))
1511 return root;
1512
1513 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
Chris Masone02119d2008-09-05 16:13:11 -04001514 root->ref_cows = 1;
Li Zefan08fe4db2011-03-28 02:01:25 +00001515 btrfs_check_and_init_root_item(&root->root_item);
1516 }
Yan, Zheng13a8a7c2009-09-21 15:56:00 -04001517
Chris Mason5eda7b52007-06-22 14:16:25 -04001518 return root;
1519}
1520
Miao Xiecb517ea2013-05-15 07:48:19 +00001521int btrfs_init_fs_root(struct btrfs_root *root)
1522{
1523 int ret;
1524
1525 root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
1526 root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
1527 GFP_NOFS);
1528 if (!root->free_ino_pinned || !root->free_ino_ctl) {
1529 ret = -ENOMEM;
1530 goto fail;
1531 }
1532
1533 btrfs_init_free_ino_ctl(root);
1534 mutex_init(&root->fs_commit_mutex);
1535 spin_lock_init(&root->cache_lock);
1536 init_waitqueue_head(&root->cache_wait);
1537
1538 ret = get_anon_bdev(&root->anon_dev);
1539 if (ret)
1540 goto fail;
1541 return 0;
1542fail:
1543 kfree(root->free_ino_ctl);
1544 kfree(root->free_ino_pinned);
1545 return ret;
1546}
1547
Sergei Trofimovich171170c2013-08-14 23:27:46 +03001548static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
1549 u64 root_id)
Miao Xiecb517ea2013-05-15 07:48:19 +00001550{
1551 struct btrfs_root *root;
1552
1553 spin_lock(&fs_info->fs_roots_radix_lock);
1554 root = radix_tree_lookup(&fs_info->fs_roots_radix,
1555 (unsigned long)root_id);
1556 spin_unlock(&fs_info->fs_roots_radix_lock);
1557 return root;
1558}
1559
1560int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
1561 struct btrfs_root *root)
1562{
1563 int ret;
1564
1565 ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
1566 if (ret)
1567 return ret;
1568
1569 spin_lock(&fs_info->fs_roots_radix_lock);
1570 ret = radix_tree_insert(&fs_info->fs_roots_radix,
1571 (unsigned long)root->root_key.objectid,
1572 root);
1573 if (ret == 0)
1574 root->in_radix = 1;
1575 spin_unlock(&fs_info->fs_roots_radix_lock);
1576 radix_tree_preload_end();
1577
1578 return ret;
1579}
1580
Miao Xiec00869f2013-09-25 21:47:44 +08001581struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
1582 struct btrfs_key *location,
1583 bool check_ref)
Chris Mason5eda7b52007-06-22 14:16:25 -04001584{
1585 struct btrfs_root *root;
1586 int ret;
1587
Chris Masonedbd8d42007-12-21 16:27:24 -05001588 if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1589 return fs_info->tree_root;
1590 if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
1591 return fs_info->extent_root;
Chris Mason8f18cf12008-04-25 16:53:30 -04001592 if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
1593 return fs_info->chunk_root;
1594 if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
1595 return fs_info->dev_root;
Yan Zheng0403e472008-12-10 20:32:51 -05001596 if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
1597 return fs_info->csum_root;
Arne Jansenbcef60f2011-09-13 15:23:30 +02001598 if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
1599 return fs_info->quota_root ? fs_info->quota_root :
1600 ERR_PTR(-ENOENT);
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02001601 if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
1602 return fs_info->uuid_root ? fs_info->uuid_root :
1603 ERR_PTR(-ENOENT);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04001604again:
Miao Xiecb517ea2013-05-15 07:48:19 +00001605 root = btrfs_lookup_fs_root(fs_info, location->objectid);
Stefan Behrens48475472013-08-23 10:34:42 +02001606 if (root) {
Miao Xiec00869f2013-09-25 21:47:44 +08001607 if (check_ref && btrfs_root_refs(&root->root_item) == 0)
Stefan Behrens48475472013-08-23 10:34:42 +02001608 return ERR_PTR(-ENOENT);
Chris Mason5eda7b52007-06-22 14:16:25 -04001609 return root;
Stefan Behrens48475472013-08-23 10:34:42 +02001610 }
Chris Mason5eda7b52007-06-22 14:16:25 -04001611
Miao Xiecb517ea2013-05-15 07:48:19 +00001612 root = btrfs_read_fs_root(fs_info->tree_root, location);
Chris Mason5eda7b52007-06-22 14:16:25 -04001613 if (IS_ERR(root))
1614 return root;
Chris Mason3394e162008-11-17 20:42:26 -05001615
Miao Xiec00869f2013-09-25 21:47:44 +08001616 if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
Yan, Zhengd68fc572010-05-16 10:49:58 -04001617 ret = -ENOENT;
1618 goto fail;
1619 }
1620
Miao Xiecb517ea2013-05-15 07:48:19 +00001621 ret = btrfs_init_fs_root(root);
1622 if (ret)
1623 goto fail;
1624
Yan, Zhengd68fc572010-05-16 10:49:58 -04001625 ret = btrfs_find_orphan_item(fs_info->tree_root, location->objectid);
1626 if (ret < 0)
1627 goto fail;
1628 if (ret == 0)
1629 root->orphan_item_inserted = 1;
1630
Miao Xiecb517ea2013-05-15 07:48:19 +00001631 ret = btrfs_insert_fs_root(fs_info, root);
Chris Mason0f7d52f2007-04-09 10:42:37 -04001632 if (ret) {
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04001633 if (ret == -EEXIST) {
1634 free_fs_root(root);
1635 goto again;
1636 }
1637 goto fail;
Chris Mason0f7d52f2007-04-09 10:42:37 -04001638 }
Chris Masonedbd8d42007-12-21 16:27:24 -05001639 return root;
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04001640fail:
1641 free_fs_root(root);
1642 return ERR_PTR(ret);
Chris Masonedbd8d42007-12-21 16:27:24 -05001643}
1644
Chris Mason04160082008-03-26 10:28:07 -04001645static int btrfs_congested_fn(void *congested_data, int bdi_bits)
1646{
1647 struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
1648 int ret = 0;
Chris Mason04160082008-03-26 10:28:07 -04001649 struct btrfs_device *device;
1650 struct backing_dev_info *bdi;
Chris Masonb7967db2009-04-27 07:29:04 -04001651
Xiao Guangrong1f781602011-04-20 10:09:16 +00001652 rcu_read_lock();
1653 list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
Chris Masondfe25022008-05-13 13:46:40 -04001654 if (!device->bdev)
1655 continue;
Chris Mason04160082008-03-26 10:28:07 -04001656 bdi = blk_get_backing_dev_info(device->bdev);
1657 if (bdi && bdi_congested(bdi, bdi_bits)) {
1658 ret = 1;
1659 break;
1660 }
1661 }
Xiao Guangrong1f781602011-04-20 10:09:16 +00001662 rcu_read_unlock();
Chris Mason04160082008-03-26 10:28:07 -04001663 return ret;
1664}
1665
Chris Mason38b66982008-04-22 09:22:11 -04001666/*
Jens Axboead081f12009-06-12 14:43:40 +02001667 * If this fails, caller must call bdi_destroy() to get rid of the
1668 * bdi again.
1669 */
Chris Mason04160082008-03-26 10:28:07 -04001670static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
1671{
Jens Axboead081f12009-06-12 14:43:40 +02001672 int err;
1673
1674 bdi->capabilities = BDI_CAP_MAP_COPY;
Jens Axboee6d086d2010-04-26 10:27:54 +02001675 err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
Jens Axboead081f12009-06-12 14:43:40 +02001676 if (err)
1677 return err;
1678
Chris Mason4575c9c2008-04-18 16:13:31 -04001679 bdi->ra_pages = default_backing_dev_info.ra_pages;
Chris Mason04160082008-03-26 10:28:07 -04001680 bdi->congested_fn = btrfs_congested_fn;
1681 bdi->congested_data = info;
1682 return 0;
1683}
1684
Chris Mason8b712842008-06-11 16:50:36 -04001685/*
1686 * called by the kthread helper functions to finally call the bio end_io
1687 * functions. This is where read checksum verification actually happens
1688 */
1689static void end_workqueue_fn(struct btrfs_work *work)
Chris Masonce9adaa2008-04-09 16:28:12 -04001690{
Chris Masonce9adaa2008-04-09 16:28:12 -04001691 struct bio *bio;
Chris Mason8b712842008-06-11 16:50:36 -04001692 struct end_io_wq *end_io_wq;
1693 struct btrfs_fs_info *fs_info;
Chris Masonce9adaa2008-04-09 16:28:12 -04001694 int error;
Chris Masonce9adaa2008-04-09 16:28:12 -04001695
Chris Mason8b712842008-06-11 16:50:36 -04001696 end_io_wq = container_of(work, struct end_io_wq, work);
1697 bio = end_io_wq->bio;
1698 fs_info = end_io_wq->info;
Chris Masonce9adaa2008-04-09 16:28:12 -04001699
Chris Mason8b712842008-06-11 16:50:36 -04001700 error = end_io_wq->error;
1701 bio->bi_private = end_io_wq->private;
1702 bio->bi_end_io = end_io_wq->end_io;
1703 kfree(end_io_wq);
Chris Mason8b712842008-06-11 16:50:36 -04001704 bio_endio(bio, error);
Chris Mason44b8bd72008-04-16 11:14:51 -04001705}
1706
Chris Masona74a4b92008-06-25 16:01:31 -04001707static int cleaner_kthread(void *arg)
1708{
1709 struct btrfs_root *root = arg;
Miao Xied0278242013-05-14 10:20:40 +00001710 int again;
Chris Masona74a4b92008-06-25 16:01:31 -04001711
1712 do {
Miao Xied0278242013-05-14 10:20:40 +00001713 again = 0;
David Sterba9d1a2a32013-03-12 15:13:28 +00001714
Miao Xied0278242013-05-14 10:20:40 +00001715 /* Make the cleaner go to sleep early. */
Miao Xiebabbf1702013-05-14 10:20:43 +00001716 if (btrfs_need_cleaner_sleep(root))
Miao Xied0278242013-05-14 10:20:40 +00001717 goto sleep;
Chris Masona74a4b92008-06-25 16:01:31 -04001718
Miao Xied0278242013-05-14 10:20:40 +00001719 if (!mutex_trylock(&root->fs_info->cleaner_mutex))
1720 goto sleep;
1721
Miao Xiedc7f3702013-05-14 10:20:42 +00001722 /*
1723 * Avoid the problem that we change the status of the fs
1724 * during the above check and trylock.
1725 */
Miao Xiebabbf1702013-05-14 10:20:43 +00001726 if (btrfs_need_cleaner_sleep(root)) {
Miao Xiedc7f3702013-05-14 10:20:42 +00001727 mutex_unlock(&root->fs_info->cleaner_mutex);
1728 goto sleep;
Chris Masona74a4b92008-06-25 16:01:31 -04001729 }
1730
Miao Xied0278242013-05-14 10:20:40 +00001731 btrfs_run_delayed_iputs(root);
1732 again = btrfs_clean_one_deleted_snapshot(root);
1733 mutex_unlock(&root->fs_info->cleaner_mutex);
1734
1735 /*
Miao Xie05323cd2013-05-14 10:20:41 +00001736 * The defragger has dealt with the R/O remount and umount,
1737 * needn't do anything special here.
Miao Xied0278242013-05-14 10:20:40 +00001738 */
1739 btrfs_run_defrag_inodes(root->fs_info);
1740sleep:
David Sterba9d1a2a32013-03-12 15:13:28 +00001741 if (!try_to_freeze() && !again) {
Chris Masona74a4b92008-06-25 16:01:31 -04001742 set_current_state(TASK_INTERRUPTIBLE);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001743 if (!kthread_should_stop())
1744 schedule();
Chris Masona74a4b92008-06-25 16:01:31 -04001745 __set_current_state(TASK_RUNNING);
1746 }
1747 } while (!kthread_should_stop());
1748 return 0;
1749}
1750
1751static int transaction_kthread(void *arg)
1752{
1753 struct btrfs_root *root = arg;
1754 struct btrfs_trans_handle *trans;
1755 struct btrfs_transaction *cur;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001756 u64 transid;
Chris Masona74a4b92008-06-25 16:01:31 -04001757 unsigned long now;
1758 unsigned long delay;
Jan Kara914b2002012-03-12 16:05:50 +01001759 bool cannot_commit;
Chris Masona74a4b92008-06-25 16:01:31 -04001760
1761 do {
Jan Kara914b2002012-03-12 16:05:50 +01001762 cannot_commit = false;
David Sterba8b87dc12013-08-01 18:14:52 +02001763 delay = HZ * root->fs_info->commit_interval;
Chris Masona74a4b92008-06-25 16:01:31 -04001764 mutex_lock(&root->fs_info->transaction_kthread_mutex);
1765
Josef Bacika4abeea2011-04-11 17:25:13 -04001766 spin_lock(&root->fs_info->trans_lock);
Chris Masona74a4b92008-06-25 16:01:31 -04001767 cur = root->fs_info->running_transaction;
1768 if (!cur) {
Josef Bacika4abeea2011-04-11 17:25:13 -04001769 spin_unlock(&root->fs_info->trans_lock);
Chris Masona74a4b92008-06-25 16:01:31 -04001770 goto sleep;
1771 }
Yan Zheng31153d82008-07-28 15:32:19 -04001772
Chris Masona74a4b92008-06-25 16:01:31 -04001773 now = get_seconds();
Miao Xie4a9d8bd2013-05-17 03:53:43 +00001774 if (cur->state < TRANS_STATE_BLOCKED &&
David Sterba8b87dc12013-08-01 18:14:52 +02001775 (now < cur->start_time ||
1776 now - cur->start_time < root->fs_info->commit_interval)) {
Josef Bacika4abeea2011-04-11 17:25:13 -04001777 spin_unlock(&root->fs_info->trans_lock);
Chris Masona74a4b92008-06-25 16:01:31 -04001778 delay = HZ * 5;
1779 goto sleep;
1780 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001781 transid = cur->transid;
Josef Bacika4abeea2011-04-11 17:25:13 -04001782 spin_unlock(&root->fs_info->trans_lock);
Chris Mason56bec292009-03-13 10:10:06 -04001783
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001784 /* If the file system is aborted, this will always fail. */
Miao Xie354aa0f2012-09-20 01:54:00 -06001785 trans = btrfs_attach_transaction(root);
Jan Kara914b2002012-03-12 16:05:50 +01001786 if (IS_ERR(trans)) {
Miao Xie354aa0f2012-09-20 01:54:00 -06001787 if (PTR_ERR(trans) != -ENOENT)
1788 cannot_commit = true;
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001789 goto sleep;
Jan Kara914b2002012-03-12 16:05:50 +01001790 }
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001791 if (transid == trans->transid) {
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001792 btrfs_commit_transaction(trans, root);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001793 } else {
1794 btrfs_end_transaction(trans, root);
1795 }
Chris Masona74a4b92008-06-25 16:01:31 -04001796sleep:
1797 wake_up_process(root->fs_info->cleaner_kthread);
1798 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1799
Josef Bacik4e121c02013-09-27 16:32:39 -04001800 if (unlikely(test_bit(BTRFS_FS_STATE_ERROR,
1801 &root->fs_info->fs_state)))
1802 btrfs_cleanup_transaction(root);
Tejun Heoa0acae02011-11-21 12:32:22 -08001803 if (!try_to_freeze()) {
Chris Masona74a4b92008-06-25 16:01:31 -04001804 set_current_state(TASK_INTERRUPTIBLE);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001805 if (!kthread_should_stop() &&
Jan Kara914b2002012-03-12 16:05:50 +01001806 (!btrfs_transaction_blocked(root->fs_info) ||
1807 cannot_commit))
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04001808 schedule_timeout(delay);
Chris Masona74a4b92008-06-25 16:01:31 -04001809 __set_current_state(TASK_RUNNING);
1810 }
1811 } while (!kthread_should_stop());
1812 return 0;
1813}
1814
Chris Masonaf31f5e2011-11-03 15:17:42 -04001815/*
1816 * this will find the highest generation in the array of
1817 * root backups. The index of the highest array is returned,
1818 * or -1 if we can't find anything.
1819 *
1820 * We check to make sure the array is valid by comparing the
1821 * generation of the latest root in the array with the generation
1822 * in the super block. If they don't match we pitch it.
1823 */
1824static int find_newest_super_backup(struct btrfs_fs_info *info, u64 newest_gen)
1825{
1826 u64 cur;
1827 int newest_index = -1;
1828 struct btrfs_root_backup *root_backup;
1829 int i;
1830
1831 for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
1832 root_backup = info->super_copy->super_roots + i;
1833 cur = btrfs_backup_tree_root_gen(root_backup);
1834 if (cur == newest_gen)
1835 newest_index = i;
1836 }
1837
1838 /* check to see if we actually wrapped around */
1839 if (newest_index == BTRFS_NUM_BACKUP_ROOTS - 1) {
1840 root_backup = info->super_copy->super_roots;
1841 cur = btrfs_backup_tree_root_gen(root_backup);
1842 if (cur == newest_gen)
1843 newest_index = 0;
1844 }
1845 return newest_index;
1846}
1847
1848
1849/*
1850 * find the oldest backup so we know where to store new entries
1851 * in the backup array. This will set the backup_root_index
1852 * field in the fs_info struct
1853 */
1854static void find_oldest_super_backup(struct btrfs_fs_info *info,
1855 u64 newest_gen)
1856{
1857 int newest_index = -1;
1858
1859 newest_index = find_newest_super_backup(info, newest_gen);
1860 /* if there was garbage in there, just move along */
1861 if (newest_index == -1) {
1862 info->backup_root_index = 0;
1863 } else {
1864 info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS;
1865 }
1866}
1867
1868/*
1869 * copy all the root pointers into the super backup array.
1870 * this will bump the backup pointer by one when it is
1871 * done
1872 */
1873static void backup_super_roots(struct btrfs_fs_info *info)
1874{
1875 int next_backup;
1876 struct btrfs_root_backup *root_backup;
1877 int last_backup;
1878
1879 next_backup = info->backup_root_index;
1880 last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
1881 BTRFS_NUM_BACKUP_ROOTS;
1882
1883 /*
1884 * just overwrite the last backup if we're at the same generation
1885 * this happens only at umount
1886 */
1887 root_backup = info->super_for_commit->super_roots + last_backup;
1888 if (btrfs_backup_tree_root_gen(root_backup) ==
1889 btrfs_header_generation(info->tree_root->node))
1890 next_backup = last_backup;
1891
1892 root_backup = info->super_for_commit->super_roots + next_backup;
1893
1894 /*
1895 * make sure all of our padding and empty slots get zero filled
1896 * regardless of which ones we use today
1897 */
1898 memset(root_backup, 0, sizeof(*root_backup));
1899
1900 info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
1901
1902 btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
1903 btrfs_set_backup_tree_root_gen(root_backup,
1904 btrfs_header_generation(info->tree_root->node));
1905
1906 btrfs_set_backup_tree_root_level(root_backup,
1907 btrfs_header_level(info->tree_root->node));
1908
1909 btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
1910 btrfs_set_backup_chunk_root_gen(root_backup,
1911 btrfs_header_generation(info->chunk_root->node));
1912 btrfs_set_backup_chunk_root_level(root_backup,
1913 btrfs_header_level(info->chunk_root->node));
1914
1915 btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
1916 btrfs_set_backup_extent_root_gen(root_backup,
1917 btrfs_header_generation(info->extent_root->node));
1918 btrfs_set_backup_extent_root_level(root_backup,
1919 btrfs_header_level(info->extent_root->node));
1920
Chris Mason7c7e82a2011-11-06 18:50:56 -05001921 /*
1922 * we might commit during log recovery, which happens before we set
1923 * the fs_root. Make sure it is valid before we fill it in.
1924 */
1925 if (info->fs_root && info->fs_root->node) {
1926 btrfs_set_backup_fs_root(root_backup,
1927 info->fs_root->node->start);
1928 btrfs_set_backup_fs_root_gen(root_backup,
Chris Masonaf31f5e2011-11-03 15:17:42 -04001929 btrfs_header_generation(info->fs_root->node));
Chris Mason7c7e82a2011-11-06 18:50:56 -05001930 btrfs_set_backup_fs_root_level(root_backup,
Chris Masonaf31f5e2011-11-03 15:17:42 -04001931 btrfs_header_level(info->fs_root->node));
Chris Mason7c7e82a2011-11-06 18:50:56 -05001932 }
Chris Masonaf31f5e2011-11-03 15:17:42 -04001933
1934 btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
1935 btrfs_set_backup_dev_root_gen(root_backup,
1936 btrfs_header_generation(info->dev_root->node));
1937 btrfs_set_backup_dev_root_level(root_backup,
1938 btrfs_header_level(info->dev_root->node));
1939
1940 btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
1941 btrfs_set_backup_csum_root_gen(root_backup,
1942 btrfs_header_generation(info->csum_root->node));
1943 btrfs_set_backup_csum_root_level(root_backup,
1944 btrfs_header_level(info->csum_root->node));
1945
1946 btrfs_set_backup_total_bytes(root_backup,
1947 btrfs_super_total_bytes(info->super_copy));
1948 btrfs_set_backup_bytes_used(root_backup,
1949 btrfs_super_bytes_used(info->super_copy));
1950 btrfs_set_backup_num_devices(root_backup,
1951 btrfs_super_num_devices(info->super_copy));
1952
1953 /*
1954 * if we don't copy this out to the super_copy, it won't get remembered
1955 * for the next commit
1956 */
1957 memcpy(&info->super_copy->super_roots,
1958 &info->super_for_commit->super_roots,
1959 sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
1960}
1961
1962/*
1963 * this copies info out of the root backup array and back into
1964 * the in-memory super block. It is meant to help iterate through
1965 * the array, so you send it the number of backups you've already
1966 * tried and the last backup index you used.
1967 *
1968 * this returns -1 when it has tried all the backups
1969 */
1970static noinline int next_root_backup(struct btrfs_fs_info *info,
1971 struct btrfs_super_block *super,
1972 int *num_backups_tried, int *backup_index)
1973{
1974 struct btrfs_root_backup *root_backup;
1975 int newest = *backup_index;
1976
1977 if (*num_backups_tried == 0) {
1978 u64 gen = btrfs_super_generation(super);
1979
1980 newest = find_newest_super_backup(info, gen);
1981 if (newest == -1)
1982 return -1;
1983
1984 *backup_index = newest;
1985 *num_backups_tried = 1;
1986 } else if (*num_backups_tried == BTRFS_NUM_BACKUP_ROOTS) {
1987 /* we've tried all the backups, all done */
1988 return -1;
1989 } else {
1990 /* jump to the next oldest backup */
1991 newest = (*backup_index + BTRFS_NUM_BACKUP_ROOTS - 1) %
1992 BTRFS_NUM_BACKUP_ROOTS;
1993 *backup_index = newest;
1994 *num_backups_tried += 1;
1995 }
1996 root_backup = super->super_roots + newest;
1997
1998 btrfs_set_super_generation(super,
1999 btrfs_backup_tree_root_gen(root_backup));
2000 btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
2001 btrfs_set_super_root_level(super,
2002 btrfs_backup_tree_root_level(root_backup));
2003 btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
2004
2005 /*
2006 * fixme: the total bytes and num_devices need to match or we should
2007 * need a fsck
2008 */
2009 btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
2010 btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
2011 return 0;
2012}
2013
Liu Bo7abadb62013-03-17 02:10:31 +00002014/* helper to cleanup workers */
2015static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
2016{
2017 btrfs_stop_workers(&fs_info->generic_worker);
2018 btrfs_stop_workers(&fs_info->fixup_workers);
2019 btrfs_stop_workers(&fs_info->delalloc_workers);
2020 btrfs_stop_workers(&fs_info->workers);
2021 btrfs_stop_workers(&fs_info->endio_workers);
2022 btrfs_stop_workers(&fs_info->endio_meta_workers);
2023 btrfs_stop_workers(&fs_info->endio_raid56_workers);
2024 btrfs_stop_workers(&fs_info->rmw_workers);
2025 btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2026 btrfs_stop_workers(&fs_info->endio_write_workers);
2027 btrfs_stop_workers(&fs_info->endio_freespace_worker);
2028 btrfs_stop_workers(&fs_info->submit_workers);
2029 btrfs_stop_workers(&fs_info->delayed_workers);
2030 btrfs_stop_workers(&fs_info->caching_workers);
2031 btrfs_stop_workers(&fs_info->readahead_workers);
2032 btrfs_stop_workers(&fs_info->flush_workers);
Jan Schmidt2f232032013-04-25 16:04:51 +00002033 btrfs_stop_workers(&fs_info->qgroup_rescan_workers);
Liu Bo7abadb62013-03-17 02:10:31 +00002034}
2035
Rashika2e9f5952013-10-31 02:45:20 +05302036static void free_root_extent_buffers(struct btrfs_root *root)
2037{
2038 if (root) {
2039 free_extent_buffer(root->node);
2040 free_extent_buffer(root->commit_root);
2041 root->node = NULL;
2042 root->commit_root = NULL;
2043 }
2044}
2045
Chris Masonaf31f5e2011-11-03 15:17:42 -04002046/* helper to cleanup tree roots */
2047static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
2048{
Rashika2e9f5952013-10-31 02:45:20 +05302049 free_root_extent_buffers(info->tree_root);
Josef Bacik655b09f2013-05-17 14:06:51 -04002050
Rashika2e9f5952013-10-31 02:45:20 +05302051 free_root_extent_buffers(info->dev_root);
2052 free_root_extent_buffers(info->extent_root);
2053 free_root_extent_buffers(info->csum_root);
2054 free_root_extent_buffers(info->quota_root);
2055 free_root_extent_buffers(info->uuid_root);
2056 if (chunk_root)
2057 free_root_extent_buffers(info->chunk_root);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002058}
2059
Josef Bacik171f6532013-04-24 16:35:41 -04002060static void del_fs_roots(struct btrfs_fs_info *fs_info)
2061{
2062 int ret;
2063 struct btrfs_root *gang[8];
2064 int i;
2065
2066 while (!list_empty(&fs_info->dead_roots)) {
2067 gang[0] = list_entry(fs_info->dead_roots.next,
2068 struct btrfs_root, root_list);
2069 list_del(&gang[0]->root_list);
2070
2071 if (gang[0]->in_radix) {
Miao Xiecb517ea2013-05-15 07:48:19 +00002072 btrfs_drop_and_free_fs_root(fs_info, gang[0]);
Josef Bacik171f6532013-04-24 16:35:41 -04002073 } else {
2074 free_extent_buffer(gang[0]->node);
2075 free_extent_buffer(gang[0]->commit_root);
Miao Xieb0feb9d2013-05-15 07:48:20 +00002076 btrfs_put_fs_root(gang[0]);
Josef Bacik171f6532013-04-24 16:35:41 -04002077 }
2078 }
2079
2080 while (1) {
2081 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
2082 (void **)gang, 0,
2083 ARRAY_SIZE(gang));
2084 if (!ret)
2085 break;
2086 for (i = 0; i < ret; i++)
Miao Xiecb517ea2013-05-15 07:48:19 +00002087 btrfs_drop_and_free_fs_root(fs_info, gang[i]);
Josef Bacik171f6532013-04-24 16:35:41 -04002088 }
2089}
Chris Masonaf31f5e2011-11-03 15:17:42 -04002090
Al Viroad2b2c82011-11-17 01:10:02 -05002091int open_ctree(struct super_block *sb,
2092 struct btrfs_fs_devices *fs_devices,
2093 char *options)
Chris Masoneb60cea2007-02-02 09:18:22 -05002094{
Chris Masondb945352007-10-15 16:15:53 -04002095 u32 sectorsize;
2096 u32 nodesize;
2097 u32 leafsize;
2098 u32 blocksize;
Chris Mason87ee04e2007-11-30 11:30:34 -05002099 u32 stripesize;
Yan Zheng84234f32008-10-29 14:49:05 -04002100 u64 generation;
Josef Bacikf2b636e2008-12-02 06:36:08 -05002101 u64 features;
Chris Mason3de45862008-11-17 21:02:50 -05002102 struct btrfs_key location;
Chris Masona061fc82008-05-07 11:43:44 -04002103 struct buffer_head *bh;
Ilya Dryomov4d34b272011-11-09 00:08:15 +02002104 struct btrfs_super_block *disk_super;
Al Viro815745c2011-11-17 15:40:49 -05002105 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
Al Virof84a8bd2011-11-17 15:57:57 -05002106 struct btrfs_root *tree_root;
Ilya Dryomov4d34b272011-11-09 00:08:15 +02002107 struct btrfs_root *extent_root;
2108 struct btrfs_root *csum_root;
2109 struct btrfs_root *chunk_root;
2110 struct btrfs_root *dev_root;
Arne Jansenbcef60f2011-09-13 15:23:30 +02002111 struct btrfs_root *quota_root;
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02002112 struct btrfs_root *uuid_root;
Chris Masone02119d2008-09-05 16:13:11 -04002113 struct btrfs_root *log_tree_root;
Chris Masoneb60cea2007-02-02 09:18:22 -05002114 int ret;
Yane58ca022008-04-01 11:21:34 -04002115 int err = -EINVAL;
Chris Masonaf31f5e2011-11-03 15:17:42 -04002116 int num_backups_tried = 0;
2117 int backup_index = 0;
Stefan Behrens70f80172013-08-15 17:11:23 +02002118 bool create_uuid_tree;
2119 bool check_uuid_tree;
Chris Mason4543df72008-06-11 21:47:56 -04002120
Al Virof84a8bd2011-11-17 15:57:57 -05002121 tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
Al Viro6f07e422011-11-17 00:46:16 -05002122 chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
Miao Xiecb517ea2013-05-15 07:48:19 +00002123 if (!tree_root || !chunk_root) {
Chris Mason39279cc2007-06-12 06:35:45 -04002124 err = -ENOMEM;
2125 goto fail;
2126 }
Yan, Zheng76dda932009-09-21 16:00:26 -04002127
2128 ret = init_srcu_struct(&fs_info->subvol_srcu);
2129 if (ret) {
2130 err = ret;
2131 goto fail;
2132 }
2133
2134 ret = setup_bdi(fs_info, &fs_info->bdi);
2135 if (ret) {
2136 err = ret;
2137 goto fail_srcu;
2138 }
2139
Miao Xiee2d84522013-01-29 10:09:20 +00002140 ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0);
2141 if (ret) {
2142 err = ret;
2143 goto fail_bdi;
2144 }
2145 fs_info->dirty_metadata_batch = PAGE_CACHE_SIZE *
2146 (1 + ilog2(nr_cpu_ids));
2147
Miao Xie963d6782013-01-29 10:10:51 +00002148 ret = percpu_counter_init(&fs_info->delalloc_bytes, 0);
2149 if (ret) {
2150 err = ret;
2151 goto fail_dirty_metadata_bytes;
2152 }
2153
Yan, Zheng76dda932009-09-21 16:00:26 -04002154 fs_info->btree_inode = new_inode(sb);
2155 if (!fs_info->btree_inode) {
2156 err = -ENOMEM;
Miao Xie963d6782013-01-29 10:10:51 +00002157 goto fail_delalloc_bytes;
Yan, Zheng76dda932009-09-21 16:00:26 -04002158 }
2159
Chris Masona6591712011-07-19 12:04:14 -04002160 mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
Miao Xie1561ded2011-03-27 16:07:36 +08002161
Yan, Zheng76dda932009-09-21 16:00:26 -04002162 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
Chris Mason8fd17792007-04-19 21:01:03 -04002163 INIT_LIST_HEAD(&fs_info->trans_list);
Chris Masonfacda1e2007-06-08 18:11:48 -04002164 INIT_LIST_HEAD(&fs_info->dead_roots);
Yan, Zheng24bbcf042009-11-12 09:36:34 +00002165 INIT_LIST_HEAD(&fs_info->delayed_iputs);
Miao Xieeb73c1b2013-05-15 07:48:22 +00002166 INIT_LIST_HEAD(&fs_info->delalloc_roots);
Yan Zheng11833d62009-09-11 16:11:19 -04002167 INIT_LIST_HEAD(&fs_info->caching_block_groups);
Miao Xieeb73c1b2013-05-15 07:48:22 +00002168 spin_lock_init(&fs_info->delalloc_root_lock);
Josef Bacika4abeea2011-04-11 17:25:13 -04002169 spin_lock_init(&fs_info->trans_lock);
Yan, Zheng76dda932009-09-21 16:00:26 -04002170 spin_lock_init(&fs_info->fs_roots_radix_lock);
Yan, Zheng24bbcf042009-11-12 09:36:34 +00002171 spin_lock_init(&fs_info->delayed_iput_lock);
Chris Mason4cb53002011-05-24 15:35:30 -04002172 spin_lock_init(&fs_info->defrag_inodes_lock);
Josef Bacik2bf64752011-09-26 17:12:22 -04002173 spin_lock_init(&fs_info->free_chunk_lock);
Jan Schmidtf29021b2012-05-16 17:55:38 +02002174 spin_lock_init(&fs_info->tree_mod_seq_lock);
Miao Xieceda0862013-04-11 10:30:16 +00002175 spin_lock_init(&fs_info->super_lock);
Jan Schmidtf29021b2012-05-16 17:55:38 +02002176 rwlock_init(&fs_info->tree_mod_log_lock);
Chris Mason75857172011-06-13 20:00:16 -04002177 mutex_init(&fs_info->reloc_mutex);
Miao Xiede98ced2013-01-29 10:13:12 +00002178 seqlock_init(&fs_info->profiles_lock);
Chris Mason19c00dd2007-10-15 16:19:22 -04002179
Josef Bacik58176a92007-08-29 15:47:34 -04002180 init_completion(&fs_info->kobj_unregister);
Chris Mason0b86a832008-03-24 15:01:56 -04002181 INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
Chris Mason6324fbf2008-03-24 15:01:59 -04002182 INIT_LIST_HEAD(&fs_info->space_info);
Jan Schmidtf29021b2012-05-16 17:55:38 +02002183 INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
Chris Mason0b86a832008-03-24 15:01:56 -04002184 btrfs_mapping_init(&fs_info->mapping_tree);
Miao Xie66d8f3d2012-09-06 04:02:28 -06002185 btrfs_init_block_rsv(&fs_info->global_block_rsv,
2186 BTRFS_BLOCK_RSV_GLOBAL);
2187 btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
2188 BTRFS_BLOCK_RSV_DELALLOC);
2189 btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
2190 btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
2191 btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
2192 btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
2193 BTRFS_BLOCK_RSV_DELOPS);
Chris Masoncb03c742008-05-15 16:15:45 -04002194 atomic_set(&fs_info->nr_async_submits, 0);
Chris Mason771ed682008-11-06 22:02:51 -05002195 atomic_set(&fs_info->async_delalloc_pages, 0);
Chris Mason8c8bee12008-09-29 11:19:10 -04002196 atomic_set(&fs_info->async_submit_draining, 0);
Chris Mason0986fe9e2008-08-15 15:34:15 -04002197 atomic_set(&fs_info->nr_async_bios, 0);
Chris Mason4cb53002011-05-24 15:35:30 -04002198 atomic_set(&fs_info->defrag_running, 0);
Jan Schmidtfc36ed7e2013-04-24 16:57:33 +00002199 atomic64_set(&fs_info->tree_mod_seq, 0);
Chris Masone20d96d2007-03-22 12:13:20 -04002200 fs_info->sb = sb;
Chris Mason6f568d32008-01-29 16:03:38 -05002201 fs_info->max_inline = 8192 * 1024;
Josef Bacik9ed74f22009-09-11 16:12:44 -04002202 fs_info->metadata_ratio = 0;
Chris Mason4cb53002011-05-24 15:35:30 -04002203 fs_info->defrag_inodes = RB_ROOT;
Josef Bacik2bf64752011-09-26 17:12:22 -04002204 fs_info->free_chunk_space = 0;
Jan Schmidtf29021b2012-05-16 17:55:38 +02002205 fs_info->tree_mod_log = RB_ROOT;
David Sterba8b87dc12013-08-01 18:14:52 +02002206 fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
Chris Masonc8b97812008-10-29 14:49:59 -04002207
Arne Jansen90519d62011-05-23 14:30:00 +02002208 /* readahead state */
2209 INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
2210 spin_lock_init(&fs_info->reada_lock);
Chris Mason2c90e5d2007-04-02 10:50:19 -04002211
Chris Masonb34b0862008-12-19 15:43:22 -05002212 fs_info->thread_pool_size = min_t(unsigned long,
2213 num_online_cpus() + 2, 8);
Chris Mason0afbaf82008-04-18 14:17:20 -04002214
Miao Xie199c2a92013-05-15 07:48:23 +00002215 INIT_LIST_HEAD(&fs_info->ordered_roots);
2216 spin_lock_init(&fs_info->ordered_root_lock);
Miao Xie16cdcec2011-04-22 18:12:22 +08002217 fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2218 GFP_NOFS);
2219 if (!fs_info->delayed_root) {
2220 err = -ENOMEM;
2221 goto fail_iput;
2222 }
2223 btrfs_init_delayed_root(fs_info->delayed_root);
Chris Mason3eaa2882008-07-24 11:57:52 -04002224
Arne Jansena2de7332011-03-08 14:14:00 +01002225 mutex_init(&fs_info->scrub_lock);
2226 atomic_set(&fs_info->scrubs_running, 0);
2227 atomic_set(&fs_info->scrub_pause_req, 0);
2228 atomic_set(&fs_info->scrubs_paused, 0);
2229 atomic_set(&fs_info->scrub_cancel_req, 0);
2230 init_waitqueue_head(&fs_info->scrub_pause_wait);
Arne Jansena2de7332011-03-08 14:14:00 +01002231 fs_info->scrub_workers_refcnt = 0;
Stefan Behrens21adbd52011-11-09 13:44:05 +01002232#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2233 fs_info->check_integrity_print_mask = 0;
2234#endif
Arne Jansena2de7332011-03-08 14:14:00 +01002235
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02002236 spin_lock_init(&fs_info->balance_lock);
2237 mutex_init(&fs_info->balance_mutex);
Ilya Dryomov837d5b62012-01-16 22:04:49 +02002238 atomic_set(&fs_info->balance_running, 0);
2239 atomic_set(&fs_info->balance_pause_req, 0);
Ilya Dryomova7e99c62012-01-16 22:04:49 +02002240 atomic_set(&fs_info->balance_cancel_req, 0);
Ilya Dryomovc9e9f972012-01-16 22:04:47 +02002241 fs_info->balance_ctl = NULL;
Ilya Dryomov837d5b62012-01-16 22:04:49 +02002242 init_waitqueue_head(&fs_info->balance_wait_q);
Chris Masona061fc82008-05-07 11:43:44 -04002243
Chris Mason0afbaf82008-04-18 14:17:20 -04002244 sb->s_blocksize = 4096;
2245 sb->s_blocksize_bits = blksize_bits(4096);
Jens Axboe32a88aa2009-09-16 15:02:33 +02002246 sb->s_bdi = &fs_info->bdi;
Chris Mason0afbaf82008-04-18 14:17:20 -04002247
Yan, Zheng76dda932009-09-21 16:00:26 -04002248 fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
Miklos Szeredibfe86842011-10-28 14:13:29 +02002249 set_nlink(fs_info->btree_inode, 1);
Chris Mason0afbaf82008-04-18 14:17:20 -04002250 /*
2251 * we set the i_size on the btree inode to the max possible int.
2252 * the real end of the address space is determined by all of
2253 * the devices in the system
2254 */
2255 fs_info->btree_inode->i_size = OFFSET_MAX;
Chris Masond98237b2007-03-28 13:57:48 -04002256 fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
Chris Mason04160082008-03-26 10:28:07 -04002257 fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;
2258
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002259 RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
Chris Masond1310b22008-01-24 16:13:08 -05002260 extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
David Sterbaf993c882011-04-20 23:35:57 +02002261 fs_info->btree_inode->i_mapping);
Josef Bacik0b32f4b2012-03-13 09:38:00 -04002262 BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
David Sterbaa8067e02011-04-21 00:34:43 +02002263 extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
Chris Mason0da54682007-11-07 21:08:01 -05002264
Chris Masond1310b22008-01-24 16:13:08 -05002265 BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
2266
Chris Mason0f7d52f2007-04-09 10:42:37 -04002267 BTRFS_I(fs_info->btree_inode)->root = tree_root;
2268 memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
2269 sizeof(struct btrfs_key));
Josef Bacik72ac3c02012-05-23 14:13:11 -04002270 set_bit(BTRFS_INODE_DUMMY,
2271 &BTRFS_I(fs_info->btree_inode)->runtime_flags);
Filipe David Borba Manana778ba822013-10-06 22:22:33 +01002272 btrfs_insert_inode_hash(fs_info->btree_inode);
Chris Mason39279cc2007-06-12 06:35:45 -04002273
Chris Masone02119d2008-09-05 16:13:11 -04002274 spin_lock_init(&fs_info->block_group_cache_lock);
Eric Paris6bef4d32010-02-23 19:43:04 +00002275 fs_info->block_group_cache_tree = RB_ROOT;
Liu Boa1897fd2012-12-27 09:01:23 +00002276 fs_info->first_logical_byte = (u64)-1;
Chris Mason925baed2008-06-25 16:01:30 -04002277
Yan Zheng11833d62009-09-11 16:11:19 -04002278 extent_io_tree_init(&fs_info->freed_extents[0],
David Sterbaf993c882011-04-20 23:35:57 +02002279 fs_info->btree_inode->i_mapping);
Yan Zheng11833d62009-09-11 16:11:19 -04002280 extent_io_tree_init(&fs_info->freed_extents[1],
David Sterbaf993c882011-04-20 23:35:57 +02002281 fs_info->btree_inode->i_mapping);
Yan Zheng11833d62009-09-11 16:11:19 -04002282 fs_info->pinned_extents = &fs_info->freed_extents[0];
Chris Masone6dcd2d2008-07-17 12:53:50 -04002283 fs_info->do_barriers = 1;
Chris Masonf9295742008-07-17 12:54:14 -04002284
Chris Masond98237b2007-03-28 13:57:48 -04002285
Chris Mason5a3f23d2009-03-31 13:27:11 -04002286 mutex_init(&fs_info->ordered_operations_mutex);
Josef Bacik9ffba8c2013-08-14 11:33:56 -04002287 mutex_init(&fs_info->ordered_extent_flush_mutex);
Chris Mason30ae8462007-03-29 09:59:15 -04002288 mutex_init(&fs_info->tree_log_mutex);
Chris Mason925baed2008-06-25 16:01:30 -04002289 mutex_init(&fs_info->chunk_mutex);
2290 mutex_init(&fs_info->transaction_kthread_mutex);
Chris Masona74a4b92008-06-25 16:01:31 -04002291 mutex_init(&fs_info->cleaner_mutex);
2292 mutex_init(&fs_info->volume_mutex);
Yan Zheng276e6802009-07-30 09:40:40 -04002293 init_rwsem(&fs_info->extent_commit_sem);
Yan, Zhengc71bf092009-11-12 09:34:40 +00002294 init_rwsem(&fs_info->cleanup_work_sem);
Yan, Zheng76dda932009-09-21 16:00:26 -04002295 init_rwsem(&fs_info->subvol_sem);
Stefan Behrens803b2f52013-08-15 17:11:21 +02002296 sema_init(&fs_info->uuid_tree_rescan_sem, 1);
Stefan Behrense922e082012-11-05 17:26:40 +01002297 fs_info->dev_replace.lock_owner = 0;
2298 atomic_set(&fs_info->dev_replace.nesting_level, 0);
2299 mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
2300 mutex_init(&fs_info->dev_replace.lock_management_lock);
2301 mutex_init(&fs_info->dev_replace.lock);
Chris Masonfa9c0d792009-04-03 09:47:43 -04002302
Arne Jansen416ac512011-09-13 12:56:09 +02002303 spin_lock_init(&fs_info->qgroup_lock);
Wang Shilongf2f6ed32013-04-07 10:50:16 +00002304 mutex_init(&fs_info->qgroup_ioctl_lock);
Arne Jansen416ac512011-09-13 12:56:09 +02002305 fs_info->qgroup_tree = RB_ROOT;
2306 INIT_LIST_HEAD(&fs_info->dirty_qgroups);
2307 fs_info->qgroup_seq = 1;
2308 fs_info->quota_enabled = 0;
2309 fs_info->pending_quota_state = 0;
Wang Shilong1e8f9152013-05-06 11:03:27 +00002310 fs_info->qgroup_ulist = NULL;
Jan Schmidt2f232032013-04-25 16:04:51 +00002311 mutex_init(&fs_info->qgroup_rescan_lock);
Arne Jansen416ac512011-09-13 12:56:09 +02002312
Chris Masonfa9c0d792009-04-03 09:47:43 -04002313 btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2314 btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2315
Chris Mason7d9eb122008-07-08 14:19:17 -04002316 init_waitqueue_head(&fs_info->transaction_throttle);
Chris Mason3768f362007-03-13 16:47:54 -04002317 init_waitqueue_head(&fs_info->transaction_wait);
Sage Weilbb9c12c2010-10-29 15:37:34 -04002318 init_waitqueue_head(&fs_info->transaction_blocked_wait);
Chris Mason4854ddd2008-08-15 15:34:17 -04002319 init_waitqueue_head(&fs_info->async_submit_wait);
Chris Mason9a8dd152007-02-23 08:38:36 -05002320
David Woodhouse53b381b2013-01-29 18:40:14 -05002321 ret = btrfs_alloc_stripe_hash_table(fs_info);
2322 if (ret) {
David Sterba83c82662013-03-01 15:03:00 +00002323 err = ret;
David Woodhouse53b381b2013-01-29 18:40:14 -05002324 goto fail_alloc;
2325 }
2326
Chris Mason0b86a832008-03-24 15:01:56 -04002327 __setup_root(4096, 4096, 4096, 4096, tree_root,
Chris Mason2c90e5d2007-04-02 10:50:19 -04002328 fs_info, BTRFS_ROOT_TREE_OBJECTID);
Chris Mason7eccb902007-04-11 15:53:25 -04002329
Chris Mason3c4bb262012-03-27 18:56:56 -04002330 invalidate_bdev(fs_devices->latest_bdev);
David Sterba1104a882013-03-06 15:57:46 +01002331
2332 /*
2333 * Read super block and check the signature bytes only
2334 */
Yan Zhenga512bbf2008-12-08 16:46:26 -05002335 bh = btrfs_read_dev_super(fs_devices->latest_bdev);
Dave Young20b45072011-01-08 10:09:13 +00002336 if (!bh) {
2337 err = -EINVAL;
Miao Xie16cdcec2011-04-22 18:12:22 +08002338 goto fail_alloc;
Dave Young20b45072011-01-08 10:09:13 +00002339 }
Chris Mason39279cc2007-06-12 06:35:45 -04002340
David Sterba1104a882013-03-06 15:57:46 +01002341 /*
2342 * We want to check superblock checksum, the type is stored inside.
2343 * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
2344 */
2345 if (btrfs_check_super_csum(bh->b_data)) {
2346 printk(KERN_ERR "btrfs: superblock checksum mismatch\n");
2347 err = -EINVAL;
2348 goto fail_alloc;
2349 }
2350
2351 /*
2352 * super_copy is zeroed at allocation time and we never touch the
2353 * following bytes up to INFO_SIZE, the checksum is calculated from
2354 * the whole block of INFO_SIZE
2355 */
David Sterba6c417612011-04-13 15:41:04 +02002356 memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
2357 memcpy(fs_info->super_for_commit, fs_info->super_copy,
2358 sizeof(*fs_info->super_for_commit));
Chris Masona061fc82008-05-07 11:43:44 -04002359 brelse(bh);
Chris Mason5f39d392007-10-15 16:14:19 -04002360
David Sterba6c417612011-04-13 15:41:04 +02002361 memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
Chris Mason0b86a832008-03-24 15:01:56 -04002362
David Sterba1104a882013-03-06 15:57:46 +01002363 ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
2364 if (ret) {
2365 printk(KERN_ERR "btrfs: superblock contains fatal errors\n");
2366 err = -EINVAL;
2367 goto fail_alloc;
2368 }
2369
David Sterba6c417612011-04-13 15:41:04 +02002370 disk_super = fs_info->super_copy;
Chris Mason0f7d52f2007-04-09 10:42:37 -04002371 if (!btrfs_super_root(disk_super))
Miao Xie16cdcec2011-04-22 18:12:22 +08002372 goto fail_alloc;
Chris Mason0f7d52f2007-04-09 10:42:37 -04002373
liuboacce9522011-01-06 19:30:25 +08002374 /* check FS state, whether FS is broken. */
Miao Xie87533c42013-01-29 10:14:48 +00002375 if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
2376 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
liuboacce9522011-01-06 19:30:25 +08002377
Liu Bo75e7cb72011-03-22 10:12:20 +00002378 /*
Chris Masonaf31f5e2011-11-03 15:17:42 -04002379 * run through our array of backup supers and setup
2380 * our ring pointer to the oldest one
2381 */
2382 generation = btrfs_super_generation(disk_super);
2383 find_oldest_super_backup(fs_info, generation);
2384
2385 /*
Liu Bo75e7cb72011-03-22 10:12:20 +00002386 * In the long term, we'll store the compression type in the super
2387 * block, and it'll be used for per file compression control.
2388 */
2389 fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
2390
Yan Zheng2b820322008-11-17 21:11:30 -05002391 ret = btrfs_parse_options(tree_root, options);
2392 if (ret) {
2393 err = ret;
Miao Xie16cdcec2011-04-22 18:12:22 +08002394 goto fail_alloc;
Yan Zheng2b820322008-11-17 21:11:30 -05002395 }
Chris Masondfe25022008-05-13 13:46:40 -04002396
Josef Bacikf2b636e2008-12-02 06:36:08 -05002397 features = btrfs_super_incompat_flags(disk_super) &
2398 ~BTRFS_FEATURE_INCOMPAT_SUPP;
2399 if (features) {
2400 printk(KERN_ERR "BTRFS: couldn't mount because of "
2401 "unsupported optional features (%Lx).\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +02002402 features);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002403 err = -EINVAL;
Miao Xie16cdcec2011-04-22 18:12:22 +08002404 goto fail_alloc;
Josef Bacikf2b636e2008-12-02 06:36:08 -05002405 }
2406
Chris Mason727011e2010-08-06 13:21:20 -04002407 if (btrfs_super_leafsize(disk_super) !=
2408 btrfs_super_nodesize(disk_super)) {
2409 printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2410 "blocksizes don't match. node %d leaf %d\n",
2411 btrfs_super_nodesize(disk_super),
2412 btrfs_super_leafsize(disk_super));
2413 err = -EINVAL;
2414 goto fail_alloc;
2415 }
2416 if (btrfs_super_leafsize(disk_super) > BTRFS_MAX_METADATA_BLOCKSIZE) {
2417 printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2418 "blocksize (%d) was too large\n",
2419 btrfs_super_leafsize(disk_super));
2420 err = -EINVAL;
2421 goto fail_alloc;
2422 }
2423
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002424 features = btrfs_super_incompat_flags(disk_super);
Li Zefana6fa6fa2010-10-25 15:12:26 +08002425 features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
Li Zefan69e380d2012-06-11 17:10:51 +08002426 if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
Li Zefana6fa6fa2010-10-25 15:12:26 +08002427 features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
Chris Mason727011e2010-08-06 13:21:20 -04002428
Josef Bacik3173a182013-03-07 14:22:04 -05002429 if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
2430 printk(KERN_ERR "btrfs: has skinny extents\n");
2431
Chris Mason727011e2010-08-06 13:21:20 -04002432 /*
2433 * flag our filesystem as having big metadata blocks if
2434 * they are bigger than the page size
2435 */
2436 if (btrfs_super_leafsize(disk_super) > PAGE_CACHE_SIZE) {
2437 if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
2438 printk(KERN_INFO "btrfs flagging fs with big metadata feature\n");
2439 features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
2440 }
2441
Chris Masonbc3f1162012-03-29 17:02:47 -04002442 nodesize = btrfs_super_nodesize(disk_super);
2443 leafsize = btrfs_super_leafsize(disk_super);
2444 sectorsize = btrfs_super_sectorsize(disk_super);
2445 stripesize = btrfs_super_stripesize(disk_super);
Miao Xiee2d84522013-01-29 10:09:20 +00002446 fs_info->dirty_metadata_batch = leafsize * (1 + ilog2(nr_cpu_ids));
Miao Xie963d6782013-01-29 10:10:51 +00002447 fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
Chris Masonbc3f1162012-03-29 17:02:47 -04002448
2449 /*
2450 * mixed block groups end up with duplicate but slightly offset
2451 * extent buffers for the same range. It leads to corruptions
2452 */
2453 if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
2454 (sectorsize != leafsize)) {
2455 printk(KERN_WARNING "btrfs: unequal leaf/node/sector sizes "
2456 "are not allowed for mixed block groups on %s\n",
2457 sb->s_id);
2458 goto fail_alloc;
2459 }
2460
Miao Xieceda0862013-04-11 10:30:16 +00002461 /*
2462 * Needn't use the lock because there is no other task which will
2463 * update the flag.
2464 */
Li Zefana6fa6fa2010-10-25 15:12:26 +08002465 btrfs_set_super_incompat_flags(disk_super, features);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002466
Josef Bacikf2b636e2008-12-02 06:36:08 -05002467 features = btrfs_super_compat_ro_flags(disk_super) &
2468 ~BTRFS_FEATURE_COMPAT_RO_SUPP;
2469 if (!(sb->s_flags & MS_RDONLY) && features) {
2470 printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
2471 "unsupported option features (%Lx).\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +02002472 features);
Josef Bacikf2b636e2008-12-02 06:36:08 -05002473 err = -EINVAL;
Miao Xie16cdcec2011-04-22 18:12:22 +08002474 goto fail_alloc;
Josef Bacikf2b636e2008-12-02 06:36:08 -05002475 }
Chris Mason61d92c32009-10-02 19:11:56 -04002476
2477 btrfs_init_workers(&fs_info->generic_worker,
2478 "genwork", 1, NULL);
2479
Chris Mason5443be42008-08-15 15:34:16 -04002480 btrfs_init_workers(&fs_info->workers, "worker",
Chris Mason61d92c32009-10-02 19:11:56 -04002481 fs_info->thread_pool_size,
2482 &fs_info->generic_worker);
Chris Masonc8b97812008-10-29 14:49:59 -04002483
Chris Mason771ed682008-11-06 22:02:51 -05002484 btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
Josef Bacik45d5fd12013-08-29 16:51:22 -04002485 fs_info->thread_pool_size, NULL);
Chris Mason771ed682008-11-06 22:02:51 -05002486
Miao Xie8ccf6f192012-10-25 09:28:04 +00002487 btrfs_init_workers(&fs_info->flush_workers, "flush_delalloc",
Josef Bacik45d5fd12013-08-29 16:51:22 -04002488 fs_info->thread_pool_size, NULL);
Miao Xie8ccf6f192012-10-25 09:28:04 +00002489
Chris Mason5443be42008-08-15 15:34:16 -04002490 btrfs_init_workers(&fs_info->submit_workers, "submit",
Chris Masonb720d202008-08-15 15:34:14 -04002491 min_t(u64, fs_devices->num_devices,
Josef Bacik45d5fd12013-08-29 16:51:22 -04002492 fs_info->thread_pool_size), NULL);
Chris Mason61b49442008-07-31 15:42:53 -04002493
Josef Bacikbab39bf2011-06-30 14:42:28 -04002494 btrfs_init_workers(&fs_info->caching_workers, "cache",
Josef Bacik45d5fd12013-08-29 16:51:22 -04002495 fs_info->thread_pool_size, NULL);
Josef Bacikbab39bf2011-06-30 14:42:28 -04002496
Chris Mason61b49442008-07-31 15:42:53 -04002497 /* a higher idle thresh on the submit workers makes it much more
2498 * likely that bios will be send down in a sane order to the
2499 * devices
2500 */
2501 fs_info->submit_workers.idle_thresh = 64;
Chris Mason53863232008-08-15 15:34:18 -04002502
Chris Mason771ed682008-11-06 22:02:51 -05002503 fs_info->workers.idle_thresh = 16;
Chris Mason4a69a412008-11-06 22:03:00 -05002504 fs_info->workers.ordered = 1;
Chris Mason61b49442008-07-31 15:42:53 -04002505
Chris Mason771ed682008-11-06 22:02:51 -05002506 fs_info->delalloc_workers.idle_thresh = 2;
2507 fs_info->delalloc_workers.ordered = 1;
2508
Chris Mason61d92c32009-10-02 19:11:56 -04002509 btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
2510 &fs_info->generic_worker);
Chris Mason5443be42008-08-15 15:34:16 -04002511 btrfs_init_workers(&fs_info->endio_workers, "endio",
Chris Mason61d92c32009-10-02 19:11:56 -04002512 fs_info->thread_pool_size,
2513 &fs_info->generic_worker);
Chris Masond20f7042008-12-08 16:58:54 -05002514 btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
Chris Mason61d92c32009-10-02 19:11:56 -04002515 fs_info->thread_pool_size,
2516 &fs_info->generic_worker);
Chris Masoncad321a2008-12-17 14:51:42 -05002517 btrfs_init_workers(&fs_info->endio_meta_write_workers,
Chris Mason61d92c32009-10-02 19:11:56 -04002518 "endio-meta-write", fs_info->thread_pool_size,
2519 &fs_info->generic_worker);
David Woodhouse53b381b2013-01-29 18:40:14 -05002520 btrfs_init_workers(&fs_info->endio_raid56_workers,
2521 "endio-raid56", fs_info->thread_pool_size,
2522 &fs_info->generic_worker);
2523 btrfs_init_workers(&fs_info->rmw_workers,
2524 "rmw", fs_info->thread_pool_size,
2525 &fs_info->generic_worker);
Chris Mason5443be42008-08-15 15:34:16 -04002526 btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
Chris Mason61d92c32009-10-02 19:11:56 -04002527 fs_info->thread_pool_size,
2528 &fs_info->generic_worker);
Josef Bacik0cb59c92010-07-02 12:14:14 -04002529 btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
2530 1, &fs_info->generic_worker);
Miao Xie16cdcec2011-04-22 18:12:22 +08002531 btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
2532 fs_info->thread_pool_size,
2533 &fs_info->generic_worker);
Arne Jansen90519d62011-05-23 14:30:00 +02002534 btrfs_init_workers(&fs_info->readahead_workers, "readahead",
2535 fs_info->thread_pool_size,
2536 &fs_info->generic_worker);
Jan Schmidt2f232032013-04-25 16:04:51 +00002537 btrfs_init_workers(&fs_info->qgroup_rescan_workers, "qgroup-rescan", 1,
2538 &fs_info->generic_worker);
Chris Mason61b49442008-07-31 15:42:53 -04002539
2540 /*
2541 * endios are largely parallel and should have a very
2542 * low idle thresh
2543 */
2544 fs_info->endio_workers.idle_thresh = 4;
Chris Masonb51912c2009-02-04 09:23:24 -05002545 fs_info->endio_meta_workers.idle_thresh = 4;
David Woodhouse53b381b2013-01-29 18:40:14 -05002546 fs_info->endio_raid56_workers.idle_thresh = 4;
2547 fs_info->rmw_workers.idle_thresh = 2;
Chris Masonb51912c2009-02-04 09:23:24 -05002548
Chris Mason90428462009-08-04 16:56:34 -04002549 fs_info->endio_write_workers.idle_thresh = 2;
2550 fs_info->endio_meta_write_workers.idle_thresh = 2;
Arne Jansen90519d62011-05-23 14:30:00 +02002551 fs_info->readahead_workers.idle_thresh = 2;
Chris Mason90428462009-08-04 16:56:34 -04002552
Josef Bacik0dc3b842011-11-18 14:37:27 -05002553 /*
2554 * btrfs_start_workers can really only fail because of ENOMEM so just
2555 * return -ENOMEM if any of these fail.
2556 */
2557 ret = btrfs_start_workers(&fs_info->workers);
2558 ret |= btrfs_start_workers(&fs_info->generic_worker);
2559 ret |= btrfs_start_workers(&fs_info->submit_workers);
2560 ret |= btrfs_start_workers(&fs_info->delalloc_workers);
2561 ret |= btrfs_start_workers(&fs_info->fixup_workers);
2562 ret |= btrfs_start_workers(&fs_info->endio_workers);
2563 ret |= btrfs_start_workers(&fs_info->endio_meta_workers);
David Woodhouse53b381b2013-01-29 18:40:14 -05002564 ret |= btrfs_start_workers(&fs_info->rmw_workers);
2565 ret |= btrfs_start_workers(&fs_info->endio_raid56_workers);
Josef Bacik0dc3b842011-11-18 14:37:27 -05002566 ret |= btrfs_start_workers(&fs_info->endio_meta_write_workers);
2567 ret |= btrfs_start_workers(&fs_info->endio_write_workers);
2568 ret |= btrfs_start_workers(&fs_info->endio_freespace_worker);
2569 ret |= btrfs_start_workers(&fs_info->delayed_workers);
2570 ret |= btrfs_start_workers(&fs_info->caching_workers);
2571 ret |= btrfs_start_workers(&fs_info->readahead_workers);
Miao Xie8ccf6f192012-10-25 09:28:04 +00002572 ret |= btrfs_start_workers(&fs_info->flush_workers);
Jan Schmidt2f232032013-04-25 16:04:51 +00002573 ret |= btrfs_start_workers(&fs_info->qgroup_rescan_workers);
Josef Bacik0dc3b842011-11-18 14:37:27 -05002574 if (ret) {
Ilya Dryomovfed425c2012-06-22 12:13:01 -06002575 err = -ENOMEM;
Josef Bacik0dc3b842011-11-18 14:37:27 -05002576 goto fail_sb_buffer;
2577 }
Chris Mason4543df72008-06-11 21:47:56 -04002578
Chris Mason4575c9c2008-04-18 16:13:31 -04002579 fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
Chris Masonc8b97812008-10-29 14:49:59 -04002580 fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
2581 4 * 1024 * 1024 / PAGE_CACHE_SIZE);
Chris Mason4575c9c2008-04-18 16:13:31 -04002582
Chris Masondb945352007-10-15 16:15:53 -04002583 tree_root->nodesize = nodesize;
2584 tree_root->leafsize = leafsize;
2585 tree_root->sectorsize = sectorsize;
Chris Mason87ee04e2007-11-30 11:30:34 -05002586 tree_root->stripesize = stripesize;
Chris Masona061fc82008-05-07 11:43:44 -04002587
2588 sb->s_blocksize = sectorsize;
2589 sb->s_blocksize_bits = blksize_bits(sectorsize);
Chris Masondb945352007-10-15 16:15:53 -04002590
Qu Wenruo3cae2102013-07-16 11:19:18 +08002591 if (btrfs_super_magic(disk_super) != BTRFS_MAGIC) {
Chris Masond3977122009-01-05 21:25:51 -05002592 printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
Chris Mason39279cc2007-06-12 06:35:45 -04002593 goto fail_sb_buffer;
2594 }
Chris Mason19c00dd2007-10-15 16:19:22 -04002595
Liu Bo8d082fb2012-04-03 09:56:53 +08002596 if (sectorsize != PAGE_SIZE) {
2597 printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "
2598 "found on %s\n", (unsigned long)sectorsize, sb->s_id);
Keith Mannthey941b2dd2011-11-29 17:44:12 -08002599 goto fail_sb_buffer;
2600 }
2601
Chris Mason925baed2008-06-25 16:01:30 -04002602 mutex_lock(&fs_info->chunk_mutex);
Yan Zhenge4404d62008-12-12 10:03:26 -05002603 ret = btrfs_read_sys_array(tree_root);
Chris Mason925baed2008-06-25 16:01:30 -04002604 mutex_unlock(&fs_info->chunk_mutex);
Chris Mason84eed902008-04-25 09:04:37 -04002605 if (ret) {
Chris Masond3977122009-01-05 21:25:51 -05002606 printk(KERN_WARNING "btrfs: failed to read the system "
2607 "array on %s\n", sb->s_id);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002608 goto fail_sb_buffer;
Chris Mason84eed902008-04-25 09:04:37 -04002609 }
Chris Mason0b86a832008-03-24 15:01:56 -04002610
2611 blocksize = btrfs_level_size(tree_root,
2612 btrfs_super_chunk_root_level(disk_super));
Yan Zheng84234f32008-10-29 14:49:05 -04002613 generation = btrfs_super_chunk_root_generation(disk_super);
Chris Mason0b86a832008-03-24 15:01:56 -04002614
2615 __setup_root(nodesize, leafsize, sectorsize, stripesize,
2616 chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
2617
2618 chunk_root->node = read_tree_block(chunk_root,
2619 btrfs_super_chunk_root(disk_super),
Yan Zheng84234f32008-10-29 14:49:05 -04002620 blocksize, generation);
Josef Bacik416bc652013-04-23 14:17:42 -04002621 if (!chunk_root->node ||
2622 !test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
David Woodhouse83121942009-07-22 16:52:13 -04002623 printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
2624 sb->s_id);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002625 goto fail_tree_roots;
David Woodhouse83121942009-07-22 16:52:13 -04002626 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002627 btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
2628 chunk_root->commit_root = btrfs_root_node(chunk_root);
Chris Mason0b86a832008-03-24 15:01:56 -04002629
Chris Masone17cade2008-04-15 15:41:47 -04002630 read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
Geert Uytterhoevenb308bc22013-08-20 13:20:15 +02002631 btrfs_header_chunk_tree_uuid(chunk_root->node), BTRFS_UUID_SIZE);
Chris Masone17cade2008-04-15 15:41:47 -04002632
Chris Mason0b86a832008-03-24 15:01:56 -04002633 ret = btrfs_read_chunk_tree(chunk_root);
Yan Zheng2b820322008-11-17 21:11:30 -05002634 if (ret) {
Chris Masond3977122009-01-05 21:25:51 -05002635 printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
2636 sb->s_id);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002637 goto fail_tree_roots;
Yan Zheng2b820322008-11-17 21:11:30 -05002638 }
Chris Mason0b86a832008-03-24 15:01:56 -04002639
Stefan Behrens8dabb742012-11-06 13:15:27 +01002640 /*
2641 * keep the device that is marked to be the target device for the
2642 * dev_replace procedure
2643 */
2644 btrfs_close_extra_devices(fs_info, fs_devices, 0);
Chris Masondfe25022008-05-13 13:46:40 -04002645
Chris Masona6b0d5c2012-02-20 20:53:43 -05002646 if (!fs_devices->latest_bdev) {
2647 printk(KERN_CRIT "btrfs: failed to read devices on %s\n",
2648 sb->s_id);
2649 goto fail_tree_roots;
2650 }
2651
Chris Masonaf31f5e2011-11-03 15:17:42 -04002652retry_root_backup:
Chris Masondb945352007-10-15 16:15:53 -04002653 blocksize = btrfs_level_size(tree_root,
2654 btrfs_super_root_level(disk_super));
Yan Zheng84234f32008-10-29 14:49:05 -04002655 generation = btrfs_super_generation(disk_super);
Chris Mason0b86a832008-03-24 15:01:56 -04002656
Chris Masone20d96d2007-03-22 12:13:20 -04002657 tree_root->node = read_tree_block(tree_root,
Chris Masondb945352007-10-15 16:15:53 -04002658 btrfs_super_root(disk_super),
Yan Zheng84234f32008-10-29 14:49:05 -04002659 blocksize, generation);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002660 if (!tree_root->node ||
2661 !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
David Woodhouse83121942009-07-22 16:52:13 -04002662 printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
2663 sb->s_id);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002664
2665 goto recovery_tree_root;
David Woodhouse83121942009-07-22 16:52:13 -04002666 }
Chris Masonaf31f5e2011-11-03 15:17:42 -04002667
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002668 btrfs_set_root_node(&tree_root->root_item, tree_root->node);
2669 tree_root->commit_root = btrfs_root_node(tree_root);
Stefan Behrens69e9c6c2013-09-05 16:58:43 +02002670 btrfs_set_root_refs(&tree_root->root_item, 1);
Chris Masondb945352007-10-15 16:15:53 -04002671
Miao Xiecb517ea2013-05-15 07:48:19 +00002672 location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
2673 location.type = BTRFS_ROOT_ITEM_KEY;
2674 location.offset = 0;
2675
2676 extent_root = btrfs_read_tree_root(tree_root, &location);
2677 if (IS_ERR(extent_root)) {
2678 ret = PTR_ERR(extent_root);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002679 goto recovery_tree_root;
Miao Xiecb517ea2013-05-15 07:48:19 +00002680 }
Chris Mason0b86a832008-03-24 15:01:56 -04002681 extent_root->track_dirty = 1;
Miao Xiecb517ea2013-05-15 07:48:19 +00002682 fs_info->extent_root = extent_root;
Chris Mason0b86a832008-03-24 15:01:56 -04002683
Miao Xiecb517ea2013-05-15 07:48:19 +00002684 location.objectid = BTRFS_DEV_TREE_OBJECTID;
2685 dev_root = btrfs_read_tree_root(tree_root, &location);
2686 if (IS_ERR(dev_root)) {
2687 ret = PTR_ERR(dev_root);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002688 goto recovery_tree_root;
Miao Xiecb517ea2013-05-15 07:48:19 +00002689 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002690 dev_root->track_dirty = 1;
Miao Xiecb517ea2013-05-15 07:48:19 +00002691 fs_info->dev_root = dev_root;
2692 btrfs_init_devices_late(fs_info);
Chris Mason3768f362007-03-13 16:47:54 -04002693
Miao Xiecb517ea2013-05-15 07:48:19 +00002694 location.objectid = BTRFS_CSUM_TREE_OBJECTID;
2695 csum_root = btrfs_read_tree_root(tree_root, &location);
2696 if (IS_ERR(csum_root)) {
2697 ret = PTR_ERR(csum_root);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002698 goto recovery_tree_root;
Miao Xiecb517ea2013-05-15 07:48:19 +00002699 }
Chris Masond20f7042008-12-08 16:58:54 -05002700 csum_root->track_dirty = 1;
Miao Xiecb517ea2013-05-15 07:48:19 +00002701 fs_info->csum_root = csum_root;
Chris Masond20f7042008-12-08 16:58:54 -05002702
Miao Xiecb517ea2013-05-15 07:48:19 +00002703 location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
2704 quota_root = btrfs_read_tree_root(tree_root, &location);
2705 if (!IS_ERR(quota_root)) {
Arne Jansenbcef60f2011-09-13 15:23:30 +02002706 quota_root->track_dirty = 1;
2707 fs_info->quota_enabled = 1;
2708 fs_info->pending_quota_state = 1;
Miao Xiecb517ea2013-05-15 07:48:19 +00002709 fs_info->quota_root = quota_root;
Arne Jansenbcef60f2011-09-13 15:23:30 +02002710 }
2711
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02002712 location.objectid = BTRFS_UUID_TREE_OBJECTID;
2713 uuid_root = btrfs_read_tree_root(tree_root, &location);
2714 if (IS_ERR(uuid_root)) {
2715 ret = PTR_ERR(uuid_root);
2716 if (ret != -ENOENT)
2717 goto recovery_tree_root;
2718 create_uuid_tree = true;
Stefan Behrens70f80172013-08-15 17:11:23 +02002719 check_uuid_tree = false;
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02002720 } else {
2721 uuid_root->track_dirty = 1;
2722 fs_info->uuid_root = uuid_root;
Stefan Behrens70f80172013-08-15 17:11:23 +02002723 create_uuid_tree = false;
2724 check_uuid_tree =
2725 generation != btrfs_super_uuid_tree_generation(disk_super);
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02002726 }
2727
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04002728 fs_info->generation = generation;
2729 fs_info->last_trans_committed = generation;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04002730
Ilya Dryomov68310a52012-06-22 12:24:12 -06002731 ret = btrfs_recover_balance(fs_info);
2732 if (ret) {
2733 printk(KERN_WARNING "btrfs: failed to recover balance\n");
2734 goto fail_block_groups;
2735 }
2736
Stefan Behrens733f4fb2012-05-25 16:06:10 +02002737 ret = btrfs_init_dev_stats(fs_info);
2738 if (ret) {
2739 printk(KERN_ERR "btrfs: failed to init dev_stats: %d\n",
2740 ret);
2741 goto fail_block_groups;
2742 }
2743
Stefan Behrens8dabb742012-11-06 13:15:27 +01002744 ret = btrfs_init_dev_replace(fs_info);
2745 if (ret) {
2746 pr_err("btrfs: failed to init dev_replace: %d\n", ret);
2747 goto fail_block_groups;
2748 }
2749
2750 btrfs_close_extra_devices(fs_info, fs_devices, 1);
2751
liuboc59021f2011-03-07 02:13:14 +00002752 ret = btrfs_init_space_info(fs_info);
2753 if (ret) {
2754 printk(KERN_ERR "Failed to initial space info: %d\n", ret);
2755 goto fail_block_groups;
2756 }
2757
Josef Bacik1b1d1f62010-03-19 20:49:55 +00002758 ret = btrfs_read_block_groups(extent_root);
2759 if (ret) {
2760 printk(KERN_ERR "Failed to read block groups: %d\n", ret);
2761 goto fail_block_groups;
2762 }
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02002763 fs_info->num_tolerated_disk_barrier_failures =
2764 btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
Stefan Behrens292fd7f2012-10-30 17:16:16 +00002765 if (fs_info->fs_devices->missing_devices >
2766 fs_info->num_tolerated_disk_barrier_failures &&
2767 !(sb->s_flags & MS_RDONLY)) {
2768 printk(KERN_WARNING
2769 "Btrfs: too many missing devices, writeable mount is not allowed\n");
2770 goto fail_block_groups;
2771 }
Chris Mason9078a3e2007-04-26 16:46:15 -04002772
Chris Masona74a4b92008-06-25 16:01:31 -04002773 fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
2774 "btrfs-cleaner");
Qinghuang Feng57506d52009-01-21 10:49:16 -05002775 if (IS_ERR(fs_info->cleaner_kthread))
Josef Bacik1b1d1f62010-03-19 20:49:55 +00002776 goto fail_block_groups;
Chris Masona74a4b92008-06-25 16:01:31 -04002777
2778 fs_info->transaction_kthread = kthread_run(transaction_kthread,
2779 tree_root,
2780 "btrfs-transaction");
Qinghuang Feng57506d52009-01-21 10:49:16 -05002781 if (IS_ERR(fs_info->transaction_kthread))
Chris Mason3f157a22008-06-25 16:01:31 -04002782 goto fail_cleaner;
Chris Masona74a4b92008-06-25 16:01:31 -04002783
Chris Masonc2898112009-06-10 09:51:32 -04002784 if (!btrfs_test_opt(tree_root, SSD) &&
2785 !btrfs_test_opt(tree_root, NOSSD) &&
2786 !fs_info->fs_devices->rotating) {
2787 printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
2788 "mode\n");
2789 btrfs_set_opt(fs_info->mount_opt, SSD);
2790 }
2791
Stefan Behrens21adbd52011-11-09 13:44:05 +01002792#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2793 if (btrfs_test_opt(tree_root, CHECK_INTEGRITY)) {
2794 ret = btrfsic_mount(tree_root, fs_devices,
2795 btrfs_test_opt(tree_root,
2796 CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
2797 1 : 0,
2798 fs_info->check_integrity_print_mask);
2799 if (ret)
2800 printk(KERN_WARNING "btrfs: failed to initialize"
2801 " integrity check module %s\n", sb->s_id);
2802 }
2803#endif
Arne Jansenbcef60f2011-09-13 15:23:30 +02002804 ret = btrfs_read_qgroup_config(fs_info);
2805 if (ret)
2806 goto fail_trans_kthread;
Stefan Behrens21adbd52011-11-09 13:44:05 +01002807
liuboacce9522011-01-06 19:30:25 +08002808 /* do not make disk changes in broken FS */
Stefan Behrens68ce9682012-08-01 05:45:52 -06002809 if (btrfs_super_log_root(disk_super) != 0) {
Chris Masone02119d2008-09-05 16:13:11 -04002810 u64 bytenr = btrfs_super_log_root(disk_super);
Chris Masond18a2c42008-04-04 15:40:00 -04002811
Chris Mason7c2ca462008-11-19 15:13:35 -05002812 if (fs_devices->rw_devices == 0) {
Chris Masond3977122009-01-05 21:25:51 -05002813 printk(KERN_WARNING "Btrfs log replay required "
2814 "on RO media\n");
Chris Mason7c2ca462008-11-19 15:13:35 -05002815 err = -EIO;
Arne Jansenbcef60f2011-09-13 15:23:30 +02002816 goto fail_qgroup;
Chris Mason7c2ca462008-11-19 15:13:35 -05002817 }
Chris Masone02119d2008-09-05 16:13:11 -04002818 blocksize =
2819 btrfs_level_size(tree_root,
2820 btrfs_super_log_root_level(disk_super));
2821
Al Viro6f07e422011-11-17 00:46:16 -05002822 log_tree_root = btrfs_alloc_root(fs_info);
Dan Carpenter676e4c82010-05-29 09:43:07 +00002823 if (!log_tree_root) {
2824 err = -ENOMEM;
Arne Jansenbcef60f2011-09-13 15:23:30 +02002825 goto fail_qgroup;
Dan Carpenter676e4c82010-05-29 09:43:07 +00002826 }
Chris Masone02119d2008-09-05 16:13:11 -04002827
2828 __setup_root(nodesize, leafsize, sectorsize, stripesize,
2829 log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
2830
2831 log_tree_root->node = read_tree_block(tree_root, bytenr,
Yan Zheng84234f32008-10-29 14:49:05 -04002832 blocksize,
2833 generation + 1);
Josef Bacik416bc652013-04-23 14:17:42 -04002834 if (!log_tree_root->node ||
2835 !extent_buffer_uptodate(log_tree_root->node)) {
2836 printk(KERN_ERR "btrfs: failed to read log tree\n");
2837 free_extent_buffer(log_tree_root->node);
2838 kfree(log_tree_root);
2839 goto fail_trans_kthread;
2840 }
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002841 /* returns with log_tree_root freed on success */
Chris Masone02119d2008-09-05 16:13:11 -04002842 ret = btrfs_recover_log_trees(log_tree_root);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002843 if (ret) {
2844 btrfs_error(tree_root->fs_info, ret,
2845 "Failed to recover log tree");
2846 free_extent_buffer(log_tree_root->node);
2847 kfree(log_tree_root);
2848 goto fail_trans_kthread;
2849 }
Yan Zhenge556ce22008-11-20 10:25:19 -05002850
2851 if (sb->s_flags & MS_RDONLY) {
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002852 ret = btrfs_commit_super(tree_root);
2853 if (ret)
2854 goto fail_trans_kthread;
Yan Zhenge556ce22008-11-20 10:25:19 -05002855 }
Chris Masone02119d2008-09-05 16:13:11 -04002856 }
Zheng Yan1a40e232008-09-26 10:09:34 -04002857
Yan, Zheng76dda932009-09-21 16:00:26 -04002858 ret = btrfs_find_orphan_roots(tree_root);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002859 if (ret)
2860 goto fail_trans_kthread;
Yan, Zheng76dda932009-09-21 16:00:26 -04002861
Chris Mason7c2ca462008-11-19 15:13:35 -05002862 if (!(sb->s_flags & MS_RDONLY)) {
Yan, Zhengd68fc572010-05-16 10:49:58 -04002863 ret = btrfs_cleanup_fs_roots(fs_info);
Ilya Dryomov44c44af2012-06-22 12:14:13 -06002864 if (ret)
2865 goto fail_trans_kthread;
Yan, Zhengd68fc572010-05-16 10:49:58 -04002866
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002867 ret = btrfs_recover_relocation(tree_root);
Miao Xied7ce5842010-02-02 08:46:44 +00002868 if (ret < 0) {
2869 printk(KERN_WARNING
2870 "btrfs: failed to recover relocation\n");
2871 err = -EINVAL;
Arne Jansenbcef60f2011-09-13 15:23:30 +02002872 goto fail_qgroup;
Miao Xied7ce5842010-02-02 08:46:44 +00002873 }
Chris Mason7c2ca462008-11-19 15:13:35 -05002874 }
Zheng Yan1a40e232008-09-26 10:09:34 -04002875
Chris Mason3de45862008-11-17 21:02:50 -05002876 location.objectid = BTRFS_FS_TREE_OBJECTID;
2877 location.type = BTRFS_ROOT_ITEM_KEY;
Miao Xiecb517ea2013-05-15 07:48:19 +00002878 location.offset = 0;
Chris Mason3de45862008-11-17 21:02:50 -05002879
Chris Mason3de45862008-11-17 21:02:50 -05002880 fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
Dan Carpenter3140c9a2010-05-29 09:44:10 +00002881 if (IS_ERR(fs_info->fs_root)) {
2882 err = PTR_ERR(fs_info->fs_root);
Arne Jansenbcef60f2011-09-13 15:23:30 +02002883 goto fail_qgroup;
Dan Carpenter3140c9a2010-05-29 09:44:10 +00002884 }
Chris Masonc2898112009-06-10 09:51:32 -04002885
Ilya Dryomov2b6ba622012-06-22 12:24:13 -06002886 if (sb->s_flags & MS_RDONLY)
2887 return 0;
Ilya Dryomov59641012012-01-16 22:04:48 +02002888
Ilya Dryomov2b6ba622012-06-22 12:24:13 -06002889 down_read(&fs_info->cleanup_work_sem);
2890 if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
2891 (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
Josef Bacike3acc2a2010-01-26 14:30:53 +00002892 up_read(&fs_info->cleanup_work_sem);
Ilya Dryomov2b6ba622012-06-22 12:24:13 -06002893 close_ctree(tree_root);
2894 return ret;
2895 }
2896 up_read(&fs_info->cleanup_work_sem);
Ilya Dryomov59641012012-01-16 22:04:48 +02002897
Ilya Dryomov2b6ba622012-06-22 12:24:13 -06002898 ret = btrfs_resume_balance_async(fs_info);
2899 if (ret) {
2900 printk(KERN_WARNING "btrfs: failed to resume balance\n");
2901 close_ctree(tree_root);
2902 return ret;
Josef Bacike3acc2a2010-01-26 14:30:53 +00002903 }
2904
Stefan Behrens8dabb742012-11-06 13:15:27 +01002905 ret = btrfs_resume_dev_replace_async(fs_info);
2906 if (ret) {
2907 pr_warn("btrfs: failed to resume dev_replace\n");
2908 close_ctree(tree_root);
2909 return ret;
2910 }
2911
Jan Schmidtb382a322013-05-28 15:47:24 +00002912 btrfs_qgroup_rescan_resume(fs_info);
2913
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02002914 if (create_uuid_tree) {
2915 pr_info("btrfs: creating UUID tree\n");
2916 ret = btrfs_create_uuid_tree(fs_info);
2917 if (ret) {
2918 pr_warn("btrfs: failed to create the UUID tree %d\n",
2919 ret);
2920 close_ctree(tree_root);
2921 return ret;
2922 }
Stefan Behrensf420ee12013-08-15 17:11:24 +02002923 } else if (check_uuid_tree ||
2924 btrfs_test_opt(tree_root, RESCAN_UUID_TREE)) {
Stefan Behrens70f80172013-08-15 17:11:23 +02002925 pr_info("btrfs: checking UUID tree\n");
2926 ret = btrfs_check_uuid_tree(fs_info);
2927 if (ret) {
2928 pr_warn("btrfs: failed to check the UUID tree %d\n",
2929 ret);
2930 close_ctree(tree_root);
2931 return ret;
2932 }
2933 } else {
2934 fs_info->update_uuid_tree_gen = 1;
Stefan Behrensf7a81ea2013-08-15 17:11:19 +02002935 }
2936
Al Viroad2b2c82011-11-17 01:10:02 -05002937 return 0;
Chris Mason39279cc2007-06-12 06:35:45 -04002938
Arne Jansenbcef60f2011-09-13 15:23:30 +02002939fail_qgroup:
2940 btrfs_free_qgroup_config(fs_info);
Chris Mason7c2ca462008-11-19 15:13:35 -05002941fail_trans_kthread:
2942 kthread_stop(fs_info->transaction_kthread);
Josef Bacik54067ae2013-04-25 13:44:38 -04002943 btrfs_cleanup_transaction(fs_info->tree_root);
Josef Bacik7b5ff902013-06-06 10:29:40 -04002944 del_fs_roots(fs_info);
Chris Mason3f157a22008-06-25 16:01:31 -04002945fail_cleaner:
Chris Masona74a4b92008-06-25 16:01:31 -04002946 kthread_stop(fs_info->cleaner_kthread);
Chris Mason7c2ca462008-11-19 15:13:35 -05002947
2948 /*
2949 * make sure we're done with the btree inode before we stop our
2950 * kthreads
2951 */
2952 filemap_write_and_wait(fs_info->btree_inode->i_mapping);
Chris Mason7c2ca462008-11-19 15:13:35 -05002953
Josef Bacik1b1d1f62010-03-19 20:49:55 +00002954fail_block_groups:
Josef Bacik54067ae2013-04-25 13:44:38 -04002955 btrfs_put_block_group_cache(fs_info);
Josef Bacik1b1d1f62010-03-19 20:49:55 +00002956 btrfs_free_block_groups(fs_info);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002957
2958fail_tree_roots:
2959 free_root_pointers(fs_info, 1);
Miao Xie2b8195b2013-02-07 06:01:35 +00002960 invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
Chris Masonaf31f5e2011-11-03 15:17:42 -04002961
Chris Mason39279cc2007-06-12 06:35:45 -04002962fail_sb_buffer:
Liu Bo7abadb62013-03-17 02:10:31 +00002963 btrfs_stop_all_workers(fs_info);
Miao Xie16cdcec2011-04-22 18:12:22 +08002964fail_alloc:
Chris Mason4543df72008-06-11 21:47:56 -04002965fail_iput:
Ilya Dryomov586e46e2011-11-09 13:26:37 +02002966 btrfs_mapping_tree_free(&fs_info->mapping_tree);
2967
Chris Mason4543df72008-06-11 21:47:56 -04002968 iput(fs_info->btree_inode);
Miao Xie963d6782013-01-29 10:10:51 +00002969fail_delalloc_bytes:
2970 percpu_counter_destroy(&fs_info->delalloc_bytes);
Miao Xiee2d84522013-01-29 10:09:20 +00002971fail_dirty_metadata_bytes:
2972 percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
Jens Axboead081f12009-06-12 14:43:40 +02002973fail_bdi:
Qinghuang Feng7e662852009-01-21 10:49:16 -05002974 bdi_destroy(&fs_info->bdi);
Yan, Zheng76dda932009-09-21 16:00:26 -04002975fail_srcu:
2976 cleanup_srcu_struct(&fs_info->subvol_srcu);
Qinghuang Feng7e662852009-01-21 10:49:16 -05002977fail:
David Woodhouse53b381b2013-01-29 18:40:14 -05002978 btrfs_free_stripe_hash_table(fs_info);
Ilya Dryomov586e46e2011-11-09 13:26:37 +02002979 btrfs_close_devices(fs_info->fs_devices);
Al Viroad2b2c82011-11-17 01:10:02 -05002980 return err;
Chris Masonaf31f5e2011-11-03 15:17:42 -04002981
2982recovery_tree_root:
Chris Masonaf31f5e2011-11-03 15:17:42 -04002983 if (!btrfs_test_opt(tree_root, RECOVERY))
2984 goto fail_tree_roots;
2985
2986 free_root_pointers(fs_info, 0);
2987
2988 /* don't use the log in recovery mode, it won't be valid */
2989 btrfs_set_super_log_root(disk_super, 0);
2990
2991 /* we can't trust the free space cache either */
2992 btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
2993
2994 ret = next_root_backup(fs_info, fs_info->super_copy,
2995 &num_backups_tried, &backup_index);
2996 if (ret == -1)
2997 goto fail_block_groups;
2998 goto retry_root_backup;
Chris Masoneb60cea2007-02-02 09:18:22 -05002999}
3000
Chris Masonf2984462008-04-10 16:19:33 -04003001static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
3002{
Chris Masonf2984462008-04-10 16:19:33 -04003003 if (uptodate) {
3004 set_buffer_uptodate(bh);
3005 } else {
Stefan Behrens442a4f62012-05-25 16:06:08 +02003006 struct btrfs_device *device = (struct btrfs_device *)
3007 bh->b_private;
3008
Josef Bacik606686e2012-06-04 14:03:51 -04003009 printk_ratelimited_in_rcu(KERN_WARNING "lost page write due to "
3010 "I/O error on %s\n",
3011 rcu_str_deref(device->name));
Chris Mason1259ab72008-05-12 13:39:03 -04003012 /* note, we dont' set_buffer_write_io_error because we have
3013 * our own ways of dealing with the IO errors
3014 */
Chris Masonf2984462008-04-10 16:19:33 -04003015 clear_buffer_uptodate(bh);
Stefan Behrens442a4f62012-05-25 16:06:08 +02003016 btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
Chris Masonf2984462008-04-10 16:19:33 -04003017 }
3018 unlock_buffer(bh);
3019 put_bh(bh);
3020}
3021
Yan Zhenga512bbf2008-12-08 16:46:26 -05003022struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
3023{
3024 struct buffer_head *bh;
3025 struct buffer_head *latest = NULL;
3026 struct btrfs_super_block *super;
3027 int i;
3028 u64 transid = 0;
3029 u64 bytenr;
3030
3031 /* we would like to check all the supers, but that would make
3032 * a btrfs mount succeed after a mkfs from a different FS.
3033 * So, we need to add a special mount option to scan for
3034 * later supers, using BTRFS_SUPER_MIRROR_MAX instead
3035 */
3036 for (i = 0; i < 1; i++) {
3037 bytenr = btrfs_sb_offset(i);
Anand Jain8068a472013-07-26 01:29:35 +08003038 if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3039 i_size_read(bdev->bd_inode))
Yan Zhenga512bbf2008-12-08 16:46:26 -05003040 break;
Anand Jain8068a472013-07-26 01:29:35 +08003041 bh = __bread(bdev, bytenr / 4096,
3042 BTRFS_SUPER_INFO_SIZE);
Yan Zhenga512bbf2008-12-08 16:46:26 -05003043 if (!bh)
3044 continue;
3045
3046 super = (struct btrfs_super_block *)bh->b_data;
3047 if (btrfs_super_bytenr(super) != bytenr ||
Qu Wenruo3cae2102013-07-16 11:19:18 +08003048 btrfs_super_magic(super) != BTRFS_MAGIC) {
Yan Zhenga512bbf2008-12-08 16:46:26 -05003049 brelse(bh);
3050 continue;
3051 }
3052
3053 if (!latest || btrfs_super_generation(super) > transid) {
3054 brelse(latest);
3055 latest = bh;
3056 transid = btrfs_super_generation(super);
3057 } else {
3058 brelse(bh);
3059 }
3060 }
3061 return latest;
3062}
3063
Hisashi Hifumi4eedeb72009-06-10 15:28:55 -04003064/*
3065 * this should be called twice, once with wait == 0 and
3066 * once with wait == 1. When wait == 0 is done, all the buffer heads
3067 * we write are pinned.
3068 *
3069 * They are released when wait == 1 is done.
3070 * max_mirrors must be the same for both runs, and it indicates how
3071 * many supers on this one device should be written.
3072 *
3073 * max_mirrors == 0 means to write them all.
3074 */
Yan Zhenga512bbf2008-12-08 16:46:26 -05003075static int write_dev_supers(struct btrfs_device *device,
3076 struct btrfs_super_block *sb,
3077 int do_barriers, int wait, int max_mirrors)
3078{
3079 struct buffer_head *bh;
3080 int i;
3081 int ret;
3082 int errors = 0;
3083 u32 crc;
3084 u64 bytenr;
Yan Zhenga512bbf2008-12-08 16:46:26 -05003085
3086 if (max_mirrors == 0)
3087 max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3088
Yan Zhenga512bbf2008-12-08 16:46:26 -05003089 for (i = 0; i < max_mirrors; i++) {
3090 bytenr = btrfs_sb_offset(i);
3091 if (bytenr + BTRFS_SUPER_INFO_SIZE >= device->total_bytes)
3092 break;
3093
3094 if (wait) {
3095 bh = __find_get_block(device->bdev, bytenr / 4096,
3096 BTRFS_SUPER_INFO_SIZE);
Josef Bacik634554d2013-04-29 10:05:57 -04003097 if (!bh) {
3098 errors++;
3099 continue;
3100 }
Yan Zhenga512bbf2008-12-08 16:46:26 -05003101 wait_on_buffer(bh);
Hisashi Hifumi4eedeb72009-06-10 15:28:55 -04003102 if (!buffer_uptodate(bh))
3103 errors++;
3104
3105 /* drop our reference */
3106 brelse(bh);
3107
3108 /* drop the reference from the wait == 0 run */
3109 brelse(bh);
3110 continue;
Yan Zhenga512bbf2008-12-08 16:46:26 -05003111 } else {
3112 btrfs_set_super_bytenr(sb, bytenr);
3113
3114 crc = ~(u32)0;
Liu Bob0496682013-03-14 14:57:45 +00003115 crc = btrfs_csum_data((char *)sb +
Yan Zhenga512bbf2008-12-08 16:46:26 -05003116 BTRFS_CSUM_SIZE, crc,
3117 BTRFS_SUPER_INFO_SIZE -
3118 BTRFS_CSUM_SIZE);
3119 btrfs_csum_final(crc, sb->csum);
3120
Hisashi Hifumi4eedeb72009-06-10 15:28:55 -04003121 /*
3122 * one reference for us, and we leave it for the
3123 * caller
3124 */
Yan Zhenga512bbf2008-12-08 16:46:26 -05003125 bh = __getblk(device->bdev, bytenr / 4096,
3126 BTRFS_SUPER_INFO_SIZE);
Josef Bacik634554d2013-04-29 10:05:57 -04003127 if (!bh) {
3128 printk(KERN_ERR "btrfs: couldn't get super "
3129 "buffer head for bytenr %Lu\n", bytenr);
3130 errors++;
3131 continue;
3132 }
3133
Yan Zhenga512bbf2008-12-08 16:46:26 -05003134 memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
3135
Hisashi Hifumi4eedeb72009-06-10 15:28:55 -04003136 /* one reference for submit_bh */
Yan Zhenga512bbf2008-12-08 16:46:26 -05003137 get_bh(bh);
Hisashi Hifumi4eedeb72009-06-10 15:28:55 -04003138
3139 set_buffer_uptodate(bh);
Yan Zhenga512bbf2008-12-08 16:46:26 -05003140 lock_buffer(bh);
3141 bh->b_end_io = btrfs_end_buffer_write_sync;
Stefan Behrens442a4f62012-05-25 16:06:08 +02003142 bh->b_private = device;
Yan Zhenga512bbf2008-12-08 16:46:26 -05003143 }
3144
Chris Mason387125f2011-11-18 15:07:51 -05003145 /*
3146 * we fua the first super. The others we allow
3147 * to go down lazy.
3148 */
Stefan Behrens21adbd52011-11-09 13:44:05 +01003149 ret = btrfsic_submit_bh(WRITE_FUA, bh);
Hisashi Hifumi4eedeb72009-06-10 15:28:55 -04003150 if (ret)
Yan Zhenga512bbf2008-12-08 16:46:26 -05003151 errors++;
Yan Zhenga512bbf2008-12-08 16:46:26 -05003152 }
3153 return errors < i ? 0 : -1;
3154}
3155
Chris Mason387125f2011-11-18 15:07:51 -05003156/*
3157 * endio for the write_dev_flush, this will wake anyone waiting
3158 * for the barrier when it is done
3159 */
3160static void btrfs_end_empty_barrier(struct bio *bio, int err)
3161{
3162 if (err) {
3163 if (err == -EOPNOTSUPP)
3164 set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
3165 clear_bit(BIO_UPTODATE, &bio->bi_flags);
3166 }
3167 if (bio->bi_private)
3168 complete(bio->bi_private);
3169 bio_put(bio);
3170}
3171
3172/*
3173 * trigger flushes for one the devices. If you pass wait == 0, the flushes are
3174 * sent down. With wait == 1, it waits for the previous flush.
3175 *
3176 * any device where the flush fails with eopnotsupp are flagged as not-barrier
3177 * capable
3178 */
3179static int write_dev_flush(struct btrfs_device *device, int wait)
3180{
3181 struct bio *bio;
3182 int ret = 0;
3183
3184 if (device->nobarriers)
3185 return 0;
3186
3187 if (wait) {
3188 bio = device->flush_bio;
3189 if (!bio)
3190 return 0;
3191
3192 wait_for_completion(&device->flush_wait);
3193
3194 if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
Josef Bacik606686e2012-06-04 14:03:51 -04003195 printk_in_rcu("btrfs: disabling barriers on dev %s\n",
3196 rcu_str_deref(device->name));
Chris Mason387125f2011-11-18 15:07:51 -05003197 device->nobarriers = 1;
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003198 } else if (!bio_flagged(bio, BIO_UPTODATE)) {
Chris Mason387125f2011-11-18 15:07:51 -05003199 ret = -EIO;
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003200 btrfs_dev_stat_inc_and_print(device,
3201 BTRFS_DEV_STAT_FLUSH_ERRS);
Chris Mason387125f2011-11-18 15:07:51 -05003202 }
3203
3204 /* drop the reference from the wait == 0 run */
3205 bio_put(bio);
3206 device->flush_bio = NULL;
3207
3208 return ret;
3209 }
3210
3211 /*
3212 * one reference for us, and we leave it for the
3213 * caller
3214 */
Jesper Juhl9c017ab2012-02-27 00:04:56 +01003215 device->flush_bio = NULL;
Chris Mason9be33952013-05-17 18:30:14 -04003216 bio = btrfs_io_bio_alloc(GFP_NOFS, 0);
Chris Mason387125f2011-11-18 15:07:51 -05003217 if (!bio)
3218 return -ENOMEM;
3219
3220 bio->bi_end_io = btrfs_end_empty_barrier;
3221 bio->bi_bdev = device->bdev;
3222 init_completion(&device->flush_wait);
3223 bio->bi_private = &device->flush_wait;
3224 device->flush_bio = bio;
3225
3226 bio_get(bio);
Stefan Behrens21adbd52011-11-09 13:44:05 +01003227 btrfsic_submit_bio(WRITE_FLUSH, bio);
Chris Mason387125f2011-11-18 15:07:51 -05003228
3229 return 0;
3230}
3231
3232/*
3233 * send an empty flush down to each device in parallel,
3234 * then wait for them
3235 */
3236static int barrier_all_devices(struct btrfs_fs_info *info)
3237{
3238 struct list_head *head;
3239 struct btrfs_device *dev;
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003240 int errors_send = 0;
3241 int errors_wait = 0;
Chris Mason387125f2011-11-18 15:07:51 -05003242 int ret;
3243
3244 /* send down all the barriers */
3245 head = &info->fs_devices->devices;
3246 list_for_each_entry_rcu(dev, head, dev_list) {
3247 if (!dev->bdev) {
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003248 errors_send++;
Chris Mason387125f2011-11-18 15:07:51 -05003249 continue;
3250 }
3251 if (!dev->in_fs_metadata || !dev->writeable)
3252 continue;
3253
3254 ret = write_dev_flush(dev, 0);
3255 if (ret)
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003256 errors_send++;
Chris Mason387125f2011-11-18 15:07:51 -05003257 }
3258
3259 /* wait for all the barriers */
3260 list_for_each_entry_rcu(dev, head, dev_list) {
3261 if (!dev->bdev) {
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003262 errors_wait++;
Chris Mason387125f2011-11-18 15:07:51 -05003263 continue;
3264 }
3265 if (!dev->in_fs_metadata || !dev->writeable)
3266 continue;
3267
3268 ret = write_dev_flush(dev, 1);
3269 if (ret)
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003270 errors_wait++;
Chris Mason387125f2011-11-18 15:07:51 -05003271 }
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003272 if (errors_send > info->num_tolerated_disk_barrier_failures ||
3273 errors_wait > info->num_tolerated_disk_barrier_failures)
Chris Mason387125f2011-11-18 15:07:51 -05003274 return -EIO;
3275 return 0;
3276}
3277
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003278int btrfs_calc_num_tolerated_disk_barrier_failures(
3279 struct btrfs_fs_info *fs_info)
3280{
3281 struct btrfs_ioctl_space_info space;
3282 struct btrfs_space_info *sinfo;
3283 u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
3284 BTRFS_BLOCK_GROUP_SYSTEM,
3285 BTRFS_BLOCK_GROUP_METADATA,
3286 BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
3287 int num_types = 4;
3288 int i;
3289 int c;
3290 int num_tolerated_disk_barrier_failures =
3291 (int)fs_info->fs_devices->num_devices;
3292
3293 for (i = 0; i < num_types; i++) {
3294 struct btrfs_space_info *tmp;
3295
3296 sinfo = NULL;
3297 rcu_read_lock();
3298 list_for_each_entry_rcu(tmp, &fs_info->space_info, list) {
3299 if (tmp->flags == types[i]) {
3300 sinfo = tmp;
3301 break;
3302 }
3303 }
3304 rcu_read_unlock();
3305
3306 if (!sinfo)
3307 continue;
3308
3309 down_read(&sinfo->groups_sem);
3310 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3311 if (!list_empty(&sinfo->block_groups[c])) {
3312 u64 flags;
3313
3314 btrfs_get_block_group_info(
3315 &sinfo->block_groups[c], &space);
3316 if (space.total_bytes == 0 ||
3317 space.used_bytes == 0)
3318 continue;
3319 flags = space.flags;
3320 /*
3321 * return
3322 * 0: if dup, single or RAID0 is configured for
3323 * any of metadata, system or data, else
3324 * 1: if RAID5 is configured, or if RAID1 or
3325 * RAID10 is configured and only two mirrors
3326 * are used, else
3327 * 2: if RAID6 is configured, else
3328 * num_mirrors - 1: if RAID1 or RAID10 is
3329 * configured and more than
3330 * 2 mirrors are used.
3331 */
3332 if (num_tolerated_disk_barrier_failures > 0 &&
3333 ((flags & (BTRFS_BLOCK_GROUP_DUP |
3334 BTRFS_BLOCK_GROUP_RAID0)) ||
3335 ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)
3336 == 0)))
3337 num_tolerated_disk_barrier_failures = 0;
David Woodhouse53b381b2013-01-29 18:40:14 -05003338 else if (num_tolerated_disk_barrier_failures > 1) {
3339 if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
3340 BTRFS_BLOCK_GROUP_RAID5 |
3341 BTRFS_BLOCK_GROUP_RAID10)) {
3342 num_tolerated_disk_barrier_failures = 1;
3343 } else if (flags &
Henrik Nordvik15b0a892013-04-29 18:09:23 +00003344 BTRFS_BLOCK_GROUP_RAID6) {
David Woodhouse53b381b2013-01-29 18:40:14 -05003345 num_tolerated_disk_barrier_failures = 2;
3346 }
3347 }
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003348 }
3349 }
3350 up_read(&sinfo->groups_sem);
3351 }
3352
3353 return num_tolerated_disk_barrier_failures;
3354}
3355
Eric Sandeen48a3b632013-04-25 20:41:01 +00003356static int write_all_supers(struct btrfs_root *root, int max_mirrors)
Chris Masonf2984462008-04-10 16:19:33 -04003357{
Chris Masone5e9a522009-06-10 15:17:02 -04003358 struct list_head *head;
Chris Masonf2984462008-04-10 16:19:33 -04003359 struct btrfs_device *dev;
Chris Masona061fc82008-05-07 11:43:44 -04003360 struct btrfs_super_block *sb;
Chris Masonf2984462008-04-10 16:19:33 -04003361 struct btrfs_dev_item *dev_item;
Chris Masonf2984462008-04-10 16:19:33 -04003362 int ret;
3363 int do_barriers;
Chris Masona236aed2008-04-29 09:38:00 -04003364 int max_errors;
3365 int total_errors = 0;
Chris Masona061fc82008-05-07 11:43:44 -04003366 u64 flags;
Chris Masonf2984462008-04-10 16:19:33 -04003367
3368 do_barriers = !btrfs_test_opt(root, NOBARRIER);
Chris Masonaf31f5e2011-11-03 15:17:42 -04003369 backup_super_roots(root->fs_info);
Chris Masonf2984462008-04-10 16:19:33 -04003370
David Sterba6c417612011-04-13 15:41:04 +02003371 sb = root->fs_info->super_for_commit;
Chris Masona061fc82008-05-07 11:43:44 -04003372 dev_item = &sb->dev_item;
Chris Masone5e9a522009-06-10 15:17:02 -04003373
Chris Mason174ba502011-05-27 10:03:58 -04003374 mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
Chris Masone5e9a522009-06-10 15:17:02 -04003375 head = &root->fs_info->fs_devices->devices;
Filipe David Borba Mananad7306802013-08-09 15:41:36 +01003376 max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
Chris Mason387125f2011-11-18 15:07:51 -05003377
Stefan Behrens5af3e8c2012-08-01 18:56:49 +02003378 if (do_barriers) {
3379 ret = barrier_all_devices(root->fs_info);
3380 if (ret) {
3381 mutex_unlock(
3382 &root->fs_info->fs_devices->device_list_mutex);
3383 btrfs_error(root->fs_info, ret,
3384 "errors while submitting device barriers.");
3385 return ret;
3386 }
3387 }
Chris Mason387125f2011-11-18 15:07:51 -05003388
Xiao Guangrong1f781602011-04-20 10:09:16 +00003389 list_for_each_entry_rcu(dev, head, dev_list) {
Chris Masondfe25022008-05-13 13:46:40 -04003390 if (!dev->bdev) {
3391 total_errors++;
3392 continue;
3393 }
Yan Zheng2b820322008-11-17 21:11:30 -05003394 if (!dev->in_fs_metadata || !dev->writeable)
Chris Masondfe25022008-05-13 13:46:40 -04003395 continue;
3396
Yan Zheng2b820322008-11-17 21:11:30 -05003397 btrfs_set_stack_device_generation(dev_item, 0);
Chris Masona061fc82008-05-07 11:43:44 -04003398 btrfs_set_stack_device_type(dev_item, dev->type);
3399 btrfs_set_stack_device_id(dev_item, dev->devid);
3400 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
3401 btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
3402 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
3403 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
3404 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
3405 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
Yan Zheng2b820322008-11-17 21:11:30 -05003406 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Yan Zhenga512bbf2008-12-08 16:46:26 -05003407
Chris Masona061fc82008-05-07 11:43:44 -04003408 flags = btrfs_super_flags(sb);
3409 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
Chris Masonf2984462008-04-10 16:19:33 -04003410
Yan Zhenga512bbf2008-12-08 16:46:26 -05003411 ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
Chris Masona236aed2008-04-29 09:38:00 -04003412 if (ret)
3413 total_errors++;
Chris Masonf2984462008-04-10 16:19:33 -04003414 }
Chris Masona236aed2008-04-29 09:38:00 -04003415 if (total_errors > max_errors) {
Chris Masond3977122009-01-05 21:25:51 -05003416 printk(KERN_ERR "btrfs: %d errors while writing supers\n",
3417 total_errors);
Stefan Behrensa724b432013-09-11 09:59:22 +02003418 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003419
Stefan Behrens9d565ba2013-08-09 17:08:40 +02003420 /* FUA is masked off if unsupported and can't be the reason */
3421 btrfs_error(root->fs_info, -EIO,
3422 "%d errors while writing supers", total_errors);
3423 return -EIO;
Chris Masona236aed2008-04-29 09:38:00 -04003424 }
Chris Masonf2984462008-04-10 16:19:33 -04003425
Yan Zhenga512bbf2008-12-08 16:46:26 -05003426 total_errors = 0;
Xiao Guangrong1f781602011-04-20 10:09:16 +00003427 list_for_each_entry_rcu(dev, head, dev_list) {
Chris Masondfe25022008-05-13 13:46:40 -04003428 if (!dev->bdev)
3429 continue;
Yan Zheng2b820322008-11-17 21:11:30 -05003430 if (!dev->in_fs_metadata || !dev->writeable)
Chris Masondfe25022008-05-13 13:46:40 -04003431 continue;
3432
Yan Zhenga512bbf2008-12-08 16:46:26 -05003433 ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
3434 if (ret)
3435 total_errors++;
Chris Masonf2984462008-04-10 16:19:33 -04003436 }
Chris Mason174ba502011-05-27 10:03:58 -04003437 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
Chris Masona236aed2008-04-29 09:38:00 -04003438 if (total_errors > max_errors) {
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003439 btrfs_error(root->fs_info, -EIO,
3440 "%d errors while writing supers", total_errors);
3441 return -EIO;
Chris Masona236aed2008-04-29 09:38:00 -04003442 }
Chris Masonf2984462008-04-10 16:19:33 -04003443 return 0;
3444}
3445
Yan Zhenga512bbf2008-12-08 16:46:26 -05003446int write_ctree_super(struct btrfs_trans_handle *trans,
3447 struct btrfs_root *root, int max_mirrors)
Chris Masoncfaa7292007-02-21 17:04:57 -05003448{
Chris Masone66f7092007-04-20 13:16:02 -04003449 int ret;
Chris Mason2c90e5d2007-04-02 10:50:19 -04003450
Yan Zhenga512bbf2008-12-08 16:46:26 -05003451 ret = write_all_supers(root, max_mirrors);
Chris Mason5f39d392007-10-15 16:14:19 -04003452 return ret;
Chris Masoncfaa7292007-02-21 17:04:57 -05003453}
3454
Miao Xiecb517ea2013-05-15 07:48:19 +00003455/* Drop a fs root from the radix tree and free it. */
3456void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
3457 struct btrfs_root *root)
Chris Mason2619ba12007-04-10 16:58:11 -04003458{
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003459 spin_lock(&fs_info->fs_roots_radix_lock);
Chris Mason2619ba12007-04-10 16:58:11 -04003460 radix_tree_delete(&fs_info->fs_roots_radix,
3461 (unsigned long)root->root_key.objectid);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003462 spin_unlock(&fs_info->fs_roots_radix_lock);
Yan, Zheng76dda932009-09-21 16:00:26 -04003463
3464 if (btrfs_root_refs(&root->root_item) == 0)
3465 synchronize_srcu(&fs_info->subvol_srcu);
3466
Liu Bod7634482013-03-11 09:20:00 +00003467 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
Liu Bo33217192013-02-27 13:28:24 +00003468 btrfs_free_log(NULL, root);
3469 btrfs_free_log_root_tree(NULL, fs_info);
3470 }
3471
Li Zefan581bb052011-04-20 10:06:11 +08003472 __btrfs_remove_free_space_cache(root->free_ino_pinned);
3473 __btrfs_remove_free_space_cache(root->free_ino_ctl);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003474 free_fs_root(root);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003475}
3476
3477static void free_fs_root(struct btrfs_root *root)
3478{
Li Zefan82d59022011-04-20 10:33:24 +08003479 iput(root->cache_inode);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003480 WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
Filipe David Borba Manana1cb048f2013-08-20 00:52:51 +01003481 btrfs_free_block_rsv(root, root->orphan_block_rsv);
3482 root->orphan_block_rsv = NULL;
Al Viro0ee5dc62011-07-07 15:44:25 -04003483 if (root->anon_dev)
3484 free_anon_bdev(root->anon_dev);
Yan, Zheng4df27c4d2009-09-21 15:56:00 -04003485 free_extent_buffer(root->node);
3486 free_extent_buffer(root->commit_root);
Li Zefan581bb052011-04-20 10:06:11 +08003487 kfree(root->free_ino_ctl);
3488 kfree(root->free_ino_pinned);
Chris Masond3977122009-01-05 21:25:51 -05003489 kfree(root->name);
Miao Xieb0feb9d2013-05-15 07:48:20 +00003490 btrfs_put_fs_root(root);
Chris Mason2619ba12007-04-10 16:58:11 -04003491}
3492
Miao Xiecb517ea2013-05-15 07:48:19 +00003493void btrfs_free_fs_root(struct btrfs_root *root)
3494{
3495 free_fs_root(root);
Chris Masoneb60cea2007-02-02 09:18:22 -05003496}
3497
Yan Zhengc146afa2008-11-12 14:34:12 -05003498int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
3499{
3500 u64 root_objectid = 0;
3501 struct btrfs_root *gang[8];
3502 int i;
3503 int ret;
3504
3505 while (1) {
3506 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3507 (void **)gang, root_objectid,
3508 ARRAY_SIZE(gang));
3509 if (!ret)
3510 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003511
3512 root_objectid = gang[ret - 1]->root_key.objectid + 1;
Yan Zhengc146afa2008-11-12 14:34:12 -05003513 for (i = 0; i < ret; i++) {
Josef Bacik66b4ffd2011-01-31 16:22:42 -05003514 int err;
3515
Yan Zhengc146afa2008-11-12 14:34:12 -05003516 root_objectid = gang[i]->root_key.objectid;
Josef Bacik66b4ffd2011-01-31 16:22:42 -05003517 err = btrfs_orphan_cleanup(gang[i]);
3518 if (err)
3519 return err;
Yan Zhengc146afa2008-11-12 14:34:12 -05003520 }
3521 root_objectid++;
3522 }
3523 return 0;
3524}
3525
3526int btrfs_commit_super(struct btrfs_root *root)
3527{
3528 struct btrfs_trans_handle *trans;
3529 int ret;
3530
3531 mutex_lock(&root->fs_info->cleaner_mutex);
Yan, Zheng24bbcf042009-11-12 09:36:34 +00003532 btrfs_run_delayed_iputs(root);
Yan Zhengc146afa2008-11-12 14:34:12 -05003533 mutex_unlock(&root->fs_info->cleaner_mutex);
David Sterba9d1a2a32013-03-12 15:13:28 +00003534 wake_up_process(root->fs_info->cleaner_kthread);
Yan, Zhengc71bf092009-11-12 09:34:40 +00003535
3536 /* wait until ongoing cleanup work done */
3537 down_write(&root->fs_info->cleanup_work_sem);
3538 up_write(&root->fs_info->cleanup_work_sem);
3539
Josef Bacik7a7eaa42011-04-13 12:54:33 -04003540 trans = btrfs_join_transaction(root);
Tsutomu Itoh3612b492011-01-25 02:51:38 +00003541 if (IS_ERR(trans))
3542 return PTR_ERR(trans);
Yan Zhengc146afa2008-11-12 14:34:12 -05003543 ret = btrfs_commit_transaction(trans, root);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003544 if (ret)
3545 return ret;
Yan Zhengc146afa2008-11-12 14:34:12 -05003546 /* run commit again to drop the original snapshot */
Josef Bacik7a7eaa42011-04-13 12:54:33 -04003547 trans = btrfs_join_transaction(root);
Tsutomu Itoh3612b492011-01-25 02:51:38 +00003548 if (IS_ERR(trans))
3549 return PTR_ERR(trans);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003550 ret = btrfs_commit_transaction(trans, root);
3551 if (ret)
3552 return ret;
Yan Zhengc146afa2008-11-12 14:34:12 -05003553 ret = btrfs_write_and_wait_transaction(NULL, root);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01003554 if (ret) {
3555 btrfs_error(root->fs_info, ret,
3556 "Failed to sync btree inode to disk.");
3557 return ret;
3558 }
Yan Zhengc146afa2008-11-12 14:34:12 -05003559
Yan Zhenga512bbf2008-12-08 16:46:26 -05003560 ret = write_ctree_super(NULL, root, 0);
Yan Zhengc146afa2008-11-12 14:34:12 -05003561 return ret;
3562}
3563
Chris Masone20d96d2007-03-22 12:13:20 -04003564int close_ctree(struct btrfs_root *root)
Chris Masoneb60cea2007-02-02 09:18:22 -05003565{
Chris Mason0f7d52f2007-04-09 10:42:37 -04003566 struct btrfs_fs_info *fs_info = root->fs_info;
Yan Zhengc146afa2008-11-12 14:34:12 -05003567 int ret;
Chris Masone089f052007-03-16 16:20:31 -04003568
Chris Masonfacda1e2007-06-08 18:11:48 -04003569 fs_info->closing = 1;
Chris Masona2135012008-06-25 16:01:30 -04003570 smp_mb();
3571
Stefan Behrens803b2f52013-08-15 17:11:21 +02003572 /* wait for the uuid_scan task to finish */
3573 down(&fs_info->uuid_tree_rescan_sem);
3574 /* avoid complains from lockdep et al., set sem back to initial state */
3575 up(&fs_info->uuid_tree_rescan_sem);
3576
Ilya Dryomov837d5b62012-01-16 22:04:49 +02003577 /* pause restriper - we want to resume on mount */
Stefan Behrensaa1b8cd2012-11-05 17:03:39 +01003578 btrfs_pause_balance(fs_info);
Ilya Dryomov837d5b62012-01-16 22:04:49 +02003579
Stefan Behrens8dabb742012-11-06 13:15:27 +01003580 btrfs_dev_replace_suspend_for_unmount(fs_info);
3581
Stefan Behrensaa1b8cd2012-11-05 17:03:39 +01003582 btrfs_scrub_cancel(fs_info);
Chris Mason4cb53002011-05-24 15:35:30 -04003583
3584 /* wait for any defraggers to finish */
3585 wait_event(fs_info->transaction_wait,
3586 (atomic_read(&fs_info->defrag_running) == 0));
3587
3588 /* clear out the rbtree of defraggable inodes */
Miao Xie26176e72012-11-26 09:26:20 +00003589 btrfs_cleanup_defrag_inodes(fs_info);
Chris Mason4cb53002011-05-24 15:35:30 -04003590
Yan Zhengc146afa2008-11-12 14:34:12 -05003591 if (!(fs_info->sb->s_flags & MS_RDONLY)) {
liuboacce9522011-01-06 19:30:25 +08003592 ret = btrfs_commit_super(root);
3593 if (ret)
3594 printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
3595 }
3596
Miao Xie87533c42013-01-29 10:14:48 +00003597 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
Stefan Behrens68ce9682012-08-01 05:45:52 -06003598 btrfs_error_commit_super(root);
Chris Masoned2ff2c2007-03-01 18:59:40 -05003599
Josef Bacik300e4f82011-08-29 14:06:00 -04003600 btrfs_put_block_group_cache(fs_info);
3601
Al Viroe3029d92011-11-17 00:56:18 -05003602 kthread_stop(fs_info->transaction_kthread);
3603 kthread_stop(fs_info->cleaner_kthread);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003604
Yan Zhengf25784b2009-07-28 08:41:57 -04003605 fs_info->closing = 2;
3606 smp_mb();
3607
Arne Jansenbcef60f2011-09-13 15:23:30 +02003608 btrfs_free_qgroup_config(root->fs_info);
3609
Miao Xie963d6782013-01-29 10:10:51 +00003610 if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
3611 printk(KERN_INFO "btrfs: at unmount delalloc count %lld\n",
3612 percpu_counter_sum(&fs_info->delalloc_bytes));
Chris Masonb0c68f82008-01-31 11:05:37 -05003613 }
Yanbcc63ab2008-07-30 16:29:20 -04003614
Chris Mason0f7d52f2007-04-09 10:42:37 -04003615 del_fs_roots(fs_info);
Chris Masond10c5f32007-12-17 20:14:04 -05003616
Josef Bacik2b1360d2013-10-07 15:14:44 -04003617 btrfs_free_block_groups(fs_info);
3618
Josef Bacik96192492013-10-16 13:53:28 -04003619 btrfs_stop_all_workers(fs_info);
3620
Josef Bacik13e6c372013-05-30 16:55:44 -04003621 free_root_pointers(fs_info, 1);
Chris Mason9ad6b7b2008-04-18 16:11:30 -04003622
Josef Bacik13e6c372013-05-30 16:55:44 -04003623 iput(fs_info->btree_inode);
Chris Masond6bfde82008-04-30 13:59:35 -04003624
Stefan Behrens21adbd52011-11-09 13:44:05 +01003625#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3626 if (btrfs_test_opt(root, CHECK_INTEGRITY))
3627 btrfsic_unmount(root, fs_info->fs_devices);
3628#endif
3629
Chris Masondfe25022008-05-13 13:46:40 -04003630 btrfs_close_devices(fs_info->fs_devices);
Chris Mason0b86a832008-03-24 15:01:56 -04003631 btrfs_mapping_tree_free(&fs_info->mapping_tree);
Chris Masonb248a412008-04-14 09:48:18 -04003632
Miao Xiee2d84522013-01-29 10:09:20 +00003633 percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
Miao Xie963d6782013-01-29 10:10:51 +00003634 percpu_counter_destroy(&fs_info->delalloc_bytes);
Chris Mason04160082008-03-26 10:28:07 -04003635 bdi_destroy(&fs_info->bdi);
Yan, Zheng76dda932009-09-21 16:00:26 -04003636 cleanup_srcu_struct(&fs_info->subvol_srcu);
Chris Mason0b86a832008-03-24 15:01:56 -04003637
David Woodhouse53b381b2013-01-29 18:40:14 -05003638 btrfs_free_stripe_hash_table(fs_info);
3639
Filipe David Borba Manana1cb048f2013-08-20 00:52:51 +01003640 btrfs_free_block_rsv(root, root->orphan_block_rsv);
3641 root->orphan_block_rsv = NULL;
3642
Chris Masoneb60cea2007-02-02 09:18:22 -05003643 return 0;
3644}
3645
Chris Masonb9fab912012-05-06 07:23:47 -04003646int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
3647 int atomic)
Chris Masonccd467d2007-06-28 15:57:36 -04003648{
Chris Mason1259ab72008-05-12 13:39:03 -04003649 int ret;
Chris Mason727011e2010-08-06 13:21:20 -04003650 struct inode *btree_inode = buf->pages[0]->mapping->host;
Chris Mason1259ab72008-05-12 13:39:03 -04003651
Josef Bacik0b32f4b2012-03-13 09:38:00 -04003652 ret = extent_buffer_uptodate(buf);
Chris Mason1259ab72008-05-12 13:39:03 -04003653 if (!ret)
3654 return ret;
3655
3656 ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
Chris Masonb9fab912012-05-06 07:23:47 -04003657 parent_transid, atomic);
3658 if (ret == -EAGAIN)
3659 return ret;
Chris Mason1259ab72008-05-12 13:39:03 -04003660 return !ret;
Chris Mason5f39d392007-10-15 16:14:19 -04003661}
Chris Mason6702ed42007-08-07 16:15:09 -04003662
Chris Mason5f39d392007-10-15 16:14:19 -04003663int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
3664{
Josef Bacik0b32f4b2012-03-13 09:38:00 -04003665 return set_extent_buffer_uptodate(buf);
Chris Mason5f39d392007-10-15 16:14:19 -04003666}
3667
3668void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
3669{
Josef Bacik06ea65a2013-09-19 16:07:01 -04003670 struct btrfs_root *root;
Chris Mason5f39d392007-10-15 16:14:19 -04003671 u64 transid = btrfs_header_generation(buf);
Chris Masonb9473432009-03-13 11:00:37 -04003672 int was_dirty;
Chris Masonb4ce94d2009-02-04 09:25:08 -05003673
Josef Bacik06ea65a2013-09-19 16:07:01 -04003674#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3675 /*
3676 * This is a fast path so only do this check if we have sanity tests
3677 * enabled. Normal people shouldn't be marking dummy buffers as dirty
3678 * outside of the sanity tests.
3679 */
3680 if (unlikely(test_bit(EXTENT_BUFFER_DUMMY, &buf->bflags)))
3681 return;
3682#endif
3683 root = BTRFS_I(buf->pages[0]->mapping->host)->root;
Chris Masonb9447ef2009-03-09 11:45:38 -04003684 btrfs_assert_tree_locked(buf);
Julia Lawall31b1a2b2012-11-03 10:58:34 +00003685 if (transid != root->fs_info->generation)
3686 WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, "
Chris Masond3977122009-01-05 21:25:51 -05003687 "found %llu running %llu\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +02003688 buf->start, transid, root->fs_info->generation);
Josef Bacik0b32f4b2012-03-13 09:38:00 -04003689 was_dirty = set_extent_buffer_dirty(buf);
Miao Xiee2d84522013-01-29 10:09:20 +00003690 if (!was_dirty)
3691 __percpu_counter_add(&root->fs_info->dirty_metadata_bytes,
3692 buf->len,
3693 root->fs_info->dirty_metadata_batch);
Chris Masoneb60cea2007-02-02 09:18:22 -05003694}
3695
Liu Bob53d3f52012-11-14 14:34:34 +00003696static void __btrfs_btree_balance_dirty(struct btrfs_root *root,
3697 int flush_delayed)
Chris Mason35b7e472007-05-02 15:53:43 -04003698{
Chris Mason188de642008-05-09 11:52:25 -04003699 /*
3700 * looks as though older kernels can get into trouble with
3701 * this code, they end up stuck in balance_dirty_pages forever
3702 */
Miao Xiee2d84522013-01-29 10:09:20 +00003703 int ret;
Chris Masond6bfde82008-04-30 13:59:35 -04003704
Jens Axboe6933c022009-03-17 09:36:37 +01003705 if (current->flags & PF_MEMALLOC)
Chris Masond6bfde82008-04-30 13:59:35 -04003706 return;
3707
Liu Bob53d3f52012-11-14 14:34:34 +00003708 if (flush_delayed)
3709 btrfs_balance_delayed_items(root);
Miao Xie16cdcec2011-04-22 18:12:22 +08003710
Miao Xiee2d84522013-01-29 10:09:20 +00003711 ret = percpu_counter_compare(&root->fs_info->dirty_metadata_bytes,
3712 BTRFS_DIRTY_METADATA_THRESH);
3713 if (ret > 0) {
Namjae Jeond0e1d662012-12-11 16:00:21 -08003714 balance_dirty_pages_ratelimited(
3715 root->fs_info->btree_inode->i_mapping);
Miao Xie16cdcec2011-04-22 18:12:22 +08003716 }
3717 return;
3718}
3719
Liu Bob53d3f52012-11-14 14:34:34 +00003720void btrfs_btree_balance_dirty(struct btrfs_root *root)
Miao Xie16cdcec2011-04-22 18:12:22 +08003721{
Liu Bob53d3f52012-11-14 14:34:34 +00003722 __btrfs_btree_balance_dirty(root, 1);
3723}
Miao Xie16cdcec2011-04-22 18:12:22 +08003724
Liu Bob53d3f52012-11-14 14:34:34 +00003725void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root)
3726{
3727 __btrfs_btree_balance_dirty(root, 0);
Chris Mason35b7e472007-05-02 15:53:43 -04003728}
Chris Mason6b800532007-10-15 16:17:34 -04003729
Chris Masonca7a79a2008-05-12 12:59:19 -04003730int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
Chris Mason6b800532007-10-15 16:17:34 -04003731{
Chris Mason727011e2010-08-06 13:21:20 -04003732 struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
Josef Bacik0b32f4b2012-03-13 09:38:00 -04003733 return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
Chris Mason6b800532007-10-15 16:17:34 -04003734}
Chris Mason0da54682007-11-07 21:08:01 -05003735
David Sterbafcd1f0652012-03-06 00:06:18 +01003736static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
liuboacce9522011-01-06 19:30:25 +08003737 int read_only)
3738{
David Sterba1104a882013-03-06 15:57:46 +01003739 /*
3740 * Placeholder for checks
3741 */
David Sterbafcd1f0652012-03-06 00:06:18 +01003742 return 0;
liuboacce9522011-01-06 19:30:25 +08003743}
3744
Eric Sandeen48a3b632013-04-25 20:41:01 +00003745static void btrfs_error_commit_super(struct btrfs_root *root)
liuboacce9522011-01-06 19:30:25 +08003746{
liuboacce9522011-01-06 19:30:25 +08003747 mutex_lock(&root->fs_info->cleaner_mutex);
3748 btrfs_run_delayed_iputs(root);
3749 mutex_unlock(&root->fs_info->cleaner_mutex);
3750
3751 down_write(&root->fs_info->cleanup_work_sem);
3752 up_write(&root->fs_info->cleanup_work_sem);
3753
3754 /* cleanup FS via transaction */
3755 btrfs_cleanup_transaction(root);
liuboacce9522011-01-06 19:30:25 +08003756}
3757
Josef Bacik569e0f32013-02-13 11:09:14 -05003758static void btrfs_destroy_ordered_operations(struct btrfs_transaction *t,
3759 struct btrfs_root *root)
liuboacce9522011-01-06 19:30:25 +08003760{
3761 struct btrfs_inode *btrfs_inode;
3762 struct list_head splice;
3763
3764 INIT_LIST_HEAD(&splice);
3765
3766 mutex_lock(&root->fs_info->ordered_operations_mutex);
Miao Xie199c2a92013-05-15 07:48:23 +00003767 spin_lock(&root->fs_info->ordered_root_lock);
liuboacce9522011-01-06 19:30:25 +08003768
Josef Bacik569e0f32013-02-13 11:09:14 -05003769 list_splice_init(&t->ordered_operations, &splice);
liuboacce9522011-01-06 19:30:25 +08003770 while (!list_empty(&splice)) {
3771 btrfs_inode = list_entry(splice.next, struct btrfs_inode,
3772 ordered_operations);
3773
3774 list_del_init(&btrfs_inode->ordered_operations);
Miao Xie199c2a92013-05-15 07:48:23 +00003775 spin_unlock(&root->fs_info->ordered_root_lock);
liuboacce9522011-01-06 19:30:25 +08003776
3777 btrfs_invalidate_inodes(btrfs_inode->root);
Miao Xieb216cbf2013-05-15 07:48:21 +00003778
Miao Xie199c2a92013-05-15 07:48:23 +00003779 spin_lock(&root->fs_info->ordered_root_lock);
liuboacce9522011-01-06 19:30:25 +08003780 }
3781
Miao Xie199c2a92013-05-15 07:48:23 +00003782 spin_unlock(&root->fs_info->ordered_root_lock);
liuboacce9522011-01-06 19:30:25 +08003783 mutex_unlock(&root->fs_info->ordered_operations_mutex);
liuboacce9522011-01-06 19:30:25 +08003784}
3785
Jeff Mahoney143bede2012-03-01 14:56:26 +01003786static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
liuboacce9522011-01-06 19:30:25 +08003787{
liuboacce9522011-01-06 19:30:25 +08003788 struct btrfs_ordered_extent *ordered;
liuboacce9522011-01-06 19:30:25 +08003789
Miao Xie199c2a92013-05-15 07:48:23 +00003790 spin_lock(&root->ordered_extent_lock);
Josef Bacik779880e2013-01-31 14:30:08 -05003791 /*
3792 * This will just short circuit the ordered completion stuff which will
3793 * make sure the ordered extent gets properly cleaned up.
3794 */
Miao Xie199c2a92013-05-15 07:48:23 +00003795 list_for_each_entry(ordered, &root->ordered_extents,
Josef Bacik779880e2013-01-31 14:30:08 -05003796 root_extent_list)
3797 set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
Miao Xie199c2a92013-05-15 07:48:23 +00003798 spin_unlock(&root->ordered_extent_lock);
3799}
3800
3801static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
3802{
3803 struct btrfs_root *root;
3804 struct list_head splice;
3805
3806 INIT_LIST_HEAD(&splice);
3807
3808 spin_lock(&fs_info->ordered_root_lock);
3809 list_splice_init(&fs_info->ordered_roots, &splice);
3810 while (!list_empty(&splice)) {
3811 root = list_first_entry(&splice, struct btrfs_root,
3812 ordered_root);
Josef Bacik1de2cfd2013-09-27 16:36:02 -04003813 list_move_tail(&root->ordered_root,
3814 &fs_info->ordered_roots);
Miao Xie199c2a92013-05-15 07:48:23 +00003815
3816 btrfs_destroy_ordered_extents(root);
3817
3818 cond_resched_lock(&fs_info->ordered_root_lock);
3819 }
3820 spin_unlock(&fs_info->ordered_root_lock);
liuboacce9522011-01-06 19:30:25 +08003821}
3822
Stefan Behrens35a36212013-08-14 18:12:25 +02003823static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
3824 struct btrfs_root *root)
liuboacce9522011-01-06 19:30:25 +08003825{
3826 struct rb_node *node;
3827 struct btrfs_delayed_ref_root *delayed_refs;
3828 struct btrfs_delayed_ref_node *ref;
3829 int ret = 0;
3830
3831 delayed_refs = &trans->delayed_refs;
3832
3833 spin_lock(&delayed_refs->lock);
3834 if (delayed_refs->num_entries == 0) {
David Sterbacfece4d2011-04-25 19:43:52 -04003835 spin_unlock(&delayed_refs->lock);
liuboacce9522011-01-06 19:30:25 +08003836 printk(KERN_INFO "delayed_refs has NO entry\n");
3837 return ret;
3838 }
3839
Josef Bacikb939d1a2012-05-31 11:06:33 -04003840 while ((node = rb_first(&delayed_refs->root)) != NULL) {
Josef Bacikeb12db62013-01-30 16:03:59 -05003841 struct btrfs_delayed_ref_head *head = NULL;
Josef Bacike78417d2013-06-03 16:42:36 -04003842 bool pin_bytes = false;
liuboacce9522011-01-06 19:30:25 +08003843
Josef Bacikeb12db62013-01-30 16:03:59 -05003844 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
liuboacce9522011-01-06 19:30:25 +08003845 atomic_set(&ref->refs, 1);
3846 if (btrfs_delayed_ref_is_head(ref)) {
liuboacce9522011-01-06 19:30:25 +08003847
3848 head = btrfs_delayed_node_to_head(ref);
Josef Bacikb939d1a2012-05-31 11:06:33 -04003849 if (!mutex_trylock(&head->mutex)) {
3850 atomic_inc(&ref->refs);
3851 spin_unlock(&delayed_refs->lock);
3852
3853 /* Need to wait for the delayed ref to run */
3854 mutex_lock(&head->mutex);
3855 mutex_unlock(&head->mutex);
3856 btrfs_put_delayed_ref(ref);
3857
Josef Bacike18fca72012-06-18 07:23:18 -06003858 spin_lock(&delayed_refs->lock);
Josef Bacikb939d1a2012-05-31 11:06:33 -04003859 continue;
3860 }
3861
Josef Bacik54067ae2013-04-25 13:44:38 -04003862 if (head->must_insert_reserved)
Josef Bacike78417d2013-06-03 16:42:36 -04003863 pin_bytes = true;
Miao Xie78a61842012-11-21 02:21:28 +00003864 btrfs_free_delayed_extent_op(head->extent_op);
liuboacce9522011-01-06 19:30:25 +08003865 delayed_refs->num_heads--;
3866 if (list_empty(&head->cluster))
3867 delayed_refs->num_heads_ready--;
3868 list_del_init(&head->cluster);
liuboacce9522011-01-06 19:30:25 +08003869 }
Josef Bacikeb12db62013-01-30 16:03:59 -05003870
Josef Bacikb939d1a2012-05-31 11:06:33 -04003871 ref->in_tree = 0;
3872 rb_erase(&ref->rb_node, &delayed_refs->root);
3873 delayed_refs->num_entries--;
liuboacce9522011-01-06 19:30:25 +08003874 spin_unlock(&delayed_refs->lock);
Josef Bacike78417d2013-06-03 16:42:36 -04003875 if (head) {
3876 if (pin_bytes)
3877 btrfs_pin_extent(root, ref->bytenr,
3878 ref->num_bytes, 1);
3879 mutex_unlock(&head->mutex);
3880 }
liuboacce9522011-01-06 19:30:25 +08003881 btrfs_put_delayed_ref(ref);
3882
3883 cond_resched();
3884 spin_lock(&delayed_refs->lock);
3885 }
3886
3887 spin_unlock(&delayed_refs->lock);
3888
3889 return ret;
3890}
3891
Jeff Mahoney143bede2012-03-01 14:56:26 +01003892static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
liuboacce9522011-01-06 19:30:25 +08003893{
3894 struct btrfs_inode *btrfs_inode;
3895 struct list_head splice;
3896
3897 INIT_LIST_HEAD(&splice);
3898
Miao Xieeb73c1b2013-05-15 07:48:22 +00003899 spin_lock(&root->delalloc_lock);
3900 list_splice_init(&root->delalloc_inodes, &splice);
liuboacce9522011-01-06 19:30:25 +08003901
3902 while (!list_empty(&splice)) {
Miao Xieeb73c1b2013-05-15 07:48:22 +00003903 btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
3904 delalloc_inodes);
liuboacce9522011-01-06 19:30:25 +08003905
3906 list_del_init(&btrfs_inode->delalloc_inodes);
Miao Xiedf0af1a2013-01-29 10:11:59 +00003907 clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
3908 &btrfs_inode->runtime_flags);
Miao Xieeb73c1b2013-05-15 07:48:22 +00003909 spin_unlock(&root->delalloc_lock);
liuboacce9522011-01-06 19:30:25 +08003910
3911 btrfs_invalidate_inodes(btrfs_inode->root);
Miao Xieb216cbf2013-05-15 07:48:21 +00003912
Miao Xieeb73c1b2013-05-15 07:48:22 +00003913 spin_lock(&root->delalloc_lock);
liuboacce9522011-01-06 19:30:25 +08003914 }
3915
Miao Xieeb73c1b2013-05-15 07:48:22 +00003916 spin_unlock(&root->delalloc_lock);
3917}
3918
3919static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
3920{
3921 struct btrfs_root *root;
3922 struct list_head splice;
3923
3924 INIT_LIST_HEAD(&splice);
3925
3926 spin_lock(&fs_info->delalloc_root_lock);
3927 list_splice_init(&fs_info->delalloc_roots, &splice);
3928 while (!list_empty(&splice)) {
3929 root = list_first_entry(&splice, struct btrfs_root,
3930 delalloc_root);
3931 list_del_init(&root->delalloc_root);
3932 root = btrfs_grab_fs_root(root);
3933 BUG_ON(!root);
3934 spin_unlock(&fs_info->delalloc_root_lock);
3935
3936 btrfs_destroy_delalloc_inodes(root);
3937 btrfs_put_fs_root(root);
3938
3939 spin_lock(&fs_info->delalloc_root_lock);
3940 }
3941 spin_unlock(&fs_info->delalloc_root_lock);
liuboacce9522011-01-06 19:30:25 +08003942}
3943
3944static int btrfs_destroy_marked_extents(struct btrfs_root *root,
3945 struct extent_io_tree *dirty_pages,
3946 int mark)
3947{
3948 int ret;
liuboacce9522011-01-06 19:30:25 +08003949 struct extent_buffer *eb;
3950 u64 start = 0;
3951 u64 end;
liuboacce9522011-01-06 19:30:25 +08003952
3953 while (1) {
3954 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
Josef Bacike6138872012-09-27 17:07:30 -04003955 mark, NULL);
liuboacce9522011-01-06 19:30:25 +08003956 if (ret)
3957 break;
3958
3959 clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
3960 while (start <= end) {
Josef Bacikfd8b2b62013-04-24 16:41:19 -04003961 eb = btrfs_find_tree_block(root, start,
3962 root->leafsize);
Josef Bacik69a85bd2013-05-08 13:30:11 -04003963 start += root->leafsize;
Josef Bacikfd8b2b62013-04-24 16:41:19 -04003964 if (!eb)
liuboacce9522011-01-06 19:30:25 +08003965 continue;
Josef Bacikfd8b2b62013-04-24 16:41:19 -04003966 wait_on_extent_buffer_writeback(eb);
liuboacce9522011-01-06 19:30:25 +08003967
Josef Bacikfd8b2b62013-04-24 16:41:19 -04003968 if (test_and_clear_bit(EXTENT_BUFFER_DIRTY,
3969 &eb->bflags))
3970 clear_extent_buffer_dirty(eb);
3971 free_extent_buffer_stale(eb);
liuboacce9522011-01-06 19:30:25 +08003972 }
3973 }
3974
3975 return ret;
3976}
3977
3978static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
3979 struct extent_io_tree *pinned_extents)
3980{
3981 struct extent_io_tree *unpin;
3982 u64 start;
3983 u64 end;
3984 int ret;
Liu Boed0eaa12012-06-14 02:23:21 -06003985 bool loop = true;
liuboacce9522011-01-06 19:30:25 +08003986
3987 unpin = pinned_extents;
Liu Boed0eaa12012-06-14 02:23:21 -06003988again:
liuboacce9522011-01-06 19:30:25 +08003989 while (1) {
3990 ret = find_first_extent_bit(unpin, 0, &start, &end,
Josef Bacike6138872012-09-27 17:07:30 -04003991 EXTENT_DIRTY, NULL);
liuboacce9522011-01-06 19:30:25 +08003992 if (ret)
3993 break;
3994
3995 /* opt_discard */
Li Dongyang5378e602011-03-24 10:24:27 +00003996 if (btrfs_test_opt(root, DISCARD))
3997 ret = btrfs_error_discard_extent(root, start,
3998 end + 1 - start,
3999 NULL);
liuboacce9522011-01-06 19:30:25 +08004000
4001 clear_extent_dirty(unpin, start, end, GFP_NOFS);
4002 btrfs_error_unpin_extent_range(root, start, end);
4003 cond_resched();
4004 }
4005
Liu Boed0eaa12012-06-14 02:23:21 -06004006 if (loop) {
4007 if (unpin == &root->fs_info->freed_extents[0])
4008 unpin = &root->fs_info->freed_extents[1];
4009 else
4010 unpin = &root->fs_info->freed_extents[0];
4011 loop = false;
4012 goto again;
4013 }
4014
liuboacce9522011-01-06 19:30:25 +08004015 return 0;
4016}
4017
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004018void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
4019 struct btrfs_root *root)
4020{
Josef Bacik724e2312013-09-30 11:36:38 -04004021 btrfs_destroy_ordered_operations(cur_trans, root);
4022
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004023 btrfs_destroy_delayed_refs(cur_trans, root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004024
Miao Xie4a9d8bd2013-05-17 03:53:43 +00004025 cur_trans->state = TRANS_STATE_COMMIT_START;
Josef Bacikd7096fc2012-05-31 15:49:57 -04004026 wake_up(&root->fs_info->transaction_blocked_wait);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004027
Miao Xie4a9d8bd2013-05-17 03:53:43 +00004028 cur_trans->state = TRANS_STATE_UNBLOCKED;
Josef Bacikd7096fc2012-05-31 15:49:57 -04004029 wake_up(&root->fs_info->transaction_wait);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004030
Miao Xie67cde342012-06-14 02:23:22 -06004031 btrfs_destroy_delayed_inodes(root);
4032 btrfs_assert_delayed_root_empty(root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004033
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004034 btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
4035 EXTENT_DIRTY);
Liu Bo6e841e32012-06-14 02:23:20 -06004036 btrfs_destroy_pinned_extent(root,
4037 root->fs_info->pinned_extents);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004038
Miao Xie4a9d8bd2013-05-17 03:53:43 +00004039 cur_trans->state =TRANS_STATE_COMPLETED;
4040 wake_up(&cur_trans->commit_wait);
4041
Jeff Mahoney49b25e02012-03-01 17:24:58 +01004042 /*
4043 memset(cur_trans, 0, sizeof(*cur_trans));
4044 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
4045 */
4046}
4047
Eric Sandeen48a3b632013-04-25 20:41:01 +00004048static int btrfs_cleanup_transaction(struct btrfs_root *root)
liuboacce9522011-01-06 19:30:25 +08004049{
4050 struct btrfs_transaction *t;
liuboacce9522011-01-06 19:30:25 +08004051
liuboacce9522011-01-06 19:30:25 +08004052 mutex_lock(&root->fs_info->transaction_kthread_mutex);
4053
Josef Bacika4abeea2011-04-11 17:25:13 -04004054 spin_lock(&root->fs_info->trans_lock);
Josef Bacik724e2312013-09-30 11:36:38 -04004055 while (!list_empty(&root->fs_info->trans_list)) {
4056 t = list_first_entry(&root->fs_info->trans_list,
4057 struct btrfs_transaction, list);
4058 if (t->state >= TRANS_STATE_COMMIT_START) {
4059 atomic_inc(&t->use_count);
4060 spin_unlock(&root->fs_info->trans_lock);
4061 btrfs_wait_for_commit(root, t->transid);
4062 btrfs_put_transaction(t);
4063 spin_lock(&root->fs_info->trans_lock);
4064 continue;
4065 }
4066 if (t == root->fs_info->running_transaction) {
4067 t->state = TRANS_STATE_COMMIT_DOING;
4068 spin_unlock(&root->fs_info->trans_lock);
4069 /*
4070 * We wait for 0 num_writers since we don't hold a trans
4071 * handle open currently for this transaction.
4072 */
4073 wait_event(t->writer_wait,
4074 atomic_read(&t->num_writers) == 0);
4075 } else {
4076 spin_unlock(&root->fs_info->trans_lock);
4077 }
4078 btrfs_cleanup_one_transaction(t, root);
Josef Bacika4abeea2011-04-11 17:25:13 -04004079
Josef Bacik724e2312013-09-30 11:36:38 -04004080 spin_lock(&root->fs_info->trans_lock);
4081 if (t == root->fs_info->running_transaction)
4082 root->fs_info->running_transaction = NULL;
liuboacce9522011-01-06 19:30:25 +08004083 list_del_init(&t->list);
Josef Bacik724e2312013-09-30 11:36:38 -04004084 spin_unlock(&root->fs_info->trans_lock);
liuboacce9522011-01-06 19:30:25 +08004085
Josef Bacik724e2312013-09-30 11:36:38 -04004086 btrfs_put_transaction(t);
4087 trace_btrfs_transaction_commit(root);
4088 spin_lock(&root->fs_info->trans_lock);
4089 }
4090 spin_unlock(&root->fs_info->trans_lock);
4091 btrfs_destroy_all_ordered_extents(root->fs_info);
4092 btrfs_destroy_delayed_inodes(root);
4093 btrfs_assert_delayed_root_empty(root);
4094 btrfs_destroy_pinned_extent(root, root->fs_info->pinned_extents);
4095 btrfs_destroy_all_delalloc_inodes(root->fs_info);
liuboacce9522011-01-06 19:30:25 +08004096 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
liuboacce9522011-01-06 19:30:25 +08004097
4098 return 0;
4099}
4100
Chris Masond1310b22008-01-24 16:13:08 -05004101static struct extent_io_ops btree_extent_io_ops = {
Chris Masonce9adaa2008-04-09 16:28:12 -04004102 .readpage_end_io_hook = btree_readpage_end_io_hook,
Arne Jansen4bb31e92011-06-10 13:55:54 +02004103 .readpage_io_failed_hook = btree_io_failed_hook,
Chris Mason0b86a832008-03-24 15:01:56 -04004104 .submit_bio_hook = btree_submit_bio_hook,
Chris Mason239b14b2008-03-24 15:02:07 -04004105 /* note we're sharing with inode.c for the merge bio hook */
4106 .merge_bio_hook = btrfs_merge_bio_hook,
Chris Mason0da54682007-11-07 21:08:01 -05004107};