Skip to contentSkip to conversation

Btrfs: setup blank root and fs_info for mount time

PATCH In review Josef Bacik 3 participants 9 messages Nov 19, 2010 – Nov 22, 2010 Btrfs file system

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 Btrfs: setup blank root and fs_info for mount time

There is a problem with how we use sget, it searches through the list of supers attached to the fs_type looking for a super with the same fs_devices as what we're trying to mount. This depends on sb->s_fs_info being filled, but we don't fill that in until we get to btrfs_fill_super, so we could hit supers on the fs_type super list that have a null s_fs_info. In order to fix that we need to go ahead and setup a blank root with a blank fs_info to hold fs_devices, that way our test will work out right and then we can set s_fs_info in btrfs_set_super, and then open_ctree will simply use our pre-allocated root and fs_info when setting everything up. Thanks,

---
 fs/btrfs/disk-io.c |    6 ++----
 fs/btrfs/super.c   |   35 ++++++++++++++++++++++++++++++++---
 2 files changed, 34 insertions(+), 7 deletions(-)
fs/btrfs/disk-io.c +2 -4
index fb827d0..f0aa204 100644
@@ -1538,10 +1538,8 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 						 GFP_NOFS);
 	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
 						 GFP_NOFS);
-	struct btrfs_root *tree_root = kzalloc(sizeof(struct btrfs_root),
-					       GFP_NOFS);
-	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
-						GFP_NOFS);
+	struct btrfs_root *tree_root = btrfs_sb(sb);
+	struct btrfs_fs_info *fs_info = tree_root->fs_info;
 	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
 						GFP_NOFS);
 	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
fs/btrfs/super.c +32 -3
index 8299a25..9145551 100644
@@ -562,12 +562,20 @@ static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
 
 static int btrfs_test_super(struct super_block *s, void *data)
 {
-	struct btrfs_fs_devices *test_fs_devices = data;
+	struct btrfs_root *test_root = data;
 	struct btrfs_root *root = btrfs_sb(s);
 
-	return root->fs_info->fs_devices == test_fs_devices;
+	return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
 }
 
+static int btrfs_set_super(struct super_block *s, void *data)
+{
+	s->s_fs_info = data;
+
+	return set_anon_super(s, data);
+}
+
+
 /*
  * Find a superblock for the given device / mount point.
  *
@@ -581,6 +589,8 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
 	struct super_block *s;
 	struct dentry *root;
 	struct btrfs_fs_devices *fs_devices = NULL;
+	struct btrfs_root *tree_root = NULL;
+	struct btrfs_fs_info *fs_info = NULL;
 	fmode_t mode = FMODE_READ;
 	char *subvol_name = NULL;
 	u64 subvol_objectid = 0;
@@ -608,8 +618,25 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
 		goto error_close_devices;
 	}
 
+	/*
+	 * Setup a dummy root and fs_info for test/set super.  This is because
+	 * we don't actually fill this stuff out until open_ctree, but we need
+	 * it for searching for existing supers, so this lets us do that and
+	 * then open_ctree will properly initialize everything later.
+	 */
+	fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
+	tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
+	if (!fs_info || !tree_root) {
+		kfree(fs_info);
+		kfree(tree_root);
+		goto error_close_devices;
+	}
+	fs_info->tree_root = tree_root;
+	fs_info->fs_devices = fs_devices;
+	tree_root->fs_info = fs_info;
+
 	bdev = fs_devices->latest_bdev;
-	s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
+	s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
 	if (IS_ERR(s))
 		goto error_s;
 
@@ -675,6 +702,8 @@ error_s:
 	error = PTR_ERR(s);
 error_close_devices:
 	btrfs_close_devices(fs_devices);
+	kfree(fs_info);
+	kfree(tree_root);
 error_free_subvol_name:
 	kfree(subvol_name);
 	return ERR_PTR(error);
Signature · 1 line
1.6.6.1
#1 lore raw

fs/btrfs/super.c static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · line 631

