Return-Path: Received: from mail-wm0-f53.google.com ([74.125.82.53]:35205 "EHLO mail-wm0-f53.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752253AbcCHPqI (ORCPT ); Tue, 8 Mar 2016 10:46:08 -0500 Received: by mail-wm0-f53.google.com with SMTP id l68so137824711wml.0 for ; Tue, 08 Mar 2016 07:46:07 -0800 (PST) Date: Tue, 8 Mar 2016 16:47:16 +0100 From: Miklos Szeredi To: linux-unionfs@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-nfs@vger.kernel.org Cc: Goldwyn Rodrigues , Trond Myklebust Subject: [PATCH 1/2] vfs: add file_dentry() Message-ID: <20160308154716.GC8655@tucsk> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Sender: linux-nfs-owner@vger.kernel.org List-ID: From: Miklos Szeredi Regular files opened on overlayfs will result in the file being opened on the underlying filesystem, while f_path points to the overlayfs mount/dentry. This confuses filesystems which get the dentry from struct file and assume it's theirs. Add a new helper, file_dentry() [*], to get the filesystem's own dentry from the file. This simply compares file_inode(file->f_path.dentry) to file_inode(file) and if they are equal returns file->f_path.dentry (this is the common, non-overlayfs case). In the uncommon case (regular file on overlayfs) it will call into overlayfs's ->d_native_dentry() to get the underlying dentry matching file_inode(file). [*] If possible, it's better simply to use file_inode() instead. Fixes: 4bacc9c9234c ("overlayfs: Make f_path always point to the overlay and f_inode to the underlay") Signed-off-by: Miklos Szeredi Tested-by: Goldwyn Rodrigues --- fs/open.c | 11 +++++++++++ fs/overlayfs/super.c | 16 ++++++++++++++++ include/linux/dcache.h | 1 + include/linux/fs.h | 2 ++ 4 files changed, 30 insertions(+) --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -1234,6 +1234,8 @@ static inline struct inode *file_inode(c return f->f_inode; } +extern struct dentry *file_dentry(const struct file *file); + static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl) { return locks_lock_inode_wait(file_inode(filp), fl); --- a/fs/open.c +++ b/fs/open.c @@ -831,6 +831,17 @@ char *file_path(struct file *filp, char } EXPORT_SYMBOL(file_path); +struct dentry *file_dentry(const struct file *file) +{ + struct dentry *dentry = file->f_path.dentry; + + if (likely(d_inode(dentry) == file_inode(file))) + return dentry; + else + return dentry->d_op->d_native_dentry(dentry, file_inode(file)); +} +EXPORT_SYMBOL(file_dentry); + /** * vfs_open - open the file at the given path * @path: path to open --- a/fs/overlayfs/super.c +++ b/fs/overlayfs/super.c @@ -336,14 +336,30 @@ static int ovl_dentry_weak_revalidate(st return ret; } +static struct dentry *ovl_d_native_dentry(struct dentry *dentry, + struct inode *inode) +{ + struct ovl_entry *oe = dentry->d_fsdata; + struct dentry *realentry = ovl_upperdentry_dereference(oe); + + if (realentry && inode == d_inode(realentry)) + return realentry; + realentry = __ovl_dentry_lower(oe); + if (realentry && inode == d_inode(realentry)) + return realentry; + BUG(); +} + static const struct dentry_operations ovl_dentry_operations = { .d_release = ovl_dentry_release, .d_select_inode = ovl_d_select_inode, + .d_native_dentry = ovl_d_native_dentry, }; static const struct dentry_operations ovl_reval_dentry_operations = { .d_release = ovl_dentry_release, .d_select_inode = ovl_d_select_inode, + .d_native_dentry = ovl_d_native_dentry, .d_revalidate = ovl_dentry_revalidate, .d_weak_revalidate = ovl_dentry_weak_revalidate, }; --- a/include/linux/dcache.h +++ b/include/linux/dcache.h @@ -161,6 +161,7 @@ struct dentry_operations { struct vfsmount *(*d_automount)(struct path *); int (*d_manage)(struct dentry *, bool); struct inode *(*d_select_inode)(struct dentry *, unsigned); + struct dentry *(*d_native_dentry)(struct dentry *, struct inode *); } ____cacheline_aligned; /*