Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-13 00:20:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'btrfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Browse Source 
* 'btrfs' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  btrfs: take allocation of ->tree_root into open_ctree()
  btrfs: let ->s_fs_info point to fs_info, not root...
  btrfs: consolidate failure exits in btrfs_mount() a bit
  btrfs: make free_fs_info() call ->kill_sb() unconditional
  btrfs: merge free_fs_info() calls on fill_super failures
  btrfs: kill pointless reassignment of ->s_fs_info in btrfs_fill_super()
  btrfs: make open_ctree() return int
  btrfs: sanitizing ->fs_info, part 5
  btrfs: sanitizing ->fs_info, part 4
  btrfs: sanitizing ->fs_info, part 3
  btrfs: sanitizing ->fs_info, part 2
  btrfs: sanitizing ->fs_info, part 1
  btrfs: fix a deadlock in btrfs_scan_one_device()
  btrfs: fix mount/umount race
  btrfs: get ->kill_sb() of its own
  btrfs: preparation to fixing mount/umount race
This commit is contained in:
Linus Torvalds 2012-01-17 15:52:51 -08:00
commit d65773b22b
7 changed files with 110 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/btrfs/ctree.h
View File

@ -2364,7 +2364,7 @@ static inline u32 btrfs_file_extent_inline_item_len(struct extent_buffer *eb,
return btrfs_item_size(eb, e) - offset; return btrfs_item_size(eb, e) - offset;
} }
static inline struct btrfs_root *btrfs_sb(struct super_block *sb) static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
{ {
return sb->s_fs_info; return sb->s_fs_info;
} }

70
fs/btrfs/disk-io.c
View File