Quoted 11 lines
fs/btrfs/super.c +11 -0
+	/*
+	 * Setup a dummy root and fs_info for test/set super.  This is because
+	 * we don't actually fill this stuff out until open_ctree, but we need
+	 * it for searching for existing supers, so this lets us do that and
+	 * then open_ctree will properly initialize everything later.
+	 */
+	fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
+	tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
+	if (!fs_info || !tree_root) {
+		kfree(fs_info);
+		kfree(tree_root);

The above 2 kfree() calls are redundant.

And error should be set to -ENOMEM.

Quoted 21 lines
fs/btrfs/super.c +9 -1
+		goto error_close_devices;
+	}
+	fs_info->tree_root = tree_root;
+	fs_info->fs_devices = fs_devices;
+	tree_root->fs_info = fs_info;
+
 	bdev = fs_devices->latest_bdev;
-	s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
+	s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
 	if (IS_ERR(s))
 		goto error_s;
@@ -675,6 +702,8 @@ error_s:
 	error = PTR_ERR(s);
 error_close_devices:
 	btrfs_close_devices(fs_devices);
+	kfree(fs_info);
+	kfree(tree_root);
 error_free_subvol_name:
 	kfree(subvol_name);
 	return ERR_PTR(error);
#2 lore raw
Quoted 5 lines · Li Zefan
Quoted 5 lines
fs/btrfs/super.c +5 -0
+	/*
+	 * Setup a dummy root and fs_info for test/set super.  This is because
+	 * we don't actually fill this stuff out until open_ctree, but we need
+	 * it for searching for existing supers, so this lets us do that and
+	 * then open_ctree will properly initialize everything later.
Quoted 8 lines

fs/btrfs/super.c static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · line 631

Quoted 6 lines
fs/btrfs/super.c +6 -0
+	 */
+	fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
+	tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
+	if (!fs_info || !tree_root) {
+		kfree(fs_info);
+		kfree(tree_root);

The above 2 kfree() calls are redundant.

That's what I thought when I first looked at it but what happens when fs_info != NULL and tree_root == NULL.

Although I do wonder if doing two successive allocation requests and then checking both is a good idea. If memory is low there may be a bunch of page scanning to try and free memory and if it eventually fails that same process probably would happen all over again on the second call. I'm not sure though.

Quoted 2 lines

And error should be set to -ENOMEM.

Ah, yes .. I missed that.

Quoted 22 lines
Quoted 22 lines
fs/btrfs/super.c +9 -1
+		goto error_close_devices;
+	}
+	fs_info->tree_root = tree_root;
+	fs_info->fs_devices = fs_devices;
+	tree_root->fs_info = fs_info;
+
 	bdev = fs_devices->latest_bdev;
-	s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
+	s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
 	if (IS_ERR(s))
 		goto error_s;
@@ -675,6 +702,8 @@ error_s:
 	error = PTR_ERR(s);
 error_close_devices:
 	btrfs_close_devices(fs_devices);
+	kfree(fs_info);
+	kfree(tree_root);
 error_free_subvol_name:
 	kfree(subvol_name);
 	return ERR_PTR(error);
#3 lore raw
Quoted 15 lines · Ian Kent
Quoted 5 lines · Li Zefan
Quoted 5 lines
fs/btrfs/super.c +5 -0
+	/*
+	 * Setup a dummy root and fs_info for test/set super.  This is because
+	 * we don't actually fill this stuff out until open_ctree, but we need
+	 * it for searching for existing supers, so this lets us do that and
+	 * then open_ctree will properly initialize everything later.
Quoted 8 lines

fs/btrfs/super.c static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · line 631

Quoted 6 lines
fs/btrfs/super.c +6 -0
+	 */
+	fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
+	tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
+	if (!fs_info || !tree_root) {
+		kfree(fs_info);
+		kfree(tree_root);

The above 2 kfree() calls are redundant.

Quoted 3 lines

That's what I thought when I first looked at it but what happens when fs_info != NULL and tree_root == NULL.

When i do goto error_close_devices; i do the kfree's there too, my bad, I'll fix it up.

Quoted 6 lines

Although I do wonder if doing two successive allocation requests and then checking both is a good idea. If memory is low there may be a bunch of page scanning to try and free memory and if it eventually fails that same process probably would happen all over again on the second call. I'm not sure though.

Sure but how often is that going to happen :)

Quoted 5 lines
Quoted 2 lines

And error should be set to -ENOMEM.

Ah, yes .. I missed that.

