blob: d71a11d13dfaa8b3065222c87ce964d8ba28e5b5 [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
Yan4b82d6e2007-08-29 09:11:44 -040019#include <linux/blkdev.h>
Chris Mason2e635a22007-03-21 11:12:56 -040020#include <linux/module.h>
Chris Masone20d96d2007-03-22 12:13:20 -040021#include <linux/buffer_head.h>
Chris Mason2e635a22007-03-21 11:12:56 -040022#include <linux/fs.h>
23#include <linux/pagemap.h>
24#include <linux/highmem.h>
25#include <linux/time.h>
26#include <linux/init.h>
Eric Parisa9572a12009-04-02 16:46:06 -040027#include <linux/seq_file.h>
Chris Mason2e635a22007-03-21 11:12:56 -040028#include <linux/string.h>
Chris Mason2e635a22007-03-21 11:12:56 -040029#include <linux/backing-dev.h>
Yan4b82d6e2007-08-29 09:11:44 -040030#include <linux/mount.h>
Chris Masondee26a92007-03-26 16:00:06 -040031#include <linux/mpage.h>
Chris Mason75dfe392007-03-29 11:56:46 -040032#include <linux/swap.h>
33#include <linux/writeback.h>
Chris Mason8fd17792007-04-19 21:01:03 -040034#include <linux/statfs.h>
Chris Mason08607c12007-06-08 15:33:54 -040035#include <linux/compat.h>
Chris Mason95e05282007-08-29 09:11:44 -040036#include <linux/parser.h>
Chris Masonc59f8952007-12-17 20:14:04 -050037#include <linux/ctype.h>
Chris Mason6da6aba2007-12-18 16:15:09 -050038#include <linux/namei.h>
Chris Masona9218f62008-03-24 15:02:04 -040039#include <linux/miscdevice.h>
Qinghuang Feng1bcbf312009-01-15 13:51:03 -080040#include <linux/magic.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Dan Magenheimer90a887c2011-05-26 10:01:56 -060042#include <linux/cleancache.h>
Josef Bacik22c44fe2011-11-30 10:45:38 -050043#include <linux/ratelimit.h>
Filipe Brandenburger55e301f2013-01-29 06:04:50 +000044#include <linux/btrfs.h>
Miao Xie16cdcec2011-04-22 18:12:22 +080045#include "delayed-inode.h"
Chris Mason2e635a22007-03-21 11:12:56 -040046#include "ctree.h"
Chris Masone20d96d2007-03-22 12:13:20 -040047#include "disk-io.h"
Chris Masond5719762007-03-23 10:01:08 -040048#include "transaction.h"
Chris Mason2c90e5d2007-04-02 10:50:19 -040049#include "btrfs_inode.h"
Chris Mason3a686372007-05-24 13:35:57 -040050#include "print-tree.h"
Josef Bacik5103e942007-11-16 11:45:54 -050051#include "xattr.h"
Chris Mason8a4b83c2008-03-24 15:02:07 -040052#include "volumes.h"
Balaji Raobe6e8dc2008-07-21 02:01:56 +053053#include "export.h"
Chris Masonc8b97812008-10-29 14:49:59 -040054#include "compression.h"
Josef Bacik9c5085c2012-06-05 14:13:12 -040055#include "rcu-string.h"
Stefan Behrens8dabb742012-11-06 13:15:27 +010056#include "dev-replace.h"
Josef Bacik74255aa2013-03-15 09:47:08 -040057#include "free-space-cache.h"
Wang Shilongb9e9a6c2013-08-09 13:25:36 +080058#include "backref.h"
Josef Bacikdc11dd5d2013-08-14 15:05:12 -040059#include "tests/btrfs-tests.h"
Chris Mason2e635a22007-03-21 11:12:56 -040060
liubo1abe9b82011-03-24 11:18:59 +000061#define CREATE_TRACE_POINTS
62#include <trace/events/btrfs.h>
63
Alexey Dobriyanb87221d2009-09-21 17:01:09 -070064static const struct super_operations btrfs_super_ops;
Josef Bacik830c4ad2011-07-25 15:55:42 -040065static struct file_system_type btrfs_fs_type;
Chris Masone20d96d2007-03-22 12:13:20 -040066
David Sterba08748812013-03-12 14:46:08 +000067static const char *btrfs_decode_error(int errno)
liuboacce9522011-01-06 19:30:25 +080068{
David Sterba08748812013-03-12 14:46:08 +000069 char *errstr = "unknown";
liuboacce9522011-01-06 19:30:25 +080070
71 switch (errno) {
72 case -EIO:
73 errstr = "IO failure";
74 break;
75 case -ENOMEM:
76 errstr = "Out of memory";
77 break;
78 case -EROFS:
79 errstr = "Readonly filesystem";
80 break;
Jeff Mahoney8c342932011-10-03 23:22:31 -040081 case -EEXIST:
82 errstr = "Object already exists";
83 break;
David Sterba94ef7282013-03-20 14:29:47 +000084 case -ENOSPC:
85 errstr = "No space left";
86 break;
87 case -ENOENT:
88 errstr = "No such entry";
89 break;
liuboacce9522011-01-06 19:30:25 +080090 }
91
92 return errstr;
93}
94
David Sterbabbece8a2013-03-11 17:07:45 +000095static void save_error_info(struct btrfs_fs_info *fs_info)
liuboacce9522011-01-06 19:30:25 +080096{
97 /*
98 * today we only save the error info into ram. Long term we'll
99 * also send it down to the disk
100 */
Miao Xie87533c42013-01-29 10:14:48 +0000101 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
liuboacce9522011-01-06 19:30:25 +0800102}
103
liuboacce9522011-01-06 19:30:25 +0800104/* btrfs handle error by forcing the filesystem readonly */
105static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
106{
107 struct super_block *sb = fs_info->sb;
108
109 if (sb->s_flags & MS_RDONLY)
110 return;
111
Miao Xie87533c42013-01-29 10:14:48 +0000112 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
liuboacce9522011-01-06 19:30:25 +0800113 sb->s_flags |= MS_RDONLY;
Simon Kirbyc2cf52e2013-03-19 22:41:23 +0000114 btrfs_info(fs_info, "forced readonly");
Stefan Behrens1acd6832012-11-05 17:11:06 +0100115 /*
116 * Note that a running device replace operation is not
117 * canceled here although there is no way to update
118 * the progress. It would add the risk of a deadlock,
119 * therefore the canceling is ommited. The only penalty
120 * is that some I/O remains active until the procedure
121 * completes. The next time when the filesystem is
122 * mounted writeable again, the device replace
123 * operation continues.
124 */
liuboacce9522011-01-06 19:30:25 +0800125 }
126}
127
Joe Perches533574c2012-07-30 14:40:13 -0700128#ifdef CONFIG_PRINTK
liuboacce9522011-01-06 19:30:25 +0800129/*
130 * __btrfs_std_error decodes expected errors from the caller and
131 * invokes the approciate error response.
132 */
133void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
Jeff Mahoney4da35112012-03-01 14:57:30 +0100134 unsigned int line, int errno, const char *fmt, ...)
liuboacce9522011-01-06 19:30:25 +0800135{
136 struct super_block *sb = fs_info->sb;
liuboacce9522011-01-06 19:30:25 +0800137 const char *errstr;
138
139 /*
140 * Special case: if the error is EROFS, and we're already
141 * under MS_RDONLY, then it is safe here.
142 */
143 if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
Jeff Mahoney4da35112012-03-01 14:57:30 +0100144 return;
liuboacce9522011-01-06 19:30:25 +0800145
David Sterba08748812013-03-12 14:46:08 +0000146 errstr = btrfs_decode_error(errno);
Jeff Mahoney4da35112012-03-01 14:57:30 +0100147 if (fmt) {
Eric Sandeen37252a62013-01-31 00:54:58 +0000148 struct va_format vaf;
149 va_list args;
150
151 va_start(args, fmt);
152 vaf.fmt = fmt;
153 vaf.va = &args;
liuboacce9522011-01-06 19:30:25 +0800154
David Sterba08748812013-03-12 14:46:08 +0000155 printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: errno=%d %s (%pV)\n",
156 sb->s_id, function, line, errno, errstr, &vaf);
Eric Sandeen37252a62013-01-31 00:54:58 +0000157 va_end(args);
Jeff Mahoney4da35112012-03-01 14:57:30 +0100158 } else {
David Sterba08748812013-03-12 14:46:08 +0000159 printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: errno=%d %s\n",
160 sb->s_id, function, line, errno, errstr);
Jeff Mahoney4da35112012-03-01 14:57:30 +0100161 }
162
163 /* Don't go through full error handling during mount */
Josef Bacikcf79ffb2013-04-01 11:23:58 -0400164 save_error_info(fs_info);
165 if (sb->s_flags & MS_BORN)
Jeff Mahoney4da35112012-03-01 14:57:30 +0100166 btrfs_handle_error(fs_info);
Jeff Mahoney4da35112012-03-01 14:57:30 +0100167}
168
Joe Perches533574c2012-07-30 14:40:13 -0700169static const char * const logtypes[] = {
Jeff Mahoney4da35112012-03-01 14:57:30 +0100170 "emergency",
171 "alert",
172 "critical",
173 "error",
174 "warning",
175 "notice",
176 "info",
177 "debug",
178};
179
Simon Kirbyc2cf52e2013-03-19 22:41:23 +0000180void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
Jeff Mahoney4da35112012-03-01 14:57:30 +0100181{
182 struct super_block *sb = fs_info->sb;
183 char lvl[4];
184 struct va_format vaf;
185 va_list args;
186 const char *type = logtypes[4];
Joe Perches533574c2012-07-30 14:40:13 -0700187 int kern_level;
Jeff Mahoney4da35112012-03-01 14:57:30 +0100188
189 va_start(args, fmt);
190
Joe Perches533574c2012-07-30 14:40:13 -0700191 kern_level = printk_get_level(fmt);
192 if (kern_level) {
193 size_t size = printk_skip_level(fmt) - fmt;
194 memcpy(lvl, fmt, size);
195 lvl[size] = '\0';
196 fmt += size;
197 type = logtypes[kern_level - '0'];
Jeff Mahoney4da35112012-03-01 14:57:30 +0100198 } else
199 *lvl = '\0';
200
201 vaf.fmt = fmt;
202 vaf.va = &args;
Joe Perches533574c2012-07-30 14:40:13 -0700203
Simon Kirbyc2cf52e2013-03-19 22:41:23 +0000204 printk("%sBTRFS %s (device %s): %pV\n", lvl, type, sb->s_id, &vaf);
Joe Perches533574c2012-07-30 14:40:13 -0700205
206 va_end(args);
liuboacce9522011-01-06 19:30:25 +0800207}
208
Joe Perches533574c2012-07-30 14:40:13 -0700209#else
210
211void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
212 unsigned int line, int errno, const char *fmt, ...)
213{
214 struct super_block *sb = fs_info->sb;
215
216 /*
217 * Special case: if the error is EROFS, and we're already
218 * under MS_RDONLY, then it is safe here.
219 */
220 if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
221 return;
222
223 /* Don't go through full error handling during mount */
224 if (sb->s_flags & MS_BORN) {
225 save_error_info(fs_info);
226 btrfs_handle_error(fs_info);
227 }
228}
229#endif
230
Jeff Mahoney8c342932011-10-03 23:22:31 -0400231/*
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100232 * We only mark the transaction aborted and then set the file system read-only.
233 * This will prevent new transactions from starting or trying to join this
234 * one.
235 *
236 * This means that error recovery at the call site is limited to freeing
237 * any local memory allocations and passing the error code up without
238 * further cleanup. The transaction should complete as it normally would
239 * in the call path but will return -EIO.
240 *
241 * We'll complete the cleanup in btrfs_end_transaction and
242 * btrfs_commit_transaction.
243 */
244void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
245 struct btrfs_root *root, const char *function,
246 unsigned int line, int errno)
247{
David Sterba08748812013-03-12 14:46:08 +0000248 /*
249 * Report first abort since mount
250 */
251 if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,
252 &root->fs_info->fs_state)) {
253 WARN(1, KERN_DEBUG "btrfs: Transaction aborted (error %d)\n",
254 errno);
255 }
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100256 trans->aborted = errno;
257 /* Nothing used. The other threads that have joined this
258 * transaction may be able to continue. */
259 if (!trans->blocks_used) {
Miao Xie69ce9772012-09-06 04:04:44 -0600260 const char *errstr;
261
David Sterba08748812013-03-12 14:46:08 +0000262 errstr = btrfs_decode_error(errno);
Simon Kirbyc2cf52e2013-03-19 22:41:23 +0000263 btrfs_warn(root->fs_info,
264 "%s:%d: Aborting unused transaction(%s).",
265 function, line, errstr);
Chris Masone20d96d2007-03-22 12:13:20 -0400266 return;
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100267 }
Miao Xie8d25a082013-01-15 06:27:25 +0000268 ACCESS_ONCE(trans->transaction->aborted) = errno;
Josef Bacik501407a2013-06-10 16:47:23 -0400269 /* Wake up anybody who may be waiting on this transaction */
270 wake_up(&root->fs_info->transaction_wait);
271 wake_up(&root->fs_info->transaction_blocked_wait);
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100272 __btrfs_std_error(root->fs_info, function, line, errno, NULL);
273}
274/*
Jeff Mahoney8c342932011-10-03 23:22:31 -0400275 * __btrfs_panic decodes unexpected, fatal errors from the caller,
276 * issues an alert, and either panics or BUGs, depending on mount options.
277 */
278void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
279 unsigned int line, int errno, const char *fmt, ...)
280{
Jeff Mahoney8c342932011-10-03 23:22:31 -0400281 char *s_id = "<unknown>";
282 const char *errstr;
283 struct va_format vaf = { .fmt = fmt };
284 va_list args;
285
286 if (fs_info)
287 s_id = fs_info->sb->s_id;
288
289 va_start(args, fmt);
290 vaf.va = &args;
Chris Masone20d96d2007-03-22 12:13:20 -0400291
David Sterba08748812013-03-12 14:46:08 +0000292 errstr = btrfs_decode_error(errno);
Eric Sandeenaa43a172013-01-31 00:54:55 +0000293 if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))
David Sterba08748812013-03-12 14:46:08 +0000294 panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
295 s_id, function, line, &vaf, errno, errstr);
Chris Masone20d96d2007-03-22 12:13:20 -0400296
David Sterba08748812013-03-12 14:46:08 +0000297 printk(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
298 s_id, function, line, &vaf, errno, errstr);
Jeff Mahoney8c342932011-10-03 23:22:31 -0400299 va_end(args);
300 /* Caller calls BUG() */
Chris Masone20d96d2007-03-22 12:13:20 -0400301}
302
Chris Masond3977122009-01-05 21:25:51 -0500303static void btrfs_put_super(struct super_block *sb)
Chris Masone20d96d2007-03-22 12:13:20 -0400304{
Al Viro815745c2011-11-17 15:40:49 -0500305 (void)close_ctree(btrfs_sb(sb)->tree_root);
Al Viroaea52e12011-11-17 01:22:46 -0500306 /* FIXME: need to fix VFS to return error? */
307 /* AV: return it _where_? ->put_super() can be triggered by any number
308 * of async events, up to and including delivery of SIGKILL to the
309 * last process that kept it busy. Or segfault in the aforementioned
310 * process... Whom would you report that to?
311 */
Chris Masone20d96d2007-03-22 12:13:20 -0400312}
Chris Mason2e635a22007-03-21 11:12:56 -0400313
Chris Mason95e05282007-08-29 09:11:44 -0400314enum {
Josef Bacik73f73412009-12-04 17:38:27 +0000315 Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
Josef Bacik287a0ab2010-03-19 18:07:23 +0000316 Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
317 Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
Li Zefan261507a02010-12-17 14:21:50 +0800318 Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
319 Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
Chris Mason91435652011-02-16 13:10:41 -0500320 Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
Ilya Dryomov9555c6c2012-01-16 22:04:48 +0200321 Opt_enospc_debug, Opt_subvolrootid, Opt_defrag, Opt_inode_cache,
322 Opt_no_space_cache, Opt_recovery, Opt_skip_balance,
Stefan Behrens21adbd52011-11-09 13:44:05 +0100323 Opt_check_integrity, Opt_check_integrity_including_extent_data,
Stefan Behrensf420ee12013-08-15 17:11:24 +0200324 Opt_check_integrity_print_mask, Opt_fatal_errors, Opt_rescan_uuid_tree,
David Sterba8b87dc12013-08-01 18:14:52 +0200325 Opt_commit_interval,
Ilya Dryomov9555c6c2012-01-16 22:04:48 +0200326 Opt_err,
Chris Mason95e05282007-08-29 09:11:44 -0400327};
328
329static match_table_t tokens = {
Chris Masondfe25022008-05-13 13:46:40 -0400330 {Opt_degraded, "degraded"},
Chris Mason95e05282007-08-29 09:11:44 -0400331 {Opt_subvol, "subvol=%s"},
Wang Shilong14933812013-07-24 10:29:20 +0800332 {Opt_subvolid, "subvolid=%s"},
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400333 {Opt_device, "device=%s"},
Chris Masonb6cda9b2007-12-14 15:30:32 -0500334 {Opt_nodatasum, "nodatasum"},
Chris Masonbe20aa92007-12-17 20:14:01 -0500335 {Opt_nodatacow, "nodatacow"},
Chris Mason21ad10c2008-01-09 09:23:21 -0500336 {Opt_nobarrier, "nobarrier"},
Chris Mason6f568d32008-01-29 16:03:38 -0500337 {Opt_max_inline, "max_inline=%s"},
Chris Mason8f662a72008-01-02 10:01:11 -0500338 {Opt_alloc_start, "alloc_start=%s"},
Chris Mason4543df72008-06-11 21:47:56 -0400339 {Opt_thread_pool, "thread_pool=%d"},
Chris Masonc8b97812008-10-29 14:49:59 -0400340 {Opt_compress, "compress"},
Li Zefan261507a02010-12-17 14:21:50 +0800341 {Opt_compress_type, "compress=%s"},
Chris Masona555f812010-01-28 16:18:15 -0500342 {Opt_compress_force, "compress-force"},
Li Zefan261507a02010-12-17 14:21:50 +0800343 {Opt_compress_force_type, "compress-force=%s"},
Chris Masone18e4802008-01-18 10:54:22 -0500344 {Opt_ssd, "ssd"},
Chris Mason451d7582009-06-09 20:28:34 -0400345 {Opt_ssd_spread, "ssd_spread"},
Chris Mason3b30c222009-06-09 16:42:22 -0400346 {Opt_nossd, "nossd"},
Josef Bacik33268ea2008-07-24 12:16:36 -0400347 {Opt_noacl, "noacl"},
Sage Weil3a5e1402009-04-02 16:49:40 -0400348 {Opt_notreelog, "notreelog"},
Sage Weildccae992009-04-02 16:59:01 -0400349 {Opt_flushoncommit, "flushoncommit"},
Josef Bacik97e728d2009-04-21 17:40:57 -0400350 {Opt_ratio, "metadata_ratio=%d"},
Christoph Hellwige244a0a2009-10-14 09:24:59 -0400351 {Opt_discard, "discard"},
Josef Bacik0af3d002010-06-21 14:48:16 -0400352 {Opt_space_cache, "space_cache"},
Josef Bacik88c2ba32010-09-21 14:21:34 -0400353 {Opt_clear_cache, "clear_cache"},
Sage Weil4260f7c2010-10-29 15:46:43 -0400354 {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
Chris Mason91435652011-02-16 13:10:41 -0500355 {Opt_enospc_debug, "enospc_debug"},
Xin Zhonge15d0542011-04-06 07:33:51 +0000356 {Opt_subvolrootid, "subvolrootid=%d"},
Chris Mason4cb53002011-05-24 15:35:30 -0400357 {Opt_defrag, "autodefrag"},
Chris Mason4b9465c2011-06-03 09:36:29 -0400358 {Opt_inode_cache, "inode_cache"},
David Sterba89655932011-11-11 10:14:57 -0500359 {Opt_no_space_cache, "nospace_cache"},
Chris Masonaf31f5e2011-11-03 15:17:42 -0400360 {Opt_recovery, "recovery"},
Ilya Dryomov9555c6c2012-01-16 22:04:48 +0200361 {Opt_skip_balance, "skip_balance"},
Stefan Behrens21adbd52011-11-09 13:44:05 +0100362 {Opt_check_integrity, "check_int"},
363 {Opt_check_integrity_including_extent_data, "check_int_data"},
364 {Opt_check_integrity_print_mask, "check_int_print_mask=%d"},
Stefan Behrensf420ee12013-08-15 17:11:24 +0200365 {Opt_rescan_uuid_tree, "rescan_uuid_tree"},
Jeff Mahoney8c342932011-10-03 23:22:31 -0400366 {Opt_fatal_errors, "fatal_errors=%s"},
David Sterba8b87dc12013-08-01 18:14:52 +0200367 {Opt_commit_interval, "commit=%d"},
Josef Bacik33268ea2008-07-24 12:16:36 -0400368 {Opt_err, NULL},
Chris Mason95e05282007-08-29 09:11:44 -0400369};
370
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400371/*
372 * Regular mount options parser. Everything that is needed only when
373 * reading in a new superblock is parsed here.
Jeff Mahoney49b25e02012-03-01 17:24:58 +0100374 * XXX JDM: This needs to be cleaned up for remount.
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400375 */
376int btrfs_parse_options(struct btrfs_root *root, char *options)
Chris Mason95e05282007-08-29 09:11:44 -0400377{
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400378 struct btrfs_fs_info *info = root->fs_info;
Chris Mason95e05282007-08-29 09:11:44 -0400379 substring_t args[MAX_OPT_ARGS];
Josef Bacik73bc1872011-10-03 14:07:49 -0400380 char *p, *num, *orig = NULL;
381 u64 cache_gen;
Chris Mason4543df72008-06-11 21:47:56 -0400382 int intarg;
Sage Weila7a3f7c2009-11-07 06:19:16 +0000383 int ret = 0;
Li Zefan261507a02010-12-17 14:21:50 +0800384 char *compress_type;
385 bool compress_force = false;
Chris Masonb6cda9b2007-12-14 15:30:32 -0500386
David Sterba6c417612011-04-13 15:41:04 +0200387 cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
Josef Bacik73bc1872011-10-03 14:07:49 -0400388 if (cache_gen)
389 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
390
Chris Mason95e05282007-08-29 09:11:44 -0400391 if (!options)
Josef Bacik73bc1872011-10-03 14:07:49 -0400392 goto out;
Chris Mason95e05282007-08-29 09:11:44 -0400393
Chris Masonbe20aa92007-12-17 20:14:01 -0500394 /*
395 * strsep changes the string, duplicate it because parse_options
396 * gets called twice
397 */
398 options = kstrdup(options, GFP_NOFS);
399 if (!options)
400 return -ENOMEM;
401
Josef Bacikda495ec2010-02-25 20:38:35 +0000402 orig = options;
Chris Masonbe20aa92007-12-17 20:14:01 -0500403
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400404 while ((p = strsep(&options, ",")) != NULL) {
Chris Mason95e05282007-08-29 09:11:44 -0400405 int token;
406 if (!*p)
407 continue;
408
409 token = match_token(p, tokens, args);
410 switch (token) {
Chris Masondfe25022008-05-13 13:46:40 -0400411 case Opt_degraded:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400412 printk(KERN_INFO "btrfs: allowing degraded mounts\n");
413 btrfs_set_opt(info->mount_opt, DEGRADED);
Chris Masondfe25022008-05-13 13:46:40 -0400414 break;
Chris Mason95e05282007-08-29 09:11:44 -0400415 case Opt_subvol:
Josef Bacik73f73412009-12-04 17:38:27 +0000416 case Opt_subvolid:
Xin Zhonge15d0542011-04-06 07:33:51 +0000417 case Opt_subvolrootid:
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400418 case Opt_device:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400419 /*
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400420 * These are parsed by btrfs_parse_early_options
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400421 * and can be happily ignored here.
422 */
Chris Masonb6cda9b2007-12-14 15:30:32 -0500423 break;
424 case Opt_nodatasum:
Chris Mason067c28a2009-06-11 09:30:13 -0400425 printk(KERN_INFO "btrfs: setting nodatasum\n");
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400426 btrfs_set_opt(info->mount_opt, NODATASUM);
Chris Masonbe20aa92007-12-17 20:14:01 -0500427 break;
428 case Opt_nodatacow:
Andrei Popabedb2cc2012-09-20 08:42:11 -0600429 if (!btrfs_test_opt(root, COMPRESS) ||
430 !btrfs_test_opt(root, FORCE_COMPRESS)) {
431 printk(KERN_INFO "btrfs: setting nodatacow, compression disabled\n");
432 } else {
433 printk(KERN_INFO "btrfs: setting nodatacow\n");
434 }
Andrei Popabedb2cc2012-09-20 08:42:11 -0600435 btrfs_clear_opt(info->mount_opt, COMPRESS);
436 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400437 btrfs_set_opt(info->mount_opt, NODATACOW);
438 btrfs_set_opt(info->mount_opt, NODATASUM);
Chris Mason95e05282007-08-29 09:11:44 -0400439 break;
Chris Masona555f812010-01-28 16:18:15 -0500440 case Opt_compress_force:
Li Zefan261507a02010-12-17 14:21:50 +0800441 case Opt_compress_force_type:
442 compress_force = true;
Eric Sandeen1c697d42013-01-31 00:54:56 +0000443 /* Fallthrough */
Li Zefan261507a02010-12-17 14:21:50 +0800444 case Opt_compress:
445 case Opt_compress_type:
446 if (token == Opt_compress ||
447 token == Opt_compress_force ||
448 strcmp(args[0].from, "zlib") == 0) {
449 compress_type = "zlib";
450 info->compress_type = BTRFS_COMPRESS_ZLIB;
Arnd Hannemann063849e2012-04-16 15:27:51 +0200451 btrfs_set_opt(info->mount_opt, COMPRESS);
Andrei Popabedb2cc2012-09-20 08:42:11 -0600452 btrfs_clear_opt(info->mount_opt, NODATACOW);
453 btrfs_clear_opt(info->mount_opt, NODATASUM);
Li Zefana6fa6fa2010-10-25 15:12:26 +0800454 } else if (strcmp(args[0].from, "lzo") == 0) {
455 compress_type = "lzo";
456 info->compress_type = BTRFS_COMPRESS_LZO;
Arnd Hannemann063849e2012-04-16 15:27:51 +0200457 btrfs_set_opt(info->mount_opt, COMPRESS);
Andrei Popabedb2cc2012-09-20 08:42:11 -0600458 btrfs_clear_opt(info->mount_opt, NODATACOW);
459 btrfs_clear_opt(info->mount_opt, NODATASUM);
Mitch Harder2b0ce2c2012-07-24 11:58:43 -0600460 btrfs_set_fs_incompat(info, COMPRESS_LZO);
Arnd Hannemann063849e2012-04-16 15:27:51 +0200461 } else if (strncmp(args[0].from, "no", 2) == 0) {
462 compress_type = "no";
Arnd Hannemann063849e2012-04-16 15:27:51 +0200463 btrfs_clear_opt(info->mount_opt, COMPRESS);
464 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
465 compress_force = false;
Li Zefan261507a02010-12-17 14:21:50 +0800466 } else {
467 ret = -EINVAL;
468 goto out;
469 }
470
Li Zefan261507a02010-12-17 14:21:50 +0800471 if (compress_force) {
472 btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
473 pr_info("btrfs: force %s compression\n",
474 compress_type);
Miao Xiea7e252a2013-11-22 18:47:59 +0800475 } else if (btrfs_test_opt(root, COMPRESS)) {
Li Zefan261507a02010-12-17 14:21:50 +0800476 pr_info("btrfs: use %s compression\n",
477 compress_type);
Miao Xiea7e252a2013-11-22 18:47:59 +0800478 }
Chris Masona555f812010-01-28 16:18:15 -0500479 break;
Chris Masone18e4802008-01-18 10:54:22 -0500480 case Opt_ssd:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400481 printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
482 btrfs_set_opt(info->mount_opt, SSD);
Chris Masone18e4802008-01-18 10:54:22 -0500483 break;
Chris Mason451d7582009-06-09 20:28:34 -0400484 case Opt_ssd_spread:
485 printk(KERN_INFO "btrfs: use spread ssd "
486 "allocation scheme\n");
487 btrfs_set_opt(info->mount_opt, SSD);
488 btrfs_set_opt(info->mount_opt, SSD_SPREAD);
489 break;
Chris Mason3b30c222009-06-09 16:42:22 -0400490 case Opt_nossd:
Chris Mason451d7582009-06-09 20:28:34 -0400491 printk(KERN_INFO "btrfs: not using ssd allocation "
492 "scheme\n");
Chris Masonc2898112009-06-10 09:51:32 -0400493 btrfs_set_opt(info->mount_opt, NOSSD);
Chris Mason3b30c222009-06-09 16:42:22 -0400494 btrfs_clear_opt(info->mount_opt, SSD);
Chris Mason451d7582009-06-09 20:28:34 -0400495 btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
Chris Mason3b30c222009-06-09 16:42:22 -0400496 break;
Chris Mason21ad10c2008-01-09 09:23:21 -0500497 case Opt_nobarrier:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400498 printk(KERN_INFO "btrfs: turning off barriers\n");
499 btrfs_set_opt(info->mount_opt, NOBARRIER);
Chris Mason21ad10c2008-01-09 09:23:21 -0500500 break;
Chris Mason4543df72008-06-11 21:47:56 -0400501 case Opt_thread_pool:
Wang Shilong2c334e82013-07-24 10:29:05 +0800502 ret = match_int(&args[0], &intarg);
503 if (ret) {
504 goto out;
505 } else if (intarg > 0) {
Chris Mason4543df72008-06-11 21:47:56 -0400506 info->thread_pool_size = intarg;
Wang Shilong2c334e82013-07-24 10:29:05 +0800507 } else {
508 ret = -EINVAL;
509 goto out;
510 }
Chris Mason4543df72008-06-11 21:47:56 -0400511 break;
Chris Mason6f568d32008-01-29 16:03:38 -0500512 case Opt_max_inline:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400513 num = match_strdup(&args[0]);
514 if (num) {
Akinobu Mita91748462010-02-28 10:59:11 +0000515 info->max_inline = memparse(num, NULL);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400516 kfree(num);
Chris Mason6f568d32008-01-29 16:03:38 -0500517
Chris Mason15ada042008-06-11 16:51:38 -0400518 if (info->max_inline) {
519 info->max_inline = max_t(u64,
520 info->max_inline,
521 root->sectorsize);
522 }
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400523 printk(KERN_INFO "btrfs: max_inline at %llu\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200524 info->max_inline);
Wang Shilong2c334e82013-07-24 10:29:05 +0800525 } else {
526 ret = -ENOMEM;
527 goto out;
Chris Mason6f568d32008-01-29 16:03:38 -0500528 }
529 break;
Chris Mason8f662a72008-01-02 10:01:11 -0500530 case Opt_alloc_start:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400531 num = match_strdup(&args[0]);
532 if (num) {
Miao Xiec018dae2013-01-29 10:07:33 +0000533 mutex_lock(&info->chunk_mutex);
Akinobu Mita91748462010-02-28 10:59:11 +0000534 info->alloc_start = memparse(num, NULL);
Miao Xiec018dae2013-01-29 10:07:33 +0000535 mutex_unlock(&info->chunk_mutex);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400536 kfree(num);
537 printk(KERN_INFO
538 "btrfs: allocations start at %llu\n",
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200539 info->alloc_start);
Wang Shilong2c334e82013-07-24 10:29:05 +0800540 } else {
541 ret = -ENOMEM;
542 goto out;
Chris Mason8f662a72008-01-02 10:01:11 -0500543 }
544 break;
Josef Bacik33268ea2008-07-24 12:16:36 -0400545 case Opt_noacl:
546 root->fs_info->sb->s_flags &= ~MS_POSIXACL;
547 break;
Sage Weil3a5e1402009-04-02 16:49:40 -0400548 case Opt_notreelog:
549 printk(KERN_INFO "btrfs: disabling tree log\n");
550 btrfs_set_opt(info->mount_opt, NOTREELOG);
551 break;
Sage Weildccae992009-04-02 16:59:01 -0400552 case Opt_flushoncommit:
553 printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
554 btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
555 break;
Josef Bacik97e728d2009-04-21 17:40:57 -0400556 case Opt_ratio:
Wang Shilong2c334e82013-07-24 10:29:05 +0800557 ret = match_int(&args[0], &intarg);
558 if (ret) {
559 goto out;
560 } else if (intarg >= 0) {
Josef Bacik97e728d2009-04-21 17:40:57 -0400561 info->metadata_ratio = intarg;
562 printk(KERN_INFO "btrfs: metadata ratio %d\n",
563 info->metadata_ratio);
Wang Shilong2c334e82013-07-24 10:29:05 +0800564 } else {
565 ret = -EINVAL;
566 goto out;
Josef Bacik97e728d2009-04-21 17:40:57 -0400567 }
568 break;
Christoph Hellwige244a0a2009-10-14 09:24:59 -0400569 case Opt_discard:
570 btrfs_set_opt(info->mount_opt, DISCARD);
571 break;
Josef Bacik0af3d002010-06-21 14:48:16 -0400572 case Opt_space_cache:
Josef Bacik0af3d002010-06-21 14:48:16 -0400573 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
Josef Bacik0de90872010-11-19 13:40:41 +0000574 break;
Stefan Behrensf420ee12013-08-15 17:11:24 +0200575 case Opt_rescan_uuid_tree:
576 btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
577 break;
Josef Bacik73bc1872011-10-03 14:07:49 -0400578 case Opt_no_space_cache:
579 printk(KERN_INFO "btrfs: disabling disk space caching\n");
580 btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
581 break;
Chris Mason4b9465c2011-06-03 09:36:29 -0400582 case Opt_inode_cache:
583 printk(KERN_INFO "btrfs: enabling inode map caching\n");
584 btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
585 break;
Josef Bacik88c2ba32010-09-21 14:21:34 -0400586 case Opt_clear_cache:
587 printk(KERN_INFO "btrfs: force clearing of disk cache\n");
588 btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
Josef Bacik0af3d002010-06-21 14:48:16 -0400589 break;
Sage Weil4260f7c2010-10-29 15:46:43 -0400590 case Opt_user_subvol_rm_allowed:
591 btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
592 break;
Chris Mason91435652011-02-16 13:10:41 -0500593 case Opt_enospc_debug:
594 btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
595 break;
Chris Mason4cb53002011-05-24 15:35:30 -0400596 case Opt_defrag:
Daniel J Blueman48940662012-05-07 06:35:38 -0600597 printk(KERN_INFO "btrfs: enabling auto defrag\n");
Chris Mason4cb53002011-05-24 15:35:30 -0400598 btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
599 break;
Chris Masonaf31f5e2011-11-03 15:17:42 -0400600 case Opt_recovery:
Daniel J Blueman48940662012-05-07 06:35:38 -0600601 printk(KERN_INFO "btrfs: enabling auto recovery\n");
Chris Masonaf31f5e2011-11-03 15:17:42 -0400602 btrfs_set_opt(info->mount_opt, RECOVERY);
603 break;
Ilya Dryomov9555c6c2012-01-16 22:04:48 +0200604 case Opt_skip_balance:
605 btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
606 break;
Stefan Behrens21adbd52011-11-09 13:44:05 +0100607#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
608 case Opt_check_integrity_including_extent_data:
609 printk(KERN_INFO "btrfs: enabling check integrity"
610 " including extent data\n");
611 btrfs_set_opt(info->mount_opt,
612 CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
613 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
614 break;
615 case Opt_check_integrity:
616 printk(KERN_INFO "btrfs: enabling check integrity\n");
617 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
618 break;
619 case Opt_check_integrity_print_mask:
Wang Shilong2c334e82013-07-24 10:29:05 +0800620 ret = match_int(&args[0], &intarg);
621 if (ret) {
622 goto out;
623 } else if (intarg >= 0) {
Stefan Behrens21adbd52011-11-09 13:44:05 +0100624 info->check_integrity_print_mask = intarg;
625 printk(KERN_INFO "btrfs:"
626 " check_integrity_print_mask 0x%x\n",
627 info->check_integrity_print_mask);
Wang Shilong2c334e82013-07-24 10:29:05 +0800628 } else {
629 ret = -EINVAL;
630 goto out;
Stefan Behrens21adbd52011-11-09 13:44:05 +0100631 }
632 break;
633#else
634 case Opt_check_integrity_including_extent_data:
635 case Opt_check_integrity:
636 case Opt_check_integrity_print_mask:
637 printk(KERN_ERR "btrfs: support for check_integrity*"
638 " not compiled in!\n");
639 ret = -EINVAL;
640 goto out;
641#endif
Jeff Mahoney8c342932011-10-03 23:22:31 -0400642 case Opt_fatal_errors:
643 if (strcmp(args[0].from, "panic") == 0)
644 btrfs_set_opt(info->mount_opt,
645 PANIC_ON_FATAL_ERROR);
646 else if (strcmp(args[0].from, "bug") == 0)
647 btrfs_clear_opt(info->mount_opt,
648 PANIC_ON_FATAL_ERROR);
649 else {
650 ret = -EINVAL;
651 goto out;
652 }
653 break;
David Sterba8b87dc12013-08-01 18:14:52 +0200654 case Opt_commit_interval:
655 intarg = 0;
656 ret = match_int(&args[0], &intarg);
657 if (ret < 0) {
658 printk(KERN_ERR
659 "btrfs: invalid commit interval\n");
660 ret = -EINVAL;
661 goto out;
662 }
663 if (intarg > 0) {
664 if (intarg > 300) {
665 printk(KERN_WARNING
666 "btrfs: excessive commit interval %d\n",
667 intarg);
668 }
669 info->commit_interval = intarg;
670 } else {
671 printk(KERN_INFO
672 "btrfs: using default commit interval %ds\n",
673 BTRFS_DEFAULT_COMMIT_INTERVAL);
674 info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
675 }
676 break;
Sage Weila7a3f7c2009-11-07 06:19:16 +0000677 case Opt_err:
678 printk(KERN_INFO "btrfs: unrecognized mount option "
679 "'%s'\n", p);
680 ret = -EINVAL;
681 goto out;
Chris Mason95e05282007-08-29 09:11:44 -0400682 default:
Chris Masonbe20aa92007-12-17 20:14:01 -0500683 break;
Chris Mason95e05282007-08-29 09:11:44 -0400684 }
685 }
Sage Weila7a3f7c2009-11-07 06:19:16 +0000686out:
Josef Bacik73bc1872011-10-03 14:07:49 -0400687 if (!ret && btrfs_test_opt(root, SPACE_CACHE))
688 printk(KERN_INFO "btrfs: disk space caching is enabled\n");
Josef Bacikda495ec2010-02-25 20:38:35 +0000689 kfree(orig);
Sage Weila7a3f7c2009-11-07 06:19:16 +0000690 return ret;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400691}
692
693/*
694 * Parse mount options that are required early in the mount process.
695 *
696 * All other options will be parsed on much later in the mount process and
697 * only when we need to allocate a new super block.
698 */
Christoph Hellwig97288f22008-12-02 06:36:09 -0500699static int btrfs_parse_early_options(const char *options, fmode_t flags,
Josef Bacik73f73412009-12-04 17:38:27 +0000700 void *holder, char **subvol_name, u64 *subvol_objectid,
David Sterba5e2a4b22013-03-20 13:21:10 +0000701 struct btrfs_fs_devices **fs_devices)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400702{
703 substring_t args[MAX_OPT_ARGS];
Jeff Liu83c8c9b2011-09-14 14:11:21 +0800704 char *device_name, *opts, *orig, *p;
Wang Shilong14933812013-07-24 10:29:20 +0800705 char *num = NULL;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400706 int error = 0;
707
708 if (!options)
Josef Bacik830c4ad2011-07-25 15:55:42 -0400709 return 0;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400710
711 /*
712 * strsep changes the string, duplicate it because parse_options
713 * gets called twice
714 */
715 opts = kstrdup(options, GFP_KERNEL);
716 if (!opts)
717 return -ENOMEM;
Tero Roponen3f3d0bc2010-12-27 16:43:13 +0800718 orig = opts;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400719
720 while ((p = strsep(&opts, ",")) != NULL) {
721 int token;
722 if (!*p)
723 continue;
724
725 token = match_token(p, tokens, args);
726 switch (token) {
727 case Opt_subvol:
Ilya Dryomova90e8b62011-11-08 16:47:55 +0200728 kfree(*subvol_name);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400729 *subvol_name = match_strdup(&args[0]);
Wang Shilong2c334e82013-07-24 10:29:05 +0800730 if (!*subvol_name) {
731 error = -ENOMEM;
732 goto out;
733 }
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400734 break;
Josef Bacik73f73412009-12-04 17:38:27 +0000735 case Opt_subvolid:
Wang Shilong14933812013-07-24 10:29:20 +0800736 num = match_strdup(&args[0]);
737 if (num) {
738 *subvol_objectid = memparse(num, NULL);
739 kfree(num);
Josef Bacik4849f01d2009-12-14 19:18:38 +0000740 /* we want the original fs_tree */
Wang Shilong14933812013-07-24 10:29:20 +0800741 if (!*subvol_objectid)
Josef Bacik4849f01d2009-12-14 19:18:38 +0000742 *subvol_objectid =
743 BTRFS_FS_TREE_OBJECTID;
Wang Shilong2c334e82013-07-24 10:29:05 +0800744 } else {
745 error = -EINVAL;
746 goto out;
Josef Bacik4849f01d2009-12-14 19:18:38 +0000747 }
Josef Bacik73f73412009-12-04 17:38:27 +0000748 break;
Xin Zhonge15d0542011-04-06 07:33:51 +0000749 case Opt_subvolrootid:
David Sterba5e2a4b22013-03-20 13:21:10 +0000750 printk(KERN_WARNING
751 "btrfs: 'subvolrootid' mount option is deprecated and has no effect\n");
Xin Zhonge15d0542011-04-06 07:33:51 +0000752 break;
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400753 case Opt_device:
Jeff Liu83c8c9b2011-09-14 14:11:21 +0800754 device_name = match_strdup(&args[0]);
755 if (!device_name) {
756 error = -ENOMEM;
757 goto out;
758 }
759 error = btrfs_scan_one_device(device_name,
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400760 flags, holder, fs_devices);
Jeff Liu83c8c9b2011-09-14 14:11:21 +0800761 kfree(device_name);
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400762 if (error)
Josef Bacik830c4ad2011-07-25 15:55:42 -0400763 goto out;
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400764 break;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400765 default:
766 break;
767 }
768 }
769
Josef Bacik830c4ad2011-07-25 15:55:42 -0400770out:
Tero Roponen3f3d0bc2010-12-27 16:43:13 +0800771 kfree(orig);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400772 return error;
Chris Mason95e05282007-08-29 09:11:44 -0400773}
774
Josef Bacik73f73412009-12-04 17:38:27 +0000775static struct dentry *get_default_root(struct super_block *sb,
776 u64 subvol_objectid)
777{
Al Viro815745c2011-11-17 15:40:49 -0500778 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
779 struct btrfs_root *root = fs_info->tree_root;
Josef Bacik73f73412009-12-04 17:38:27 +0000780 struct btrfs_root *new_root;
781 struct btrfs_dir_item *di;
782 struct btrfs_path *path;
783 struct btrfs_key location;
784 struct inode *inode;
Josef Bacik73f73412009-12-04 17:38:27 +0000785 u64 dir_id;
786 int new = 0;
787
788 /*
789 * We have a specific subvol we want to mount, just setup location and
790 * go look up the root.
791 */
792 if (subvol_objectid) {
793 location.objectid = subvol_objectid;
794 location.type = BTRFS_ROOT_ITEM_KEY;
795 location.offset = (u64)-1;
796 goto find_root;
797 }
798
799 path = btrfs_alloc_path();
800 if (!path)
801 return ERR_PTR(-ENOMEM);
802 path->leave_spinning = 1;
803
804 /*
805 * Find the "default" dir item which points to the root item that we
806 * will mount by default if we haven't been given a specific subvolume
807 * to mount.
808 */
Al Viro815745c2011-11-17 15:40:49 -0500809 dir_id = btrfs_super_root_dir(fs_info->super_copy);
Josef Bacik73f73412009-12-04 17:38:27 +0000810 di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
Julia Lawallb0839162011-05-14 07:10:51 +0000811 if (IS_ERR(di)) {
812 btrfs_free_path(path);
Dan Carpenterfb4f6f92010-05-29 09:40:57 +0000813 return ERR_CAST(di);
Julia Lawallb0839162011-05-14 07:10:51 +0000814 }
Josef Bacik73f73412009-12-04 17:38:27 +0000815 if (!di) {
816 /*
817 * Ok the default dir item isn't there. This is weird since
818 * it's always been there, but don't freak out, just try and
819 * mount to root most subvolume.
820 */
821 btrfs_free_path(path);
822 dir_id = BTRFS_FIRST_FREE_OBJECTID;
Al Viro815745c2011-11-17 15:40:49 -0500823 new_root = fs_info->fs_root;
Josef Bacik73f73412009-12-04 17:38:27 +0000824 goto setup_root;
825 }
826
827 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
828 btrfs_free_path(path);
829
830find_root:
Al Viro815745c2011-11-17 15:40:49 -0500831 new_root = btrfs_read_fs_root_no_name(fs_info, &location);
Josef Bacik73f73412009-12-04 17:38:27 +0000832 if (IS_ERR(new_root))
Julia Lawalld0b678c2010-10-29 15:14:23 -0400833 return ERR_CAST(new_root);
Josef Bacik73f73412009-12-04 17:38:27 +0000834
Josef Bacik73f73412009-12-04 17:38:27 +0000835 dir_id = btrfs_root_dirid(&new_root->root_item);
836setup_root:
837 location.objectid = dir_id;
838 location.type = BTRFS_INODE_ITEM_KEY;
839 location.offset = 0;
840
841 inode = btrfs_iget(sb, &location, new_root, &new);
Dan Carpenter4cbd1142010-05-29 09:42:19 +0000842 if (IS_ERR(inode))
843 return ERR_CAST(inode);
Josef Bacik73f73412009-12-04 17:38:27 +0000844
845 /*
846 * If we're just mounting the root most subvol put the inode and return
847 * a reference to the dentry. We will have already gotten a reference
848 * to the inode in btrfs_fill_super so we're good to go.
849 */
850 if (!new && sb->s_root->d_inode == inode) {
851 iput(inode);
852 return dget(sb->s_root);
853 }
854
Josef Bacikba5b8952011-07-25 15:40:35 -0400855 return d_obtain_alias(inode);
Josef Bacik73f73412009-12-04 17:38:27 +0000856}
857
Chris Masond3977122009-01-05 21:25:51 -0500858static int btrfs_fill_super(struct super_block *sb,
Chris Mason8a4b83c2008-03-24 15:02:07 -0400859 struct btrfs_fs_devices *fs_devices,
Chris Masond3977122009-01-05 21:25:51 -0500860 void *data, int silent)
Chris Mason2e635a22007-03-21 11:12:56 -0400861{
Chris Masond3977122009-01-05 21:25:51 -0500862 struct inode *inode;
Al Viro815745c2011-11-17 15:40:49 -0500863 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400864 struct btrfs_key key;
Chris Mason39279cc2007-06-12 06:35:45 -0400865 int err;
Chris Mason2e635a22007-03-21 11:12:56 -0400866
867 sb->s_maxbytes = MAX_LFS_FILESIZE;
Chris Mason2e635a22007-03-21 11:12:56 -0400868 sb->s_magic = BTRFS_SUPER_MAGIC;
Chris Masone20d96d2007-03-22 12:13:20 -0400869 sb->s_op = &btrfs_super_ops;
Al Viroaf53d292010-12-20 10:56:06 -0500870 sb->s_d_op = &btrfs_dentry_operations;
Balaji Raobe6e8dc2008-07-21 02:01:56 +0530871 sb->s_export_op = &btrfs_export_ops;
Josef Bacik5103e942007-11-16 11:45:54 -0500872 sb->s_xattr = btrfs_xattr_handlers;
Chris Mason2e635a22007-03-21 11:12:56 -0400873 sb->s_time_gran = 1;
Chris Mason0eda2942009-10-13 13:50:18 -0400874#ifdef CONFIG_BTRFS_FS_POSIX_ACL
Josef Bacik33268ea2008-07-24 12:16:36 -0400875 sb->s_flags |= MS_POSIXACL;
Chris Ball49cf6f42009-09-29 13:51:04 -0400876#endif
Josef Bacik0c4d2d92012-04-05 15:03:02 -0400877 sb->s_flags |= MS_I_VERSION;
Al Viroad2b2c82011-11-17 01:10:02 -0500878 err = open_ctree(sb, fs_devices, (char *)data);
879 if (err) {
Chris Masone20d96d2007-03-22 12:13:20 -0400880 printk("btrfs: open_ctree failed\n");
Al Viroad2b2c82011-11-17 01:10:02 -0500881 return err;
Chris Masone20d96d2007-03-22 12:13:20 -0400882 }
Chris Masonb888db22007-08-27 16:49:44 -0400883
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400884 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
885 key.type = BTRFS_INODE_ITEM_KEY;
886 key.offset = 0;
Al Viro98c70892011-11-17 01:00:31 -0500887 inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400888 if (IS_ERR(inode)) {
889 err = PTR_ERR(inode);
Chris Mason39279cc2007-06-12 06:35:45 -0400890 goto fail_close;
891 }
Chris Mason2e635a22007-03-21 11:12:56 -0400892
Al Viro48fde702012-01-08 22:15:13 -0500893 sb->s_root = d_make_root(inode);
894 if (!sb->s_root) {
Chris Mason39279cc2007-06-12 06:35:45 -0400895 err = -ENOMEM;
896 goto fail_close;
Chris Mason2e635a22007-03-21 11:12:56 -0400897 }
Josef Bacik58176a92007-08-29 15:47:34 -0400898
Chris Mason6885f302008-02-20 16:11:05 -0500899 save_mount_options(sb, data);
Dan Magenheimer90a887c2011-05-26 10:01:56 -0600900 cleancache_init_fs(sb);
Al Viro59553ed2011-11-17 01:56:28 -0500901 sb->s_flags |= MS_ACTIVE;
Chris Mason2e635a22007-03-21 11:12:56 -0400902 return 0;
Chris Mason2e635a22007-03-21 11:12:56 -0400903
Chris Mason39279cc2007-06-12 06:35:45 -0400904fail_close:
Al Viro815745c2011-11-17 15:40:49 -0500905 close_ctree(fs_info->tree_root);
Chris Masond5719762007-03-23 10:01:08 -0400906 return err;
907}
908
Sage Weil6bf13c02008-06-10 10:07:39 -0400909int btrfs_sync_fs(struct super_block *sb, int wait)
Chris Masond5719762007-03-23 10:01:08 -0400910{
911 struct btrfs_trans_handle *trans;
Al Viro815745c2011-11-17 15:40:49 -0500912 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
913 struct btrfs_root *root = fs_info->tree_root;
Chris Masondf2ce342007-03-23 11:00:45 -0400914
liubo1abe9b82011-03-24 11:18:59 +0000915 trace_btrfs_sync_fs(wait);
916
Chris Masond561c022007-03-23 19:47:49 -0400917 if (!wait) {
Al Viro815745c2011-11-17 15:40:49 -0500918 filemap_flush(fs_info->btree_inode->i_mapping);
Chris Masond561c022007-03-23 19:47:49 -0400919 return 0;
920 }
Chris Mason771ed682008-11-06 22:02:51 -0500921
Miao Xieb0244192013-11-04 23:13:25 +0800922 btrfs_wait_ordered_roots(fs_info, -1);
Chris Mason771ed682008-11-06 22:02:51 -0500923
Miao Xied4edf392013-02-20 09:17:06 +0000924 trans = btrfs_attach_transaction_barrier(root);
Josef Bacik60376ce2012-09-14 10:34:40 -0400925 if (IS_ERR(trans)) {
Miao Xie354aa0f2012-09-20 01:54:00 -0600926 /* no transaction, don't bother */
927 if (PTR_ERR(trans) == -ENOENT)
Josef Bacik60376ce2012-09-14 10:34:40 -0400928 return 0;
Tsutomu Itoh98d5dc12011-01-20 06:19:37 +0000929 return PTR_ERR(trans);
Josef Bacik60376ce2012-09-14 10:34:40 -0400930 }
Josef Bacikbd7de2c2012-08-24 12:53:03 -0600931 return btrfs_commit_transaction(trans, root);
Chris Masond5719762007-03-23 10:01:08 -0400932}
933
Al Viro34c80b12011-12-08 21:32:45 -0500934static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
Eric Parisa9572a12009-04-02 16:46:06 -0400935{
Al Viro815745c2011-11-17 15:40:49 -0500936 struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
937 struct btrfs_root *root = info->tree_root;
Tsutomu Itoh200da642011-03-31 00:44:29 +0000938 char *compress_type;
Eric Parisa9572a12009-04-02 16:46:06 -0400939
940 if (btrfs_test_opt(root, DEGRADED))
941 seq_puts(seq, ",degraded");
942 if (btrfs_test_opt(root, NODATASUM))
943 seq_puts(seq, ",nodatasum");
944 if (btrfs_test_opt(root, NODATACOW))
945 seq_puts(seq, ",nodatacow");
946 if (btrfs_test_opt(root, NOBARRIER))
947 seq_puts(seq, ",nobarrier");
Eric Parisa9572a12009-04-02 16:46:06 -0400948 if (info->max_inline != 8192 * 1024)
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200949 seq_printf(seq, ",max_inline=%llu", info->max_inline);
Eric Parisa9572a12009-04-02 16:46:06 -0400950 if (info->alloc_start != 0)
Geert Uytterhoevenc1c9ff72013-08-20 13:20:07 +0200951 seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
Eric Parisa9572a12009-04-02 16:46:06 -0400952 if (info->thread_pool_size != min_t(unsigned long,
953 num_online_cpus() + 2, 8))
954 seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
Tsutomu Itoh200da642011-03-31 00:44:29 +0000955 if (btrfs_test_opt(root, COMPRESS)) {
956 if (info->compress_type == BTRFS_COMPRESS_ZLIB)
957 compress_type = "zlib";
958 else
959 compress_type = "lzo";
960 if (btrfs_test_opt(root, FORCE_COMPRESS))
961 seq_printf(seq, ",compress-force=%s", compress_type);
962 else
963 seq_printf(seq, ",compress=%s", compress_type);
964 }
Chris Masonc2898112009-06-10 09:51:32 -0400965 if (btrfs_test_opt(root, NOSSD))
966 seq_puts(seq, ",nossd");
Chris Mason451d7582009-06-09 20:28:34 -0400967 if (btrfs_test_opt(root, SSD_SPREAD))
968 seq_puts(seq, ",ssd_spread");
969 else if (btrfs_test_opt(root, SSD))
Eric Parisa9572a12009-04-02 16:46:06 -0400970 seq_puts(seq, ",ssd");
Sage Weil3a5e1402009-04-02 16:49:40 -0400971 if (btrfs_test_opt(root, NOTREELOG))
Sage Weil6b65c5c2009-05-14 13:52:21 -0400972 seq_puts(seq, ",notreelog");
Sage Weildccae992009-04-02 16:59:01 -0400973 if (btrfs_test_opt(root, FLUSHONCOMMIT))
Sage Weil6b65c5c2009-05-14 13:52:21 -0400974 seq_puts(seq, ",flushoncommit");
Matthew Wilcox20a52392009-12-14 22:01:12 +0000975 if (btrfs_test_opt(root, DISCARD))
976 seq_puts(seq, ",discard");
Eric Parisa9572a12009-04-02 16:46:06 -0400977 if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
978 seq_puts(seq, ",noacl");
Tsutomu Itoh200da642011-03-31 00:44:29 +0000979 if (btrfs_test_opt(root, SPACE_CACHE))
980 seq_puts(seq, ",space_cache");
Josef Bacik73bc1872011-10-03 14:07:49 -0400981 else
David Sterba89655932011-11-11 10:14:57 -0500982 seq_puts(seq, ",nospace_cache");
Stefan Behrensf420ee12013-08-15 17:11:24 +0200983 if (btrfs_test_opt(root, RESCAN_UUID_TREE))
984 seq_puts(seq, ",rescan_uuid_tree");
Tsutomu Itoh200da642011-03-31 00:44:29 +0000985 if (btrfs_test_opt(root, CLEAR_CACHE))
986 seq_puts(seq, ",clear_cache");
987 if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
988 seq_puts(seq, ",user_subvol_rm_allowed");
David Sterba0942caa2011-06-28 15:10:37 +0000989 if (btrfs_test_opt(root, ENOSPC_DEBUG))
990 seq_puts(seq, ",enospc_debug");
991 if (btrfs_test_opt(root, AUTO_DEFRAG))
992 seq_puts(seq, ",autodefrag");
993 if (btrfs_test_opt(root, INODE_MAP_CACHE))
994 seq_puts(seq, ",inode_cache");
Ilya Dryomov9555c6c2012-01-16 22:04:48 +0200995 if (btrfs_test_opt(root, SKIP_BALANCE))
996 seq_puts(seq, ",skip_balance");
Wang Shilong8507d212013-07-24 10:30:02 +0800997 if (btrfs_test_opt(root, RECOVERY))
998 seq_puts(seq, ",recovery");
999#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1000 if (btrfs_test_opt(root, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
1001 seq_puts(seq, ",check_int_data");
1002 else if (btrfs_test_opt(root, CHECK_INTEGRITY))
1003 seq_puts(seq, ",check_int");
1004 if (info->check_integrity_print_mask)
1005 seq_printf(seq, ",check_int_print_mask=%d",
1006 info->check_integrity_print_mask);
1007#endif
1008 if (info->metadata_ratio)
1009 seq_printf(seq, ",metadata_ratio=%d",
1010 info->metadata_ratio);
Jeff Mahoney8c342932011-10-03 23:22:31 -04001011 if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
1012 seq_puts(seq, ",fatal_errors=panic");
David Sterba8b87dc12013-08-01 18:14:52 +02001013 if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
1014 seq_printf(seq, ",commit=%d", info->commit_interval);
Eric Parisa9572a12009-04-02 16:46:06 -04001015 return 0;
1016}
1017
Chris Masona061fc82008-05-07 11:43:44 -04001018static int btrfs_test_super(struct super_block *s, void *data)
Chris Mason2e635a22007-03-21 11:12:56 -04001019{
Al Viro815745c2011-11-17 15:40:49 -05001020 struct btrfs_fs_info *p = data;
1021 struct btrfs_fs_info *fs_info = btrfs_sb(s);
Yan4b82d6e2007-08-29 09:11:44 -04001022
Al Viro815745c2011-11-17 15:40:49 -05001023 return fs_info->fs_devices == p->fs_devices;
Yan4b82d6e2007-08-29 09:11:44 -04001024}
1025
Josef Bacik450ba0e2010-11-19 14:59:15 -05001026static int btrfs_set_super(struct super_block *s, void *data)
1027{
Al Viro6de1d092011-11-17 01:29:09 -05001028 int err = set_anon_super(s, data);
1029 if (!err)
1030 s->s_fs_info = data;
1031 return err;
Josef Bacik450ba0e2010-11-19 14:59:15 -05001032}
1033
Josef Bacik830c4ad2011-07-25 15:55:42 -04001034/*
David Sterbaf9d9ef62011-09-29 13:11:33 +02001035 * subvolumes are identified by ino 256
1036 */
1037static inline int is_subvolume_inode(struct inode *inode)
1038{
1039 if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
1040 return 1;
1041 return 0;
1042}
1043
1044/*
Josef Bacik830c4ad2011-07-25 15:55:42 -04001045 * This will strip out the subvol=%s argument for an argument string and add
1046 * subvolid=0 to make sure we get the actual tree root for path walking to the
1047 * subvol we want.
1048 */
1049static char *setup_root_args(char *args)
1050{
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001051 unsigned len = strlen(args) + 2 + 1;
1052 char *src, *dst, *buf;
Josef Bacik830c4ad2011-07-25 15:55:42 -04001053
1054 /*
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001055 * We need the same args as before, but with this substitution:
1056 * s!subvol=[^,]+!subvolid=0!
Josef Bacik830c4ad2011-07-25 15:55:42 -04001057 *
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001058 * Since the replacement string is up to 2 bytes longer than the
1059 * original, allocate strlen(args) + 2 + 1 bytes.
Josef Bacik830c4ad2011-07-25 15:55:42 -04001060 */
Josef Bacik830c4ad2011-07-25 15:55:42 -04001061
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001062 src = strstr(args, "subvol=");
Josef Bacik830c4ad2011-07-25 15:55:42 -04001063 /* This shouldn't happen, but just in case.. */
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001064 if (!src)
Josef Bacik830c4ad2011-07-25 15:55:42 -04001065 return NULL;
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001066
1067 buf = dst = kmalloc(len, GFP_NOFS);
1068 if (!buf)
1069 return NULL;
Josef Bacik830c4ad2011-07-25 15:55:42 -04001070
1071 /*
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001072 * If the subvol= arg is not at the start of the string,
1073 * copy whatever precedes it into buf.
Josef Bacik830c4ad2011-07-25 15:55:42 -04001074 */
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001075 if (src != args) {
1076 *src++ = '\0';
1077 strcpy(buf, args);
1078 dst += strlen(args);
Josef Bacik830c4ad2011-07-25 15:55:42 -04001079 }
1080
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001081 strcpy(dst, "subvolid=0");
1082 dst += strlen("subvolid=0");
Josef Bacik830c4ad2011-07-25 15:55:42 -04001083
1084 /*
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001085 * If there is a "," after the original subvol=... string,
1086 * copy that suffix into our buffer. Otherwise, we're done.
Josef Bacik830c4ad2011-07-25 15:55:42 -04001087 */
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001088 src = strchr(src, ',');
1089 if (src)
1090 strcpy(dst, src);
Josef Bacik830c4ad2011-07-25 15:55:42 -04001091
Jim Meyeringf60d16a2012-04-25 21:24:17 +02001092 return buf;
Josef Bacik830c4ad2011-07-25 15:55:42 -04001093}
1094
1095static struct dentry *mount_subvol(const char *subvol_name, int flags,
1096 const char *device_name, char *data)
1097{
Josef Bacik830c4ad2011-07-25 15:55:42 -04001098 struct dentry *root;
1099 struct vfsmount *mnt;
Josef Bacik830c4ad2011-07-25 15:55:42 -04001100 char *newargs;
Josef Bacik830c4ad2011-07-25 15:55:42 -04001101
1102 newargs = setup_root_args(data);
1103 if (!newargs)
1104 return ERR_PTR(-ENOMEM);
1105 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
1106 newargs);
1107 kfree(newargs);
1108 if (IS_ERR(mnt))
1109 return ERR_CAST(mnt);
1110
Al Viroea441d12011-11-16 21:43:59 -05001111 root = mount_subtree(mnt, subvol_name);
Josef Bacik830c4ad2011-07-25 15:55:42 -04001112
Al Viroea441d12011-11-16 21:43:59 -05001113 if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
1114 struct super_block *s = root->d_sb;
1115 dput(root);
1116 root = ERR_PTR(-EINVAL);
1117 deactivate_locked_super(s);
David Sterbaf9d9ef62011-09-29 13:11:33 +02001118 printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
1119 subvol_name);
David Sterbaf9d9ef62011-09-29 13:11:33 +02001120 }
1121
Josef Bacik830c4ad2011-07-25 15:55:42 -04001122 return root;
1123}
Josef Bacik450ba0e2010-11-19 14:59:15 -05001124
Christoph Hellwigedf24ab2008-06-10 10:40:29 -04001125/*
1126 * Find a superblock for the given device / mount point.
1127 *
1128 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
1129 * for multiple device setup. Make sure to keep it in sync.
1130 */
Al Viro061dbc62010-07-26 16:21:33 +04001131static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
David Sterba306e16c2011-04-19 14:29:38 +02001132 const char *device_name, void *data)
Yan4b82d6e2007-08-29 09:11:44 -04001133{
1134 struct block_device *bdev = NULL;
1135 struct super_block *s;
1136 struct dentry *root;
Chris Mason8a4b83c2008-03-24 15:02:07 -04001137 struct btrfs_fs_devices *fs_devices = NULL;
Josef Bacik450ba0e2010-11-19 14:59:15 -05001138 struct btrfs_fs_info *fs_info = NULL;
Christoph Hellwig97288f22008-12-02 06:36:09 -05001139 fmode_t mode = FMODE_READ;
Josef Bacik73f73412009-12-04 17:38:27 +00001140 char *subvol_name = NULL;
1141 u64 subvol_objectid = 0;
Yan4b82d6e2007-08-29 09:11:44 -04001142 int error = 0;
1143
Christoph Hellwig97288f22008-12-02 06:36:09 -05001144 if (!(flags & MS_RDONLY))
1145 mode |= FMODE_WRITE;
1146
1147 error = btrfs_parse_early_options(data, mode, fs_type,
Josef Bacik73f73412009-12-04 17:38:27 +00001148 &subvol_name, &subvol_objectid,
David Sterba5e2a4b22013-03-20 13:21:10 +00001149 &fs_devices);
Ilya Dryomovf23c8af2011-11-08 19:15:05 +02001150 if (error) {
1151 kfree(subvol_name);
Al Viro061dbc62010-07-26 16:21:33 +04001152 return ERR_PTR(error);
Ilya Dryomovf23c8af2011-11-08 19:15:05 +02001153 }
Christoph Hellwigedf24ab2008-06-10 10:40:29 -04001154
Josef Bacik830c4ad2011-07-25 15:55:42 -04001155 if (subvol_name) {
1156 root = mount_subvol(subvol_name, flags, device_name, data);
1157 kfree(subvol_name);
1158 return root;
1159 }
1160
David Sterba306e16c2011-04-19 14:29:38 +02001161 error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
Chris Mason8a4b83c2008-03-24 15:02:07 -04001162 if (error)
Josef Bacik830c4ad2011-07-25 15:55:42 -04001163 return ERR_PTR(error);
Yan4b82d6e2007-08-29 09:11:44 -04001164
Josef Bacik450ba0e2010-11-19 14:59:15 -05001165 /*
1166 * Setup a dummy root and fs_info for test/set super. This is because
1167 * we don't actually fill this stuff out until open_ctree, but we need
1168 * it for searching for existing supers, so this lets us do that and
1169 * then open_ctree will properly initialize everything later.
1170 */
1171 fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
Ilya Dryomov04d21a22011-11-09 14:41:22 +02001172 if (!fs_info)
1173 return ERR_PTR(-ENOMEM);
1174
Josef Bacik450ba0e2010-11-19 14:59:15 -05001175 fs_info->fs_devices = fs_devices;
Josef Bacik450ba0e2010-11-19 14:59:15 -05001176
David Sterba6c417612011-04-13 15:41:04 +02001177 fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1178 fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1179 if (!fs_info->super_copy || !fs_info->super_for_commit) {
1180 error = -ENOMEM;
Ilya Dryomov04d21a22011-11-09 14:41:22 +02001181 goto error_fs_info;
1182 }
1183
1184 error = btrfs_open_devices(fs_devices, mode, fs_type);
1185 if (error)
1186 goto error_fs_info;
1187
1188 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
1189 error = -EACCES;
David Sterba6c417612011-04-13 15:41:04 +02001190 goto error_close_devices;
1191 }
1192
Chris Masondfe25022008-05-13 13:46:40 -04001193 bdev = fs_devices->latest_bdev;
David Howells9249e172012-06-25 12:55:37 +01001194 s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
1195 fs_info);
Josef Bacik830c4ad2011-07-25 15:55:42 -04001196 if (IS_ERR(s)) {
1197 error = PTR_ERR(s);
1198 goto error_close_devices;
1199 }
Yan4b82d6e2007-08-29 09:11:44 -04001200
1201 if (s->s_root) {
Yan Zheng2b820322008-11-17 21:11:30 -05001202 btrfs_close_devices(fs_devices);
David Sterba6c417612011-04-13 15:41:04 +02001203 free_fs_info(fs_info);
Al Viro59553ed2011-11-17 01:56:28 -05001204 if ((flags ^ s->s_flags) & MS_RDONLY)
1205 error = -EBUSY;
Yan4b82d6e2007-08-29 09:11:44 -04001206 } else {
1207 char b[BDEVNAME_SIZE];
1208
Yan4b82d6e2007-08-29 09:11:44 -04001209 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
Al Viro815745c2011-11-17 15:40:49 -05001210 btrfs_sb(s)->bdev_holder = fs_type;
Chris Mason8a4b83c2008-03-24 15:02:07 -04001211 error = btrfs_fill_super(s, fs_devices, data,
1212 flags & MS_SILENT ? 1 : 0);
Yan4b82d6e2007-08-29 09:11:44 -04001213 }
1214
Al Viro59553ed2011-11-17 01:56:28 -05001215 root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
1216 if (IS_ERR(root))
Josef Bacik830c4ad2011-07-25 15:55:42 -04001217 deactivate_locked_super(s);
Yan4b82d6e2007-08-29 09:11:44 -04001218
Al Viro061dbc62010-07-26 16:21:33 +04001219 return root;
Yan4b82d6e2007-08-29 09:11:44 -04001220
Yan Zhengc146afa2008-11-12 14:34:12 -05001221error_close_devices:
Chris Mason8a4b83c2008-03-24 15:02:07 -04001222 btrfs_close_devices(fs_devices);
Ilya Dryomov04d21a22011-11-09 14:41:22 +02001223error_fs_info:
David Sterba6c417612011-04-13 15:41:04 +02001224 free_fs_info(fs_info);
Al Viro061dbc62010-07-26 16:21:33 +04001225 return ERR_PTR(error);
Yan4b82d6e2007-08-29 09:11:44 -04001226}
Chris Mason2e635a22007-03-21 11:12:56 -04001227
Sergei Trofimovich0d2450a2012-04-24 22:59:16 +03001228static void btrfs_set_max_workers(struct btrfs_workers *workers, int new_limit)
1229{
1230 spin_lock_irq(&workers->lock);
1231 workers->max_workers = new_limit;
1232 spin_unlock_irq(&workers->lock);
1233}
1234
1235static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
1236 int new_pool_size, int old_pool_size)
1237{
1238 if (new_pool_size == old_pool_size)
1239 return;
1240
1241 fs_info->thread_pool_size = new_pool_size;
1242
1243 printk(KERN_INFO "btrfs: resize thread pool %d -> %d\n",
1244 old_pool_size, new_pool_size);
1245
1246 btrfs_set_max_workers(&fs_info->generic_worker, new_pool_size);
1247 btrfs_set_max_workers(&fs_info->workers, new_pool_size);
1248 btrfs_set_max_workers(&fs_info->delalloc_workers, new_pool_size);
1249 btrfs_set_max_workers(&fs_info->submit_workers, new_pool_size);
1250 btrfs_set_max_workers(&fs_info->caching_workers, new_pool_size);
1251 btrfs_set_max_workers(&fs_info->fixup_workers, new_pool_size);
1252 btrfs_set_max_workers(&fs_info->endio_workers, new_pool_size);
1253 btrfs_set_max_workers(&fs_info->endio_meta_workers, new_pool_size);
1254 btrfs_set_max_workers(&fs_info->endio_meta_write_workers, new_pool_size);
1255 btrfs_set_max_workers(&fs_info->endio_write_workers, new_pool_size);
1256 btrfs_set_max_workers(&fs_info->endio_freespace_worker, new_pool_size);
1257 btrfs_set_max_workers(&fs_info->delayed_workers, new_pool_size);
1258 btrfs_set_max_workers(&fs_info->readahead_workers, new_pool_size);
Stefan Behrensff023aa2012-11-06 11:43:11 +01001259 btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
1260 new_pool_size);
Sergei Trofimovich0d2450a2012-04-24 22:59:16 +03001261}
1262
Miao Xief42a34b2013-04-11 10:29:35 +00001263static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
Miao Xiedc81cdc2013-02-20 23:32:52 -07001264{
1265 set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
Miao Xief42a34b2013-04-11 10:29:35 +00001266}
Miao Xiedc81cdc2013-02-20 23:32:52 -07001267
Miao Xief42a34b2013-04-11 10:29:35 +00001268static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
1269 unsigned long old_opts, int flags)
1270{
Miao Xiedc81cdc2013-02-20 23:32:52 -07001271 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1272 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1273 (flags & MS_RDONLY))) {
1274 /* wait for any defraggers to finish */
1275 wait_event(fs_info->transaction_wait,
1276 (atomic_read(&fs_info->defrag_running) == 0));
1277 if (flags & MS_RDONLY)
1278 sync_filesystem(fs_info->sb);
1279 }
1280}
1281
1282static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,
1283 unsigned long old_opts)
1284{
1285 /*
1286 * We need cleanup all defragable inodes if the autodefragment is
1287 * close or the fs is R/O.
1288 */
1289 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1290 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1291 (fs_info->sb->s_flags & MS_RDONLY))) {
1292 btrfs_cleanup_defrag_inodes(fs_info);
1293 }
1294
1295 clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1296}
1297
Yan Zhengc146afa2008-11-12 14:34:12 -05001298static int btrfs_remount(struct super_block *sb, int *flags, char *data)
1299{
Al Viro815745c2011-11-17 15:40:49 -05001300 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1301 struct btrfs_root *root = fs_info->tree_root;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001302 unsigned old_flags = sb->s_flags;
1303 unsigned long old_opts = fs_info->mount_opt;
1304 unsigned long old_compress_type = fs_info->compress_type;
1305 u64 old_max_inline = fs_info->max_inline;
1306 u64 old_alloc_start = fs_info->alloc_start;
1307 int old_thread_pool_size = fs_info->thread_pool_size;
1308 unsigned int old_metadata_ratio = fs_info->metadata_ratio;
Yan Zhengc146afa2008-11-12 14:34:12 -05001309 int ret;
1310
Miao Xief42a34b2013-04-11 10:29:35 +00001311 btrfs_remount_prepare(fs_info);
Miao Xiedc81cdc2013-02-20 23:32:52 -07001312
Chris Masonb2880522009-02-12 09:37:35 -05001313 ret = btrfs_parse_options(root, data);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001314 if (ret) {
1315 ret = -EINVAL;
1316 goto restore;
1317 }
Chris Masonb2880522009-02-12 09:37:35 -05001318
Miao Xief42a34b2013-04-11 10:29:35 +00001319 btrfs_remount_begin(fs_info, old_opts, *flags);
Sergei Trofimovich0d2450a2012-04-24 22:59:16 +03001320 btrfs_resize_thread_pool(fs_info,
1321 fs_info->thread_pool_size, old_thread_pool_size);
1322
Yan Zhengc146afa2008-11-12 14:34:12 -05001323 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
Miao Xiedc81cdc2013-02-20 23:32:52 -07001324 goto out;
Yan Zhengc146afa2008-11-12 14:34:12 -05001325
1326 if (*flags & MS_RDONLY) {
Stefan Behrens8dabb742012-11-06 13:15:27 +01001327 /*
1328 * this also happens on 'umount -rf' or on shutdown, when
1329 * the filesystem is busy.
1330 */
Stefan Behrens361c0932013-10-11 17:14:58 +02001331
1332 /* wait for the uuid_scan task to finish */
1333 down(&fs_info->uuid_tree_rescan_sem);
1334 /* avoid complains from lockdep et al. */
1335 up(&fs_info->uuid_tree_rescan_sem);
1336
Yan Zhengc146afa2008-11-12 14:34:12 -05001337 sb->s_flags |= MS_RDONLY;
1338
Stefan Behrens8dabb742012-11-06 13:15:27 +01001339 btrfs_dev_replace_suspend_for_unmount(fs_info);
1340 btrfs_scrub_cancel(fs_info);
Miao Xie061594e2013-05-15 07:48:17 +00001341 btrfs_pause_balance(fs_info);
Stefan Behrens8dabb742012-11-06 13:15:27 +01001342
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001343 ret = btrfs_commit_super(root);
1344 if (ret)
1345 goto restore;
Yan Zhengc146afa2008-11-12 14:34:12 -05001346 } else {
David Sterba6ef3de92013-09-13 17:41:20 +02001347 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
1348 btrfs_err(fs_info,
1349 "Remounting read-write after error is not allowed\n");
1350 ret = -EINVAL;
1351 goto restore;
1352 }
Sergei Trofimovich8a3db182012-04-16 06:44:37 +03001353 if (fs_info->fs_devices->rw_devices == 0) {
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001354 ret = -EACCES;
1355 goto restore;
Sergei Trofimovich8a3db182012-04-16 06:44:37 +03001356 }
Yan Zheng2b820322008-11-17 21:11:30 -05001357
Stefan Behrens292fd7f2012-10-30 17:16:16 +00001358 if (fs_info->fs_devices->missing_devices >
1359 fs_info->num_tolerated_disk_barrier_failures &&
1360 !(*flags & MS_RDONLY)) {
1361 printk(KERN_WARNING
1362 "Btrfs: too many missing devices, writeable remount is not allowed\n");
1363 ret = -EACCES;
1364 goto restore;
1365 }
1366
Sergei Trofimovich8a3db182012-04-16 06:44:37 +03001367 if (btrfs_super_log_root(fs_info->super_copy) != 0) {
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001368 ret = -EINVAL;
1369 goto restore;
Sergei Trofimovich8a3db182012-04-16 06:44:37 +03001370 }
Yan Zhengc146afa2008-11-12 14:34:12 -05001371
Al Viro815745c2011-11-17 15:40:49 -05001372 ret = btrfs_cleanup_fs_roots(fs_info);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001373 if (ret)
1374 goto restore;
Yan Zhengc146afa2008-11-12 14:34:12 -05001375
Yan, Zhengd68fc572010-05-16 10:49:58 -04001376 /* recover relocation */
1377 ret = btrfs_recover_relocation(root);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001378 if (ret)
1379 goto restore;
Yan Zhengc146afa2008-11-12 14:34:12 -05001380
Ilya Dryomov2b6ba622012-06-22 12:24:13 -06001381 ret = btrfs_resume_balance_async(fs_info);
1382 if (ret)
1383 goto restore;
1384
Stefan Behrens8dabb742012-11-06 13:15:27 +01001385 ret = btrfs_resume_dev_replace_async(fs_info);
1386 if (ret) {
1387 pr_warn("btrfs: failed to resume dev_replace\n");
1388 goto restore;
1389 }
Josef Bacik94aebfb2013-09-20 22:33:20 -04001390
1391 if (!fs_info->uuid_root) {
1392 pr_info("btrfs: creating UUID tree\n");
1393 ret = btrfs_create_uuid_tree(fs_info);
1394 if (ret) {
1395 pr_warn("btrfs: failed to create the uuid tree"
1396 "%d\n", ret);
1397 goto restore;
1398 }
1399 }
Yan Zhengc146afa2008-11-12 14:34:12 -05001400 sb->s_flags &= ~MS_RDONLY;
1401 }
Miao Xiedc81cdc2013-02-20 23:32:52 -07001402out:
1403 btrfs_remount_cleanup(fs_info, old_opts);
Yan Zhengc146afa2008-11-12 14:34:12 -05001404 return 0;
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001405
1406restore:
1407 /* We've hit an error - don't reset MS_RDONLY */
1408 if (sb->s_flags & MS_RDONLY)
1409 old_flags |= MS_RDONLY;
1410 sb->s_flags = old_flags;
1411 fs_info->mount_opt = old_opts;
1412 fs_info->compress_type = old_compress_type;
1413 fs_info->max_inline = old_max_inline;
Miao Xiec018dae2013-01-29 10:07:33 +00001414 mutex_lock(&fs_info->chunk_mutex);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001415 fs_info->alloc_start = old_alloc_start;
Miao Xiec018dae2013-01-29 10:07:33 +00001416 mutex_unlock(&fs_info->chunk_mutex);
Sergei Trofimovich0d2450a2012-04-24 22:59:16 +03001417 btrfs_resize_thread_pool(fs_info,
1418 old_thread_pool_size, fs_info->thread_pool_size);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001419 fs_info->metadata_ratio = old_metadata_ratio;
Miao Xiedc81cdc2013-02-20 23:32:52 -07001420 btrfs_remount_cleanup(fs_info, old_opts);
Jeff Mahoney49b25e02012-03-01 17:24:58 +01001421 return ret;
Yan Zhengc146afa2008-11-12 14:34:12 -05001422}
1423
Arne Jansenbcd53742011-04-12 10:43:21 +02001424/* Used to sort the devices by max_avail(descending sort) */
1425static int btrfs_cmp_device_free_bytes(const void *dev_info1,
1426 const void *dev_info2)
1427{
1428 if (((struct btrfs_device_info *)dev_info1)->max_avail >
1429 ((struct btrfs_device_info *)dev_info2)->max_avail)
1430 return -1;
1431 else if (((struct btrfs_device_info *)dev_info1)->max_avail <
1432 ((struct btrfs_device_info *)dev_info2)->max_avail)
1433 return 1;
1434 else
1435 return 0;
1436}
1437
1438/*
1439 * sort the devices by max_avail, in which max free extent size of each device
1440 * is stored.(Descending Sort)
1441 */
1442static inline void btrfs_descending_sort_devices(
1443 struct btrfs_device_info *devices,
1444 size_t nr_devices)
1445{
1446 sort(devices, nr_devices, sizeof(struct btrfs_device_info),
1447 btrfs_cmp_device_free_bytes, NULL);
1448}
1449
Miao Xie6d07bce2011-01-05 10:07:31 +00001450/*
1451 * The helper to calc the free space on the devices that can be used to store
1452 * file data.
1453 */
1454static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
1455{
1456 struct btrfs_fs_info *fs_info = root->fs_info;
1457 struct btrfs_device_info *devices_info;
1458 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
1459 struct btrfs_device *device;
1460 u64 skip_space;
1461 u64 type;
1462 u64 avail_space;
1463 u64 used_space;
1464 u64 min_stripe_size;
Miao Xie39fb26c2011-12-14 20:12:02 -05001465 int min_stripes = 1, num_stripes = 1;
Miao Xie6d07bce2011-01-05 10:07:31 +00001466 int i = 0, nr_devices;
1467 int ret;
1468
Li Zefanb772a862011-11-28 16:43:00 +08001469 nr_devices = fs_info->fs_devices->open_devices;
Miao Xie6d07bce2011-01-05 10:07:31 +00001470 BUG_ON(!nr_devices);
1471
Dulshani Gunawardhanad9b0d9b2013-10-31 10:32:18 +05301472 devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
Miao Xie6d07bce2011-01-05 10:07:31 +00001473 GFP_NOFS);
1474 if (!devices_info)
1475 return -ENOMEM;
1476
1477 /* calc min stripe number for data space alloction */
1478 type = btrfs_get_alloc_profile(root, 1);
Miao Xie39fb26c2011-12-14 20:12:02 -05001479 if (type & BTRFS_BLOCK_GROUP_RAID0) {
Miao Xie6d07bce2011-01-05 10:07:31 +00001480 min_stripes = 2;
Miao Xie39fb26c2011-12-14 20:12:02 -05001481 num_stripes = nr_devices;
1482 } else if (type & BTRFS_BLOCK_GROUP_RAID1) {
Miao Xie6d07bce2011-01-05 10:07:31 +00001483 min_stripes = 2;
Miao Xie39fb26c2011-12-14 20:12:02 -05001484 num_stripes = 2;
1485 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
Miao Xie6d07bce2011-01-05 10:07:31 +00001486 min_stripes = 4;
Miao Xie39fb26c2011-12-14 20:12:02 -05001487 num_stripes = 4;
1488 }
Miao Xie6d07bce2011-01-05 10:07:31 +00001489
1490 if (type & BTRFS_BLOCK_GROUP_DUP)
1491 min_stripe_size = 2 * BTRFS_STRIPE_LEN;
1492 else
1493 min_stripe_size = BTRFS_STRIPE_LEN;
1494
Li Zefanb772a862011-11-28 16:43:00 +08001495 list_for_each_entry(device, &fs_devices->devices, dev_list) {
Stefan Behrens63a212a2012-11-05 18:29:28 +01001496 if (!device->in_fs_metadata || !device->bdev ||
1497 device->is_tgtdev_for_dev_replace)
Miao Xie6d07bce2011-01-05 10:07:31 +00001498 continue;
1499
1500 avail_space = device->total_bytes - device->bytes_used;
1501
1502 /* align with stripe_len */
1503 do_div(avail_space, BTRFS_STRIPE_LEN);
1504 avail_space *= BTRFS_STRIPE_LEN;
1505
1506 /*
1507 * In order to avoid overwritting the superblock on the drive,
1508 * btrfs starts at an offset of at least 1MB when doing chunk
1509 * allocation.
1510 */
1511 skip_space = 1024 * 1024;
1512
1513 /* user can set the offset in fs_info->alloc_start. */
1514 if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
1515 device->total_bytes)
1516 skip_space = max(fs_info->alloc_start, skip_space);
1517
1518 /*
1519 * btrfs can not use the free space in [0, skip_space - 1],
1520 * we must subtract it from the total. In order to implement
1521 * it, we account the used space in this range first.
1522 */
1523 ret = btrfs_account_dev_extents_size(device, 0, skip_space - 1,
1524 &used_space);
1525 if (ret) {
1526 kfree(devices_info);
1527 return ret;
1528 }
1529
1530 /* calc the free space in [0, skip_space - 1] */
1531 skip_space -= used_space;
1532
1533 /*
1534 * we can use the free space in [0, skip_space - 1], subtract
1535 * it from the total.
1536 */
1537 if (avail_space && avail_space >= skip_space)
1538 avail_space -= skip_space;
1539 else
1540 avail_space = 0;
1541
1542 if (avail_space < min_stripe_size)
1543 continue;
1544
1545 devices_info[i].dev = device;
1546 devices_info[i].max_avail = avail_space;
1547
1548 i++;
1549 }
1550
1551 nr_devices = i;
1552
1553 btrfs_descending_sort_devices(devices_info, nr_devices);
1554
1555 i = nr_devices - 1;
1556 avail_space = 0;
1557 while (nr_devices >= min_stripes) {
Miao Xie39fb26c2011-12-14 20:12:02 -05001558 if (num_stripes > nr_devices)
1559 num_stripes = nr_devices;
1560
Miao Xie6d07bce2011-01-05 10:07:31 +00001561 if (devices_info[i].max_avail >= min_stripe_size) {
1562 int j;
1563 u64 alloc_size;
1564
Miao Xie39fb26c2011-12-14 20:12:02 -05001565 avail_space += devices_info[i].max_avail * num_stripes;
Miao Xie6d07bce2011-01-05 10:07:31 +00001566 alloc_size = devices_info[i].max_avail;
Miao Xie39fb26c2011-12-14 20:12:02 -05001567 for (j = i + 1 - num_stripes; j <= i; j++)
Miao Xie6d07bce2011-01-05 10:07:31 +00001568 devices_info[j].max_avail -= alloc_size;
1569 }
1570 i--;
1571 nr_devices--;
1572 }
1573
1574 kfree(devices_info);
1575 *free_bytes = avail_space;
1576 return 0;
1577}
1578
Chris Mason8fd17792007-04-19 21:01:03 -04001579static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1580{
Al Viro815745c2011-11-17 15:40:49 -05001581 struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
1582 struct btrfs_super_block *disk_super = fs_info->super_copy;
1583 struct list_head *head = &fs_info->space_info;
Josef Bacikbd4d1082010-03-05 21:59:21 +00001584 struct btrfs_space_info *found;
1585 u64 total_used = 0;
Miao Xie6d07bce2011-01-05 10:07:31 +00001586 u64 total_free_data = 0;
Chris Masondb945352007-10-15 16:15:53 -04001587 int bits = dentry->d_sb->s_blocksize_bits;
Al Viro815745c2011-11-17 15:40:49 -05001588 __be32 *fsid = (__be32 *)fs_info->fsid;
Miao Xie6d07bce2011-01-05 10:07:31 +00001589 int ret;
Chris Mason8fd17792007-04-19 21:01:03 -04001590
Miao Xie6d07bce2011-01-05 10:07:31 +00001591 /* holding chunk_muext to avoid allocating new chunks */
Al Viro815745c2011-11-17 15:40:49 -05001592 mutex_lock(&fs_info->chunk_mutex);
Josef Bacikbd4d1082010-03-05 21:59:21 +00001593 rcu_read_lock();
Josef Bacik89a55892010-10-14 14:52:27 -04001594 list_for_each_entry_rcu(found, head, list) {
Miao Xie6d07bce2011-01-05 10:07:31 +00001595 if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
1596 total_free_data += found->disk_total - found->disk_used;
1597 total_free_data -=
1598 btrfs_account_ro_block_groups_free_space(found);
1599 }
1600
Yan, Zhengb742bb82010-05-16 10:46:24 -04001601 total_used += found->disk_used;
Josef Bacik89a55892010-10-14 14:52:27 -04001602 }
Josef Bacikbd4d1082010-03-05 21:59:21 +00001603 rcu_read_unlock();
1604
Chris Mason8fd17792007-04-19 21:01:03 -04001605 buf->f_namelen = BTRFS_NAME_LEN;
Chris Masondb945352007-10-15 16:15:53 -04001606 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
Josef Bacikbd4d1082010-03-05 21:59:21 +00001607 buf->f_bfree = buf->f_blocks - (total_used >> bits);
Chris Mason8fd17792007-04-19 21:01:03 -04001608 buf->f_bsize = dentry->d_sb->s_blocksize;
1609 buf->f_type = BTRFS_SUPER_MAGIC;
Miao Xie6d07bce2011-01-05 10:07:31 +00001610 buf->f_bavail = total_free_data;
Al Viro815745c2011-11-17 15:40:49 -05001611 ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
Miao Xie6d07bce2011-01-05 10:07:31 +00001612 if (ret) {
Al Viro815745c2011-11-17 15:40:49 -05001613 mutex_unlock(&fs_info->chunk_mutex);
Miao Xie6d07bce2011-01-05 10:07:31 +00001614 return ret;
1615 }
1616 buf->f_bavail += total_free_data;
1617 buf->f_bavail = buf->f_bavail >> bits;
Al Viro815745c2011-11-17 15:40:49 -05001618 mutex_unlock(&fs_info->chunk_mutex);
Chris Masond3977122009-01-05 21:25:51 -05001619
David Woodhouse9d036322008-08-18 12:01:52 +01001620 /* We treat it as constant endianness (it doesn't matter _which_)
Chris Masond3977122009-01-05 21:25:51 -05001621 because we want the fsid to come out the same whether mounted
David Woodhouse9d036322008-08-18 12:01:52 +01001622 on a big-endian or little-endian host */
1623 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
1624 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
David Woodhouse32d48fa2008-08-18 13:10:20 +01001625 /* Mask in the root object ID too, to disambiguate subvols */
1626 buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
1627 buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
1628
Chris Mason8fd17792007-04-19 21:01:03 -04001629 return 0;
1630}
Chris Masonb5133862007-04-24 11:52:22 -04001631
Al Viroaea52e12011-11-17 01:22:46 -05001632static void btrfs_kill_super(struct super_block *sb)
1633{
Al Viro815745c2011-11-17 15:40:49 -05001634 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
Al Viroaea52e12011-11-17 01:22:46 -05001635 kill_anon_super(sb);
Al Virod22ca7d2011-11-17 01:46:50 -05001636 free_fs_info(fs_info);
Al Viroaea52e12011-11-17 01:22:46 -05001637}
1638
Chris Mason2e635a22007-03-21 11:12:56 -04001639static struct file_system_type btrfs_fs_type = {
1640 .owner = THIS_MODULE,
1641 .name = "btrfs",
Al Viro061dbc62010-07-26 16:21:33 +04001642 .mount = btrfs_mount,
Al Viroaea52e12011-11-17 01:22:46 -05001643 .kill_sb = btrfs_kill_super,
Chris Mason2e635a22007-03-21 11:12:56 -04001644 .fs_flags = FS_REQUIRES_DEV,
1645};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08001646MODULE_ALIAS_FS("btrfs");
Chris Masona9218f62008-03-24 15:02:04 -04001647
Chris Masond352ac62008-09-29 15:18:18 -04001648/*
1649 * used by btrfsctl to scan devices when no FS is mounted
1650 */
Chris Mason8a4b83c2008-03-24 15:02:07 -04001651static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
1652 unsigned long arg)
1653{
1654 struct btrfs_ioctl_vol_args *vol;
1655 struct btrfs_fs_devices *fs_devices;
Chris Masonc071fcf2009-01-16 11:59:08 -05001656 int ret = -ENOTTY;
Chris Mason8a4b83c2008-03-24 15:02:07 -04001657
Chris Masone441d542009-01-05 16:57:23 -05001658 if (!capable(CAP_SYS_ADMIN))
1659 return -EPERM;
1660
Li Zefandae7b662009-04-08 15:06:54 +08001661 vol = memdup_user((void __user *)arg, sizeof(*vol));
1662 if (IS_ERR(vol))
1663 return PTR_ERR(vol);
Chris Masonc071fcf2009-01-16 11:59:08 -05001664
Chris Mason8a4b83c2008-03-24 15:02:07 -04001665 switch (cmd) {
1666 case BTRFS_IOC_SCAN_DEV:
Christoph Hellwig97288f22008-12-02 06:36:09 -05001667 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
Chris Mason8a4b83c2008-03-24 15:02:07 -04001668 &btrfs_fs_type, &fs_devices);
1669 break;
Josef Bacik02db0842012-06-21 16:03:58 -04001670 case BTRFS_IOC_DEVICES_READY:
1671 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1672 &btrfs_fs_type, &fs_devices);
1673 if (ret)
1674 break;
1675 ret = !(fs_devices->num_devices == fs_devices->total_devices);
1676 break;
Chris Mason8a4b83c2008-03-24 15:02:07 -04001677 }
Li Zefandae7b662009-04-08 15:06:54 +08001678
Chris Mason8a4b83c2008-03-24 15:02:07 -04001679 kfree(vol);
Linda Knippersf819d832008-06-09 22:17:11 -04001680 return ret;
Chris Mason8a4b83c2008-03-24 15:02:07 -04001681}
1682
Linus Torvalds01762602009-01-10 06:09:52 -08001683static int btrfs_freeze(struct super_block *sb)
Yaned0dab62008-01-22 12:46:56 -05001684{
Miao Xie354aa0f2012-09-20 01:54:00 -06001685 struct btrfs_trans_handle *trans;
1686 struct btrfs_root *root = btrfs_sb(sb)->tree_root;
1687
Miao Xied4edf392013-02-20 09:17:06 +00001688 trans = btrfs_attach_transaction_barrier(root);
Miao Xie354aa0f2012-09-20 01:54:00 -06001689 if (IS_ERR(trans)) {
1690 /* no transaction, don't bother */
1691 if (PTR_ERR(trans) == -ENOENT)
1692 return 0;
1693 return PTR_ERR(trans);
1694 }
1695 return btrfs_commit_transaction(trans, root);
Yaned0dab62008-01-22 12:46:56 -05001696}
1697
Linus Torvalds01762602009-01-10 06:09:52 -08001698static int btrfs_unfreeze(struct super_block *sb)
Yaned0dab62008-01-22 12:46:56 -05001699{
Linus Torvalds01762602009-01-10 06:09:52 -08001700 return 0;
Yaned0dab62008-01-22 12:46:56 -05001701}
Chris Mason2e635a22007-03-21 11:12:56 -04001702
Josef Bacik9c5085c2012-06-05 14:13:12 -04001703static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
1704{
1705 struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
1706 struct btrfs_fs_devices *cur_devices;
1707 struct btrfs_device *dev, *first_dev = NULL;
1708 struct list_head *head;
1709 struct rcu_string *name;
1710
1711 mutex_lock(&fs_info->fs_devices->device_list_mutex);
1712 cur_devices = fs_info->fs_devices;
1713 while (cur_devices) {
1714 head = &cur_devices->devices;
1715 list_for_each_entry(dev, head, dev_list) {
Josef Bacikaa9ddcd2012-08-02 10:22:20 -04001716 if (dev->missing)
1717 continue;
Josef Bacik9c5085c2012-06-05 14:13:12 -04001718 if (!first_dev || dev->devid < first_dev->devid)
1719 first_dev = dev;
1720 }
1721 cur_devices = cur_devices->seed;
1722 }
1723
1724 if (first_dev) {
1725 rcu_read_lock();
1726 name = rcu_dereference(first_dev->name);
1727 seq_escape(m, name->str, " \t\n\\");
1728 rcu_read_unlock();
1729 } else {
1730 WARN_ON(1);
1731 }
1732 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1733 return 0;
1734}
1735
Alexey Dobriyanb87221d2009-09-21 17:01:09 -07001736static const struct super_operations btrfs_super_ops = {
Yan, Zheng76dda932009-09-21 16:00:26 -04001737 .drop_inode = btrfs_drop_inode,
Al Virobd555972010-06-07 11:35:40 -04001738 .evict_inode = btrfs_evict_inode,
Chris Masone20d96d2007-03-22 12:13:20 -04001739 .put_super = btrfs_put_super,
Chris Masond5719762007-03-23 10:01:08 -04001740 .sync_fs = btrfs_sync_fs,
Eric Parisa9572a12009-04-02 16:46:06 -04001741 .show_options = btrfs_show_options,
Josef Bacik9c5085c2012-06-05 14:13:12 -04001742 .show_devname = btrfs_show_devname,
Chris Mason4730a4b2007-03-26 12:00:39 -04001743 .write_inode = btrfs_write_inode,
Chris Mason2c90e5d2007-04-02 10:50:19 -04001744 .alloc_inode = btrfs_alloc_inode,
1745 .destroy_inode = btrfs_destroy_inode,
Chris Mason8fd17792007-04-19 21:01:03 -04001746 .statfs = btrfs_statfs,
Yan Zhengc146afa2008-11-12 14:34:12 -05001747 .remount_fs = btrfs_remount,
Linus Torvalds01762602009-01-10 06:09:52 -08001748 .freeze_fs = btrfs_freeze,
1749 .unfreeze_fs = btrfs_unfreeze,
Chris Masone20d96d2007-03-22 12:13:20 -04001750};
Chris Masona9218f62008-03-24 15:02:04 -04001751
1752static const struct file_operations btrfs_ctl_fops = {
1753 .unlocked_ioctl = btrfs_control_ioctl,
1754 .compat_ioctl = btrfs_control_ioctl,
1755 .owner = THIS_MODULE,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001756 .llseek = noop_llseek,
Chris Masona9218f62008-03-24 15:02:04 -04001757};
1758
1759static struct miscdevice btrfs_misc = {
Kay Sievers578454f2010-05-20 18:07:20 +02001760 .minor = BTRFS_MINOR,
Chris Masona9218f62008-03-24 15:02:04 -04001761 .name = "btrfs-control",
1762 .fops = &btrfs_ctl_fops
1763};
1764
Kay Sievers578454f2010-05-20 18:07:20 +02001765MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
1766MODULE_ALIAS("devname:btrfs-control");
1767
Chris Masona9218f62008-03-24 15:02:04 -04001768static int btrfs_interface_init(void)
1769{
1770 return misc_register(&btrfs_misc);
1771}
1772
Christoph Hellwigb2950862008-12-02 09:54:17 -05001773static void btrfs_interface_exit(void)
Chris Masona9218f62008-03-24 15:02:04 -04001774{
1775 if (misc_deregister(&btrfs_misc) < 0)
Daniel J Blueman48940662012-05-07 06:35:38 -06001776 printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
Chris Masona9218f62008-03-24 15:02:04 -04001777}
1778
David Sterba85965602013-04-30 16:51:59 +00001779static void btrfs_print_info(void)
1780{
1781 printk(KERN_INFO "Btrfs loaded"
1782#ifdef CONFIG_BTRFS_DEBUG
1783 ", debug=on"
1784#endif
Stefan Behrens79556c32013-09-03 15:25:27 +02001785#ifdef CONFIG_BTRFS_ASSERT
1786 ", assert=on"
1787#endif
David Sterba85965602013-04-30 16:51:59 +00001788#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1789 ", integrity-checker=on"
1790#endif
1791 "\n");
1792}
1793
Josef Bacikdc11dd5d2013-08-14 15:05:12 -04001794static int btrfs_run_sanity_tests(void)
1795{
Josef Bacik06ea65a2013-09-19 16:07:01 -04001796 int ret;
1797
Josef Bacik294e30f2013-10-09 12:00:56 -04001798 ret = btrfs_init_test_fs();
Josef Bacik06ea65a2013-09-19 16:07:01 -04001799 if (ret)
1800 return ret;
Josef Bacik294e30f2013-10-09 12:00:56 -04001801
1802 ret = btrfs_test_free_space_cache();
1803 if (ret)
1804 goto out;
1805 ret = btrfs_test_extent_buffer_operations();
1806 if (ret)
1807 goto out;
1808 ret = btrfs_test_extent_io();
Josef Bacikaaedb552013-10-11 14:44:09 -04001809 if (ret)
1810 goto out;
1811 ret = btrfs_test_inodes();
Josef Bacik294e30f2013-10-09 12:00:56 -04001812out:
1813 btrfs_destroy_test_fs();
1814 return ret;
Josef Bacikdc11dd5d2013-08-14 15:05:12 -04001815}
1816
Chris Mason2e635a22007-03-21 11:12:56 -04001817static int __init init_btrfs_fs(void)
1818{
Chris Mason2c90e5d2007-04-02 10:50:19 -04001819 int err;
Josef Bacik58176a92007-08-29 15:47:34 -04001820
1821 err = btrfs_init_sysfs();
1822 if (err)
1823 return err;
1824
Jeff Mahoney143bede2012-03-01 14:56:26 +01001825 btrfs_init_compress();
Chris Masond1310b22008-01-24 16:13:08 -05001826
Li Zefan261507a02010-12-17 14:21:50 +08001827 err = btrfs_init_cachep();
1828 if (err)
1829 goto free_compress;
1830
Chris Masond1310b22008-01-24 16:13:08 -05001831 err = extent_io_init();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -05001832 if (err)
1833 goto free_cachep;
1834
Chris Masond1310b22008-01-24 16:13:08 -05001835 err = extent_map_init();
1836 if (err)
1837 goto free_extent_io;
1838
Miao Xie6352b912012-09-06 04:01:51 -06001839 err = ordered_data_init();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -05001840 if (err)
1841 goto free_extent_map;
Chris Masonc8b97812008-10-29 14:49:59 -04001842
Miao Xie6352b912012-09-06 04:01:51 -06001843 err = btrfs_delayed_inode_init();
1844 if (err)
1845 goto free_ordered_data;
1846
Miao Xie9247f312012-11-26 09:24:43 +00001847 err = btrfs_auto_defrag_init();
Miao Xie16cdcec2011-04-22 18:12:22 +08001848 if (err)
1849 goto free_delayed_inode;
1850
Miao Xie78a61842012-11-21 02:21:28 +00001851 err = btrfs_delayed_ref_init();
Miao Xie9247f312012-11-26 09:24:43 +00001852 if (err)
1853 goto free_auto_defrag;
1854
Wang Shilongb9e9a6c2013-08-09 13:25:36 +08001855 err = btrfs_prelim_ref_init();
1856 if (err)
1857 goto free_prelim_ref;
1858
Miao Xie78a61842012-11-21 02:21:28 +00001859 err = btrfs_interface_init();
1860 if (err)
1861 goto free_delayed_ref;
1862
Jan Schmidte565d4b2012-03-23 17:14:20 +01001863 btrfs_init_lockdep();
1864
David Sterba85965602013-04-30 16:51:59 +00001865 btrfs_print_info();
Josef Bacikdc11dd5d2013-08-14 15:05:12 -04001866
1867 err = btrfs_run_sanity_tests();
1868 if (err)
1869 goto unregister_ioctl;
1870
1871 err = register_filesystem(&btrfs_fs_type);
1872 if (err)
1873 goto unregister_ioctl;
Josef Bacik74255aa2013-03-15 09:47:08 -04001874
Wyatt Banks2f4cbe62007-11-19 10:22:33 -05001875 return 0;
1876
Chris Masona9218f62008-03-24 15:02:04 -04001877unregister_ioctl:
1878 btrfs_interface_exit();
Wang Shilongb9e9a6c2013-08-09 13:25:36 +08001879free_prelim_ref:
1880 btrfs_prelim_ref_exit();
Miao Xie78a61842012-11-21 02:21:28 +00001881free_delayed_ref:
1882 btrfs_delayed_ref_exit();
Miao Xie9247f312012-11-26 09:24:43 +00001883free_auto_defrag:
1884 btrfs_auto_defrag_exit();
Miao Xie16cdcec2011-04-22 18:12:22 +08001885free_delayed_inode:
1886 btrfs_delayed_inode_exit();
Miao Xie6352b912012-09-06 04:01:51 -06001887free_ordered_data:
1888 ordered_data_exit();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -05001889free_extent_map:
1890 extent_map_exit();
Chris Masond1310b22008-01-24 16:13:08 -05001891free_extent_io:
1892 extent_io_exit();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -05001893free_cachep:
1894 btrfs_destroy_cachep();
Li Zefan261507a02010-12-17 14:21:50 +08001895free_compress:
1896 btrfs_exit_compress();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -05001897 btrfs_exit_sysfs();
1898 return err;
Chris Mason2e635a22007-03-21 11:12:56 -04001899}
1900
1901static void __exit exit_btrfs_fs(void)
1902{
Chris Mason39279cc2007-06-12 06:35:45 -04001903 btrfs_destroy_cachep();
Miao Xie78a61842012-11-21 02:21:28 +00001904 btrfs_delayed_ref_exit();
Miao Xie9247f312012-11-26 09:24:43 +00001905 btrfs_auto_defrag_exit();
Miao Xie16cdcec2011-04-22 18:12:22 +08001906 btrfs_delayed_inode_exit();
Wang Shilongb9e9a6c2013-08-09 13:25:36 +08001907 btrfs_prelim_ref_exit();
Miao Xie6352b912012-09-06 04:01:51 -06001908 ordered_data_exit();
Chris Masona52d9a82007-08-27 16:49:44 -04001909 extent_map_exit();
Chris Masond1310b22008-01-24 16:13:08 -05001910 extent_io_exit();
Chris Masona9218f62008-03-24 15:02:04 -04001911 btrfs_interface_exit();
Chris Mason2e635a22007-03-21 11:12:56 -04001912 unregister_filesystem(&btrfs_fs_type);
Josef Bacik58176a92007-08-29 15:47:34 -04001913 btrfs_exit_sysfs();
Chris Mason8a4b83c2008-03-24 15:02:07 -04001914 btrfs_cleanup_fs_uuids();
Li Zefan261507a02010-12-17 14:21:50 +08001915 btrfs_exit_compress();
Chris Mason2e635a22007-03-21 11:12:56 -04001916}
1917
1918module_init(init_btrfs_fs)
1919module_exit(exit_btrfs_fs)
1920
1921MODULE_LICENSE("GPL");