]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/btrfs/super.c
Btrfs: pass gfp_t to __add_prelim_ref() to avoid always using GFP_ATOMIC
[mirror_ubuntu-bionic-kernel.git] / fs / btrfs / super.c
CommitLineData
6cbd5570
CM
1/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
4b82d6e4 19#include <linux/blkdev.h>
2e635a27 20#include <linux/module.h>
e20d96d6 21#include <linux/buffer_head.h>
2e635a27
CM
22#include <linux/fs.h>
23#include <linux/pagemap.h>
24#include <linux/highmem.h>
25#include <linux/time.h>
26#include <linux/init.h>
a9572a15 27#include <linux/seq_file.h>
2e635a27 28#include <linux/string.h>
2e635a27 29#include <linux/backing-dev.h>
4b82d6e4 30#include <linux/mount.h>
dee26a9f 31#include <linux/mpage.h>
75dfe396
CM
32#include <linux/swap.h>
33#include <linux/writeback.h>
8fd17795 34#include <linux/statfs.h>
08607c1b 35#include <linux/compat.h>
95e05289 36#include <linux/parser.h>
c59f8951 37#include <linux/ctype.h>
6da6abae 38#include <linux/namei.h>
a9218f6b 39#include <linux/miscdevice.h>
1bcbf313 40#include <linux/magic.h>
5a0e3ad6 41#include <linux/slab.h>
90a887c9 42#include <linux/cleancache.h>
22c44fe6 43#include <linux/ratelimit.h>
55e301fd 44#include <linux/btrfs.h>
4b4e25f2 45#include "compat.h"
16cdcec7 46#include "delayed-inode.h"
2e635a27 47#include "ctree.h"
e20d96d6 48#include "disk-io.h"
d5719762 49#include "transaction.h"
2c90e5d6 50#include "btrfs_inode.h"
3a686375 51#include "print-tree.h"
5103e947 52#include "xattr.h"
8a4b83cc 53#include "volumes.h"
be6e8dc0 54#include "export.h"
c8b97818 55#include "compression.h"
9c5085c1 56#include "rcu-string.h"
8dabb742 57#include "dev-replace.h"
74255aa0 58#include "free-space-cache.h"
dc11dd5d 59#include "tests/btrfs-tests.h"
2e635a27 60
1abe9b8a 61#define CREATE_TRACE_POINTS
62#include <trace/events/btrfs.h>
63
b87221de 64static const struct super_operations btrfs_super_ops;
830c4adb 65static struct file_system_type btrfs_fs_type;
75dfe396 66
08748810 67static const char *btrfs_decode_error(int errno)
acce952b 68{
08748810 69 char *errstr = "unknown";
acce952b 70
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;
8c342930
JM
81 case -EEXIST:
82 errstr = "Object already exists";
83 break;
94ef7280
DS
84 case -ENOSPC:
85 errstr = "No space left";
86 break;
87 case -ENOENT:
88 errstr = "No such entry";
89 break;
acce952b 90 }
91
92 return errstr;
93}
94
bbece8a3 95static void save_error_info(struct btrfs_fs_info *fs_info)
acce952b 96{
97 /*
98 * today we only save the error info into ram. Long term we'll
99 * also send it down to the disk
100 */
87533c47 101 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
acce952b 102}
103
acce952b 104/* 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
87533c47 112 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
acce952b 113 sb->s_flags |= MS_RDONLY;
c2cf52eb 114 btrfs_info(fs_info, "forced readonly");
1acd6831
SB
115 /*
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 */
acce952b 125 }
126}
127
533574c6 128#ifdef CONFIG_PRINTK
acce952b 129/*
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,
4da35113 134 unsigned int line, int errno, const char *fmt, ...)
acce952b 135{
136 struct super_block *sb = fs_info->sb;
acce952b 137 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))
4da35113
JM
144 return;
145
08748810 146 errstr = btrfs_decode_error(errno);
4da35113 147 if (fmt) {
37252a66
ES
148 struct va_format vaf;
149 va_list args;
150
151 va_start(args, fmt);
152 vaf.fmt = fmt;
153 vaf.va = &args;
4da35113 154
08748810
DS
155 printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: errno=%d %s (%pV)\n",
156 sb->s_id, function, line, errno, errstr, &vaf);
37252a66 157 va_end(args);
4da35113 158 } else {
08748810
DS
159 printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: errno=%d %s\n",
160 sb->s_id, function, line, errno, errstr);
4da35113 161 }
acce952b 162
4da35113 163 /* Don't go through full error handling during mount */
cf79ffb5
JB
164 save_error_info(fs_info);
165 if (sb->s_flags & MS_BORN)
4da35113 166 btrfs_handle_error(fs_info);
4da35113 167}
acce952b 168
533574c6 169static const char * const logtypes[] = {
4da35113
JM
170 "emergency",
171 "alert",
172 "critical",
173 "error",
174 "warning",
175 "notice",
176 "info",
177 "debug",
178};
179
c2cf52eb 180void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
4da35113
JM
181{
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];
533574c6 187 int kern_level;
4da35113
JM
188
189 va_start(args, fmt);
190
533574c6
JP
191 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'];
4da35113
JM
198 } else
199 *lvl = '\0';
200
201 vaf.fmt = fmt;
202 vaf.va = &args;
533574c6 203
c2cf52eb 204 printk("%sBTRFS %s (device %s): %pV\n", lvl, type, sb->s_id, &vaf);
533574c6
JP
205
206 va_end(args);
207}
208
209#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 }
acce952b 228}
533574c6 229#endif
acce952b 230
49b25e05
JM
231/*
232 * 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{
08748810
DS
248 /*
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 }
49b25e05
JM
256 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) {
69ce977a
MX
260 const char *errstr;
261
08748810 262 errstr = btrfs_decode_error(errno);
c2cf52eb
SK
263 btrfs_warn(root->fs_info,
264 "%s:%d: Aborting unused transaction(%s).",
265 function, line, errstr);
acce952b 266 return;
49b25e05 267 }
8d25a086 268 ACCESS_ONCE(trans->transaction->aborted) = errno;
501407aa
JB
269 /* 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);
49b25e05
JM
272 __btrfs_std_error(root->fs_info, function, line, errno, NULL);
273}
8c342930
JM
274/*
275 * __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{
8c342930
JM
281 char *s_id = "<unknown>";
282 const char *errstr;
283 struct va_format vaf = { .fmt = fmt };
284 va_list args;
acce952b 285
8c342930
JM
286 if (fs_info)
287 s_id = fs_info->sb->s_id;
acce952b 288
8c342930
JM
289 va_start(args, fmt);
290 vaf.va = &args;
291
08748810 292 errstr = btrfs_decode_error(errno);
aa43a17c 293 if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))
08748810
DS
294 panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
295 s_id, function, line, &vaf, errno, errstr);
8c342930 296
08748810
DS
297 printk(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
298 s_id, function, line, &vaf, errno, errstr);
8c342930
JM
299 va_end(args);
300 /* Caller calls BUG() */
acce952b 301}
302
d397712b 303static void btrfs_put_super(struct super_block *sb)
b18c6685 304{
815745cf 305 (void)close_ctree(btrfs_sb(sb)->tree_root);
aea52e19
AV
306 /* 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 */
75dfe396
CM
312}
313
95e05289 314enum {
73f73415 315 Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
287a0ab9
JB
316 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,
261507a0
LZ
318 Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
319 Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
91435650 320 Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
9555c6c1
ID
321 Opt_enospc_debug, Opt_subvolrootid, Opt_defrag, Opt_inode_cache,
322 Opt_no_space_cache, Opt_recovery, Opt_skip_balance,
21adbd5c 323 Opt_check_integrity, Opt_check_integrity_including_extent_data,
f420ee1e 324 Opt_check_integrity_print_mask, Opt_fatal_errors, Opt_rescan_uuid_tree,
8b87dc17 325 Opt_commit_interval,
9555c6c1 326 Opt_err,
95e05289
CM
327};
328
329static match_table_t tokens = {
dfe25020 330 {Opt_degraded, "degraded"},
95e05289 331 {Opt_subvol, "subvol=%s"},
1493381f 332 {Opt_subvolid, "subvolid=%s"},
43e570b0 333 {Opt_device, "device=%s"},
b6cda9bc 334 {Opt_nodatasum, "nodatasum"},
be20aa9d 335 {Opt_nodatacow, "nodatacow"},
21ad10cf 336 {Opt_nobarrier, "nobarrier"},
6f568d35 337 {Opt_max_inline, "max_inline=%s"},
8f662a76 338 {Opt_alloc_start, "alloc_start=%s"},
4543df7e 339 {Opt_thread_pool, "thread_pool=%d"},
c8b97818 340 {Opt_compress, "compress"},
261507a0 341 {Opt_compress_type, "compress=%s"},
a555f810 342 {Opt_compress_force, "compress-force"},
261507a0 343 {Opt_compress_force_type, "compress-force=%s"},
e18e4809 344 {Opt_ssd, "ssd"},
451d7585 345 {Opt_ssd_spread, "ssd_spread"},
3b30c22f 346 {Opt_nossd, "nossd"},
33268eaf 347 {Opt_noacl, "noacl"},
3a5e1404 348 {Opt_notreelog, "notreelog"},
dccae999 349 {Opt_flushoncommit, "flushoncommit"},
97e728d4 350 {Opt_ratio, "metadata_ratio=%d"},
e244a0ae 351 {Opt_discard, "discard"},
0af3d00b 352 {Opt_space_cache, "space_cache"},
88c2ba3b 353 {Opt_clear_cache, "clear_cache"},
4260f7c7 354 {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
91435650 355 {Opt_enospc_debug, "enospc_debug"},
e15d0542 356 {Opt_subvolrootid, "subvolrootid=%d"},
4cb5300b 357 {Opt_defrag, "autodefrag"},
4b9465cb 358 {Opt_inode_cache, "inode_cache"},
8965593e 359 {Opt_no_space_cache, "nospace_cache"},
af31f5e5 360 {Opt_recovery, "recovery"},
9555c6c1 361 {Opt_skip_balance, "skip_balance"},
21adbd5c
SB
362 {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"},
f420ee1e 365 {Opt_rescan_uuid_tree, "rescan_uuid_tree"},
8c342930 366 {Opt_fatal_errors, "fatal_errors=%s"},
8b87dc17 367 {Opt_commit_interval, "commit=%d"},
33268eaf 368 {Opt_err, NULL},
95e05289
CM
369};
370
edf24abe
CH
371/*
372 * Regular mount options parser. Everything that is needed only when
373 * reading in a new superblock is parsed here.
49b25e05 374 * XXX JDM: This needs to be cleaned up for remount.
edf24abe
CH
375 */
376int btrfs_parse_options(struct btrfs_root *root, char *options)
95e05289 377{
edf24abe 378 struct btrfs_fs_info *info = root->fs_info;
95e05289 379 substring_t args[MAX_OPT_ARGS];
73bc1876
JB
380 char *p, *num, *orig = NULL;
381 u64 cache_gen;
4543df7e 382 int intarg;
a7a3f7ca 383 int ret = 0;
261507a0
LZ
384 char *compress_type;
385 bool compress_force = false;
b6cda9bc 386
6c41761f 387 cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
73bc1876
JB
388 if (cache_gen)
389 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
390
95e05289 391 if (!options)
73bc1876 392 goto out;
95e05289 393
be20aa9d
CM
394 /*
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
da495ecc 402 orig = options;
be20aa9d 403
edf24abe 404 while ((p = strsep(&options, ",")) != NULL) {
95e05289
CM
405 int token;
406 if (!*p)
407 continue;
408
409 token = match_token(p, tokens, args);
410 switch (token) {
dfe25020 411 case Opt_degraded:
edf24abe
CH
412 printk(KERN_INFO "btrfs: allowing degraded mounts\n");
413 btrfs_set_opt(info->mount_opt, DEGRADED);
dfe25020 414 break;
95e05289 415 case Opt_subvol:
73f73415 416 case Opt_subvolid:
e15d0542 417 case Opt_subvolrootid:
43e570b0 418 case Opt_device:
edf24abe 419 /*
43e570b0 420 * These are parsed by btrfs_parse_early_options
edf24abe
CH
421 * and can be happily ignored here.
422 */
b6cda9bc
CM
423 break;
424 case Opt_nodatasum:
067c28ad 425 printk(KERN_INFO "btrfs: setting nodatasum\n");
edf24abe 426 btrfs_set_opt(info->mount_opt, NODATASUM);
be20aa9d
CM
427 break;
428 case Opt_nodatacow:
bedb2cca
AP
429 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 }
435 info->compress_type = BTRFS_COMPRESS_NONE;
436 btrfs_clear_opt(info->mount_opt, COMPRESS);
437 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
edf24abe
CH
438 btrfs_set_opt(info->mount_opt, NODATACOW);
439 btrfs_set_opt(info->mount_opt, NODATASUM);
95e05289 440 break;
a555f810 441 case Opt_compress_force:
261507a0
LZ
442 case Opt_compress_force_type:
443 compress_force = true;
1c697d4a 444 /* Fallthrough */
261507a0
LZ
445 case Opt_compress:
446 case Opt_compress_type:
447 if (token == Opt_compress ||
448 token == Opt_compress_force ||
449 strcmp(args[0].from, "zlib") == 0) {
450 compress_type = "zlib";
451 info->compress_type = BTRFS_COMPRESS_ZLIB;
063849ea 452 btrfs_set_opt(info->mount_opt, COMPRESS);
bedb2cca
AP
453 btrfs_clear_opt(info->mount_opt, NODATACOW);
454 btrfs_clear_opt(info->mount_opt, NODATASUM);
a6fa6fae
LZ
455 } else if (strcmp(args[0].from, "lzo") == 0) {
456 compress_type = "lzo";
457 info->compress_type = BTRFS_COMPRESS_LZO;
063849ea 458 btrfs_set_opt(info->mount_opt, COMPRESS);
bedb2cca
AP
459 btrfs_clear_opt(info->mount_opt, NODATACOW);
460 btrfs_clear_opt(info->mount_opt, NODATASUM);
2b0ce2c2 461 btrfs_set_fs_incompat(info, COMPRESS_LZO);
063849ea
AH
462 } else if (strncmp(args[0].from, "no", 2) == 0) {
463 compress_type = "no";
464 info->compress_type = BTRFS_COMPRESS_NONE;
465 btrfs_clear_opt(info->mount_opt, COMPRESS);
466 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
467 compress_force = false;
261507a0
LZ
468 } else {
469 ret = -EINVAL;
470 goto out;
471 }
472
261507a0
LZ
473 if (compress_force) {
474 btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
475 pr_info("btrfs: force %s compression\n",
476 compress_type);
477 } else
478 pr_info("btrfs: use %s compression\n",
479 compress_type);
a555f810 480 break;
e18e4809 481 case Opt_ssd:
edf24abe
CH
482 printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
483 btrfs_set_opt(info->mount_opt, SSD);
e18e4809 484 break;
451d7585
CM
485 case Opt_ssd_spread:
486 printk(KERN_INFO "btrfs: use spread ssd "
487 "allocation scheme\n");
488 btrfs_set_opt(info->mount_opt, SSD);
489 btrfs_set_opt(info->mount_opt, SSD_SPREAD);
490 break;
3b30c22f 491 case Opt_nossd:
451d7585
CM
492 printk(KERN_INFO "btrfs: not using ssd allocation "
493 "scheme\n");
c289811c 494 btrfs_set_opt(info->mount_opt, NOSSD);
3b30c22f 495 btrfs_clear_opt(info->mount_opt, SSD);
451d7585 496 btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
3b30c22f 497 break;
21ad10cf 498 case Opt_nobarrier:
edf24abe
CH
499 printk(KERN_INFO "btrfs: turning off barriers\n");
500 btrfs_set_opt(info->mount_opt, NOBARRIER);
21ad10cf 501 break;
4543df7e 502 case Opt_thread_pool:
2c334e87
WS
503 ret = match_int(&args[0], &intarg);
504 if (ret) {
505 goto out;
506 } else if (intarg > 0) {
4543df7e 507 info->thread_pool_size = intarg;
2c334e87
WS
508 } else {
509 ret = -EINVAL;
510 goto out;
511 }
4543df7e 512 break;
6f568d35 513 case Opt_max_inline:
edf24abe
CH
514 num = match_strdup(&args[0]);
515 if (num) {
91748467 516 info->max_inline = memparse(num, NULL);
edf24abe
CH
517 kfree(num);
518
15ada040
CM
519 if (info->max_inline) {
520 info->max_inline = max_t(u64,
521 info->max_inline,
522 root->sectorsize);
523 }
edf24abe 524 printk(KERN_INFO "btrfs: max_inline at %llu\n",
c1c9ff7c 525 info->max_inline);
2c334e87
WS
526 } else {
527 ret = -ENOMEM;
528 goto out;
6f568d35
CM
529 }
530 break;
8f662a76 531 case Opt_alloc_start:
edf24abe
CH
532 num = match_strdup(&args[0]);
533 if (num) {
c018daec 534 mutex_lock(&info->chunk_mutex);
91748467 535 info->alloc_start = memparse(num, NULL);
c018daec 536 mutex_unlock(&info->chunk_mutex);
edf24abe
CH
537 kfree(num);
538 printk(KERN_INFO
539 "btrfs: allocations start at %llu\n",
c1c9ff7c 540 info->alloc_start);
2c334e87
WS
541 } else {
542 ret = -ENOMEM;
543 goto out;
8f662a76
CM
544 }
545 break;
33268eaf
JB
546 case Opt_noacl:
547 root->fs_info->sb->s_flags &= ~MS_POSIXACL;
548 break;
3a5e1404
SW
549 case Opt_notreelog:
550 printk(KERN_INFO "btrfs: disabling tree log\n");
551 btrfs_set_opt(info->mount_opt, NOTREELOG);
552 break;
dccae999
SW
553 case Opt_flushoncommit:
554 printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
555 btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
556 break;
97e728d4 557 case Opt_ratio:
2c334e87
WS
558 ret = match_int(&args[0], &intarg);
559 if (ret) {
560 goto out;
561 } else if (intarg >= 0) {
97e728d4
JB
562 info->metadata_ratio = intarg;
563 printk(KERN_INFO "btrfs: metadata ratio %d\n",
564 info->metadata_ratio);
2c334e87
WS
565 } else {
566 ret = -EINVAL;
567 goto out;
97e728d4
JB
568 }
569 break;
e244a0ae
CH
570 case Opt_discard:
571 btrfs_set_opt(info->mount_opt, DISCARD);
572 break;
0af3d00b 573 case Opt_space_cache:
0af3d00b 574 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
0de90876 575 break;
f420ee1e
SB
576 case Opt_rescan_uuid_tree:
577 btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
578 break;
73bc1876
JB
579 case Opt_no_space_cache:
580 printk(KERN_INFO "btrfs: disabling disk space caching\n");
581 btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
582 break;
4b9465cb
CM
583 case Opt_inode_cache:
584 printk(KERN_INFO "btrfs: enabling inode map caching\n");
585 btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
586 break;
88c2ba3b
JB
587 case Opt_clear_cache:
588 printk(KERN_INFO "btrfs: force clearing of disk cache\n");
589 btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
0af3d00b 590 break;
4260f7c7
SW
591 case Opt_user_subvol_rm_allowed:
592 btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
593 break;
91435650
CM
594 case Opt_enospc_debug:
595 btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
596 break;
4cb5300b 597 case Opt_defrag:
48940662 598 printk(KERN_INFO "btrfs: enabling auto defrag\n");
4cb5300b
CM
599 btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
600 break;
af31f5e5 601 case Opt_recovery:
48940662 602 printk(KERN_INFO "btrfs: enabling auto recovery\n");
af31f5e5
CM
603 btrfs_set_opt(info->mount_opt, RECOVERY);
604 break;
9555c6c1
ID
605 case Opt_skip_balance:
606 btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
607 break;
21adbd5c
SB
608#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
609 case Opt_check_integrity_including_extent_data:
610 printk(KERN_INFO "btrfs: enabling check integrity"
611 " including extent data\n");
612 btrfs_set_opt(info->mount_opt,
613 CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
614 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
615 break;
616 case Opt_check_integrity:
617 printk(KERN_INFO "btrfs: enabling check integrity\n");
618 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
619 break;
620 case Opt_check_integrity_print_mask:
2c334e87
WS
621 ret = match_int(&args[0], &intarg);
622 if (ret) {
623 goto out;
624 } else if (intarg >= 0) {
21adbd5c
SB
625 info->check_integrity_print_mask = intarg;
626 printk(KERN_INFO "btrfs:"
627 " check_integrity_print_mask 0x%x\n",
628 info->check_integrity_print_mask);
2c334e87
WS
629 } else {
630 ret = -EINVAL;
631 goto out;
21adbd5c
SB
632 }
633 break;
634#else
635 case Opt_check_integrity_including_extent_data:
636 case Opt_check_integrity:
637 case Opt_check_integrity_print_mask:
638 printk(KERN_ERR "btrfs: support for check_integrity*"
639 " not compiled in!\n");
640 ret = -EINVAL;
641 goto out;
642#endif
8c342930
JM
643 case Opt_fatal_errors:
644 if (strcmp(args[0].from, "panic") == 0)
645 btrfs_set_opt(info->mount_opt,
646 PANIC_ON_FATAL_ERROR);
647 else if (strcmp(args[0].from, "bug") == 0)
648 btrfs_clear_opt(info->mount_opt,
649 PANIC_ON_FATAL_ERROR);
650 else {
651 ret = -EINVAL;
652 goto out;
653 }
654 break;
8b87dc17
DS
655 case Opt_commit_interval:
656 intarg = 0;
657 ret = match_int(&args[0], &intarg);
658 if (ret < 0) {
659 printk(KERN_ERR
660 "btrfs: invalid commit interval\n");
661 ret = -EINVAL;
662 goto out;
663 }
664 if (intarg > 0) {
665 if (intarg > 300) {
666 printk(KERN_WARNING
667 "btrfs: excessive commit interval %d\n",
668 intarg);
669 }
670 info->commit_interval = intarg;
671 } else {
672 printk(KERN_INFO
673 "btrfs: using default commit interval %ds\n",
674 BTRFS_DEFAULT_COMMIT_INTERVAL);
675 info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
676 }
677 break;
a7a3f7ca
SW
678 case Opt_err:
679 printk(KERN_INFO "btrfs: unrecognized mount option "
680 "'%s'\n", p);
681 ret = -EINVAL;
682 goto out;
95e05289 683 default:
be20aa9d 684 break;
95e05289
CM
685 }
686 }
a7a3f7ca 687out:
73bc1876
JB
688 if (!ret && btrfs_test_opt(root, SPACE_CACHE))
689 printk(KERN_INFO "btrfs: disk space caching is enabled\n");
da495ecc 690 kfree(orig);
a7a3f7ca 691 return ret;
edf24abe
CH
692}
693
694/*
695 * Parse mount options that are required early in the mount process.
696 *
697 * All other options will be parsed on much later in the mount process and
698 * only when we need to allocate a new super block.
699 */
97288f2c 700static int btrfs_parse_early_options(const char *options, fmode_t flags,
73f73415 701 void *holder, char **subvol_name, u64 *subvol_objectid,
5e2a4b25 702 struct btrfs_fs_devices **fs_devices)
edf24abe
CH
703{
704 substring_t args[MAX_OPT_ARGS];
83c8c9bd 705 char *device_name, *opts, *orig, *p;
1493381f 706 char *num = NULL;
edf24abe
CH
707 int error = 0;
708
709 if (!options)
830c4adb 710 return 0;
edf24abe
CH
711
712 /*
713 * strsep changes the string, duplicate it because parse_options
714 * gets called twice
715 */
716 opts = kstrdup(options, GFP_KERNEL);
717 if (!opts)
718 return -ENOMEM;
3f3d0bc0 719 orig = opts;
edf24abe
CH
720
721 while ((p = strsep(&opts, ",")) != NULL) {
722 int token;
723 if (!*p)
724 continue;
725
726 token = match_token(p, tokens, args);
727 switch (token) {
728 case Opt_subvol:
a90e8b6f 729 kfree(*subvol_name);
edf24abe 730 *subvol_name = match_strdup(&args[0]);
2c334e87
WS
731 if (!*subvol_name) {
732 error = -ENOMEM;
733 goto out;
734 }
edf24abe 735 break;
73f73415 736 case Opt_subvolid:
1493381f
WS
737 num = match_strdup(&args[0]);
738 if (num) {
739 *subvol_objectid = memparse(num, NULL);
740 kfree(num);
4849f01d 741 /* we want the original fs_tree */
1493381f 742 if (!*subvol_objectid)
4849f01d
JB
743 *subvol_objectid =
744 BTRFS_FS_TREE_OBJECTID;
2c334e87
WS
745 } else {
746 error = -EINVAL;
747 goto out;
4849f01d 748 }
73f73415 749 break;
e15d0542 750 case Opt_subvolrootid:
5e2a4b25
DS
751 printk(KERN_WARNING
752 "btrfs: 'subvolrootid' mount option is deprecated and has no effect\n");
e15d0542 753 break;
43e570b0 754 case Opt_device:
83c8c9bd
JL
755 device_name = match_strdup(&args[0]);
756 if (!device_name) {
757 error = -ENOMEM;
758 goto out;
759 }
760 error = btrfs_scan_one_device(device_name,
43e570b0 761 flags, holder, fs_devices);
83c8c9bd 762 kfree(device_name);
43e570b0 763 if (error)
830c4adb 764 goto out;
43e570b0 765 break;
edf24abe
CH
766 default:
767 break;
768 }
769 }
770
830c4adb 771out:
3f3d0bc0 772 kfree(orig);
edf24abe 773 return error;
95e05289
CM
774}
775
73f73415
JB
776static struct dentry *get_default_root(struct super_block *sb,
777 u64 subvol_objectid)
778{
815745cf
AV
779 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
780 struct btrfs_root *root = fs_info->tree_root;
73f73415
JB
781 struct btrfs_root *new_root;
782 struct btrfs_dir_item *di;
783 struct btrfs_path *path;
784 struct btrfs_key location;
785 struct inode *inode;
73f73415
JB
786 u64 dir_id;
787 int new = 0;
788
789 /*
790 * We have a specific subvol we want to mount, just setup location and
791 * go look up the root.
792 */
793 if (subvol_objectid) {
794 location.objectid = subvol_objectid;
795 location.type = BTRFS_ROOT_ITEM_KEY;
796 location.offset = (u64)-1;
797 goto find_root;
798 }
799
800 path = btrfs_alloc_path();
801 if (!path)
802 return ERR_PTR(-ENOMEM);
803 path->leave_spinning = 1;
804
805 /*
806 * Find the "default" dir item which points to the root item that we
807 * will mount by default if we haven't been given a specific subvolume
808 * to mount.
809 */
815745cf 810 dir_id = btrfs_super_root_dir(fs_info->super_copy);
73f73415 811 di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
b0839166
JL
812 if (IS_ERR(di)) {
813 btrfs_free_path(path);
fb4f6f91 814 return ERR_CAST(di);
b0839166 815 }
73f73415
JB
816 if (!di) {
817 /*
818 * Ok the default dir item isn't there. This is weird since
819 * it's always been there, but don't freak out, just try and
820 * mount to root most subvolume.
821 */
822 btrfs_free_path(path);
823 dir_id = BTRFS_FIRST_FREE_OBJECTID;
815745cf 824 new_root = fs_info->fs_root;
73f73415
JB
825 goto setup_root;
826 }
827
828 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
829 btrfs_free_path(path);
830
831find_root:
815745cf 832 new_root = btrfs_read_fs_root_no_name(fs_info, &location);
73f73415 833 if (IS_ERR(new_root))
d0b678cb 834 return ERR_CAST(new_root);
73f73415 835
73f73415
JB
836 dir_id = btrfs_root_dirid(&new_root->root_item);
837setup_root:
838 location.objectid = dir_id;
839 location.type = BTRFS_INODE_ITEM_KEY;
840 location.offset = 0;
841
842 inode = btrfs_iget(sb, &location, new_root, &new);
4cbd1149
DC
843 if (IS_ERR(inode))
844 return ERR_CAST(inode);
73f73415
JB
845
846 /*
847 * If we're just mounting the root most subvol put the inode and return
848 * a reference to the dentry. We will have already gotten a reference
849 * to the inode in btrfs_fill_super so we're good to go.
850 */
851 if (!new && sb->s_root->d_inode == inode) {
852 iput(inode);
853 return dget(sb->s_root);
854 }
855
ba5b8958 856 return d_obtain_alias(inode);
73f73415
JB
857}
858
d397712b 859static int btrfs_fill_super(struct super_block *sb,
8a4b83cc 860 struct btrfs_fs_devices *fs_devices,
d397712b 861 void *data, int silent)
75dfe396 862{
d397712b 863 struct inode *inode;
815745cf 864 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
5d4f98a2 865 struct btrfs_key key;
39279cc3 866 int err;
a429e513 867
39279cc3
CM
868 sb->s_maxbytes = MAX_LFS_FILESIZE;
869 sb->s_magic = BTRFS_SUPER_MAGIC;
870 sb->s_op = &btrfs_super_ops;
af53d29a 871 sb->s_d_op = &btrfs_dentry_operations;
be6e8dc0 872 sb->s_export_op = &btrfs_export_ops;
5103e947 873 sb->s_xattr = btrfs_xattr_handlers;
39279cc3 874 sb->s_time_gran = 1;
0eda294d 875#ifdef CONFIG_BTRFS_FS_POSIX_ACL
33268eaf 876 sb->s_flags |= MS_POSIXACL;
49cf6f45 877#endif
0c4d2d95 878 sb->s_flags |= MS_I_VERSION;
ad2b2c80
AV
879 err = open_ctree(sb, fs_devices, (char *)data);
880 if (err) {
39279cc3 881 printk("btrfs: open_ctree failed\n");
ad2b2c80 882 return err;
a429e513
CM
883 }
884
5d4f98a2
YZ
885 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
886 key.type = BTRFS_INODE_ITEM_KEY;
887 key.offset = 0;
98c7089c 888 inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
5d4f98a2
YZ
889 if (IS_ERR(inode)) {
890 err = PTR_ERR(inode);
39279cc3 891 goto fail_close;
f254e52c 892 }
f254e52c 893
48fde701
AV
894 sb->s_root = d_make_root(inode);
895 if (!sb->s_root) {
39279cc3
CM
896 err = -ENOMEM;
897 goto fail_close;
f254e52c 898 }
58176a96 899
6885f308 900 save_mount_options(sb, data);
90a887c9 901 cleancache_init_fs(sb);
59553edf 902 sb->s_flags |= MS_ACTIVE;
2619ba1f 903 return 0;
39279cc3
CM
904
905fail_close:
815745cf 906 close_ctree(fs_info->tree_root);
39279cc3 907 return err;
2619ba1f
CM
908}
909
6bf13c0c 910int btrfs_sync_fs(struct super_block *sb, int wait)
c5739bba
CM
911{
912 struct btrfs_trans_handle *trans;
815745cf
AV
913 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
914 struct btrfs_root *root = fs_info->tree_root;
2619ba1f 915
1abe9b8a 916 trace_btrfs_sync_fs(wait);
917
39279cc3 918 if (!wait) {
815745cf 919 filemap_flush(fs_info->btree_inode->i_mapping);
39279cc3
CM
920 return 0;
921 }
771ed689 922
c73e2936 923 btrfs_wait_all_ordered_extents(fs_info, 1);
771ed689 924
d4edf39b 925 trans = btrfs_attach_transaction_barrier(root);
60376ce4 926 if (IS_ERR(trans)) {
354aa0fb
MX
927 /* no transaction, don't bother */
928 if (PTR_ERR(trans) == -ENOENT)
60376ce4 929 return 0;
98d5dc13 930 return PTR_ERR(trans);
60376ce4 931 }
bd7de2c9 932 return btrfs_commit_transaction(trans, root);
2c90e5d6
CM
933}
934
34c80b1d 935static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
a9572a15 936{
815745cf
AV
937 struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
938 struct btrfs_root *root = info->tree_root;
200da64e 939 char *compress_type;
a9572a15
EP
940
941 if (btrfs_test_opt(root, DEGRADED))
942 seq_puts(seq, ",degraded");
943 if (btrfs_test_opt(root, NODATASUM))
944 seq_puts(seq, ",nodatasum");
945 if (btrfs_test_opt(root, NODATACOW))
946 seq_puts(seq, ",nodatacow");
947 if (btrfs_test_opt(root, NOBARRIER))
948 seq_puts(seq, ",nobarrier");
a9572a15 949 if (info->max_inline != 8192 * 1024)
c1c9ff7c 950 seq_printf(seq, ",max_inline=%llu", info->max_inline);
a9572a15 951 if (info->alloc_start != 0)
c1c9ff7c 952 seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
a9572a15
EP
953 if (info->thread_pool_size != min_t(unsigned long,
954 num_online_cpus() + 2, 8))
955 seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
200da64e
TI
956 if (btrfs_test_opt(root, COMPRESS)) {
957 if (info->compress_type == BTRFS_COMPRESS_ZLIB)
958 compress_type = "zlib";
959 else
960 compress_type = "lzo";
961 if (btrfs_test_opt(root, FORCE_COMPRESS))
962 seq_printf(seq, ",compress-force=%s", compress_type);
963 else
964 seq_printf(seq, ",compress=%s", compress_type);
965 }
c289811c
CM
966 if (btrfs_test_opt(root, NOSSD))
967 seq_puts(seq, ",nossd");
451d7585
CM
968 if (btrfs_test_opt(root, SSD_SPREAD))
969 seq_puts(seq, ",ssd_spread");
970 else if (btrfs_test_opt(root, SSD))
a9572a15 971 seq_puts(seq, ",ssd");
3a5e1404 972 if (btrfs_test_opt(root, NOTREELOG))
6b65c5c6 973 seq_puts(seq, ",notreelog");
dccae999 974 if (btrfs_test_opt(root, FLUSHONCOMMIT))
6b65c5c6 975 seq_puts(seq, ",flushoncommit");
20a5239a
MW
976 if (btrfs_test_opt(root, DISCARD))
977 seq_puts(seq, ",discard");
a9572a15
EP
978 if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
979 seq_puts(seq, ",noacl");
200da64e
TI
980 if (btrfs_test_opt(root, SPACE_CACHE))
981 seq_puts(seq, ",space_cache");
73bc1876 982 else
8965593e 983 seq_puts(seq, ",nospace_cache");
f420ee1e
SB
984 if (btrfs_test_opt(root, RESCAN_UUID_TREE))
985 seq_puts(seq, ",rescan_uuid_tree");
200da64e
TI
986 if (btrfs_test_opt(root, CLEAR_CACHE))
987 seq_puts(seq, ",clear_cache");
988 if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
989 seq_puts(seq, ",user_subvol_rm_allowed");
0942caa3
DS
990 if (btrfs_test_opt(root, ENOSPC_DEBUG))
991 seq_puts(seq, ",enospc_debug");
992 if (btrfs_test_opt(root, AUTO_DEFRAG))
993 seq_puts(seq, ",autodefrag");
994 if (btrfs_test_opt(root, INODE_MAP_CACHE))
995 seq_puts(seq, ",inode_cache");
9555c6c1
ID
996 if (btrfs_test_opt(root, SKIP_BALANCE))
997 seq_puts(seq, ",skip_balance");
8507d216
WS
998 if (btrfs_test_opt(root, RECOVERY))
999 seq_puts(seq, ",recovery");
1000#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1001 if (btrfs_test_opt(root, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
1002 seq_puts(seq, ",check_int_data");
1003 else if (btrfs_test_opt(root, CHECK_INTEGRITY))
1004 seq_puts(seq, ",check_int");
1005 if (info->check_integrity_print_mask)
1006 seq_printf(seq, ",check_int_print_mask=%d",
1007 info->check_integrity_print_mask);
1008#endif
1009 if (info->metadata_ratio)
1010 seq_printf(seq, ",metadata_ratio=%d",
1011 info->metadata_ratio);
8c342930
JM
1012 if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
1013 seq_puts(seq, ",fatal_errors=panic");
8b87dc17
DS
1014 if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
1015 seq_printf(seq, ",commit=%d", info->commit_interval);
a9572a15
EP
1016 return 0;
1017}
1018
a061fc8d 1019static int btrfs_test_super(struct super_block *s, void *data)
4b82d6e4 1020{
815745cf
AV
1021 struct btrfs_fs_info *p = data;
1022 struct btrfs_fs_info *fs_info = btrfs_sb(s);
4b82d6e4 1023
815745cf 1024 return fs_info->fs_devices == p->fs_devices;
4b82d6e4
Y
1025}
1026
450ba0ea
JB
1027static int btrfs_set_super(struct super_block *s, void *data)
1028{
6de1d09d
AV
1029 int err = set_anon_super(s, data);
1030 if (!err)
1031 s->s_fs_info = data;
1032 return err;
4b82d6e4
Y
1033}
1034
f9d9ef62
DS
1035/*
1036 * subvolumes are identified by ino 256
1037 */
1038static inline int is_subvolume_inode(struct inode *inode)
1039{
1040 if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
1041 return 1;
1042 return 0;
1043}
1044
830c4adb
JB
1045/*
1046 * This will strip out the subvol=%s argument for an argument string and add
1047 * subvolid=0 to make sure we get the actual tree root for path walking to the
1048 * subvol we want.
1049 */
1050static char *setup_root_args(char *args)
1051{
f60d16a8
JM
1052 unsigned len = strlen(args) + 2 + 1;
1053 char *src, *dst, *buf;
830c4adb
JB
1054
1055 /*
f60d16a8
JM
1056 * We need the same args as before, but with this substitution:
1057 * s!subvol=[^,]+!subvolid=0!
830c4adb 1058 *
f60d16a8
JM
1059 * Since the replacement string is up to 2 bytes longer than the
1060 * original, allocate strlen(args) + 2 + 1 bytes.
830c4adb 1061 */
830c4adb 1062
f60d16a8 1063 src = strstr(args, "subvol=");
830c4adb 1064 /* This shouldn't happen, but just in case.. */
f60d16a8
JM
1065 if (!src)
1066 return NULL;
1067
1068 buf = dst = kmalloc(len, GFP_NOFS);
1069 if (!buf)
830c4adb 1070 return NULL;
830c4adb
JB
1071
1072 /*
f60d16a8
JM
1073 * If the subvol= arg is not at the start of the string,
1074 * copy whatever precedes it into buf.
830c4adb 1075 */
f60d16a8
JM
1076 if (src != args) {
1077 *src++ = '\0';
1078 strcpy(buf, args);
1079 dst += strlen(args);
830c4adb
JB
1080 }
1081
f60d16a8
JM
1082 strcpy(dst, "subvolid=0");
1083 dst += strlen("subvolid=0");
830c4adb
JB
1084
1085 /*
f60d16a8
JM
1086 * If there is a "," after the original subvol=... string,
1087 * copy that suffix into our buffer. Otherwise, we're done.
830c4adb 1088 */
f60d16a8
JM
1089 src = strchr(src, ',');
1090 if (src)
1091 strcpy(dst, src);
830c4adb 1092
f60d16a8 1093 return buf;
830c4adb
JB
1094}
1095
1096static struct dentry *mount_subvol(const char *subvol_name, int flags,
1097 const char *device_name, char *data)
1098{
830c4adb
JB
1099 struct dentry *root;
1100 struct vfsmount *mnt;
830c4adb 1101 char *newargs;
830c4adb
JB
1102
1103 newargs = setup_root_args(data);
1104 if (!newargs)
1105 return ERR_PTR(-ENOMEM);
1106 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
1107 newargs);
1108 kfree(newargs);
1109 if (IS_ERR(mnt))
1110 return ERR_CAST(mnt);
1111
ea441d11 1112 root = mount_subtree(mnt, subvol_name);
830c4adb 1113
ea441d11
AV
1114 if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
1115 struct super_block *s = root->d_sb;
1116 dput(root);
1117 root = ERR_PTR(-EINVAL);
1118 deactivate_locked_super(s);
f9d9ef62
DS
1119 printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
1120 subvol_name);
f9d9ef62
DS
1121 }
1122
830c4adb
JB
1123 return root;
1124}
450ba0ea 1125
edf24abe
CH
1126/*
1127 * Find a superblock for the given device / mount point.
1128 *
1129 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
1130 * for multiple device setup. Make sure to keep it in sync.
1131 */
061dbc6b 1132static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
306e16ce 1133 const char *device_name, void *data)
4b82d6e4
Y
1134{
1135 struct block_device *bdev = NULL;
1136 struct super_block *s;
1137 struct dentry *root;
8a4b83cc 1138 struct btrfs_fs_devices *fs_devices = NULL;
450ba0ea 1139 struct btrfs_fs_info *fs_info = NULL;
97288f2c 1140 fmode_t mode = FMODE_READ;
73f73415
JB
1141 char *subvol_name = NULL;
1142 u64 subvol_objectid = 0;
4b82d6e4
Y
1143 int error = 0;
1144
97288f2c
CH
1145 if (!(flags & MS_RDONLY))
1146 mode |= FMODE_WRITE;
1147
1148 error = btrfs_parse_early_options(data, mode, fs_type,
73f73415 1149 &subvol_name, &subvol_objectid,
5e2a4b25 1150 &fs_devices);
f23c8af8
ID
1151 if (error) {
1152 kfree(subvol_name);
061dbc6b 1153 return ERR_PTR(error);
f23c8af8 1154 }
edf24abe 1155
830c4adb
JB
1156 if (subvol_name) {
1157 root = mount_subvol(subvol_name, flags, device_name, data);
1158 kfree(subvol_name);
1159 return root;
1160 }
1161
306e16ce 1162 error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
8a4b83cc 1163 if (error)
830c4adb 1164 return ERR_PTR(error);
4b82d6e4 1165
450ba0ea
JB
1166 /*
1167 * Setup a dummy root and fs_info for test/set super. This is because
1168 * we don't actually fill this stuff out until open_ctree, but we need
1169 * it for searching for existing supers, so this lets us do that and
1170 * then open_ctree will properly initialize everything later.
1171 */
1172 fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
04d21a24
ID
1173 if (!fs_info)
1174 return ERR_PTR(-ENOMEM);
1175
450ba0ea 1176 fs_info->fs_devices = fs_devices;
450ba0ea 1177
6c41761f
DS
1178 fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1179 fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1180 if (!fs_info->super_copy || !fs_info->super_for_commit) {
1181 error = -ENOMEM;
04d21a24
ID
1182 goto error_fs_info;
1183 }
1184
1185 error = btrfs_open_devices(fs_devices, mode, fs_type);
1186 if (error)
1187 goto error_fs_info;
1188
1189 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
1190 error = -EACCES;
6c41761f
DS
1191 goto error_close_devices;
1192 }
1193
dfe25020 1194 bdev = fs_devices->latest_bdev;
9249e17f
DH
1195 s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
1196 fs_info);
830c4adb
JB
1197 if (IS_ERR(s)) {
1198 error = PTR_ERR(s);
1199 goto error_close_devices;
1200 }
4b82d6e4
Y
1201
1202 if (s->s_root) {
2b82032c 1203 btrfs_close_devices(fs_devices);
6c41761f 1204 free_fs_info(fs_info);
59553edf
AV
1205 if ((flags ^ s->s_flags) & MS_RDONLY)
1206 error = -EBUSY;
4b82d6e4
Y
1207 } else {
1208 char b[BDEVNAME_SIZE];
1209
4b82d6e4 1210 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
815745cf 1211 btrfs_sb(s)->bdev_holder = fs_type;
8a4b83cc
CM
1212 error = btrfs_fill_super(s, fs_devices, data,
1213 flags & MS_SILENT ? 1 : 0);
4b82d6e4
Y
1214 }
1215
59553edf
AV
1216 root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
1217 if (IS_ERR(root))
830c4adb 1218 deactivate_locked_super(s);
4b82d6e4 1219
061dbc6b 1220 return root;
4b82d6e4 1221
c146afad 1222error_close_devices:
8a4b83cc 1223 btrfs_close_devices(fs_devices);
04d21a24 1224error_fs_info:
6c41761f 1225 free_fs_info(fs_info);
061dbc6b 1226 return ERR_PTR(error);
4b82d6e4 1227}
2e635a27 1228
0d2450ab
ST
1229static void btrfs_set_max_workers(struct btrfs_workers *workers, int new_limit)
1230{
1231 spin_lock_irq(&workers->lock);
1232 workers->max_workers = new_limit;
1233 spin_unlock_irq(&workers->lock);
1234}
1235
1236static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
1237 int new_pool_size, int old_pool_size)
1238{
1239 if (new_pool_size == old_pool_size)
1240 return;
1241
1242 fs_info->thread_pool_size = new_pool_size;
1243
1244 printk(KERN_INFO "btrfs: resize thread pool %d -> %d\n",
1245 old_pool_size, new_pool_size);
1246
1247 btrfs_set_max_workers(&fs_info->generic_worker, new_pool_size);
1248 btrfs_set_max_workers(&fs_info->workers, new_pool_size);
1249 btrfs_set_max_workers(&fs_info->delalloc_workers, new_pool_size);
1250 btrfs_set_max_workers(&fs_info->submit_workers, new_pool_size);
1251 btrfs_set_max_workers(&fs_info->caching_workers, new_pool_size);
1252 btrfs_set_max_workers(&fs_info->fixup_workers, new_pool_size);
1253 btrfs_set_max_workers(&fs_info->endio_workers, new_pool_size);
1254 btrfs_set_max_workers(&fs_info->endio_meta_workers, new_pool_size);
1255 btrfs_set_max_workers(&fs_info->endio_meta_write_workers, new_pool_size);
1256 btrfs_set_max_workers(&fs_info->endio_write_workers, new_pool_size);
1257 btrfs_set_max_workers(&fs_info->endio_freespace_worker, new_pool_size);
1258 btrfs_set_max_workers(&fs_info->delayed_workers, new_pool_size);
1259 btrfs_set_max_workers(&fs_info->readahead_workers, new_pool_size);
ff023aac
SB
1260 btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
1261 new_pool_size);
0d2450ab
ST
1262}
1263
f42a34b2 1264static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
dc81cdc5
MX
1265{
1266 set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
f42a34b2 1267}
dc81cdc5 1268
f42a34b2
MX
1269static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
1270 unsigned long old_opts, int flags)
1271{
dc81cdc5
MX
1272 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1273 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1274 (flags & MS_RDONLY))) {
1275 /* wait for any defraggers to finish */
1276 wait_event(fs_info->transaction_wait,
1277 (atomic_read(&fs_info->defrag_running) == 0));
1278 if (flags & MS_RDONLY)
1279 sync_filesystem(fs_info->sb);
1280 }
1281}
1282
1283static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,
1284 unsigned long old_opts)
1285{
1286 /*
1287 * We need cleanup all defragable inodes if the autodefragment is
1288 * close or the fs is R/O.
1289 */
1290 if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1291 (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1292 (fs_info->sb->s_flags & MS_RDONLY))) {
1293 btrfs_cleanup_defrag_inodes(fs_info);
1294 }
1295
1296 clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1297}
1298
c146afad
YZ
1299static int btrfs_remount(struct super_block *sb, int *flags, char *data)
1300{
815745cf
AV
1301 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1302 struct btrfs_root *root = fs_info->tree_root;
49b25e05
JM
1303 unsigned old_flags = sb->s_flags;
1304 unsigned long old_opts = fs_info->mount_opt;
1305 unsigned long old_compress_type = fs_info->compress_type;
1306 u64 old_max_inline = fs_info->max_inline;
1307 u64 old_alloc_start = fs_info->alloc_start;
1308 int old_thread_pool_size = fs_info->thread_pool_size;
1309 unsigned int old_metadata_ratio = fs_info->metadata_ratio;
c146afad
YZ
1310 int ret;
1311
f42a34b2 1312 btrfs_remount_prepare(fs_info);
dc81cdc5 1313
b288052e 1314 ret = btrfs_parse_options(root, data);
49b25e05
JM
1315 if (ret) {
1316 ret = -EINVAL;
1317 goto restore;
1318 }
b288052e 1319
f42a34b2 1320 btrfs_remount_begin(fs_info, old_opts, *flags);
0d2450ab
ST
1321 btrfs_resize_thread_pool(fs_info,
1322 fs_info->thread_pool_size, old_thread_pool_size);
1323
c146afad 1324 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
dc81cdc5 1325 goto out;
c146afad
YZ
1326
1327 if (*flags & MS_RDONLY) {
8dabb742
SB
1328 /*
1329 * this also happens on 'umount -rf' or on shutdown, when
1330 * the filesystem is busy.
1331 */
c146afad
YZ
1332 sb->s_flags |= MS_RDONLY;
1333
8dabb742
SB
1334 btrfs_dev_replace_suspend_for_unmount(fs_info);
1335 btrfs_scrub_cancel(fs_info);
061594ef 1336 btrfs_pause_balance(fs_info);
8dabb742 1337
49b25e05
JM
1338 ret = btrfs_commit_super(root);
1339 if (ret)
1340 goto restore;
c146afad 1341 } else {
8a3db184 1342 if (fs_info->fs_devices->rw_devices == 0) {
49b25e05
JM
1343 ret = -EACCES;
1344 goto restore;
8a3db184 1345 }
2b82032c 1346
292fd7fc
SB
1347 if (fs_info->fs_devices->missing_devices >
1348 fs_info->num_tolerated_disk_barrier_failures &&
1349 !(*flags & MS_RDONLY)) {
1350 printk(KERN_WARNING
1351 "Btrfs: too many missing devices, writeable remount is not allowed\n");
1352 ret = -EACCES;
1353 goto restore;
1354 }
1355
8a3db184 1356 if (btrfs_super_log_root(fs_info->super_copy) != 0) {
49b25e05
JM
1357 ret = -EINVAL;
1358 goto restore;
8a3db184 1359 }
c146afad 1360
815745cf 1361 ret = btrfs_cleanup_fs_roots(fs_info);
49b25e05
JM
1362 if (ret)
1363 goto restore;
c146afad 1364
d68fc57b
YZ
1365 /* recover relocation */
1366 ret = btrfs_recover_relocation(root);
49b25e05
JM
1367 if (ret)
1368 goto restore;
c146afad 1369
2b6ba629
ID
1370 ret = btrfs_resume_balance_async(fs_info);
1371 if (ret)
1372 goto restore;
1373
8dabb742
SB
1374 ret = btrfs_resume_dev_replace_async(fs_info);
1375 if (ret) {
1376 pr_warn("btrfs: failed to resume dev_replace\n");
1377 goto restore;
1378 }
c146afad
YZ
1379 sb->s_flags &= ~MS_RDONLY;
1380 }
dc81cdc5
MX
1381out:
1382 btrfs_remount_cleanup(fs_info, old_opts);
c146afad 1383 return 0;
49b25e05
JM
1384
1385restore:
1386 /* We've hit an error - don't reset MS_RDONLY */
1387 if (sb->s_flags & MS_RDONLY)
1388 old_flags |= MS_RDONLY;
1389 sb->s_flags = old_flags;
1390 fs_info->mount_opt = old_opts;
1391 fs_info->compress_type = old_compress_type;
1392 fs_info->max_inline = old_max_inline;
c018daec 1393 mutex_lock(&fs_info->chunk_mutex);
49b25e05 1394 fs_info->alloc_start = old_alloc_start;
c018daec 1395 mutex_unlock(&fs_info->chunk_mutex);
0d2450ab
ST
1396 btrfs_resize_thread_pool(fs_info,
1397 old_thread_pool_size, fs_info->thread_pool_size);
49b25e05 1398 fs_info->metadata_ratio = old_metadata_ratio;
dc81cdc5 1399 btrfs_remount_cleanup(fs_info, old_opts);
49b25e05 1400 return ret;
c146afad
YZ
1401}
1402
bcd53741
AJ
1403/* Used to sort the devices by max_avail(descending sort) */
1404static int btrfs_cmp_device_free_bytes(const void *dev_info1,
1405 const void *dev_info2)
1406{
1407 if (((struct btrfs_device_info *)dev_info1)->max_avail >
1408 ((struct btrfs_device_info *)dev_info2)->max_avail)
1409 return -1;
1410 else if (((struct btrfs_device_info *)dev_info1)->max_avail <
1411 ((struct btrfs_device_info *)dev_info2)->max_avail)
1412 return 1;
1413 else
1414 return 0;
1415}
1416
1417/*
1418 * sort the devices by max_avail, in which max free extent size of each device
1419 * is stored.(Descending Sort)
1420 */
1421static inline void btrfs_descending_sort_devices(
1422 struct btrfs_device_info *devices,
1423 size_t nr_devices)
1424{
1425 sort(devices, nr_devices, sizeof(struct btrfs_device_info),
1426 btrfs_cmp_device_free_bytes, NULL);
1427}
1428
6d07bcec
MX
1429/*
1430 * The helper to calc the free space on the devices that can be used to store
1431 * file data.
1432 */
1433static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
1434{
1435 struct btrfs_fs_info *fs_info = root->fs_info;
1436 struct btrfs_device_info *devices_info;
1437 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
1438 struct btrfs_device *device;
1439 u64 skip_space;
1440 u64 type;
1441 u64 avail_space;
1442 u64 used_space;
1443 u64 min_stripe_size;
39fb26c3 1444 int min_stripes = 1, num_stripes = 1;
6d07bcec
MX
1445 int i = 0, nr_devices;
1446 int ret;
1447
b772a86e 1448 nr_devices = fs_info->fs_devices->open_devices;
6d07bcec
MX
1449 BUG_ON(!nr_devices);
1450
1451 devices_info = kmalloc(sizeof(*devices_info) * nr_devices,
1452 GFP_NOFS);
1453 if (!devices_info)
1454 return -ENOMEM;
1455
1456 /* calc min stripe number for data space alloction */
1457 type = btrfs_get_alloc_profile(root, 1);
39fb26c3 1458 if (type & BTRFS_BLOCK_GROUP_RAID0) {
6d07bcec 1459 min_stripes = 2;
39fb26c3
MX
1460 num_stripes = nr_devices;
1461 } else if (type & BTRFS_BLOCK_GROUP_RAID1) {
6d07bcec 1462 min_stripes = 2;
39fb26c3
MX
1463 num_stripes = 2;
1464 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
6d07bcec 1465 min_stripes = 4;
39fb26c3
MX
1466 num_stripes = 4;
1467 }
6d07bcec
MX
1468
1469 if (type & BTRFS_BLOCK_GROUP_DUP)
1470 min_stripe_size = 2 * BTRFS_STRIPE_LEN;
1471 else
1472 min_stripe_size = BTRFS_STRIPE_LEN;
1473
b772a86e 1474 list_for_each_entry(device, &fs_devices->devices, dev_list) {
63a212ab
SB
1475 if (!device->in_fs_metadata || !device->bdev ||
1476 device->is_tgtdev_for_dev_replace)
6d07bcec
MX
1477 continue;
1478
1479 avail_space = device->total_bytes - device->bytes_used;
1480
1481 /* align with stripe_len */
1482 do_div(avail_space, BTRFS_STRIPE_LEN);
1483 avail_space *= BTRFS_STRIPE_LEN;
1484
1485 /*
1486 * In order to avoid overwritting the superblock on the drive,
1487 * btrfs starts at an offset of at least 1MB when doing chunk
1488 * allocation.
1489 */
1490 skip_space = 1024 * 1024;
1491
1492 /* user can set the offset in fs_info->alloc_start. */
1493 if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
1494 device->total_bytes)
1495 skip_space = max(fs_info->alloc_start, skip_space);
1496
1497 /*
1498 * btrfs can not use the free space in [0, skip_space - 1],
1499 * we must subtract it from the total. In order to implement
1500 * it, we account the used space in this range first.
1501 */
1502 ret = btrfs_account_dev_extents_size(device, 0, skip_space - 1,
1503 &used_space);
1504 if (ret) {
1505 kfree(devices_info);
1506 return ret;
1507 }
1508
1509 /* calc the free space in [0, skip_space - 1] */
1510 skip_space -= used_space;
1511
1512 /*
1513 * we can use the free space in [0, skip_space - 1], subtract
1514 * it from the total.
1515 */
1516 if (avail_space && avail_space >= skip_space)
1517 avail_space -= skip_space;
1518 else
1519 avail_space = 0;
1520
1521 if (avail_space < min_stripe_size)
1522 continue;
1523
1524 devices_info[i].dev = device;
1525 devices_info[i].max_avail = avail_space;
1526
1527 i++;
1528 }
1529
1530 nr_devices = i;
1531
1532 btrfs_descending_sort_devices(devices_info, nr_devices);
1533
1534 i = nr_devices - 1;
1535 avail_space = 0;
1536 while (nr_devices >= min_stripes) {
39fb26c3
MX
1537 if (num_stripes > nr_devices)
1538 num_stripes = nr_devices;
1539
6d07bcec
MX
1540 if (devices_info[i].max_avail >= min_stripe_size) {
1541 int j;
1542 u64 alloc_size;
1543
39fb26c3 1544 avail_space += devices_info[i].max_avail * num_stripes;
6d07bcec 1545 alloc_size = devices_info[i].max_avail;
39fb26c3 1546 for (j = i + 1 - num_stripes; j <= i; j++)
6d07bcec
MX
1547 devices_info[j].max_avail -= alloc_size;
1548 }
1549 i--;
1550 nr_devices--;
1551 }
1552
1553 kfree(devices_info);
1554 *free_bytes = avail_space;
1555 return 0;
1556}
1557
8fd17795
CM
1558static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1559{
815745cf
AV
1560 struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
1561 struct btrfs_super_block *disk_super = fs_info->super_copy;
1562 struct list_head *head = &fs_info->space_info;
bd4d1088
JB
1563 struct btrfs_space_info *found;
1564 u64 total_used = 0;
6d07bcec 1565 u64 total_free_data = 0;
db94535d 1566 int bits = dentry->d_sb->s_blocksize_bits;
815745cf 1567 __be32 *fsid = (__be32 *)fs_info->fsid;
6d07bcec 1568 int ret;
8fd17795 1569
6d07bcec 1570 /* holding chunk_muext to avoid allocating new chunks */
815745cf 1571 mutex_lock(&fs_info->chunk_mutex);
bd4d1088 1572 rcu_read_lock();
89a55897 1573 list_for_each_entry_rcu(found, head, list) {
6d07bcec
MX
1574 if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
1575 total_free_data += found->disk_total - found->disk_used;
1576 total_free_data -=
1577 btrfs_account_ro_block_groups_free_space(found);
1578 }
1579
b742bb82 1580 total_used += found->disk_used;
89a55897 1581 }
bd4d1088
JB
1582 rcu_read_unlock();
1583
8fd17795 1584 buf->f_namelen = BTRFS_NAME_LEN;
db94535d 1585 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
bd4d1088 1586 buf->f_bfree = buf->f_blocks - (total_used >> bits);
8fd17795
CM
1587 buf->f_bsize = dentry->d_sb->s_blocksize;
1588 buf->f_type = BTRFS_SUPER_MAGIC;
6d07bcec 1589 buf->f_bavail = total_free_data;
815745cf 1590 ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
6d07bcec 1591 if (ret) {
815745cf 1592 mutex_unlock(&fs_info->chunk_mutex);
6d07bcec
MX
1593 return ret;
1594 }
1595 buf->f_bavail += total_free_data;
1596 buf->f_bavail = buf->f_bavail >> bits;
815745cf 1597 mutex_unlock(&fs_info->chunk_mutex);
d397712b 1598
9d03632e 1599 /* We treat it as constant endianness (it doesn't matter _which_)
d397712b 1600 because we want the fsid to come out the same whether mounted
9d03632e
DW
1601 on a big-endian or little-endian host */
1602 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
1603 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
32d48fa1
DW
1604 /* Mask in the root object ID too, to disambiguate subvols */
1605 buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
1606 buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
1607
8fd17795
CM
1608 return 0;
1609}
b5133862 1610
aea52e19
AV
1611static void btrfs_kill_super(struct super_block *sb)
1612{
815745cf 1613 struct btrfs_fs_info *fs_info = btrfs_sb(sb);
aea52e19 1614 kill_anon_super(sb);
d22ca7de 1615 free_fs_info(fs_info);
aea52e19
AV
1616}
1617
2e635a27
CM
1618static struct file_system_type btrfs_fs_type = {
1619 .owner = THIS_MODULE,
1620 .name = "btrfs",
061dbc6b 1621 .mount = btrfs_mount,
aea52e19 1622 .kill_sb = btrfs_kill_super,
2e635a27
CM
1623 .fs_flags = FS_REQUIRES_DEV,
1624};
7f78e035 1625MODULE_ALIAS_FS("btrfs");
a9218f6b 1626
d352ac68
CM
1627/*
1628 * used by btrfsctl to scan devices when no FS is mounted
1629 */
8a4b83cc
CM
1630static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
1631 unsigned long arg)
1632{
1633 struct btrfs_ioctl_vol_args *vol;
1634 struct btrfs_fs_devices *fs_devices;
c071fcfd 1635 int ret = -ENOTTY;
8a4b83cc 1636
e441d54d
CM
1637 if (!capable(CAP_SYS_ADMIN))
1638 return -EPERM;
1639
dae7b665
LZ
1640 vol = memdup_user((void __user *)arg, sizeof(*vol));
1641 if (IS_ERR(vol))
1642 return PTR_ERR(vol);
c071fcfd 1643
8a4b83cc
CM
1644 switch (cmd) {
1645 case BTRFS_IOC_SCAN_DEV:
97288f2c 1646 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
8a4b83cc
CM
1647 &btrfs_fs_type, &fs_devices);
1648 break;
02db0844
JB
1649 case BTRFS_IOC_DEVICES_READY:
1650 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1651 &btrfs_fs_type, &fs_devices);
1652 if (ret)
1653 break;
1654 ret = !(fs_devices->num_devices == fs_devices->total_devices);
1655 break;
8a4b83cc 1656 }
dae7b665 1657
8a4b83cc 1658 kfree(vol);
f819d837 1659 return ret;
8a4b83cc
CM
1660}
1661
0176260f 1662static int btrfs_freeze(struct super_block *sb)
ed0dab6b 1663{
354aa0fb
MX
1664 struct btrfs_trans_handle *trans;
1665 struct btrfs_root *root = btrfs_sb(sb)->tree_root;
1666
d4edf39b 1667 trans = btrfs_attach_transaction_barrier(root);
354aa0fb
MX
1668 if (IS_ERR(trans)) {
1669 /* no transaction, don't bother */
1670 if (PTR_ERR(trans) == -ENOENT)
1671 return 0;
1672 return PTR_ERR(trans);
1673 }
1674 return btrfs_commit_transaction(trans, root);
ed0dab6b
Y
1675}
1676
0176260f 1677static int btrfs_unfreeze(struct super_block *sb)
ed0dab6b 1678{
0176260f 1679 return 0;
ed0dab6b 1680}
2e635a27 1681
9c5085c1
JB
1682static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
1683{
1684 struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
1685 struct btrfs_fs_devices *cur_devices;
1686 struct btrfs_device *dev, *first_dev = NULL;
1687 struct list_head *head;
1688 struct rcu_string *name;
1689
1690 mutex_lock(&fs_info->fs_devices->device_list_mutex);
1691 cur_devices = fs_info->fs_devices;
1692 while (cur_devices) {
1693 head = &cur_devices->devices;
1694 list_for_each_entry(dev, head, dev_list) {
aa9ddcd4
JB
1695 if (dev->missing)
1696 continue;
9c5085c1
JB
1697 if (!first_dev || dev->devid < first_dev->devid)
1698 first_dev = dev;
1699 }
1700 cur_devices = cur_devices->seed;
1701 }
1702
1703 if (first_dev) {
1704 rcu_read_lock();
1705 name = rcu_dereference(first_dev->name);
1706 seq_escape(m, name->str, " \t\n\\");
1707 rcu_read_unlock();
1708 } else {
1709 WARN_ON(1);
1710 }
1711 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1712 return 0;
1713}
1714
b87221de 1715static const struct super_operations btrfs_super_ops = {
76dda93c 1716 .drop_inode = btrfs_drop_inode,
bd555975 1717 .evict_inode = btrfs_evict_inode,
e20d96d6 1718 .put_super = btrfs_put_super,
d5719762 1719 .sync_fs = btrfs_sync_fs,
a9572a15 1720 .show_options = btrfs_show_options,
9c5085c1 1721 .show_devname = btrfs_show_devname,
4730a4bc 1722 .write_inode = btrfs_write_inode,
2c90e5d6
CM
1723 .alloc_inode = btrfs_alloc_inode,
1724 .destroy_inode = btrfs_destroy_inode,
8fd17795 1725 .statfs = btrfs_statfs,
c146afad 1726 .remount_fs = btrfs_remount,
0176260f
LT
1727 .freeze_fs = btrfs_freeze,
1728 .unfreeze_fs = btrfs_unfreeze,
e20d96d6 1729};
a9218f6b
CM
1730
1731static const struct file_operations btrfs_ctl_fops = {
1732 .unlocked_ioctl = btrfs_control_ioctl,
1733 .compat_ioctl = btrfs_control_ioctl,
1734 .owner = THIS_MODULE,
6038f373 1735 .llseek = noop_llseek,
a9218f6b
CM
1736};
1737
1738static struct miscdevice btrfs_misc = {
578454ff 1739 .minor = BTRFS_MINOR,
a9218f6b
CM
1740 .name = "btrfs-control",
1741 .fops = &btrfs_ctl_fops
1742};
1743
578454ff
KS
1744MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
1745MODULE_ALIAS("devname:btrfs-control");
1746
a9218f6b
CM
1747static int btrfs_interface_init(void)
1748{
1749 return misc_register(&btrfs_misc);
1750}
1751
b2950863 1752static void btrfs_interface_exit(void)
a9218f6b
CM
1753{
1754 if (misc_deregister(&btrfs_misc) < 0)
48940662 1755 printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
a9218f6b
CM
1756}
1757
85965600
DS
1758static void btrfs_print_info(void)
1759{
1760 printk(KERN_INFO "Btrfs loaded"
1761#ifdef CONFIG_BTRFS_DEBUG
1762 ", debug=on"
1763#endif
1764#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1765 ", integrity-checker=on"
1766#endif
1767 "\n");
1768}
1769
dc11dd5d
JB
1770static int btrfs_run_sanity_tests(void)
1771{
1772 return btrfs_test_free_space_cache();
1773}
1774
2e635a27
CM
1775static int __init init_btrfs_fs(void)
1776{
2c90e5d6 1777 int err;
58176a96
JB
1778
1779 err = btrfs_init_sysfs();
1780 if (err)
1781 return err;
1782
143bede5 1783 btrfs_init_compress();
d1310b2e 1784
261507a0
LZ
1785 err = btrfs_init_cachep();
1786 if (err)
1787 goto free_compress;
1788
d1310b2e 1789 err = extent_io_init();
2f4cbe64
WB
1790 if (err)
1791 goto free_cachep;
1792
d1310b2e
CM
1793 err = extent_map_init();
1794 if (err)
1795 goto free_extent_io;
1796
6352b91d 1797 err = ordered_data_init();
2f4cbe64
WB
1798 if (err)
1799 goto free_extent_map;
c8b97818 1800
6352b91d
MX
1801 err = btrfs_delayed_inode_init();
1802 if (err)
1803 goto free_ordered_data;
1804
9247f317 1805 err = btrfs_auto_defrag_init();
16cdcec7
MX
1806 if (err)
1807 goto free_delayed_inode;
1808
78a6184a 1809 err = btrfs_delayed_ref_init();
9247f317
MX
1810 if (err)
1811 goto free_auto_defrag;
1812
78a6184a
MX
1813 err = btrfs_interface_init();
1814 if (err)
1815 goto free_delayed_ref;
1816
e565d4b9
JS
1817 btrfs_init_lockdep();
1818
85965600 1819 btrfs_print_info();
dc11dd5d
JB
1820
1821 err = btrfs_run_sanity_tests();
1822 if (err)
1823 goto unregister_ioctl;
1824
1825 err = register_filesystem(&btrfs_fs_type);
1826 if (err)
1827 goto unregister_ioctl;
74255aa0 1828
2f4cbe64
WB
1829 return 0;
1830
a9218f6b
CM
1831unregister_ioctl:
1832 btrfs_interface_exit();
78a6184a
MX
1833free_delayed_ref:
1834 btrfs_delayed_ref_exit();
9247f317
MX
1835free_auto_defrag:
1836 btrfs_auto_defrag_exit();
16cdcec7
MX
1837free_delayed_inode:
1838 btrfs_delayed_inode_exit();
6352b91d
MX
1839free_ordered_data:
1840 ordered_data_exit();
2f4cbe64
WB
1841free_extent_map:
1842 extent_map_exit();
d1310b2e
CM
1843free_extent_io:
1844 extent_io_exit();
2f4cbe64
WB
1845free_cachep:
1846 btrfs_destroy_cachep();
261507a0
LZ
1847free_compress:
1848 btrfs_exit_compress();
2f4cbe64
WB
1849 btrfs_exit_sysfs();
1850 return err;
2e635a27
CM
1851}
1852
1853static void __exit exit_btrfs_fs(void)
1854{
39279cc3 1855 btrfs_destroy_cachep();
78a6184a 1856 btrfs_delayed_ref_exit();
9247f317 1857 btrfs_auto_defrag_exit();
16cdcec7 1858 btrfs_delayed_inode_exit();
6352b91d 1859 ordered_data_exit();
a52d9a80 1860 extent_map_exit();
d1310b2e 1861 extent_io_exit();
a9218f6b 1862 btrfs_interface_exit();
2e635a27 1863 unregister_filesystem(&btrfs_fs_type);
58176a96 1864 btrfs_exit_sysfs();
8a4b83cc 1865 btrfs_cleanup_fs_uuids();
261507a0 1866 btrfs_exit_compress();
2e635a27
CM
1867}
1868
1869module_init(init_btrfs_fs)
1870module_exit(exit_btrfs_fs)
1871
1872MODULE_LICENSE("GPL");