Yup me too. Thanks for the review guys,

Josef

#4 lore raw
In reply to Ian Kent

=E4=BA=8E 2010=E5=B9=B411=E6=9C=8822=E6=97=A5 09:49, Ian Kent =E5=86=99= =E9=81=93:

Quoted 3 lines · Li Zefan
Quoted 2 lines

Review

Quoted 2 lines
(quoted diff) +2 -0
+	/*
+	 * Setup a dummy root and fs_info for test/set super.  This is be=

cause

Quoted 1 line
Quoted 1 line

Review

Quoted 1 line
(quoted diff) +1 -0
+	 * we don't actually fill this stuff out until open_ctree, but we=

need

Quoted 1 line
Quoted 1 line

Review

Quoted 1 line
(quoted diff) +1 -0
+	 * it for searching for existing supers, so this lets us do that =

and

Quoted 8 lines
Quoted 8 lines

fs/btrfs/super.c static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · line 631

Quoted 7 lines
fs/btrfs/super.c +7 -0
+	 * then open_ctree will properly initialize everything later.
+	 */
+	fs_info =3D kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
+	tree_root =3D kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
+	if (!fs_info || !tree_root) {
+		kfree(fs_info);
+		kfree(tree_root);

The above 2 kfree() calls are redundant.

Quoted 4 lines

=20
That's what I thought when I first looked at it but what happens when fs_info !=3D NULL and tree_root =3D=3D NULL.
=20

Nothing bad happens in that case. ;)

We'll do the cleanup after "goto error_close_devices", and kfree(NULL) is Ok. Did I miss something?

Quoted 2 lines

Although I do wonder if doing two successive allocation requests and then checking both is a good idea. If memory is low there may be a bu=

nch

Quoted 1 line

of page scanning to try and free memory and if it eventually fails th=

at

Quoted 7 lines

same process probably would happen all over again on the second call. I'm not sure though.
=20

Quoted 1 line

And error should be set to -ENOMEM.

=20
Ah, yes .. I missed that.
=20

--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" = in
the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#5 lore raw
Quoted 1 line · Li Zefan

=E4=BA=8E 2010=E5=B9=B411=E6=9C=8822=E6=97=A5 09:49, Ian Kent =E5=86=99=

=E9=81=93:

Quoted 3 lines
Quoted 3 lines · Li Zefan
Quoted 2 lines

Review

Quoted 2 lines
(quoted diff) +2 -0
+	/*
+	 * Setup a dummy root and fs_info for test/set super.  This is =

because

Quoted 1 line
Quoted 1 line
Quoted 1 line

Review

Quoted 1 line
(quoted diff) +1 -0
+	 * we don't actually fill this stuff out until open_ctree, but =

we need

Quoted 1 line
Quoted 1 line
Quoted 1 line

Review

Quoted 1 line
(quoted diff) +1 -0
+	 * it for searching for existing supers, so this lets us do tha=

t and

Quoted 10 lines
Quoted 10 lines
Quoted 8 lines

fs/btrfs/super.c static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · line 631

Quoted 7 lines
fs/btrfs/super.c +7 -0
+	 * then open_ctree will properly initialize everything later.
+	 */
+	fs_info =3D kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
+	tree_root =3D kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
+	if (!fs_info || !tree_root) {
+		kfree(fs_info);
+		kfree(tree_root);

The above 2 kfree() calls are redundant.

=20
That's what I thought when I first looked at it but what happens wh=

en

Quoted 6 lines
Quoted 2 lines

fs_info !=3D NULL and tree_root =3D=3D NULL.
=20

=20
Nothing bad happens in that case. ;)
=20
We'll do the cleanup after "goto error_close_devices", and kfree(NULL=

)

Quoted 1 line

is Ok. Did I miss something?

No, you were correct, Josef also pointed that out, oops!

Quoted 2 lines

=20

Quoted 1 line

Although I do wonder if doing two successive allocation requests an=

d

Quoted 1 line
Quoted 1 line

then checking both is a good idea. If memory is low there may be a =

bunch

Quoted 1 line
Quoted 1 line

of page scanning to try and free memory and if it eventually fails =

that

Quoted 1 line
Quoted 1 line

same process probably would happen all over again on the second cal=