@ -1144,7 +1144,6 @@ static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
root->orphan_item_inserted = 0; root->orphan_item_inserted = 0;
root->orphan_cleanup_state = 0; root->orphan_cleanup_state = 0;
root->fs_info = fs_info;
root->objectid = objectid; root->objectid = objectid;
root->last_trans = 0; root->last_trans = 0;
root->highest_objectid = 0; root->highest_objectid = 0;
@ -1218,6 +1217,14 @@ static int find_and_setup_root(struct btrfs_root *tree_root,
return 0; return 0;
} }
static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
{
struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
if (root)
root->fs_info = fs_info;
return root;
}
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans, static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *fs_info) struct btrfs_fs_info *fs_info)
{ {
@ -1225,7 +1232,7 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
struct btrfs_root *tree_root = fs_info->tree_root; struct btrfs_root *tree_root = fs_info->tree_root;
struct extent_buffer *leaf; struct extent_buffer *leaf;
root = kzalloc(sizeof(*root), GFP_NOFS); root = btrfs_alloc_root(fs_info);
if (!root) if (!root)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
@ -1320,7 +1327,7 @@ struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
u32 blocksize; u32 blocksize;
int ret = 0; int ret = 0;
root = kzalloc(sizeof(*root), GFP_NOFS); root = btrfs_alloc_root(fs_info);
if (!root) if (!root)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
if (location->offset == (u64)-1) { if (location->offset == (u64)-1) {
@ -1876,9 +1883,9 @@ static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
} }
struct btrfs_root *open_ctree(struct super_block *sb, int open_ctree(struct super_block *sb,
struct btrfs_fs_devices *fs_devices, struct btrfs_fs_devices *fs_devices,
char *options) char *options)
{ {
u32 sectorsize; u32 sectorsize;
u32 nodesize; u32 nodesize;
@ -1890,8 +1897,8 @@ struct btrfs_root *open_ctree(struct super_block *sb,
struct btrfs_key location; struct btrfs_key location;
struct buffer_head *bh; struct buffer_head *bh;
struct btrfs_super_block *disk_super; struct btrfs_super_block *disk_super;
struct btrfs_root *tree_root = btrfs_sb(sb); struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_fs_info *fs_info = tree_root->fs_info; struct btrfs_root *tree_root;
struct btrfs_root *extent_root; struct btrfs_root *extent_root;
struct btrfs_root *csum_root; struct btrfs_root *csum_root;
struct btrfs_root *chunk_root; struct btrfs_root *chunk_root;
@ -1902,16 +1909,14 @@ struct btrfs_root *open_ctree(struct super_block *sb,
int num_backups_tried = 0; int num_backups_tried = 0;
int backup_index = 0; int backup_index = 0;
extent_root = fs_info->extent_root = tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
kzalloc(sizeof(struct btrfs_root), GFP_NOFS); extent_root = fs_info->extent_root = btrfs_alloc_root(fs_info);
csum_root = fs_info->csum_root = csum_root = fs_info->csum_root = btrfs_alloc_root(fs_info);
kzalloc(sizeof(struct btrfs_root), GFP_NOFS); chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
chunk_root = fs_info->chunk_root = dev_root = fs_info->dev_root = btrfs_alloc_root(fs_info);
kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
dev_root = fs_info->dev_root =
kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
if (!extent_root || !csum_root || !chunk_root || !dev_root) { if (!tree_root || !extent_root || !csum_root ||
!chunk_root || !dev_root) {
err = -ENOMEM; err = -ENOMEM;
goto fail; goto fail;
} }
@ -2389,7 +2394,7 @@ retry_root_backup:
btrfs_level_size(tree_root, btrfs_level_size(tree_root,
btrfs_super_log_root_level(disk_super)); btrfs_super_log_root_level(disk_super));
log_tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS); log_tree_root = btrfs_alloc_root(fs_info);
if (!log_tree_root) { if (!log_tree_root) {
err = -ENOMEM; err = -ENOMEM;
goto fail_trans_kthread; goto fail_trans_kthread;
@ -2450,11 +2455,11 @@ retry_root_backup:
if (err) { if (err) {
close_ctree(tree_root); close_ctree(tree_root);
return ERR_PTR(err); return err;
} }
} }
return tree_root; return 0;
fail_trans_kthread: fail_trans_kthread:
kthread_stop(fs_info->transaction_kthread); kthread_stop(fs_info->transaction_kthread);
@ -2500,8 +2505,7 @@ fail_srcu:
cleanup_srcu_struct(&fs_info->subvol_srcu); cleanup_srcu_struct(&fs_info->subvol_srcu);
fail: fail:
btrfs_close_devices(fs_info->fs_devices); btrfs_close_devices(fs_info->fs_devices);
free_fs_info(fs_info); return err;
return ERR_PTR(err);
recovery_tree_root: recovery_tree_root:
if (!btrfs_test_opt(tree_root, RECOVERY)) if (!btrfs_test_opt(tree_root, RECOVERY))
@ -3007,7 +3011,7 @@ int close_ctree(struct btrfs_root *root)
(atomic_read(&fs_info->defrag_running) == 0)); (atomic_read(&fs_info->defrag_running) == 0));
/* clear out the rbtree of defraggable inodes */ /* clear out the rbtree of defraggable inodes */
btrfs_run_defrag_inodes(root->fs_info); btrfs_run_defrag_inodes(fs_info);
/* /*
* Here come 2 situations when btrfs is broken to flip readonly: * Here come 2 situations when btrfs is broken to flip readonly:
@ -3036,8 +3040,8 @@ int close_ctree(struct btrfs_root *root)
btrfs_put_block_group_cache(fs_info); btrfs_put_block_group_cache(fs_info);
kthread_stop(root->fs_info->transaction_kthread); kthread_stop(fs_info->transaction_kthread);
kthread_stop(root->fs_info->cleaner_kthread); kthread_stop(fs_info->cleaner_kthread);
fs_info->closing = 2; fs_info->closing = 2;
smp_mb(); smp_mb();
@ -3055,14 +3059,14 @@ int close_ctree(struct btrfs_root *root)
free_extent_buffer(fs_info->extent_root->commit_root); free_extent_buffer(fs_info->extent_root->commit_root);
free_extent_buffer(fs_info->tree_root->node); free_extent_buffer(fs_info->tree_root->node);
free_extent_buffer(fs_info->tree_root->commit_root); free_extent_buffer(fs_info->tree_root->commit_root);
free_extent_buffer(root->fs_info->chunk_root->node); free_extent_buffer(fs_info->chunk_root->node);
free_extent_buffer(root->fs_info->chunk_root->commit_root); free_extent_buffer(fs_info->chunk_root->commit_root);
free_extent_buffer(root->fs_info->dev_root->node); free_extent_buffer(fs_info->dev_root->node);
free_extent_buffer(root->fs_info->dev_root->commit_root); free_extent_buffer(fs_info->dev_root->commit_root);
free_extent_buffer(root->fs_info->csum_root->node); free_extent_buffer(fs_info->csum_root->node);
free_extent_buffer(root->fs_info->csum_root->commit_root); free_extent_buffer(fs_info->csum_root->commit_root);
btrfs_free_block_groups(root->fs_info); btrfs_free_block_groups(fs_info);
del_fs_roots(fs_info); del_fs_roots(fs_info);
@ -3093,8 +3097,6 @@ int close_ctree(struct btrfs_root *root)
bdi_destroy(&fs_info->bdi); bdi_destroy(&fs_info->bdi);
cleanup_srcu_struct(&fs_info->subvol_srcu); cleanup_srcu_struct(&fs_info->subvol_srcu);
free_fs_info(fs_info);
return 0; return 0;
} }

6
fs/btrfs/disk-io.h
View File

@ -46,9 +46,9 @@ struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
u64 bytenr, u32 blocksize); u64 bytenr, u32 blocksize);
int clean_tree_block(struct btrfs_trans_handle *trans, int clean_tree_block(struct btrfs_trans_handle *trans,
struct btrfs_root *root, struct extent_buffer *buf); struct btrfs_root *root, struct extent_buffer *buf);
struct btrfs_root *open_ctree(struct super_block *sb, int open_ctree(struct super_block *sb,
struct btrfs_fs_devices *fs_devices, struct btrfs_fs_devices *fs_devices,
char *options); char *options);
int close_ctree(struct btrfs_root *root); int close_ctree(struct btrfs_root *root);
int write_ctree_super(struct btrfs_trans_handle *trans, int write_ctree_super(struct btrfs_trans_handle *trans,
struct btrfs_root *root, int max_mirrors); struct btrfs_root *root, int max_mirrors);

2
fs/btrfs/export.c
View File

@ -67,7 +67,7 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
u64 root_objectid, u32 generation, u64 root_objectid, u32 generation,
int check_generation) int check_generation)
{ {
struct btrfs_fs_info *fs_info = btrfs_sb(sb)->fs_info; struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_root *root; struct btrfs_root *root;
struct inode *inode; struct inode *inode;
struct btrfs_key key; struct btrfs_key key;

7
fs/btrfs/ioctl.c
View File

@ -286,14 +286,13 @@ static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg) static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
{ {
struct btrfs_root *root = fdentry(file)->d_sb->s_fs_info; struct btrfs_fs_info *fs_info = btrfs_sb(fdentry(file)->d_sb);
struct btrfs_fs_info *fs_info = root->fs_info;
struct btrfs_device *device; struct btrfs_device *device;
struct request_queue *q; struct request_queue *q;
struct fstrim_range range; struct fstrim_range range;
u64 minlen = ULLONG_MAX; u64 minlen = ULLONG_MAX;
u64 num_devices = 0; u64 num_devices = 0;
u64 total_bytes = btrfs_super_total_bytes(root->fs_info->super_copy); u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
int ret; int ret;
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
@ -322,7 +321,7 @@ static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
range.len = min(range.len, total_bytes - range.start); range.len = min(range.len, total_bytes - range.start);
range.minlen = max(range.minlen, minlen); range.minlen = max(range.minlen, minlen);
ret = btrfs_trim_fs(root, &range); ret = btrfs_trim_fs(fs_info->tree_root, &range);
if (ret < 0) if (ret < 0)
return ret; return ret;

143
fs/btrfs/super.c
View File

@ -147,13 +147,13 @@ void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
static void btrfs_put_super(struct super_block *sb) static void btrfs_put_super(struct super_block *sb)
{ {
struct btrfs_root *root = btrfs_sb(sb); (void)close_ctree(btrfs_sb(sb)->tree_root);
int ret; /* FIXME: need to fix VFS to return error? */
/* AV: return it _where_? ->put_super() can be triggered by any number
ret = close_ctree(root); * of async events, up to and including delivery of SIGKILL to the
sb->s_fs_info = NULL; * last process that kept it busy. Or segfault in the aforementioned
* process... Whom would you report that to?
(void)ret; /* FIXME: need to fix VFS to return error? */ */
} }
enum { enum {
@ -541,7 +541,8 @@ out:
static struct dentry *get_default_root(struct super_block *sb, static struct dentry *get_default_root(struct super_block *sb,
u64 subvol_objectid) u64 subvol_objectid)
{ {
struct btrfs_root *root = sb->s_fs_info; struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_root *root = fs_info->tree_root;
struct btrfs_root *new_root; struct btrfs_root *new_root;
struct btrfs_dir_item *di; struct btrfs_dir_item *di;
struct btrfs_path *path; struct btrfs_path *path;
@ -571,7 +572,7 @@ static struct dentry *get_default_root(struct super_block *sb,
* will mount by default if we haven't been given a specific subvolume * will mount by default if we haven't been given a specific subvolume
* to mount. * to mount.
*/ */
dir_id = btrfs_super_root_dir(root->fs_info->super_copy); dir_id = btrfs_super_root_dir(fs_info->super_copy);
di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0); di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
if (IS_ERR(di)) { if (IS_ERR(di)) {
btrfs_free_path(path); btrfs_free_path(path);
@ -585,7 +586,7 @@ static struct dentry *get_default_root(struct super_block *sb,
*/ */
btrfs_free_path(path); btrfs_free_path(path);
dir_id = BTRFS_FIRST_FREE_OBJECTID; dir_id = BTRFS_FIRST_FREE_OBJECTID;
new_root = root->fs_info->fs_root; new_root = fs_info->fs_root;
goto setup_root; goto setup_root;
} }
@ -593,7 +594,7 @@ static struct dentry *get_default_root(struct super_block *sb,
btrfs_free_path(path); btrfs_free_path(path);
find_root: find_root:
new_root = btrfs_read_fs_root_no_name(root->fs_info, &location); new_root = btrfs_read_fs_root_no_name(fs_info, &location);
if (IS_ERR(new_root)) if (IS_ERR(new_root))
return ERR_CAST(new_root); return ERR_CAST(new_root);
@ -629,7 +630,7 @@ static int btrfs_fill_super(struct super_block *sb,
{ {
struct inode *inode; struct inode *inode;
struct dentry *root_dentry; struct dentry *root_dentry;
struct btrfs_root *tree_root; struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_key key; struct btrfs_key key;
int err; int err;
@ -644,18 +645,16 @@ static int btrfs_fill_super(struct super_block *sb,
sb->s_flags |= MS_POSIXACL; sb->s_flags |= MS_POSIXACL;
#endif #endif
tree_root = open_ctree(sb, fs_devices, (char *)data); err = open_ctree(sb, fs_devices, (char *)data);
if (err) {
if (IS_ERR(tree_root)) {
printk("btrfs: open_ctree failed\n"); printk("btrfs: open_ctree failed\n");
return PTR_ERR(tree_root); return err;
} }
sb->s_fs_info = tree_root;
key.objectid = BTRFS_FIRST_FREE_OBJECTID; key.objectid = BTRFS_FIRST_FREE_OBJECTID;
key.type = BTRFS_INODE_ITEM_KEY; key.type = BTRFS_INODE_ITEM_KEY;
key.offset = 0; key.offset = 0;
inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL); inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
if (IS_ERR(inode)) { if (IS_ERR(inode)) {
err = PTR_ERR(inode); err = PTR_ERR(inode);
goto fail_close; goto fail_close;
@ -672,23 +671,25 @@ static int btrfs_fill_super(struct super_block *sb,
save_mount_options(sb, data); save_mount_options(sb, data);
cleancache_init_fs(sb); cleancache_init_fs(sb);
sb->s_flags |= MS_ACTIVE;
return 0; return 0;
fail_close: fail_close:
close_ctree(tree_root); close_ctree(fs_info->tree_root);
return err; return err;
} }
int btrfs_sync_fs(struct super_block *sb, int wait) int btrfs_sync_fs(struct super_block *sb, int wait)
{ {
struct btrfs_trans_handle *trans; struct btrfs_trans_handle *trans;
struct btrfs_root *root = btrfs_sb(sb); struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_root *root = fs_info->tree_root;
int ret; int ret;
trace_btrfs_sync_fs(wait); trace_btrfs_sync_fs(wait);
if (!wait) { if (!wait) {
filemap_flush(root->fs_info->btree_inode->i_mapping); filemap_flush(fs_info->btree_inode->i_mapping);
return 0; return 0;
} }
@ -704,8 +705,8 @@ int btrfs_sync_fs(struct super_block *sb, int wait)
static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry) static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
{ {
struct btrfs_root *root = btrfs_sb(dentry->d_sb); struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
struct btrfs_fs_info *info = root->fs_info; struct btrfs_root *root = info->tree_root;
char *compress_type; char *compress_type;
if (btrfs_test_opt(root, DEGRADED)) if (btrfs_test_opt(root, DEGRADED))
@ -770,23 +771,18 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
static int btrfs_test_super(struct super_block *s, void *data) static int btrfs_test_super(struct super_block *s, void *data)
{ {
struct btrfs_root *test_root = data; struct btrfs_fs_info *p = data;
struct btrfs_root *root = btrfs_sb(s); struct btrfs_fs_info *fs_info = btrfs_sb(s);
/* return fs_info->fs_devices == p->fs_devices;
* If this super block is going away, return false as it
* can't match as an existing super block.
*/
if (!atomic_read(&s->s_active))
return 0;
return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
} }
static int btrfs_set_super(struct super_block *s, void *data) static int btrfs_set_super(struct super_block *s, void *data)
{ {
s->s_fs_info = data; int err = set_anon_super(s, data);
if (!err)
return set_anon_super(s, data); s->s_fs_info = data;
return err;
} }
/* /*
@ -946,12 +942,6 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
if (!fs_info) if (!fs_info)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
fs_info->tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
if (!fs_info->tree_root) {
error = -ENOMEM;
goto error_fs_info;
}
fs_info->tree_root->fs_info = fs_info;
fs_info->fs_devices = fs_devices; fs_info->fs_devices = fs_devices;
fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS); fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
@ -971,43 +961,30 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
} }
bdev = fs_devices->latest_bdev; bdev = fs_devices->latest_bdev;
s = sget(fs_type, btrfs_test_super, btrfs_set_super, s = sget(fs_type, btrfs_test_super, btrfs_set_super, fs_info);
fs_info->tree_root);
if (IS_ERR(s)) { if (IS_ERR(s)) {
error = PTR_ERR(s); error = PTR_ERR(s);
goto error_close_devices; goto error_close_devices;
} }
if (s->s_root) { if (s->s_root) {
if ((flags ^ s->s_flags) & MS_RDONLY) {
deactivate_locked_super(s);
error = -EBUSY;
goto error_close_devices;
}
btrfs_close_devices(fs_devices); btrfs_close_devices(fs_devices);
free_fs_info(fs_info); free_fs_info(fs_info);
if ((flags ^ s->s_flags) & MS_RDONLY)
error = -EBUSY;
} else { } else {
char b[BDEVNAME_SIZE]; char b[BDEVNAME_SIZE];
s->s_flags = flags | MS_NOSEC; s->s_flags = flags | MS_NOSEC;
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id)); strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
btrfs_sb(s)->fs_info->bdev_holder = fs_type; btrfs_sb(s)->bdev_holder = fs_type;
error = btrfs_fill_super(s, fs_devices, data, error = btrfs_fill_super(s, fs_devices, data,
flags & MS_SILENT ? 1 : 0); flags & MS_SILENT ? 1 : 0);
if (error) {
deactivate_locked_super(s);
return ERR_PTR(error);
}
s->s_flags |= MS_ACTIVE;
} }
root = get_default_root(s, subvol_objectid); root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
if (IS_ERR(root)) { if (IS_ERR(root))
deactivate_locked_super(s); deactivate_locked_super(s);
return root;
}
return root; return root;
@ -1020,7 +997,8 @@ error_fs_info:
static int btrfs_remount(struct super_block *sb, int *flags, char *data) static int btrfs_remount(struct super_block *sb, int *flags, char *data)
{ {
struct btrfs_root *root = btrfs_sb(sb); struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_root *root = fs_info->tree_root;
int ret; int ret;
ret = btrfs_parse_options(root, data); ret = btrfs_parse_options(root, data);
@ -1036,13 +1014,13 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
ret = btrfs_commit_super(root); ret = btrfs_commit_super(root);
WARN_ON(ret); WARN_ON(ret);
} else { } else {
if (root->fs_info->fs_devices->rw_devices == 0) if (fs_info->fs_devices->rw_devices == 0)
return -EACCES; return -EACCES;
if (btrfs_super_log_root(root->fs_info->super_copy) != 0) if (btrfs_super_log_root(fs_info->super_copy) != 0)
return -EINVAL; return -EINVAL;
ret = btrfs_cleanup_fs_roots(root->fs_info); ret = btrfs_cleanup_fs_roots(fs_info);
WARN_ON(ret); WARN_ON(ret);
/* recover relocation */ /* recover relocation */
@ -1211,18 +1189,18 @@ static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf) static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{ {
struct btrfs_root *root = btrfs_sb(dentry->d_sb); struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
struct btrfs_super_block *disk_super = root->fs_info->super_copy; struct btrfs_super_block *disk_super = fs_info->super_copy;
struct list_head *head = &root->fs_info->space_info; struct list_head *head = &fs_info->space_info;
struct btrfs_space_info *found; struct btrfs_space_info *found;
u64 total_used = 0; u64 total_used = 0;
u64 total_free_data = 0; u64 total_free_data = 0;
int bits = dentry->d_sb->s_blocksize_bits; int bits = dentry->d_sb->s_blocksize_bits;
__be32 *fsid = (__be32 *)root->fs_info->fsid; __be32 *fsid = (__be32 *)fs_info->fsid;
int ret; int ret;
/* holding chunk_muext to avoid allocating new chunks */ /* holding chunk_muext to avoid allocating new chunks */
mutex_lock(&root->fs_info->chunk_mutex); mutex_lock(&fs_info->chunk_mutex);
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(found, head, list) { list_for_each_entry_rcu(found, head, list) {
if (found->flags & BTRFS_BLOCK_GROUP_DATA) { if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
@ -1241,14 +1219,14 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
buf->f_bsize = dentry->d_sb->s_blocksize; buf->f_bsize = dentry->d_sb->s_blocksize;
buf->f_type = BTRFS_SUPER_MAGIC; buf->f_type = BTRFS_SUPER_MAGIC;
buf->f_bavail = total_free_data; buf->f_bavail = total_free_data;
ret = btrfs_calc_avail_data_space(root, &total_free_data); ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
if (ret) { if (ret) {
mutex_unlock(&root->fs_info->chunk_mutex); mutex_unlock(&fs_info->chunk_mutex);
return ret; return ret;
} }
buf->f_bavail += total_free_data; buf->f_bavail += total_free_data;
buf->f_bavail = buf->f_bavail >> bits; buf->f_bavail = buf->f_bavail >> bits;
mutex_unlock(&root->fs_info->chunk_mutex); mutex_unlock(&fs_info->chunk_mutex);
/* We treat it as constant endianness (it doesn't matter _which_) /* We treat it as constant endianness (it doesn't matter _which_)
because we want the fsid to come out the same whether mounted because we want the fsid to come out the same whether mounted
@ -1262,11 +1240,18 @@ static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
return 0; return 0;
} }
static void btrfs_kill_super(struct super_block *sb)
{
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
kill_anon_super(sb);
free_fs_info(fs_info);
}
static struct file_system_type btrfs_fs_type = { static struct file_system_type btrfs_fs_type = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.name = "btrfs", .name = "btrfs",
.mount = btrfs_mount, .mount = btrfs_mount,
.kill_sb = kill_anon_super, .kill_sb = btrfs_kill_super,
.fs_flags = FS_REQUIRES_DEV, .fs_flags = FS_REQUIRES_DEV,
}; };
@ -1300,17 +1285,17 @@ static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
static int btrfs_freeze(struct super_block *sb) static int btrfs_freeze(struct super_block *sb)
{ {
struct btrfs_root *root = btrfs_sb(sb); struct btrfs_fs_info *fs_info = btrfs_sb(sb);
mutex_lock(&root->fs_info->transaction_kthread_mutex); mutex_lock(&fs_info->transaction_kthread_mutex);
mutex_lock(&root->fs_info->cleaner_mutex); mutex_lock(&fs_info->cleaner_mutex);
return 0; return 0;
} }
static int btrfs_unfreeze(struct super_block *sb) static int btrfs_unfreeze(struct super_block *sb)
{ {
struct btrfs_root *root = btrfs_sb(sb); struct btrfs_fs_info *fs_info = btrfs_sb(sb);
mutex_unlock(&root->fs_info->cleaner_mutex); mutex_unlock(&fs_info->cleaner_mutex);
mutex_unlock(&root->fs_info->transaction_kthread_mutex); mutex_unlock(&fs_info->transaction_kthread_mutex);
return 0; return 0;
} }

5
fs/btrfs/volumes.c
View File

@ -708,8 +708,6 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
u64 devid; u64 devid;
u64 transid; u64 transid;
mutex_lock(&uuid_mutex);
flags |= FMODE_EXCL; flags |= FMODE_EXCL;
bdev = blkdev_get_by_path(path, flags, holder); bdev = blkdev_get_by_path(path, flags, holder);
@ -718,6 +716,7 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
goto error; goto error;
} }
mutex_lock(&uuid_mutex);
ret = set_blocksize(bdev, 4096); ret = set_blocksize(bdev, 4096);
if (ret) if (ret)
goto error_close; goto error_close;
@ -739,9 +738,9 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
brelse(bh); brelse(bh);
error_close: error_close:
mutex_unlock(&uuid_mutex);
blkdev_put(bdev, flags); blkdev_put(bdev, flags);
error: error:
mutex_unlock(&uuid_mutex);
return ret; return ret;
} }