Handle notifications on overlayfs fake path files
Subsystems (4)
Amir Goldstein
maintainerv3 cover Handle notifications on overlayfs fake path files
Miklos,
Third attempt with the eye towards simplifying d_real() interface.
Like v2, most of the vfs code should remain unaffected by this expect for the special fsnotify case that we wanted to fix.
Thanks,
Amir.
Changes since v2:
- Restore the file_fake container (Miklos)
- Re-arrange the v1 helpers (Christian)
Changes since v1:
- Drop the file_fake container
- Leave f_path fake and special case only fsnotify
Amir Goldstein (2):
fs: use fake_file container for internal files with fake f_path
ovl: enable fsnotify events on underlying real files
fs/cachefiles/namei.c | 2 +- fs/file_table.c | 91 +++++++++++++++++++++++++++++++++------- fs/internal.h | 5 ++- fs/namei.c | 16 +++---- fs/open.c | 28 ++++++++----- fs/overlayfs/file.c | 6 +-- include/linux/fs.h | 15 ++++--- include/linux/fsnotify.h | 3 +- 8 files changed, 121 insertions(+), 45 deletions(-)
Signature · 1 line
2.34.1
Amir Goldstein
maintainerPATCH v3 1/2 fs: use fake_file container for internal files with fake f_path
Overlayfs and cachefiles use open_with_fake_path() to allocate internal files, where overlayfs also puts a "fake" path in f_path - a path which is not on the same fs as f_inode.
Allocate a container struct file_fake for those internal files, that is used to hold the fake path along with an optional real path.
--- fs/cachefiles/namei.c | 2 +- fs/file_table.c | 91 ++++++++++++++++++++++++++++++++++++------- fs/internal.h | 5 ++- fs/namei.c | 16 ++++---- fs/open.c | 28 +++++++------ fs/overlayfs/file.c | 2 +- include/linux/fs.h | 15 ++++--- 7 files changed, 117 insertions(+), 42 deletions(-)
fs/cachefiles/namei.c +1 -1
@@ -561,7 +561,7 @@ static bool cachefiles_open_file(struct cachefiles_object *object, path.mnt = cache->mnt; path.dentry = dentry; file =open_with_fake_path (&path,O_RDWR |O_LARGEFILE |O_DIRECT , -d_backing_inode (dentry), cache->cache_cred); + &path, cache->cache_cred);if (IS_ERR (file)) { trace_cachefiles_vfs_error(object, d_backing_inode(dentry), PTR_ERR(file),
fs/file_table.c +76 -15
138 lines not on this page · raw message
fs/internal.h +3 -2
@@ -97,8 +97,9 @@ extern void chroot_fs_refs(const struct path *, const struct path *);/* * file_table.c */ -extern struct file *alloc_empty_file (int ,const struct cred *); -extern struct file *alloc_empty_file_noaccount (int ,const struct cred *); +extern struct file *alloc_empty_file (int flags,const struct cred *cred); +extern struct file *alloc_empty_file_fake (int flags,const struct cred *cred); +extern struct path *__f_real_path (struct file *f);static inline void put_file_access (struct file *file) {
fs/namei.c +9 -7
@@ -3721,14 +3721,16 @@ struct file *vfs_tmpfile_open(struct mnt_idmap *idmap,struct file *file;int error; - file =alloc_empty_file_noaccount (open_flag, cred); -if (!IS_ERR (file)) { - error =vfs_tmpfile (idmap, parentpath, file, mode); -if (error) { -fput (file); - file =ERR_PTR (error); - } + file =alloc_empty_file_fake (open_flag, cred); +if (IS_ERR (file)) +return file; + + error =vfs_tmpfile (idmap, parentpath, file, mode); +if (error) { +fput (file); + file =ERR_PTR (error); } +return file; }EXPORT_SYMBOL (vfs_tmpfile_open);
fs/open.c +17 -11
@@ -1116,20 +1116,26 @@ struct file *dentry_create(const struct path *path, int flags, umode_t mode, }EXPORT_SYMBOL (dentry_create); -struct file *open_with_fake_path (const struct path *path,int flags, -struct inode *inode,const struct cred *cred) +struct file *open_with_fake_path (const struct path *fake_path,int flags, +const struct path *real_path, +const struct cred *cred) { -struct file *f =alloc_empty_file_noaccount (flags, cred); -if (!IS_ERR (f)) { -int error; +struct file *f; +int error; - f->f_path = *path; - error =do_dentry_open (f, inode,NULL ); -if (error) { -fput (f); - f =ERR_PTR (error); - } + f =alloc_empty_file_fake (flags, cred); +if (IS_ERR (f)) +return f; + + f->f_path = *fake_path; +path_get (real_path); + *__f_real_path (f) = *real_path; + error =do_dentry_open (f,d_inode (real_path->dentry),NULL ); +if (error) { +fput (f); + f =ERR_PTR (error); } +return f; }EXPORT_SYMBOL (open_with_fake_path);
fs/overlayfs/file.c +1 -1
@@ -61,7 +61,7 @@ static struct file *ovl_open_realfile(const struct file *file,if (!inode_owner_or_capable (real_idmap, realinode)) flags &= ~O_NOATIME ; - realfile =open_with_fake_path (&file->f_path, flags, realinode, + realfile =open_with_fake_path (&file->f_path, flags, realpath,current_cred ()); }revert_creds (old_cred);
include/linux/fs.h +10 -5
@@ -180,8 +180,8 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,/* File represents mount that needs unmounting */ #define FMODE_NEED_UNMOUNT ((__force fmode_t)0x10000000) -/* File does not contribute to nr_files count */ -#define FMODE_NOACCOUNT ((__force fmode_t)0x20000000) +/* File is embedded in file_fake and doesn't contribute to nr_files */ +#define FMODE_FAKE_PATH ((__force fmode_t)0x20000000)/* File supports async buffered reads */ #define FMODE_BUF_RASYNC ((__force fmode_t)0x40000000)
@@ -2349,11 +2349,16 @@ static inline struct file *file_open_root_mnt(struct vfsmount *mnt,return file_open_root (&(struct path ){.mnt = mnt, .dentry = mnt->mnt_root}, name, flags, mode); } -extern struct file *dentry_open (const struct path *,int ,const struct cred *); +extern struct file *dentry_open (const struct path *path,int flags, +const struct cred *creds);extern struct file *dentry_create (const struct path *path,int flags,umode_t mode,const struct cred *cred); -extern struct file *open_with_fake_path (const struct path *,int , -struct inode *,const struct cred *); +extern struct file *open_with_fake_path (const struct path *fake_path,int flags, +const struct path *real_path, +const struct cred *cred); +extern const struct path *f_real_path (struct file *file); +extern const struct path *f_fake_path (struct file *file); +static inline struct file *file_clone_open (struct file *file) {return dentry_open (&file->f_path, file->f_flags, file->f_cred);
Signature · 1 line
2.34.1
Re: [PATCH v3 1/2] fs: use fake_file container for internal files with fake f_path
Quoted 3 lines · Amir Goldstein
Overlayfs and cachefiles use
open_with_fake_path()to allocate internal files, where overlayfs also puts a "fake" path inf_path- a path which is not on the same fs asf_inode.
But cachefs doesn't, so this needs a better explanation / documentation.
Quoted 2 lines
Allocate a container struct
file_fakefor those internal files, that is used to hold the fake path along with an optional real path.
The idea looks sensible, but fake a is a really weird term here. I know open_with_fake_path also uses it, but we really need to come up with a better name, and also good documentation of the concept here.
fs/file_table.c static struct kmem_cache *filp_cachep __read_mostly; · line 67
Quoted 10 lines
fs/file_table.c +10
-0+/* Returns the real_path field that could be empty */ +struct path *__f_real_path (struct file *f) +{ +struct file_fake *ff =file_fake (f); + +if (f->f_mode &FMODE_FAKE_PATH ) +return &ff->real_path; +else +return &f->f_path; +}
two of the three callers always have FMODE_FAKE_PATH set, so please just drop this helper and open code it in the three callers.
fs/file_table.c static struct kmem_cache *filp_cachep __read_mostly; · line 76
Quoted 9 lines
fs/file_table.c +9
-0+ +/* Returns the real_path if not empty or f_path */ +const struct path *f_real_path (struct file *f) +{ +const struct path *path =__f_real_path (f); + +return path->dentry ? path : &f->f_path; +} +EXPORT_SYMBOL (f_real_path);
This is only needed by the few places like nfsd or btrfs send that directlycall fsnotify and should at very least be EXPORT_SYMBOL_GPL. But I suspect with all the exta code, fsnotify_file really should move out of line and have an EXORT_SYMBOL_GPL instead.
fs/file_table.c static struct kmem_cache *filp_cachep __read_mostly; · line 82
Quoted 6 lines
fs/file_table.c +6
-0+ +const struct path *f_fake_path (struct file *f) +{ +return &f->f_path; +} +EXPORT_SYMBOL (f_fake_path);
.. and this helper is completely pointless.
fs/internal.h extern void chroot_fs_refs(const struct path *, const struct path *); · line 102
Quoted 3 lines
fs/internal.h +3
-0+extern struct file *alloc_empty_file (int flags,const struct cred *cred); +extern struct file *alloc_empty_file_fake (int flags,const struct cred *cred); +extern struct path *__f_real_path (struct file *f);
Please drop all the pointless externs while you're at it.
Amir Goldstein
maintainerRe: [PATCH v3 1/2] fs: use fake_file container for internal files with fake f_path
Quoted 16 lines · Christoph Hellwig
Quoted 3 lines · Amir Goldstein
Overlayfs and cachefiles use
open_with_fake_path()to allocate internal files, where overlayfs also puts a "fake" path inf_path- a path which is not on the same fs asf_inode.But cachefs doesn't, so this needs a better explanation / documentation.
Quoted 2 lines
Allocate a container struct
file_fakefor those internal files, that is used to hold the fake path along with an optional real path.The idea looks sensible, but fake a is a really weird term here. I know
open_with_fake_pathalso uses it, but we really need to come up with a better name, and also good documentation of the concept here.
Quoted 14 lines
fs/file_table.c static struct kmem_cache *filp_cachep __read_mostly; · line 67
Quoted 10 lines
fs/file_table.c +10
-0+/* Returns the real_path field that could be empty */ +struct path *__f_real_path (struct file *f) +{ +struct file_fake *ff =file_fake (f); + +if (f->f_mode &FMODE_FAKE_PATH ) +return &ff->real_path; +else +return &f->f_path; +}two of the three callers always have
FMODE_FAKE_PATHset, so please just drop this helper and open code it in the three callers.
I wanted to keep the container opaque
I can make __f_real_path not check the flag at all and only f_real_path will check the flag
Quoted 6 lines
Quoted 6 lines
fs/file_table.c +6
-0+ +/* Returns the real_path if not empty or f_path */ +const struct path *f_real_path (struct file *f) +{ +const struct path *path =__f_real_path (f); +
Quoted 9 lines
fs/file_table.c static struct kmem_cache *filp_cachep __read_mostly; · line 76
Quoted 3 lines
fs/file_table.c +3
-0+return path->dentry ? path : &f->f_path; +} +EXPORT_SYMBOL (f_real_path);This is only needed by the few places like nfsd or btrfs send that directlycall fsnotify and should at very least be
EXPORT_SYMBOL_GPL. But I suspect with all the exta code,fsnotify_filereally should move out of line and have anEXORT_SYMBOL_GPLinstead.
fsnotify_file() inline is expected to avoid to call to fsnotify() due to the optimization of zero s_fsnotify_connector
in fsnotify_parents() - this was observed as needed by some benchmarks.
Quoted 9 lines
fs/file_table.c static struct kmem_cache *filp_cachep __read_mostly; · line 82
Quoted 6 lines
fs/file_table.c +6
-0+ +const struct path *f_fake_path (struct file *f) +{ +return &f->f_path; +} +EXPORT_SYMBOL (f_fake_path);.. and this helper is completely pointless.
Quoted 5 lines
fs/internal.h extern void chroot_fs_refs(const struct path *, const struct path *); · line 102
Quoted 3 lines
fs/internal.h +3
-0+extern struct file *alloc_empty_file (int flags,const struct cred *cred); +extern struct file *alloc_empty_file_fake (int flags,const struct cred *cred); +extern struct path *__f_real_path (struct file *f);Please drop all the pointless externs while you're at it.
sure,
Thanks,
Amir.
Christian Brauner
maintainerRe: [PATCH v3 1/2] fs: use fake_file container for internal files with fake f_path
Quoted 32 lines · Amir Goldstein
Quoted 16 lines · Christoph Hellwig
Quoted 3 lines · Amir Goldstein
Overlayfs and cachefiles use
open_with_fake_path()to allocate internal files, where overlayfs also puts a "fake" path inf_path- a path which is not on the same fs asf_inode.But cachefs doesn't, so this needs a better explanation / documentation.
Quoted 2 lines
Allocate a container struct
file_fakefor those internal files, that is used to hold the fake path along with an optional real path.The idea looks sensible, but fake a is a really weird term here. I know
open_with_fake_pathalso uses it, but we really need to come up with a better name, and also good documentation of the concept here.Quoted 14 lines
fs/file_table.c static struct kmem_cache *filp_cachep __read_mostly; · line 67
Quoted 10 lines
fs/file_table.c +10
-0+/* Returns the real_path field that could be empty */ +struct path *__f_real_path (struct file *f) +{ +struct file_fake *ff =file_fake (f); + +if (f->f_mode &FMODE_FAKE_PATH ) +return &ff->real_path; +else +return &f->f_path; +}two of the three callers always have
FMODE_FAKE_PATHset, so please just drop this helper and open code it in the three callers.
Quoted 1 line
I wanted to keep the container opaque
This is preferable to me tbh to not leak this detail into callsites.
Christian Brauner
maintainerRe: [PATCH v3 1/2] fs: use fake_file container for internal files with fake f_path
In reply to Christoph HellwigQuoted 7 lines · Christoph Hellwig
Quoted 3 lines · Amir Goldstein
Overlayfs and cachefiles use
open_with_fake_path()to allocate internal files, where overlayfs also puts a "fake" path inf_path- a path which is not on the same fs asf_inode.But cachefs doesn't, so this needs a better explanation / documentation.
Quoted 7 lines
Quoted 2 lines
Allocate a container struct
file_fakefor those internal files, that is used to hold the fake path along with an optional real path.The idea looks sensible, but fake a is a really weird term here. I know
open_with_fake_pathalso uses it, but we really need to come up with a better name, and also good documentation of the concept here.
It's basically a stack so I'd either use struct file_stack or struct file_proxy; with a preference for the latter.
Amir Goldstein
maintainerRe: [PATCH v3 1/2] fs: use fake_file container for internal files with fake f_path
Quoted 12 lines · Christian Brauner
Quoted 10 lines · Christoph Hellwig
Quoted 3 lines · Amir Goldstein
Overlayfs and cachefiles use
open_with_fake_path()to allocate internal files, where overlayfs also puts a "fake" path inf_path- a path which is not on the same fs asf_inode.But cachefs doesn't, so this needs a better explanation / documentation.
Quoted 2 lines
Allocate a container struct
file_fakefor those internal files, that is used to hold the fake path along with an optional real path.
Quoted 7 lines
Quoted 4 lines
The idea looks sensible, but fake a is a really weird term here. I know
open_with_fake_pathalso uses it, but we really need to come up with a better name, and also good documentation of the concept here.It's basically a stack so I'd either use struct
file_stackor structfile_proxy; with a preference for the latter.
Let the bikeshedding begin :)
file_proxy too generic to my taste
How about:
/* File is embedded in backing_file object */
#define FMODE_BACKING ((__force fmode_t)0x2000000)
This backing_file container may be usable for cachefiles or FUSE passthrough in the future to store the path of the (netfs/fuse) file that is backed by the (local) backing file.
We had a short attempt to do the same for ovl - store the ovl path in the container and not the real_path, to get rid of file_dentry() calls, but it got complicated so deferreing that for later.
Thanks,
Amir.
Christian Brauner
maintainerRe: [PATCH v3 1/2] fs: use fake_file container for internal files with fake f_path
Quoted 21 lines · Amir Goldstein
Quoted 12 lines · Christian Brauner
Quoted 10 lines · Christoph Hellwig
Quoted 3 lines · Amir Goldstein
Overlayfs and cachefiles use
open_with_fake_path()to allocate internal files, where overlayfs also puts a "fake" path inf_path- a path which is not on the same fs asf_inode.But cachefs doesn't, so this needs a better explanation / documentation.
Quoted 2 lines
Allocate a container struct
file_fakefor those internal files, that is used to hold the fake path along with an optional real path.Quoted 7 lines
Quoted 4 lines
The idea looks sensible, but fake a is a really weird term here. I know
open_with_fake_pathalso uses it, but we really need to come up with a better name, and also good documentation of the concept here.It's basically a stack so I'd either use struct
file_stackor structfile_proxy; with a preference for the latter.
Quoted 8 lines
Let the bikeshedding begin :)
file_proxytoo generic to my tasteHow about:
/* File is embedded in
backing_fileobject */
#defineFMODE_BACKING((__forcefmode_t)0x2000000)
Yeah, that'd be ok with me.
Amir Goldstein
maintainerPATCH v3 2/2 ovl: enable fsnotify events on underlying real files
In reply to Amir GoldsteinOverlayfs creates the real underlying files with fake f_path, whose f_inode is on the underlying fs and f_path on overlayfs.
Those real files were open with FMODE_NONOTIFY, because fsnotify code was not prapared to handle fsnotify hooks on files with fake path correctly and fanotify would report unexpected event->fd with fake overlayfs path, when the underlying fs was being watched.
Teach fsnotify to handle events on the real files, and do not set real files to FMODE_NONOTIFY to allow operations on real file (e.g. open, access, modify, close) to generate async and permission events.
Because fsnotify does not have notifications on address space operations, we do not need to worry about ->vm_file not reporting events to a watched overlayfs when users are accessing a mapped overlayfs file.
--- fs/overlayfs/file.c | 4 ++-- include/linux/fsnotify.h | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-)
fs/overlayfs/file.c +2 -2
@@ -34,8 +34,8 @@ static char ovl_whatisit(struct inode *inode, struct inode *realinode)return 'm' ; } -/* No atime modification nor notify on underlying */ -#define OVL_OPEN_FLAGS (O_NOATIME | FMODE_NONOTIFY) +/* No atime modification on underlying */ +#define OVL_OPEN_FLAGS (O_NOATIME)static struct file *ovl_open_realfile (const struct file *file,const struct path *realpath)
include/linux/fsnotify.h +2 -1
@@ -91,7 +91,8 @@ static inline void fsnotify_dentry(struct dentry *dentry, __u32 mask)static inline int fsnotify_file (struct file *file,__u32 mask) { -const struct path *path = &file->f_path; +/* Overlayfs internal files have fake f_path */ +const struct path *path =f_real_path (file);if (file->f_mode &FMODE_NONOTIFY )return 0 ;
Signature · 1 line
2.34.1
Amir Goldstein
maintainerQuoted 8 lines · Amir Goldstein
Miklos,
Third attempt with the eye towards simplifying
d_real()interface.Like v2, most of the vfs code should remain unaffected by this expect for the special fsnotify case that we wanted to fix.
FYI, I've made some changes based on feedback on v3 from Christoph and Christian:
- Rename struct file_fake to backing_file
- Rename helpers to open_backing_file(), backing_file_real_path()
- Rename FMODE_FAKE_PATH to FMODE_BACKING
- Separate flag from FMODE_NOACCOUNT
- inline the non-backing branch of f_real_path()
Pushed to:
https://github.com/amir73il/linux/commits/ovl_fake_path
Will wait for your feedback before posting v4.
Thanks,
Amir.
Quoted 26 lines
Changes since v2:
- Restore thefile_fakecontainer (Miklos)
- Re-arrange the v1 helpers (Christian)Changes since v1:
- Drop thefile_fakecontainer
- Leavef_pathfake and special case only fsnotifyAmir Goldstein (2):
fs: usefake_filecontainer for internal files with fakef_path
ovl: enable fsnotify events on underlying real filesfs/cachefiles/namei.c | 2 +- fs/file_table.c | 91 +++++++++++++++++++++++++++++++++------- fs/internal.h | 5 ++- fs/namei.c | 16 +++---- fs/open.c | 28 ++++++++----- fs/overlayfs/file.c | 6 +-- include/linux/fs.h | 15 ++++--- include/linux/fsnotify.h | 3 +- 8 files changed, 121 insertions(+), 45 deletions(-)--
2.34.1