l.

Quoted 6 lines
Quoted 6 lines

I'm not sure though.
=20

Quoted 1 line

And error should be set to -ENOMEM.

=20
Ah, yes .. I missed that.
=20

--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" = in
the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#6 lore raw
In reply to Josef Bacik
Quoted 85 lines · Josef Bacik

There is a problem with how we use sget, it searches through the list of supers attached to the fs_type looking for a super with the same fs_devices as what we're trying to mount. This depends on sb->s_fs_info being filled, but we don't fill that in until we get to btrfs_fill_super, so we could hit supers on the fs_type super list that have a null s_fs_info. In order to fix that we need to go ahead and setup a blank root with a blank fs_info to hold fs_devices, that way our test will work out right and then we can set s_fs_info in btrfs_set_super, and then open_ctree will simply use our pre-allocated root and fs_info when setting everything up. Thanks,

---
 fs/btrfs/disk-io.c |    6 ++----
 fs/btrfs/super.c   |   35 ++++++++++++++++++++++++++++++++---
 2 files changed, 34 insertions(+), 7 deletions(-)
fs/btrfs/disk-io.c +2 -4
index fb827d0..f0aa204 100644
@@ -1538,10 +1538,8 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 						 GFP_NOFS);
 	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
 						 GFP_NOFS);
-	struct btrfs_root *tree_root = kzalloc(sizeof(struct btrfs_root),
-					       GFP_NOFS);
-	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
-						GFP_NOFS);
+	struct btrfs_root *tree_root = btrfs_sb(sb);
+	struct btrfs_fs_info *fs_info = tree_root->fs_info;
 	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
 						GFP_NOFS);
 	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
fs/btrfs/super.c +24 -2
index 8299a25..9145551 100644
@@ -562,12 +562,20 @@ static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
 
 static int btrfs_test_super(struct super_block *s, void *data)
 {
-	struct btrfs_fs_devices *test_fs_devices = data;
+	struct btrfs_root *test_root = data;
 	struct btrfs_root *root = btrfs_sb(s);
 
-	return root->fs_info->fs_devices == test_fs_devices;
+	return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
 }
 
+static int btrfs_set_super(struct super_block *s, void *data)
+{
+	s->s_fs_info = data;
+
+	return set_anon_super(s, data);
+}
+
+
 /*
  * Find a superblock for the given device / mount point.
  *
@@ -581,6 +589,8 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
 	struct super_block *s;
 	struct dentry *root;
 	struct btrfs_fs_devices *fs_devices = NULL;
+	struct btrfs_root *tree_root = NULL;
+	struct btrfs_fs_info *fs_info = NULL;
 	fmode_t mode = FMODE_READ;
 	char *subvol_name = NULL;
 	u64 subvol_objectid = 0;
@@ -608,8 +618,25 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
 		goto error_close_devices;
 	}
 
+	/*
+	 * Setup a dummy root and fs_info for test/set super.  This is because
+	 * we don't actually fill this stuff out until open_ctree, but we need
+	 * it for searching for existing supers, so this lets us do that and
+	 * then open_ctree will properly initialize everything later.
+	 */
+	fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
+	tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
+	if (!fs_info || !tree_root) {
+		kfree(fs_info);
+		kfree(tree_root);
+		goto error_close_devices;

fs/btrfs/super.c static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags, · line 641

Quoted 10 lines
fs/btrfs/super.c +6 -1
+	}
+	fs_info->tree_root = tree_root;
+	fs_info->fs_devices = fs_devices;
+	tree_root->fs_info = fs_info;
+
 	bdev = fs_devices->latest_bdev;
-	s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
+	s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
 	if (IS_ERR(s))
 		goto error_s;

There's no context here to comment against but just below there's a check on s->s_root which tells us that an existing super block was found. If the flags test then fails these two allocations are freed in the error exit otherwise the existing super is used and the new fs_info and tree_root are leaked.

I thought you were going to merge my patch for that in to yours?

fs/btrfs/super.c error_s: · line 709

Quoted 10 lines
fs/btrfs/super.c +2 -0
@@ -675,6 +702,8 @@ error_s:
 	error = PTR_ERR(s);
 error_close_devices:
 	btrfs_close_devices(fs_devices);
