This replicates the earlier .L patch for non-.L, and removing some
previously inserted conditionals in shared code.
Signed-off-by: Tingmao Wang <m@xxxxxxxxxx>
---
Changes since v1:
- Reflect v2 changes to the .L counterpart of this.
fs/9p/v9fs.h | 7 ++-
fs/9p/vfs_inode.c | 150 ++++++++++++++++++++++++++++++++++++++--------
2 files changed, 130 insertions(+), 27 deletions(-)
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index b4e738c1bba5..bacd0052e22c 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -202,7 +202,8 @@ extern int v9fs_vfs_rename(struct mnt_idmap *idmap,
unsigned int flags);
extern struct inode *v9fs_inode_from_fid(struct v9fs_session_info *v9ses,
struct p9_fid *fid,
- struct super_block *sb, int new);
+ struct super_block *sb,
+ struct dentry *dentry, int new);
extern const struct inode_operations v9fs_dir_inode_operations_dotl;
extern const struct inode_operations v9fs_file_inode_operations_dotl;
extern const struct inode_operations v9fs_symlink_inode_operations_dotl;
@@ -267,7 +268,7 @@ v9fs_get_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
if (v9fs_proto_dotl(v9ses))
return v9fs_inode_from_fid_dotl(v9ses, fid, sb, dentry, 0);
else
- return v9fs_inode_from_fid(v9ses, fid, sb, 0);
+ return v9fs_inode_from_fid(v9ses, fid, sb, dentry, 0);
}
/**
@@ -291,7 +292,7 @@ v9fs_get_new_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
if (v9fs_proto_dotl(v9ses))
return v9fs_inode_from_fid_dotl(v9ses, fid, sb, dentry, 1);
else
- return v9fs_inode_from_fid(v9ses, fid, sb, 1);
+ return v9fs_inode_from_fid(v9ses, fid, sb, dentry, 1);
}
#endif
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 5e56c13da733..606760f966fd 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -364,29 +364,76 @@ void v9fs_evict_inode(struct inode *inode)
clear_inode(inode);
}
+struct iget_data {
+ struct p9_wstat *st;
+
+ /* May be NULL */
+ struct dentry *dentry;
+
+ bool need_double_check;
+};
+
static int v9fs_test_inode(struct inode *inode, void *data)
{
int umode;
dev_t rdev;
struct v9fs_inode *v9inode = V9FS_I(inode);
- struct p9_wstat *st = (struct p9_wstat *)data;
+ struct p9_wstat *st = ((struct iget_data *)data)->st;
+ struct dentry *dentry = ((struct iget_data *)data)->dentry;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
+ bool cached = v9ses->cache & (CACHE_META | CACHE_LOOSE);
umode = p9mode2unixmode(v9ses, st, &rdev);
- /* don't match inode of different type */
+ /*
+ * Don't reuse inode of different type, even if path matches.
+ */
if (inode_wrong_type(inode, umode))
return 0;
- /* compare qid details */
- if (memcmp(&v9inode->qid.version,
- &st->qid.version, sizeof(v9inode->qid.version)))
- return 0;
-
if (v9inode->qid.type != st->qid.type)
return 0;
if (v9inode->qid.path != st->qid.path)
return 0;
+
+ if (cached) {
+ /*
+ * Server side changes are not supposed to happen in cached mode.
+ * If we fail this version comparison on the inode, we don't reuse
+ * it.
+ */
+ if (memcmp(&v9inode->qid.version,
+ &st->qid.version, sizeof(v9inode->qid.version)))
+ return 0;
+ }
+
+ if (v9fs_inode_ident_path(v9ses) && dentry) {
+ if (v9inode->path) {
+ if (!ino_path_compare(v9inode->path, dentry)) {
+ p9_debug(
+ P9_DEBUG_VFS,
+ "Refusing to reuse inode %p based on path mismatch",
+ inode);
+ return 0;
+ }
+ } else if (inode->i_state & I_NEW) {
+ /*
+ * iget5_locked may call this function with a still
+ * initializing (I_NEW) inode, so we're now racing with the
+ * code in v9fs_qid_iget that prepares v9inode->path.
+ * Returning from this test function now with positive result
+ * will cause us to wait for this inode to be ready, and we
+ * can then re-check in v9fs_qid_iget.
+ */
+ ((struct iget_data *)data)->need_double_check = true;
+ } else {
+ WARN_ONCE(
+ 1,
+ "Inode %p (ino %lu) does not have v9inode->path even though fs has path-based inode identification enabled?",
+ inode, inode->i_ino);
+ }
+ }
+
return 1;
}
@@ -395,33 +442,74 @@ static int v9fs_test_new_inode(struct inode *inode, void *data)
return 0;
}
-static int v9fs_set_inode(struct inode *inode, void *data)
+static int v9fs_set_inode(struct inode *inode, void *data)
{
struct v9fs_inode *v9inode = V9FS_I(inode);
- struct p9_wstat *st = (struct p9_wstat *)data;
+ struct iget_data *idata = data;
+ struct p9_wstat *st = idata->st;
memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
+ /*
+ * We can't fill v9inode->path here, because allocating an ino_path
+ * means that we might sleep, and we can't sleep here.
+ */
+ v9inode->path = NULL;
return 0;
}
-static struct inode *v9fs_qid_iget(struct super_block *sb,
- struct p9_qid *qid,
- struct p9_wstat *st,
+static struct inode *v9fs_qid_iget(struct super_block *sb, struct p9_qid *qid,
+ struct p9_wstat *st, struct dentry *dentry,
int new)
{
dev_t rdev;
int retval;
umode_t umode;
struct inode *inode;
+ struct v9fs_inode *v9inode;
struct v9fs_session_info *v9ses = sb->s_fs_info;
int (*test)(struct inode *inode, void *data);
+ struct iget_data data = {
+ .st = st,
+ .dentry = dentry,
+ .need_double_check = false,
+ };
if (new)
test = v9fs_test_new_inode;
else
test = v9fs_test_inode;
- inode = iget5_locked(sb, QID2INO(qid), test, v9fs_set_inode, st);
+ if (dentry) {
+ /*
+ * If we need to compare paths to find the inode to reuse, we need
+ * to take the rename_sem for this FS. We need to take it here,
+ * instead of inside ino_path_compare, as iget5_locked has
+ * spinlock in it (inode_hash_lock)
+ */
+ down_read(&v9ses->rename_sem);
+ }
+ while (true) {
+ data.need_double_check = false;
+ inode = iget5_locked(sb, QID2INO(qid), test, v9fs_set_inode, &data);
+ if (!data.need_double_check)
+ break;
+ /*
+ * Need to double check path as it wasn't initialized yet when we
+ * tested it
+ */
+ if (!inode || (inode->i_state & I_NEW)) {
+ WARN_ONCE(
+ 1,
+ "Expected iget5_locked to return an existing inode");
+ break;
+ }
+ if (ino_path_compare(V9FS_I(inode)->path, dentry))
+ break;
+ iput(inode);
+ }
+ if (dentry)
+ up_read(&v9ses->rename_sem);
+
if (!inode)
return ERR_PTR(-ENOMEM);
if (!(inode->i_state & I_NEW))
@@ -437,6 +525,16 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
if (retval)
goto error;
+ v9inode = V9FS_I(inode);
+ if (dentry) {
+ down_read(&v9ses->rename_sem);
+ v9inode->path = make_ino_path(dentry);
+ up_read(&v9ses->rename_sem);
+ if (!v9inode->path) {
+ retval = -ENOMEM;
+ goto error;
+ }
+ }
v9fs_stat2inode(st, inode, sb, 0);
v9fs_set_netfs_context(inode);
v9fs_cache_inode_get_cookie(inode);
@@ -448,9 +546,18 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
}
-struct inode *
-v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
- struct super_block *sb, int new)
+/**
+ * Issues a getattr request and use the result to look up the inode for
+ * the target pointed to by @fid.
+ * @v9ses: session information
+ * @fid: fid to issue attribute request for
+ * @sb: superblock on which to create inode
+ * @dentry: if not NULL, the path of the provided dentry is compared
+ * against the path stored in the inode, to determine reuse eligibility.
+ */
+struct inode *v9fs_inode_from_fid(struct v9fs_session_info *v9ses,
+ struct p9_fid *fid, struct super_block *sb,
+ struct dentry *dentry, int new)
{
struct p9_wstat *st;
struct inode *inode = NULL;
@@ -459,7 +566,7 @@ v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
if (IS_ERR(st))
return ERR_CAST(st);
- inode = v9fs_qid_iget(sb, &st->qid, st, new);
+ inode = v9fs_qid_iget(sb, &st->qid, st, dentry, new);
p9stat_free(st);
kfree(st);
return inode;
@@ -608,18 +715,14 @@ v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
"p9_client_walk failed %d\n", err);
goto error;
}
- /*
- * Instantiate inode. On .L fs, pass in dentry for inodeident=path.
- */
- inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb,
- v9fs_proto_dotl(v9ses) ? dentry : NULL);
+ /* instantiate inode and assign the unopened fid to the dentry */
+ inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb, dentry);
if (IS_ERR(inode)) {
err = PTR_ERR(inode);
p9_debug(P9_DEBUG_VFS,
"inode creation failed %d\n", err);
goto error;
}
- /* Assign the unopened fid to the dentry */
v9fs_fid_add(dentry, &fid);
d_instantiate(dentry, inode);
}
@@ -1415,4 +1518,3 @@ static const struct inode_operations v9fs_symlink_inode_operations = {
.getattr = v9fs_vfs_getattr,
.setattr = v9fs_vfs_setattr,
};
-
--
2.51.0
