2 * Copyright (C) 2007 Oracle. All rights reserved.
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.
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.
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.
19 #include <linux/blkdev.h>
20 #include <linux/module.h>
21 #include <linux/buffer_head.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/mnt_namespace.h>
44 #include <linux/ratelimit.h>
46 #include "delayed-inode.h"
49 #include "transaction.h"
50 #include "btrfs_inode.h"
52 #include "print-tree.h"
57 #include "compression.h"
59 #define CREATE_TRACE_POINTS
60 #include <trace/events/btrfs.h>
62 static const struct super_operations btrfs_super_ops;
63 static struct file_system_type btrfs_fs_type;
65 static const char *btrfs_decode_error(struct btrfs_fs_info *fs_info, int errno,
72 errstr = "IO failure";
75 errstr = "Out of memory";
78 errstr = "Readonly filesystem";
82 if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
91 static void __save_error_info(struct btrfs_fs_info *fs_info)
94 * today we only save the error info into ram. Long term we'll
95 * also send it down to the disk
97 fs_info->fs_state = BTRFS_SUPER_FLAG_ERROR;
101 * We move write_super stuff at umount in order to avoid deadlock
102 * for umount hold all lock.
104 static void save_error_info(struct btrfs_fs_info *fs_info)
106 __save_error_info(fs_info);
109 /* btrfs handle error by forcing the filesystem readonly */
110 static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
112 struct super_block *sb = fs_info->sb;
114 if (sb->s_flags & MS_RDONLY)
117 if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
118 sb->s_flags |= MS_RDONLY;
119 printk(KERN_INFO "btrfs is forced readonly\n");
124 * __btrfs_std_error decodes expected errors from the caller and
125 * invokes the approciate error response.
127 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
128 unsigned int line, int errno)
130 struct super_block *sb = fs_info->sb;
135 * Special case: if the error is EROFS, and we're already
136 * under MS_RDONLY, then it is safe here.
138 if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
141 errstr = btrfs_decode_error(fs_info, errno, nbuf);
142 printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n",
143 sb->s_id, function, line, errstr);
144 save_error_info(fs_info);
146 btrfs_handle_error(fs_info);
149 static void btrfs_put_super(struct super_block *sb)
151 struct btrfs_root *root = btrfs_sb(sb);
154 ret = close_ctree(root);
155 sb->s_fs_info = NULL;
157 (void)ret; /* FIXME: need to fix VFS to return error? */
161 Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
162 Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
163 Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
164 Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
165 Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
166 Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
167 Opt_enospc_debug, Opt_subvolrootid, Opt_defrag,
168 Opt_inode_cache, Opt_no_space_cache, Opt_recovery,
169 Opt_check_integrity, Opt_check_integrity_including_extent_data,
170 Opt_check_integrity_print_mask,
174 static match_table_t tokens = {
175 {Opt_degraded, "degraded"},
176 {Opt_subvol, "subvol=%s"},
177 {Opt_subvolid, "subvolid=%d"},
178 {Opt_device, "device=%s"},
179 {Opt_nodatasum, "nodatasum"},
180 {Opt_nodatacow, "nodatacow"},
181 {Opt_nobarrier, "nobarrier"},
182 {Opt_max_inline, "max_inline=%s"},
183 {Opt_alloc_start, "alloc_start=%s"},
184 {Opt_thread_pool, "thread_pool=%d"},
185 {Opt_compress, "compress"},
186 {Opt_compress_type, "compress=%s"},
187 {Opt_compress_force, "compress-force"},
188 {Opt_compress_force_type, "compress-force=%s"},
190 {Opt_ssd_spread, "ssd_spread"},
191 {Opt_nossd, "nossd"},
192 {Opt_noacl, "noacl"},
193 {Opt_notreelog, "notreelog"},
194 {Opt_flushoncommit, "flushoncommit"},
195 {Opt_ratio, "metadata_ratio=%d"},
196 {Opt_discard, "discard"},
197 {Opt_space_cache, "space_cache"},
198 {Opt_clear_cache, "clear_cache"},
199 {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
200 {Opt_enospc_debug, "enospc_debug"},
201 {Opt_subvolrootid, "subvolrootid=%d"},
202 {Opt_defrag, "autodefrag"},
203 {Opt_inode_cache, "inode_cache"},
204 {Opt_no_space_cache, "nospace_cache"},
205 {Opt_recovery, "recovery"},
206 {Opt_check_integrity, "check_int"},
207 {Opt_check_integrity_including_extent_data, "check_int_data"},
208 {Opt_check_integrity_print_mask, "check_int_print_mask=%d"},
213 * Regular mount options parser. Everything that is needed only when
214 * reading in a new superblock is parsed here.
216 int btrfs_parse_options(struct btrfs_root *root, char *options)
218 struct btrfs_fs_info *info = root->fs_info;
219 substring_t args[MAX_OPT_ARGS];
220 char *p, *num, *orig = NULL;
225 bool compress_force = false;
227 cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
229 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
235 * strsep changes the string, duplicate it because parse_options
238 options = kstrdup(options, GFP_NOFS);
244 while ((p = strsep(&options, ",")) != NULL) {
249 token = match_token(p, tokens, args);
252 printk(KERN_INFO "btrfs: allowing degraded mounts\n");
253 btrfs_set_opt(info->mount_opt, DEGRADED);
257 case Opt_subvolrootid:
260 * These are parsed by btrfs_parse_early_options
261 * and can be happily ignored here.
265 printk(KERN_INFO "btrfs: setting nodatasum\n");
266 btrfs_set_opt(info->mount_opt, NODATASUM);
269 printk(KERN_INFO "btrfs: setting nodatacow\n");
270 btrfs_set_opt(info->mount_opt, NODATACOW);
271 btrfs_set_opt(info->mount_opt, NODATASUM);
273 case Opt_compress_force:
274 case Opt_compress_force_type:
275 compress_force = true;
277 case Opt_compress_type:
278 if (token == Opt_compress ||
279 token == Opt_compress_force ||
280 strcmp(args[0].from, "zlib") == 0) {
281 compress_type = "zlib";
282 info->compress_type = BTRFS_COMPRESS_ZLIB;
283 } else if (strcmp(args[0].from, "lzo") == 0) {
284 compress_type = "lzo";
285 info->compress_type = BTRFS_COMPRESS_LZO;
291 btrfs_set_opt(info->mount_opt, COMPRESS);
292 if (compress_force) {
293 btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
294 pr_info("btrfs: force %s compression\n",
297 pr_info("btrfs: use %s compression\n",
301 printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
302 btrfs_set_opt(info->mount_opt, SSD);
305 printk(KERN_INFO "btrfs: use spread ssd "
306 "allocation scheme\n");
307 btrfs_set_opt(info->mount_opt, SSD);
308 btrfs_set_opt(info->mount_opt, SSD_SPREAD);
311 printk(KERN_INFO "btrfs: not using ssd allocation "
313 btrfs_set_opt(info->mount_opt, NOSSD);
314 btrfs_clear_opt(info->mount_opt, SSD);
315 btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
318 printk(KERN_INFO "btrfs: turning off barriers\n");
319 btrfs_set_opt(info->mount_opt, NOBARRIER);
321 case Opt_thread_pool:
323 match_int(&args[0], &intarg);
325 info->thread_pool_size = intarg;
326 printk(KERN_INFO "btrfs: thread pool %d\n",
327 info->thread_pool_size);
331 num = match_strdup(&args[0]);
333 info->max_inline = memparse(num, NULL);
336 if (info->max_inline) {
337 info->max_inline = max_t(u64,
341 printk(KERN_INFO "btrfs: max_inline at %llu\n",
342 (unsigned long long)info->max_inline);
345 case Opt_alloc_start:
346 num = match_strdup(&args[0]);
348 info->alloc_start = memparse(num, NULL);
351 "btrfs: allocations start at %llu\n",
352 (unsigned long long)info->alloc_start);
356 root->fs_info->sb->s_flags &= ~MS_POSIXACL;
359 printk(KERN_INFO "btrfs: disabling tree log\n");
360 btrfs_set_opt(info->mount_opt, NOTREELOG);
362 case Opt_flushoncommit:
363 printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
364 btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
368 match_int(&args[0], &intarg);
370 info->metadata_ratio = intarg;
371 printk(KERN_INFO "btrfs: metadata ratio %d\n",
372 info->metadata_ratio);
376 btrfs_set_opt(info->mount_opt, DISCARD);
378 case Opt_space_cache:
379 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
381 case Opt_no_space_cache:
382 printk(KERN_INFO "btrfs: disabling disk space caching\n");
383 btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
385 case Opt_inode_cache:
386 printk(KERN_INFO "btrfs: enabling inode map caching\n");
387 btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
389 case Opt_clear_cache:
390 printk(KERN_INFO "btrfs: force clearing of disk cache\n");
391 btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
393 case Opt_user_subvol_rm_allowed:
394 btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
396 case Opt_enospc_debug:
397 btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
400 printk(KERN_INFO "btrfs: enabling auto defrag");
401 btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
404 printk(KERN_INFO "btrfs: enabling auto recovery");
405 btrfs_set_opt(info->mount_opt, RECOVERY);
407 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
408 case Opt_check_integrity_including_extent_data:
409 printk(KERN_INFO "btrfs: enabling check integrity"
410 " including extent data\n");
411 btrfs_set_opt(info->mount_opt,
412 CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
413 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
415 case Opt_check_integrity:
416 printk(KERN_INFO "btrfs: enabling check integrity\n");
417 btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
419 case Opt_check_integrity_print_mask:
421 match_int(&args[0], &intarg);
423 info->check_integrity_print_mask = intarg;
424 printk(KERN_INFO "btrfs:"
425 " check_integrity_print_mask 0x%x\n",
426 info->check_integrity_print_mask);
430 case Opt_check_integrity_including_extent_data:
431 case Opt_check_integrity:
432 case Opt_check_integrity_print_mask:
433 printk(KERN_ERR "btrfs: support for check_integrity*"
434 " not compiled in!\n");
439 printk(KERN_INFO "btrfs: unrecognized mount option "
448 if (!ret && btrfs_test_opt(root, SPACE_CACHE))
449 printk(KERN_INFO "btrfs: disk space caching is enabled\n");
455 * Parse mount options that are required early in the mount process.
457 * All other options will be parsed on much later in the mount process and
458 * only when we need to allocate a new super block.
460 static int btrfs_parse_early_options(const char *options, fmode_t flags,
461 void *holder, char **subvol_name, u64 *subvol_objectid,
462 u64 *subvol_rootid, struct btrfs_fs_devices **fs_devices)
464 substring_t args[MAX_OPT_ARGS];
465 char *device_name, *opts, *orig, *p;
473 * strsep changes the string, duplicate it because parse_options
476 opts = kstrdup(options, GFP_KERNEL);
481 while ((p = strsep(&opts, ",")) != NULL) {
486 token = match_token(p, tokens, args);
490 *subvol_name = match_strdup(&args[0]);
494 error = match_int(&args[0], &intarg);
496 /* we want the original fs_tree */
499 BTRFS_FS_TREE_OBJECTID;
501 *subvol_objectid = intarg;
504 case Opt_subvolrootid:
506 error = match_int(&args[0], &intarg);
508 /* we want the original fs_tree */
511 BTRFS_FS_TREE_OBJECTID;
513 *subvol_rootid = intarg;
517 device_name = match_strdup(&args[0]);
522 error = btrfs_scan_one_device(device_name,
523 flags, holder, fs_devices);
538 static struct dentry *get_default_root(struct super_block *sb,
541 struct btrfs_root *root = sb->s_fs_info;
542 struct btrfs_root *new_root;
543 struct btrfs_dir_item *di;
544 struct btrfs_path *path;
545 struct btrfs_key location;
551 * We have a specific subvol we want to mount, just setup location and
552 * go look up the root.
554 if (subvol_objectid) {
555 location.objectid = subvol_objectid;
556 location.type = BTRFS_ROOT_ITEM_KEY;
557 location.offset = (u64)-1;
561 path = btrfs_alloc_path();
563 return ERR_PTR(-ENOMEM);
564 path->leave_spinning = 1;
567 * Find the "default" dir item which points to the root item that we
568 * will mount by default if we haven't been given a specific subvolume
571 dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
572 di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
574 btrfs_free_path(path);
579 * Ok the default dir item isn't there. This is weird since
580 * it's always been there, but don't freak out, just try and
581 * mount to root most subvolume.
583 btrfs_free_path(path);
584 dir_id = BTRFS_FIRST_FREE_OBJECTID;
585 new_root = root->fs_info->fs_root;
589 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
590 btrfs_free_path(path);
593 new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
594 if (IS_ERR(new_root))
595 return ERR_CAST(new_root);
597 if (btrfs_root_refs(&new_root->root_item) == 0)
598 return ERR_PTR(-ENOENT);
600 dir_id = btrfs_root_dirid(&new_root->root_item);
602 location.objectid = dir_id;
603 location.type = BTRFS_INODE_ITEM_KEY;
606 inode = btrfs_iget(sb, &location, new_root, &new);
608 return ERR_CAST(inode);
611 * If we're just mounting the root most subvol put the inode and return
612 * a reference to the dentry. We will have already gotten a reference
613 * to the inode in btrfs_fill_super so we're good to go.
615 if (!new && sb->s_root->d_inode == inode) {
617 return dget(sb->s_root);
620 return d_obtain_alias(inode);
623 static int btrfs_fill_super(struct super_block *sb,
624 struct btrfs_fs_devices *fs_devices,
625 void *data, int silent)
628 struct dentry *root_dentry;
629 struct btrfs_root *tree_root;
630 struct btrfs_key key;
633 sb->s_maxbytes = MAX_LFS_FILESIZE;
634 sb->s_magic = BTRFS_SUPER_MAGIC;
635 sb->s_op = &btrfs_super_ops;
636 sb->s_d_op = &btrfs_dentry_operations;
637 sb->s_export_op = &btrfs_export_ops;
638 sb->s_xattr = btrfs_xattr_handlers;
640 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
641 sb->s_flags |= MS_POSIXACL;
644 tree_root = open_ctree(sb, fs_devices, (char *)data);
646 if (IS_ERR(tree_root)) {
647 printk("btrfs: open_ctree failed\n");
648 return PTR_ERR(tree_root);
650 sb->s_fs_info = tree_root;
652 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
653 key.type = BTRFS_INODE_ITEM_KEY;
655 inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL);
657 err = PTR_ERR(inode);
661 root_dentry = d_alloc_root(inode);
668 sb->s_root = root_dentry;
670 save_mount_options(sb, data);
671 cleancache_init_fs(sb);
675 close_ctree(tree_root);
679 int btrfs_sync_fs(struct super_block *sb, int wait)
681 struct btrfs_trans_handle *trans;
682 struct btrfs_root *root = btrfs_sb(sb);
685 trace_btrfs_sync_fs(wait);
688 filemap_flush(root->fs_info->btree_inode->i_mapping);
692 btrfs_start_delalloc_inodes(root, 0);
693 btrfs_wait_ordered_extents(root, 0, 0);
695 trans = btrfs_start_transaction(root, 0);
697 return PTR_ERR(trans);
698 ret = btrfs_commit_transaction(trans, root);
702 static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
704 struct btrfs_root *root = btrfs_sb(vfs->mnt_sb);
705 struct btrfs_fs_info *info = root->fs_info;
708 if (btrfs_test_opt(root, DEGRADED))
709 seq_puts(seq, ",degraded");
710 if (btrfs_test_opt(root, NODATASUM))
711 seq_puts(seq, ",nodatasum");
712 if (btrfs_test_opt(root, NODATACOW))
713 seq_puts(seq, ",nodatacow");
714 if (btrfs_test_opt(root, NOBARRIER))
715 seq_puts(seq, ",nobarrier");
716 if (info->max_inline != 8192 * 1024)
717 seq_printf(seq, ",max_inline=%llu",
718 (unsigned long long)info->max_inline);
719 if (info->alloc_start != 0)
720 seq_printf(seq, ",alloc_start=%llu",
721 (unsigned long long)info->alloc_start);
722 if (info->thread_pool_size != min_t(unsigned long,
723 num_online_cpus() + 2, 8))
724 seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
725 if (btrfs_test_opt(root, COMPRESS)) {
726 if (info->compress_type == BTRFS_COMPRESS_ZLIB)
727 compress_type = "zlib";
729 compress_type = "lzo";
730 if (btrfs_test_opt(root, FORCE_COMPRESS))
731 seq_printf(seq, ",compress-force=%s", compress_type);
733 seq_printf(seq, ",compress=%s", compress_type);
735 if (btrfs_test_opt(root, NOSSD))
736 seq_puts(seq, ",nossd");
737 if (btrfs_test_opt(root, SSD_SPREAD))
738 seq_puts(seq, ",ssd_spread");
739 else if (btrfs_test_opt(root, SSD))
740 seq_puts(seq, ",ssd");
741 if (btrfs_test_opt(root, NOTREELOG))
742 seq_puts(seq, ",notreelog");
743 if (btrfs_test_opt(root, FLUSHONCOMMIT))
744 seq_puts(seq, ",flushoncommit");
745 if (btrfs_test_opt(root, DISCARD))
746 seq_puts(seq, ",discard");
747 if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
748 seq_puts(seq, ",noacl");
749 if (btrfs_test_opt(root, SPACE_CACHE))
750 seq_puts(seq, ",space_cache");
752 seq_puts(seq, ",nospace_cache");
753 if (btrfs_test_opt(root, CLEAR_CACHE))
754 seq_puts(seq, ",clear_cache");
755 if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
756 seq_puts(seq, ",user_subvol_rm_allowed");
757 if (btrfs_test_opt(root, ENOSPC_DEBUG))
758 seq_puts(seq, ",enospc_debug");
759 if (btrfs_test_opt(root, AUTO_DEFRAG))
760 seq_puts(seq, ",autodefrag");
761 if (btrfs_test_opt(root, INODE_MAP_CACHE))
762 seq_puts(seq, ",inode_cache");
766 static int btrfs_test_super(struct super_block *s, void *data)
768 struct btrfs_root *test_root = data;
769 struct btrfs_root *root = btrfs_sb(s);
772 * If this super block is going away, return false as it
773 * can't match as an existing super block.
775 if (!atomic_read(&s->s_active))
777 return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
780 static int btrfs_set_super(struct super_block *s, void *data)
784 return set_anon_super(s, data);
788 * subvolumes are identified by ino 256
790 static inline int is_subvolume_inode(struct inode *inode)
792 if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
798 * This will strip out the subvol=%s argument for an argument string and add
799 * subvolid=0 to make sure we get the actual tree root for path walking to the
802 static char *setup_root_args(char *args)
805 unsigned len = strlen(args) + 2;
810 * We need the same args as before, but minus
818 * which is a difference of 2 characters, so we allocate strlen(args) +
821 ret = kzalloc(len * sizeof(char), GFP_NOFS);
824 pos = strstr(args, "subvol=");
826 /* This shouldn't happen, but just in case.. */
833 * The subvol=<> arg is not at the front of the string, copy everybody
834 * up to that into ret.
839 copied += strlen(args);
843 strncpy(ret + copied, "subvolid=0", len - copied);
845 /* Length of subvolid=0 */
849 * If there is no , after the subvol= option then we know there's no
850 * other options and we can just return.
852 pos = strchr(pos, ',');
856 /* Copy the rest of the arguments into our buffer */
857 strncpy(ret + copied, pos, len - copied);
858 copied += strlen(pos);
863 static struct dentry *mount_subvol(const char *subvol_name, int flags,
864 const char *device_name, char *data)
866 struct super_block *s;
868 struct vfsmount *mnt;
869 struct mnt_namespace *ns_private;
874 newargs = setup_root_args(data);
876 return ERR_PTR(-ENOMEM);
877 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
881 return ERR_CAST(mnt);
883 ns_private = create_mnt_ns(mnt);
884 if (IS_ERR(ns_private)) {
886 return ERR_CAST(ns_private);
890 * This will trigger the automount of the subvol so we can just
891 * drop the mnt we have here and return the dentry that we
894 error = vfs_path_lookup(mnt->mnt_root, mnt, subvol_name,
895 LOOKUP_FOLLOW, &path);
896 put_mnt_ns(ns_private);
898 return ERR_PTR(error);
900 if (!is_subvolume_inode(path.dentry->d_inode)) {
904 printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
906 return ERR_PTR(-EINVAL);
909 /* Get a ref to the sb and the dentry we found and return it */
910 s = path.mnt->mnt_sb;
911 atomic_inc(&s->s_active);
912 root = dget(path.dentry);
914 down_write(&s->s_umount);
920 * Find a superblock for the given device / mount point.
922 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
923 * for multiple device setup. Make sure to keep it in sync.
925 static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
926 const char *device_name, void *data)
928 struct block_device *bdev = NULL;
929 struct super_block *s;
931 struct btrfs_fs_devices *fs_devices = NULL;
932 struct btrfs_fs_info *fs_info = NULL;
933 fmode_t mode = FMODE_READ;
934 char *subvol_name = NULL;
935 u64 subvol_objectid = 0;
936 u64 subvol_rootid = 0;
939 if (!(flags & MS_RDONLY))
942 error = btrfs_parse_early_options(data, mode, fs_type,
943 &subvol_name, &subvol_objectid,
944 &subvol_rootid, &fs_devices);
947 return ERR_PTR(error);
951 root = mount_subvol(subvol_name, flags, device_name, data);
956 error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
958 return ERR_PTR(error);
961 * Setup a dummy root and fs_info for test/set super. This is because
962 * we don't actually fill this stuff out until open_ctree, but we need
963 * it for searching for existing supers, so this lets us do that and
964 * then open_ctree will properly initialize everything later.
966 fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
968 return ERR_PTR(-ENOMEM);
970 fs_info->tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
971 if (!fs_info->tree_root) {
975 fs_info->tree_root->fs_info = fs_info;
976 fs_info->fs_devices = fs_devices;
978 fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
979 fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
980 if (!fs_info->super_copy || !fs_info->super_for_commit) {
985 error = btrfs_open_devices(fs_devices, mode, fs_type);
989 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
991 goto error_close_devices;
994 bdev = fs_devices->latest_bdev;
995 s = sget(fs_type, btrfs_test_super, btrfs_set_super,
999 goto error_close_devices;
1003 if ((flags ^ s->s_flags) & MS_RDONLY) {
1004 deactivate_locked_super(s);
1006 goto error_close_devices;
1009 btrfs_close_devices(fs_devices);
1010 free_fs_info(fs_info);
1012 char b[BDEVNAME_SIZE];
1014 s->s_flags = flags | MS_NOSEC;
1015 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1016 btrfs_sb(s)->fs_info->bdev_holder = fs_type;
1017 error = btrfs_fill_super(s, fs_devices, data,
1018 flags & MS_SILENT ? 1 : 0);
1020 deactivate_locked_super(s);
1021 return ERR_PTR(error);
1024 s->s_flags |= MS_ACTIVE;
1027 root = get_default_root(s, subvol_objectid);
1029 deactivate_locked_super(s);
1035 error_close_devices:
1036 btrfs_close_devices(fs_devices);
1038 free_fs_info(fs_info);
1039 return ERR_PTR(error);
1042 static int btrfs_remount(struct super_block *sb, int *flags, char *data)
1044 struct btrfs_root *root = btrfs_sb(sb);
1047 ret = btrfs_parse_options(root, data);
1051 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
1054 if (*flags & MS_RDONLY) {
1055 sb->s_flags |= MS_RDONLY;
1057 ret = btrfs_commit_super(root);
1060 if (root->fs_info->fs_devices->rw_devices == 0)
1063 if (btrfs_super_log_root(root->fs_info->super_copy) != 0)
1066 ret = btrfs_cleanup_fs_roots(root->fs_info);
1069 /* recover relocation */
1070 ret = btrfs_recover_relocation(root);
1073 sb->s_flags &= ~MS_RDONLY;
1079 /* Used to sort the devices by max_avail(descending sort) */
1080 static int btrfs_cmp_device_free_bytes(const void *dev_info1,
1081 const void *dev_info2)
1083 if (((struct btrfs_device_info *)dev_info1)->max_avail >
1084 ((struct btrfs_device_info *)dev_info2)->max_avail)
1086 else if (((struct btrfs_device_info *)dev_info1)->max_avail <
1087 ((struct btrfs_device_info *)dev_info2)->max_avail)
1094 * sort the devices by max_avail, in which max free extent size of each device
1095 * is stored.(Descending Sort)
1097 static inline void btrfs_descending_sort_devices(
1098 struct btrfs_device_info *devices,
1101 sort(devices, nr_devices, sizeof(struct btrfs_device_info),
1102 btrfs_cmp_device_free_bytes, NULL);
1106 * The helper to calc the free space on the devices that can be used to store
1109 static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
1111 struct btrfs_fs_info *fs_info = root->fs_info;
1112 struct btrfs_device_info *devices_info;
1113 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
1114 struct btrfs_device *device;
1119 u64 min_stripe_size;
1120 int min_stripes = 1, num_stripes = 1;
1121 int i = 0, nr_devices;
1124 nr_devices = fs_info->fs_devices->open_devices;
1125 BUG_ON(!nr_devices);
1127 devices_info = kmalloc(sizeof(*devices_info) * nr_devices,
1132 /* calc min stripe number for data space alloction */
1133 type = btrfs_get_alloc_profile(root, 1);
1134 if (type & BTRFS_BLOCK_GROUP_RAID0) {
1136 num_stripes = nr_devices;
1137 } else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1140 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1145 if (type & BTRFS_BLOCK_GROUP_DUP)
1146 min_stripe_size = 2 * BTRFS_STRIPE_LEN;
1148 min_stripe_size = BTRFS_STRIPE_LEN;
1150 list_for_each_entry(device, &fs_devices->devices, dev_list) {
1151 if (!device->in_fs_metadata || !device->bdev)
1154 avail_space = device->total_bytes - device->bytes_used;
1156 /* align with stripe_len */
1157 do_div(avail_space, BTRFS_STRIPE_LEN);
1158 avail_space *= BTRFS_STRIPE_LEN;
1161 * In order to avoid overwritting the superblock on the drive,
1162 * btrfs starts at an offset of at least 1MB when doing chunk
1165 skip_space = 1024 * 1024;
1167 /* user can set the offset in fs_info->alloc_start. */
1168 if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
1169 device->total_bytes)
1170 skip_space = max(fs_info->alloc_start, skip_space);
1173 * btrfs can not use the free space in [0, skip_space - 1],
1174 * we must subtract it from the total. In order to implement
1175 * it, we account the used space in this range first.
1177 ret = btrfs_account_dev_extents_size(device, 0, skip_space - 1,
1180 kfree(devices_info);
1184 /* calc the free space in [0, skip_space - 1] */
1185 skip_space -= used_space;
1188 * we can use the free space in [0, skip_space - 1], subtract
1189 * it from the total.
1191 if (avail_space && avail_space >= skip_space)
1192 avail_space -= skip_space;
1196 if (avail_space < min_stripe_size)
1199 devices_info[i].dev = device;
1200 devices_info[i].max_avail = avail_space;
1207 btrfs_descending_sort_devices(devices_info, nr_devices);
1211 while (nr_devices >= min_stripes) {
1212 if (num_stripes > nr_devices)
1213 num_stripes = nr_devices;
1215 if (devices_info[i].max_avail >= min_stripe_size) {
1219 avail_space += devices_info[i].max_avail * num_stripes;
1220 alloc_size = devices_info[i].max_avail;
1221 for (j = i + 1 - num_stripes; j <= i; j++)
1222 devices_info[j].max_avail -= alloc_size;
1228 kfree(devices_info);
1229 *free_bytes = avail_space;
1233 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1235 struct btrfs_root *root = btrfs_sb(dentry->d_sb);
1236 struct btrfs_super_block *disk_super = root->fs_info->super_copy;
1237 struct list_head *head = &root->fs_info->space_info;
1238 struct btrfs_space_info *found;
1240 u64 total_free_data = 0;
1241 int bits = dentry->d_sb->s_blocksize_bits;
1242 __be32 *fsid = (__be32 *)root->fs_info->fsid;
1245 /* holding chunk_muext to avoid allocating new chunks */
1246 mutex_lock(&root->fs_info->chunk_mutex);
1248 list_for_each_entry_rcu(found, head, list) {
1249 if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
1250 total_free_data += found->disk_total - found->disk_used;
1252 btrfs_account_ro_block_groups_free_space(found);
1255 total_used += found->disk_used;
1259 buf->f_namelen = BTRFS_NAME_LEN;
1260 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1261 buf->f_bfree = buf->f_blocks - (total_used >> bits);
1262 buf->f_bsize = dentry->d_sb->s_blocksize;
1263 buf->f_type = BTRFS_SUPER_MAGIC;
1264 buf->f_bavail = total_free_data;
1265 ret = btrfs_calc_avail_data_space(root, &total_free_data);
1267 mutex_unlock(&root->fs_info->chunk_mutex);
1270 buf->f_bavail += total_free_data;
1271 buf->f_bavail = buf->f_bavail >> bits;
1272 mutex_unlock(&root->fs_info->chunk_mutex);
1274 /* We treat it as constant endianness (it doesn't matter _which_)
1275 because we want the fsid to come out the same whether mounted
1276 on a big-endian or little-endian host */
1277 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
1278 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
1279 /* Mask in the root object ID too, to disambiguate subvols */
1280 buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
1281 buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
1286 static struct file_system_type btrfs_fs_type = {
1287 .owner = THIS_MODULE,
1289 .mount = btrfs_mount,
1290 .kill_sb = kill_anon_super,
1291 .fs_flags = FS_REQUIRES_DEV,
1295 * used by btrfsctl to scan devices when no FS is mounted
1297 static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
1300 struct btrfs_ioctl_vol_args *vol;
1301 struct btrfs_fs_devices *fs_devices;
1304 if (!capable(CAP_SYS_ADMIN))
1307 vol = memdup_user((void __user *)arg, sizeof(*vol));
1309 return PTR_ERR(vol);
1312 case BTRFS_IOC_SCAN_DEV:
1313 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1314 &btrfs_fs_type, &fs_devices);
1322 static int btrfs_freeze(struct super_block *sb)
1324 struct btrfs_root *root = btrfs_sb(sb);
1325 mutex_lock(&root->fs_info->transaction_kthread_mutex);
1326 mutex_lock(&root->fs_info->cleaner_mutex);
1330 static int btrfs_unfreeze(struct super_block *sb)
1332 struct btrfs_root *root = btrfs_sb(sb);
1333 mutex_unlock(&root->fs_info->cleaner_mutex);
1334 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1338 static void btrfs_fs_dirty_inode(struct inode *inode, int flags)
1342 ret = btrfs_dirty_inode(inode);
1344 printk_ratelimited(KERN_ERR "btrfs: fail to dirty inode %Lu "
1345 "error %d\n", btrfs_ino(inode), ret);
1348 static const struct super_operations btrfs_super_ops = {
1349 .drop_inode = btrfs_drop_inode,
1350 .evict_inode = btrfs_evict_inode,
1351 .put_super = btrfs_put_super,
1352 .sync_fs = btrfs_sync_fs,
1353 .show_options = btrfs_show_options,
1354 .write_inode = btrfs_write_inode,
1355 .dirty_inode = btrfs_fs_dirty_inode,
1356 .alloc_inode = btrfs_alloc_inode,
1357 .destroy_inode = btrfs_destroy_inode,
1358 .statfs = btrfs_statfs,
1359 .remount_fs = btrfs_remount,
1360 .freeze_fs = btrfs_freeze,
1361 .unfreeze_fs = btrfs_unfreeze,
1364 static const struct file_operations btrfs_ctl_fops = {
1365 .unlocked_ioctl = btrfs_control_ioctl,
1366 .compat_ioctl = btrfs_control_ioctl,
1367 .owner = THIS_MODULE,
1368 .llseek = noop_llseek,
1371 static struct miscdevice btrfs_misc = {
1372 .minor = BTRFS_MINOR,
1373 .name = "btrfs-control",
1374 .fops = &btrfs_ctl_fops
1377 MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
1378 MODULE_ALIAS("devname:btrfs-control");
1380 static int btrfs_interface_init(void)
1382 return misc_register(&btrfs_misc);
1385 static void btrfs_interface_exit(void)
1387 if (misc_deregister(&btrfs_misc) < 0)
1388 printk(KERN_INFO "misc_deregister failed for control device");
1391 static int __init init_btrfs_fs(void)
1395 err = btrfs_init_sysfs();
1399 err = btrfs_init_compress();
1403 err = btrfs_init_cachep();
1407 err = extent_io_init();
1411 err = extent_map_init();
1413 goto free_extent_io;
1415 err = btrfs_delayed_inode_init();
1417 goto free_extent_map;
1419 err = btrfs_interface_init();
1421 goto free_delayed_inode;
1423 err = register_filesystem(&btrfs_fs_type);
1425 goto unregister_ioctl;
1427 printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1431 btrfs_interface_exit();
1433 btrfs_delayed_inode_exit();
1439 btrfs_destroy_cachep();
1441 btrfs_exit_compress();
1447 static void __exit exit_btrfs_fs(void)
1449 btrfs_destroy_cachep();
1450 btrfs_delayed_inode_exit();
1453 btrfs_interface_exit();
1454 unregister_filesystem(&btrfs_fs_type);
1456 btrfs_cleanup_fs_uuids();
1457 btrfs_exit_compress();
1460 module_init(init_btrfs_fs)
1461 module_exit(exit_btrfs_fs)
1463 MODULE_LICENSE("GPL");