+	kfree(fs_info);
+	kfree(tree_root);
 error_free_subvol_name:
 	kfree(subvol_name);
 	return ERR_PTR(error);

This is a race against other processes that are mounting but there is the very small race window for processes that are umounting as well. I know you didn't think that was a problem but I think that was mostly because of how I described it. I was hoping you would have another look at that and include my patch in your series since it is related to this problem.

Have a look in fs/super.c:generic_shutdown_super(), called by fs/super.c:kill_anon_super(), where the super method ->put_super() is called, setting the super s_fs_info to NULL, before taking the sb_lock and removing it from the list of supers.

Here's my patch.

btrfs - fix race between btrfs_get_sb() and umount

From: Ian Kent <[email protected]>

When mounting a btrfs file system btrfs_test_super() may attempt to use sb->s_fs_info, the btrfs root, of a super block that is going away and that has had the btrfs root set to NULL in its ->put_super(). But if the super block is going away it cannot be an existing super block so we can return false in this case.

---

 fs/btrfs/super.c |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)
fs/btrfs/super.c +6 -0
index 6b57da3..960b320 100644
@@ -565,6 +565,12 @@ static int btrfs_test_super(struct super_block *s, void *data)
 	struct btrfs_fs_devices *test_fs_devices = data->fs_info->fs_devices;
 	struct btrfs_root *root = btrfs_sb(s);
 
+	/*
+	 * 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_fs_devices;
 }
 
#7 lore raw
Quoted 9 lines

Have a look in fs/super.c:generic_shutdown_super(), called by fs/super.c:kill_anon_super(), where the super method ->put_super() is called, setting the super s_fs_info to NULL, before taking the sb_lock and removing it from the list of supers.

Here's my patch.

btrfs - fix race between btrfs_get_sb() and umount

Quoted 7 lines

From: Ian Kent <[email protected]>

When mounting a btrfs file system btrfs_test_super() may attempt to use sb->s_fs_info, the btrfs root, of a super block that is going away and that has had the btrfs root set to NULL in its ->put_super(). But if the super block is going away it cannot be an existing super block so we can return false in this case.

I think your analysis is right.

Actually I ran the test script (posted in an earlier email), and it still crashed without your supplementary patch.

Quoted 26 lines

---

 fs/btrfs/super.c |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)
fs/btrfs/super.c +6 -0
index 6b57da3..960b320 100644
@@ -565,6 +565,12 @@ static int btrfs_test_super(struct super_block *s, void *data)
 	struct btrfs_fs_devices *test_fs_devices = data->fs_info->fs_devices;
 	struct btrfs_root *root = btrfs_sb(s);
 
+	/*
+	 * 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_fs_devices;
 }
 
#8 lore raw
Quoted 17 lines · Li Zefan
Quoted 9 lines

Have a look in fs/super.c:generic_shutdown_super(), called by fs/super.c:kill_anon_super(), where the super method ->put_super() is called, setting the super s_fs_info to NULL, before taking the sb_lock and removing it from the list of supers.

Here's my patch.

btrfs - fix race between btrfs_get_sb() and umount

Quoted 7 lines

From: Ian Kent <[email protected]>

When mounting a btrfs file system btrfs_test_super() may attempt to use sb->s_fs_info, the btrfs root, of a super block that is going away and that has had the btrfs root set to NULL in its ->put_super(). But if the super block is going away it cannot be an existing super block so we can return false in this case.

Quoted 4 lines

I think your analysis is right.

Actually I ran the test script (posted in an earlier email), and it still crashed without your supplementary patch.

And vice versa, as we found out working the Fedora bug, when I thought this was the actual bug at one point, both patches are needed.

Quoted 27 lines
Quoted 27 lines

---

 fs/btrfs/super.c |    6 ++++++
 1 files changed, 6 insertions(+), 0 deletions(-)
fs/btrfs/super.c +6 -0
index 6b57da3..960b320 100644
@@ -565,6 +565,12 @@ static int btrfs_test_super(struct super_block *s, void *data)
 	struct btrfs_fs_devices *test_fs_devices = data->fs_info->fs_devices;
 	struct btrfs_root *root = btrfs_sb(s);
 
+	/*
+	 * 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_fs_devices;
 }