@@ -916,7 +916,7 @@ int ll_file_open(struct inode *inode, struct file *file)
if (!it->it_disposition) {
struct dentry *dentry = file_dentry(file);
struct ll_sb_info *sbi = ll_i2sbi(inode);
- struct ll_dentry_data *ldd;
+ int open_threshold = sbi->ll_oc_thrsh_count;
/* We cannot just request lock handle now, new ELC code
* means that one of other OPEN locks for this file
@@ -927,22 +927,20 @@ int ll_file_open(struct inode *inode, struct file *file)
mutex_unlock(&lli->lli_och_mutex);
/*
* Normally called under two situations:
- * 1. NFS export.
+ * 1. fhandle / NFS export.
* 2. A race/condition on MDS resulting in no open
* handle to be returned from LOOKUP|OPEN request,
* for example if the target entry was a symlink.
*
- * In NFS path we know there's pathologic behavior
- * so we always enable open lock caching when coming
- * from there. It's detected by setting a flag in
- * ll_iget_for_nfs.
- *
* After reaching number of opens of this inode
* we always ask for an open lock on it to handle
* bad userspace actors that open and close files
* in a loop for absolutely no good reason
*/
- ldd = ll_d2d(dentry);
+ /* fhandle / NFS path. */
+ if (lli->lli_open_thrsh_count != UINT_MAX)
+ open_threshold = lli->lli_open_thrsh_count;
+
if (filename_is_volatile(dentry->d_name.name,
dentry->d_name.len,
NULL)) {
@@ -951,17 +949,9 @@ int ll_file_open(struct inode *inode, struct file *file)
* We do not want openlock for volatile
* files under any circumstances
*/
- } else if (ldd && ldd->lld_nfs_dentry) {
- /* NFS path. This also happens to catch
- * open by fh files I guess
- */
- it->it_flags |= MDS_OPEN_LOCK;
- /* clear the flag for future lookups */
- ldd->lld_nfs_dentry = 0;
- } else if (sbi->ll_oc_thrsh_count > 0) {
+ } else if (open_threshold > 0) {
/* Take MDS_OPEN_LOCK with many opens */
- if (lli->lli_open_fd_count >=
- sbi->ll_oc_thrsh_count)
+ if (lli->lli_open_fd_count >= open_threshold)
it->it_flags |= MDS_OPEN_LOCK;
/* If this is open after we just closed */
@@ -72,7 +72,6 @@
struct ll_dentry_data {
unsigned int lld_sa_generation;
unsigned int lld_invalid:1;
- unsigned int lld_nfs_dentry:1;
struct rcu_head lld_rcu_head;
};
@@ -145,11 +144,6 @@ struct ll_inode_info {
u64 lli_open_fd_write_count;
u64 lli_open_fd_exec_count;
- /* Number of times this inode was opened */
- u64 lli_open_fd_count;
- /* When last close was performed on this inode */
- ktime_t lli_close_fd_time;
-
/* Protects access to och pointers and their usage counters */
struct mutex lli_och_mutex;
@@ -162,6 +156,13 @@ struct ll_inode_info {
s64 lli_btime;
spinlock_t lli_agl_lock;
+ /* inode specific open lock caching threshold */
+ u32 lli_open_thrsh_count;
+ /* Number of times this inode was opened */
+ u64 lli_open_fd_count;
+ /* When last close was performed on this inode */
+ ktime_t lli_close_fd_time;
+
/* Try to make the d::member and f::member are aligned. Before using
* these members, make clear whether it is directory or not.
*/
@@ -114,7 +114,6 @@ struct inode *search_inode_for_lustre(struct super_block *sb,
struct lu_fid *fid, struct lu_fid *parent)
{
struct inode *inode;
- struct dentry *result;
if (!fid_is_sane(fid))
return ERR_PTR(-ESTALE);
@@ -131,19 +130,7 @@ struct inode *search_inode_for_lustre(struct super_block *sb,
return ERR_PTR(-ESTALE);
}
- result = d_obtain_alias(inode);
- if (IS_ERR(result))
- return result;
-
- /*
- * Need to signal to the ll_intent_file_open that
- * we came from NFS and so opencache needs to be
- * enabled for this one
- */
- spin_lock(&result->d_lock);
- ll_d2d(result)->lld_nfs_dentry = 1;
- spin_unlock(&result->d_lock);
- return result;
+ return d_obtain_alias(inode);
}
/**
@@ -1144,6 +1144,7 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
struct ll_sb_info *sbi = NULL;
struct pcc_create_attach pca = { NULL, NULL };
bool encrypt = false;
+ int open_threshold;
int rc = 0;
CDEBUG(D_VFSTRACE,
@@ -1224,7 +1225,12 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
* we only need to request open lock if it was requested
* for every open
*/
- if (ll_i2sbi(dir)->ll_oc_thrsh_count == 1 &&
+ if (ll_i2info(dir)->lli_open_thrsh_count != UINT_MAX)
+ open_threshold = ll_i2info(dir)->lli_open_thrsh_count;
+ else
+ open_threshold = ll_i2sbi(dir)->ll_oc_thrsh_count;
+
+ if (open_threshold == 1 &&
exp_connect_flags2(ll_i2mdexp(dir)) &
OBD_CONNECT2_ATOMIC_OPEN_LOCK)
it->it_flags |= MDS_OPEN_LOCK;
@@ -55,6 +55,8 @@ static struct inode *ll_alloc_inode(struct super_block *sb)
return NULL;
inode_init_once(&lli->lli_vfs_inode);
+ lli->lli_open_thrsh_count = UINT_MAX;
+
return &lli->lli_vfs_inode;
}
The lld_nfs_dentry flag was created for the case of caching the open lock (opencache) when fetching fhandles for NFSv3. This same path is used by the fhandle APIs. This lighter open changes key behaviors since the open lock is always cached which we don't want. Lustre introduced a way to modify caching the open lock based on the number of opens done on a file within a certain span of time. We can replace lld_nfs_dentry flag with the new open lock caching. This way for fhandle handling we match the open lock caching behavior of a normal file open. WC-bug-id: https://jira.whamcloud.com/browse/LU-16463 Lustre-commit: d7a85652f4fcb8319 ("LU-16463 llite: replace lld_nfs_dentry flag with opencache handling") Signed-off-by: James Simmons <jsimmons@infradead.org> Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/49237 Reviewed-by: Andreas Dilger <adilger@whamcloud.com> Reviewed-by: Etienne AUJAMES <eaujames@ddn.com> Reviewed-by: Oleg Drokin <green@whamcloud.com> --- fs/lustre/llite/file.c | 26 ++++++++------------------ fs/lustre/llite/llite_internal.h | 13 +++++++------ fs/lustre/llite/llite_nfs.c | 15 +-------------- fs/lustre/llite/namei.c | 8 +++++++- fs/lustre/llite/super25.c | 2 ++ 5 files changed, 25 insertions(+), 39 deletions(-)