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