vfs: Pre-allocate superblock in sget_fc() if !test
PATCH 1/1 vfs: Pre-allocate superblock in sget_fc() if !test
When the test function is not defined in sget_fc(), we always need to allocate a new superblock. So there is no point in acquiring the sb_lock twice in this case. Optimize the !test case by pre-allocating the superblock first before acquring the lock.
--- fs/super.c | 2 ++ 1 file changed, 2 insertions(+)
fs/super.c +2 -0
@@ -520,6 +520,8 @@ struct super_block *sget_fc(struct fs_context *fc,struct user_namespace *user_ns = fc->global ? &init_user_ns : fc->user_ns;int err; +if (!test) + s =alloc_super (fc->fs_type, fc->sb_flags, user_ns); retry:spin_lock (&sb_lock);if (test) {
Signature · 1 line
2.27.0
Christian Brauner
maintainerQuoted 15 lines · Waiman Long
When the test function is not defined in
sget_fc(), we always need to allocate a new superblock. So there is no point in acquiring thesb_locktwice in this case. Optimize the !test case by pre-allocating the superblock first before acquring the lock.Signed-off-by Waiman Long <[email protected]>--- fs/super.c | 2 ++ 1 file changed, 2 insertions(+)fs/super.c +0
-0
fs/super.c struct super_block *sget_fc(struct fs_context *fc, · line 524
Quoted 5 lines
fs/super.c +2
-0@@ -520,6 +520,8 @@ struct super_block *sget_fc(struct fs_context *fc,struct user_namespace *user_ns = fc->global ? &init_user_ns : fc->user_ns;int err; +if (!test) + s =alloc_super (fc->fs_type, fc->sb_flags, user_ns);
Shouldn't we treat this allocation failure as "fatal" right away and not bother taking locks, walking lists and so on? Seems strange to treat it as fatal below but not here.
(The code-flow in here has always been a bit challenging to follow imho. So not super keen to see more special-cases in there. Curious: do you see any noticeable performance impact from that lock being taken and dropped for the !test case?)
Quoted 19 lines · Christian Brauner
Quoted 18 lines · Waiman Long
When the test function is not defined in
sget_fc(), we always need to allocate a new superblock. So there is no point in acquiring thesb_locktwice in this case. Optimize the !test case by pre-allocating the superblock first before acquring the lock.Signed-off-by Waiman Long <[email protected]>--- fs/super.c | 2 ++ 1 file changed, 2 insertions(+)fs/super.c +0
-0@@ -520,6 +520,8 @@ struct super_block *sget_fc(struct fs_context *fc,struct user_namespace *user_ns = fc->global ? &init_user_ns : fc->user_ns;int err;
Quoted 5 lines
fs/super.c struct super_block *sget_fc(struct fs_context *fc, · line 524
Quoted 2 lines
fs/super.c +2
-0+if (!test) + s =alloc_super (fc->fs_type, fc->sb_flags, user_ns);Shouldn't we treat this allocation failure as "fatal" right away and not bother taking locks, walking lists and so on? Seems strange to treat it as fatal below but not here.
I didn't add the null check because it was a rare case and the check is done later on anyway. I do agree that it may look a bit odd. Perhaps I should rearrange the code flow as suggested.
Quoted 5 lines
(The code-flow in here has always been a bit challenging to follow imho. So not super keen to see more special-cases in there. Curious: do you see any noticeable performance impact from that lock being taken and dropped for the !test case?)
I don't believe there is noticeable performance impact with the !test case. The test case, however, can have some noticeable impact if the superblock list is long. I am wondering if we just always preallocate superblock with the risk that it may get unused and freed later on.
Cheers,
Longman