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