f2fs: fix multiple f2fs_add_link() calls having same name
Subsystems (3)
Jaegeuk Kim
maintainerPATCH 1/1 f2fs: fix multiple f2fs_add_link() calls having same name
VFS uses f2fs_lookup() to decide f2fs_add_link() call during file creation. But, if there is a race condition, f2fs_add_link() can be called multiple times, resulting in multiple dentries with a same name. This patches fixes it by adding __f2fs_find_entry() in f2fs_add_link() path.
--- fs/f2fs/dir.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
fs/f2fs/dir.c +12 -2
@@ -643,14 +643,24 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode, nid_t ino, umode_t mode) { struct fscrypt_name fname; +struct page *page; +struct f2fs_dir_entry *de;int err; err =fscrypt_setup_filename (dir, name,0 , &fname);if (err)return err; - err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); - + de =__f2fs_find_entry (dir, &fname, &page); +if (de) { +f2fs_dentry_kunmap (dir, page); +f2fs_put_page (page,0 ); + err = -EEXIST ; + }else if (!IS_ERR (page)) { + err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); + }else { + err =PTR_ERR (page); + }fscrypt_free_filename (&fname);return err; }
Signature · 1 line
2.11.0
Quoted 4 lines · Jaegeuk Kim
VFS uses
f2fs_lookup()to decidef2fs_add_link()call during file creation. But, if there is a race condition,f2fs_add_link()can be called multiple times, resulting in multiple dentries with a same name. This patches fixes it by adding__f2fs_find_entry()inf2fs_add_link()path.
As during ->lookup, i_mutex will be held all the time, so there is no race condition in between different file creators?
Thanks,
Quoted 39 lines
Cc <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/dir.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)fs/f2fs/dir.c +12
-2@@ -643,14 +643,24 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode, nid_t ino, umode_t mode) { struct fscrypt_name fname; +struct page *page; +struct f2fs_dir_entry *de;int err; err =fscrypt_setup_filename (dir, name,0 , &fname);if (err)return err; - err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); - + de =__f2fs_find_entry (dir, &fname, &page); +if (de) { +f2fs_dentry_kunmap (dir, page); +f2fs_put_page (page,0 ); + err = -EEXIST ; + }else if (!IS_ERR (page)) { + err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); + }else { + err =PTR_ERR (page); + }fscrypt_free_filename (&fname);return err; }
Jaegeuk Kim
maintainerQuoted 8 lines · Chao Yu
Quoted 4 lines · Jaegeuk Kim
VFS uses
f2fs_lookup()to decidef2fs_add_link()call during file creation. But, if there is a race condition,f2fs_add_link()can be called multiple times, resulting in multiple dentries with a same name. This patches fixes it by adding__f2fs_find_entry()inf2fs_add_link()path.As during ->lookup,
i_mutexwill be held all the time, so there is no race condition in between different file creators?
Hehe, yup.
I dropped this patch.
Thanks,
Quoted 42 lines
Thanks,
Quoted 39 lines
Cc <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/dir.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)fs/f2fs/dir.c +12
-2@@ -643,14 +643,24 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode, nid_t ino, umode_t mode) { struct fscrypt_name fname; +struct page *page; +struct f2fs_dir_entry *de;int err; err =fscrypt_setup_filename (dir, name,0 , &fname);if (err)return err; - err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); - + de =__f2fs_find_entry (dir, &fname, &page); +if (de) { +f2fs_dentry_kunmap (dir, page); +f2fs_put_page (page,0 ); + err = -EEXIST ; + }else if (!IS_ERR (page)) { + err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); + }else { + err =PTR_ERR (page); + }fscrypt_free_filename (&fname);return err; }
Jaegeuk Kim
maintainerQuoted 7 lines · Jaegeuk Kim
Quoted 6 lines · Chao Yu
Quoted 4 lines · Jaegeuk Kim
VFS uses
f2fs_lookup()to decidef2fs_add_link()call during file creation. But, if there is a race condition,f2fs_add_link()can be called multiple times, resulting in multiple dentries with a same name. This patches fixes it by adding__f2fs_find_entry()inf2fs_add_link()path.
Quoted 5 lines
Quoted 2 lines
As during ->lookup,
i_mutexwill be held all the time, so there is no race condition in between different file creators?Hehe, yup.
I dropped this patch.
It turns out sdcardfs has a race condition between lookup and create, and it calls vfs_create() twice. Workaround by f2fs would be needed for whole AOSP as well. And I added to check current to avoid performance regression.
Thanks,
Quoted 1 line
From
2f433dbfa491550e666a3d08f5a59ac5bed42b0fMon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Tue, 14 Feb 2017 09:54:37 -0800
Subject: [PATCH] f2fs: fix multiple f2fs_add_link() calls having same name
It turns out a stakable filesystem like sdcardfs in AOSP can trigger multiple vfs_create() to lower filesystem. In that case, f2fs will add multiple dentries having same name which breaks filesystem consistency.
Until upper layer fixes, let's work around by f2fs, which shows actually not much performance regression.
--- fs/f2fs/dir.c | 26 ++++++++++++++++++++++++-- fs/f2fs/f2fs.h | 1 + 2 files changed, 25 insertions(+), 2 deletions(-)
fs/f2fs/dir.c +24 -2
@@ -207,9 +207,11 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir,f2fs_put_page (dentry_page,0 ); } +/* This is to increase the speed of f2fs_create */ if (!de && room &&F2FS_I (dir)->chash != namehash) {F2FS_I (dir)->chash = namehash;F2FS_I (dir)->clevel = level; +F2FS_I (dir)->task = current; }return de;
@@ -643,14 +645,34 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode, nid_t ino, umode_t mode) { struct fscrypt_name fname; +struct page *page =NULL ; +struct f2fs_dir_entry *de =NULL ;int err; err =fscrypt_setup_filename (dir, name,0 , &fname);if (err)return err; - err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); - +/* +* An immature stakable filesystem shows a race condition between lookup +* and create. If we have same task when doing lookup and create, it's +* definitely fine as expected by VFS normally. Otherwise, let's just +* verify on-disk dentry one more time, which guarantees filesystem +* consistency more. +*/ +if (current !=F2FS_I (dir)->task) { + de =__f2fs_find_entry (dir, &fname, &page); +F2FS_I (dir)->task =NULL ; + } +if (de) { +f2fs_dentry_kunmap (dir, page); +f2fs_put_page (page,0 ); + err = -EEXIST ; + }else if (!IS_ERR (page)) { + err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); + }else { + err =PTR_ERR (page); + }fscrypt_free_filename (&fname);return err; }
fs/f2fs/f2fs.h +1 -0
@@ -454,6 +454,7 @@ struct f2fs_inode_info {atomic_t dirty_pages;/* # of dirty pages */ f2fs_hash_t chash;/* hash value of given file name */ unsigned int clevel;/* maximum level of given file name */ +struct task_struct *task;/* lookup and create consistency */ nid_t i_xattr_nid;/* node id that contains xattrs */ loff_t last_disk_size;/* lastly written file size */
Signature · 1 line
2.11.0
Quoted 44 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 6 lines · Chao Yu
Quoted 4 lines · Jaegeuk Kim
VFS uses
f2fs_lookup()to decidef2fs_add_link()call during file creation. But, if there is a race condition,f2fs_add_link()can be called multiple times, resulting in multiple dentries with a same name. This patches fixes it by adding__f2fs_find_entry()inf2fs_add_link()path.Quoted 5 lines
Quoted 2 lines
As during ->lookup,
i_mutexwill be held all the time, so there is no race condition in between different file creators?Hehe, yup.
I dropped this patch.It turns out sdcardfs has a race condition between lookup and create, and it calls
vfs_create()twice. Workaround by f2fs would be needed for whole AOSP as well. And I added to check current to avoid performance regression.Thanks,
Quoted 1 line
From
2f433dbfa491550e666a3d08f5a59ac5bed42b0fMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 14 Feb 2017 09:54:37 -0800
Subject: [PATCH] f2fs: fix multiplef2fs_add_link()calls having same nameIt turns out a stakable filesystem like sdcardfs in AOSP can trigger multiple
vfs_create()to lower filesystem. In that case, f2fs will add multiple dentries having same name which breaks filesystem consistency.Until upper layer fixes, let's work around by f2fs, which shows actually not much performance regression.
Cc <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/dir.c | 26 ++++++++++++++++++++++++-- fs/f2fs/f2fs.h | 1 + 2 files changed, 25 insertions(+), 2 deletions(-)fs/f2fs/dir.c +0
-0
fs/f2fs/dir.c static struct f2fs_dir_entry *find_in_level(struct inode *dir, · line 215
Quoted 9 lines
fs/f2fs/dir.c +2
-0@@ -207,9 +207,11 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir,f2fs_put_page (dentry_page,0 ); } +/* This is to increase the speed of f2fs_create */ if (!de && room &&F2FS_I (dir)->chash != namehash) {F2FS_I (dir)->chash = namehash;F2FS_I (dir)->clevel = level; +F2FS_I (dir)->task = current; }
Hash collision can happen on different file names, here, assignment of .task should be more accurately to prevent racing between lookup and creat, so how about:
if (!de && room) {
.task = current;
if (chash != namehash) {
.chash = namehash;
.clevel = level;
}
}Thanks,
Quoted 52 lines
fs/f2fs/dir.c +22
-2return de;@@ -643,14 +645,34 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode, nid_t ino, umode_t mode) { struct fscrypt_name fname; +struct page *page =NULL ; +struct f2fs_dir_entry *de =NULL ;int err; err =fscrypt_setup_filename (dir, name,0 , &fname);if (err)return err; - err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); - +/* +* An immature stakable filesystem shows a race condition between lookup +* and create. If we have same task when doing lookup and create, it's +* definitely fine as expected by VFS normally. Otherwise, let's just +* verify on-disk dentry one more time, which guarantees filesystem +* consistency more. +*/ +if (current !=F2FS_I (dir)->task) { + de =__f2fs_find_entry (dir, &fname, &page); +F2FS_I (dir)->task =NULL ; + } +if (de) { +f2fs_dentry_kunmap (dir, page); +f2fs_put_page (page,0 ); + err = -EEXIST ; + }else if (!IS_ERR (page)) { + err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); + }else { + err =PTR_ERR (page); + }fscrypt_free_filename (&fname);return err; }fs/f2fs/f2fs.h +1
-0@@ -454,6 +454,7 @@ struct f2fs_inode_info {atomic_t dirty_pages;/* # of dirty pages */ f2fs_hash_t chash;/* hash value of given file name */ unsigned int clevel;/* maximum level of given file name */ +struct task_struct *task;/* lookup and create consistency */ nid_t i_xattr_nid;/* node id that contains xattrs */ loff_t last_disk_size;/* lastly written file size */
Jaegeuk Kim
maintainerQuoted 58 lines · Chao Yu
Quoted 44 lines · Jaegeuk Kim
Quoted 7 lines · Jaegeuk Kim
Quoted 6 lines · Chao Yu
Quoted 4 lines · Jaegeuk Kim
VFS uses
f2fs_lookup()to decidef2fs_add_link()call during file creation. But, if there is a race condition,f2fs_add_link()can be called multiple times, resulting in multiple dentries with a same name. This patches fixes it by adding__f2fs_find_entry()inf2fs_add_link()path.Quoted 5 lines
Quoted 2 lines
As during ->lookup,
i_mutexwill be held all the time, so there is no race condition in between different file creators?Hehe, yup.
I dropped this patch.It turns out sdcardfs has a race condition between lookup and create, and it calls
vfs_create()twice. Workaround by f2fs would be needed for whole AOSP as well. And I added to check current to avoid performance regression.Thanks,
Quoted 1 line
From
2f433dbfa491550e666a3d08f5a59ac5bed42b0fMon Sep 17 00:00:00 2001From: Jaegeuk Kim <[email protected]>
Date: Tue, 14 Feb 2017 09:54:37 -0800
Subject: [PATCH] f2fs: fix multiplef2fs_add_link()calls having same nameIt turns out a stakable filesystem like sdcardfs in AOSP can trigger multiple
vfs_create()to lower filesystem. In that case, f2fs will add multiple dentries having same name which breaks filesystem consistency.Until upper layer fixes, let's work around by f2fs, which shows actually not much performance regression.
Cc <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/dir.c | 26 ++++++++++++++++++++++++-- fs/f2fs/f2fs.h | 1 + 2 files changed, 25 insertions(+), 2 deletions(-)fs/f2fs/dir.c +0
-0fs/f2fs/dir.c static struct f2fs_dir_entry *find_in_level(struct inode *dir, · line 215
Quoted 9 lines
fs/f2fs/dir.c +2
-0@@ -207,9 +207,11 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir,f2fs_put_page (dentry_page,0 ); } +/* This is to increase the speed of f2fs_create */ if (!de && room &&F2FS_I (dir)->chash != namehash) {F2FS_I (dir)->chash = namehash;F2FS_I (dir)->clevel = level; +F2FS_I (dir)->task = current; }Hash collision can happen on different file names, here, assignment of .task should be more accurately to prevent racing between lookup and creat, so how about:
Quoted 7 lines
if (!de && room) {
.task = current;
if (chash != namehash) {
.chash = namehash;
.clevel = level;
}
}Makes sense.
Will apply that. ;)
Thanks,
Quoted 55 lines
Thanks,
Quoted 52 lines
fs/f2fs/dir.c +22
-2return de;@@ -643,14 +645,34 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, struct inode *inode, nid_t ino, umode_t mode) { struct fscrypt_name fname; +struct page *page =NULL ; +struct f2fs_dir_entry *de =NULL ;int err; err =fscrypt_setup_filename (dir, name,0 , &fname);if (err)return err; - err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); - +/* +* An immature stakable filesystem shows a race condition between lookup +* and create. If we have same task when doing lookup and create, it's +* definitely fine as expected by VFS normally. Otherwise, let's just +* verify on-disk dentry one more time, which guarantees filesystem +* consistency more. +*/ +if (current !=F2FS_I (dir)->task) { + de =__f2fs_find_entry (dir, &fname, &page); +F2FS_I (dir)->task =NULL ; + } +if (de) { +f2fs_dentry_kunmap (dir, page); +f2fs_put_page (page,0 ); + err = -EEXIST ; + }else if (!IS_ERR (page)) { + err =__f2fs_do_add_link (dir, &fname, inode, ino, mode); + }else { + err =PTR_ERR (page); + }fscrypt_free_filename (&fname);return err; }fs/f2fs/f2fs.h +1
-0@@ -454,6 +454,7 @@ struct f2fs_inode_info {atomic_t dirty_pages;/* # of dirty pages */ f2fs_hash_t chash;/* hash value of given file name */ unsigned int clevel;/* maximum level of given file name */ +struct task_struct *task;/* lookup and create consistency */ nid_t i_xattr_nid;/* node id that contains xattrs */ loff_t last_disk_size;/* lastly written file size */