From: James Simmons Date: Tue, 7 Feb 2023 15:08:13 +0000 (-0500) Subject: LU-16463 llite: replace lld_nfs_dentry flag with opencache handling X-Git-Tag: 2.15.55~138 X-Git-Url: https://git.whamcloud.com/gitweb?a=commitdiff_plain;h=d7a85652f4fcb83192262cfc1a0211890f404c7c;p=fs%2Flustre-release.git LU-16463 llite: replace lld_nfs_dentry flag with opencache handling 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. In the case of NFS this code path will always be called with the internal kernel thread 'nfsd'. If we are called by this kernel thread set the open threshold to zero which means always cache the open lock. Once Lustre is only supported on Linux kernels above 5.5 we can remove this special NFSv3 work around. Change-Id: Iba27f7ad4579fdd1f34e1e35c2cbd547e15f129a Signed-off-by: James Simmons Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/49237 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Etienne AUJAMES Reviewed-by: Oleg Drokin --- diff --git a/lustre/llite/file.c b/lustre/llite/file.c index 15e5bb1..2d70c2a 100644 --- a/lustre/llite/file.c +++ b/lustre/llite/file.c @@ -917,7 +917,7 @@ restart: 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 @@ -928,23 +928,23 @@ restart: 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. + * For NFSv3 we need to always cache the open lock + * for pre 5.5 Linux kernels. * * 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 */ + /* fhandle / NFS path. */ + if (lli->lli_open_thrsh_count != UINT_MAX) + open_threshold = lli->lli_open_thrsh_count; - ldd = ll_d2d(dentry); if (filename_is_volatile(dentry->d_name.name, dentry->d_name.len, NULL)) { @@ -953,17 +953,9 @@ restart: * 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 */ diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h index d0e7840..198271c 100644 --- a/lustre/llite/llite_internal.h +++ b/lustre/llite/llite_internal.h @@ -84,7 +84,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; }; @@ -140,11 +139,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; @@ -157,6 +151,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. */ union { diff --git a/lustre/llite/llite_nfs.c b/lustre/llite/llite_nfs.c index 644aac2..744f4f9 100644 --- a/lustre/llite/llite_nfs.c +++ b/lustre/llite/llite_nfs.c @@ -136,22 +136,24 @@ ll_iget_for_nfs(struct super_block *sb, struct lu_fid *fid, struct lu_fid *paren /* N.B. d_obtain_alias() drops inode ref on error */ result = d_obtain_alias(inode); - if (!IS_ERR(result)) { - struct ll_dentry_data *ldd; + if (IS_ERR(result)) + RETURN(result); - if (!ll_d_setup(result, true)) - RETURN(ERR_PTR(-ENOMEM)); - ldd = ll_d2d(result); - /* - * Need to signal to the ll_file_open that - * we came from NFS and so opencache needs to be - * enabled for this one - */ - spin_lock(&result->d_lock); - ldd->lld_nfs_dentry = 1; - spin_unlock(&result->d_lock); - } + if (!ll_d_setup(result, true)) + RETURN(ERR_PTR(-ENOMEM)); +#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 5, 0) + /* If we are called by nfsd kthread set lli_open_thrsh_count + * to one. This will force caching the open lock. To be + * removed once oldest supported Linux kernel is 5.5 + */ + if ((current->flags & PF_KTHREAD) && + strcmp(current->comm, "nfsd") == 0) { + struct ll_inode_info *lli = ll_i2info(inode); + + lli->lli_open_thrsh_count = 1; + } +#endif RETURN(result); } diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c index 2681bf6..810b9e9 100644 --- a/lustre/llite/namei.c +++ b/lustre/llite/namei.c @@ -1155,9 +1155,10 @@ 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; - ENTRY; + ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), file %p, open_flags %x, mode %x opened %d\n", dentry, PFID(ll_inode2fid(dir)), dir, file, open_flags, mode, @@ -1236,7 +1237,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; diff --git a/lustre/llite/super25.c b/lustre/llite/super25.c index 71b45b9..6622625 100644 --- a/lustre/llite/super25.c +++ b/lustre/llite/super25.c @@ -62,6 +62,8 @@ static struct inode *ll_alloc_inode(struct super_block *sb) return NULL; #endif inode_init_once(&lli->lli_vfs_inode); + lli->lli_open_thrsh_count = UINT_MAX; + return &lli->lli_vfs_inode; }