From: Greg Kroah-Hartman Date: Tue, 21 Jan 2025 08:20:01 +0000 (+0100) Subject: 6.6-stable patches X-Git-Tag: v6.6.73~2 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=e42028e8f3469a9e39adfbb8f38c97681149171f;p=thirdparty%2Fkernel%2Fstable-queue.git 6.6-stable patches added patches: revert-ovl-do-not-encode-lower-fh-with-upper-sb_writers-held.patch revert-ovl-pass-realinode-to-ovl_encode_real_fh-instead-of-realdentry.patch revert-ovl-support-encoding-fid-from-inode-with-no-alias.patch --- diff --git a/queue-6.6/revert-ovl-do-not-encode-lower-fh-with-upper-sb_writers-held.patch b/queue-6.6/revert-ovl-do-not-encode-lower-fh-with-upper-sb_writers-held.patch new file mode 100644 index 0000000000..a53aeedab6 --- /dev/null +++ b/queue-6.6/revert-ovl-do-not-encode-lower-fh-with-upper-sb_writers-held.patch @@ -0,0 +1,414 @@ +From ee94867eb77c316799fa7b8f4851857c65e2740e Mon Sep 17 00:00:00 2001 +From: Greg Kroah-Hartman +Date: Tue, 21 Jan 2025 09:13:50 +0100 +Subject: Revert "ovl: do not encode lower fh with upper sb_writers held" + +From: Greg Kroah-Hartman + +This reverts commit 26423e18cd6f709ca4fe7194c29c11658cd0cdd0 which is +commit 5b02bfc1e7e3811c5bf7f0fa626a0694d0dbbd77 upstream. + +It is reported to part of a series that causes problems in the 6.6.y +tree, so revert it at this point in time and it can come back later if +still needed. + +Reported-by: Ignat Korchagin +Link: https://lore.kernel.org/r/ACD4D6CC-C4D5-4657-A805-03C34559046E@cloudflare.com +Cc: Dmitry Safonov +Cc: Amir Goldstein +Cc: Christian Brauner +Cc: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + fs/overlayfs/copy_up.c | 53 +++++++++++++++++------------------------------ + fs/overlayfs/namei.c | 37 +++++++------------------------- + fs/overlayfs/overlayfs.h | 26 ++++++----------------- + fs/overlayfs/super.c | 20 +++++------------ + fs/overlayfs/util.c | 10 -------- + 5 files changed, 42 insertions(+), 104 deletions(-) + +--- a/fs/overlayfs/copy_up.c ++++ b/fs/overlayfs/copy_up.c +@@ -426,29 +426,29 @@ out_err: + return ERR_PTR(err); + } + +-struct ovl_fh *ovl_get_origin_fh(struct ovl_fs *ofs, struct dentry *origin) ++int ovl_set_origin(struct ovl_fs *ofs, struct dentry *lower, ++ struct dentry *upper) + { ++ const struct ovl_fh *fh = NULL; ++ int err; ++ + /* + * When lower layer doesn't support export operations store a 'null' fh, + * so we can use the overlay.origin xattr to distignuish between a copy + * up and a pure upper inode. + */ +- if (!ovl_can_decode_fh(origin->d_sb)) +- return NULL; +- +- return ovl_encode_real_fh(ofs, origin, false); +-} +- +-int ovl_set_origin_fh(struct ovl_fs *ofs, const struct ovl_fh *fh, +- struct dentry *upper) +-{ +- int err; ++ if (ovl_can_decode_fh(lower->d_sb)) { ++ fh = ovl_encode_real_fh(ofs, lower, false); ++ if (IS_ERR(fh)) ++ return PTR_ERR(fh); ++ } + + /* + * Do not fail when upper doesn't support xattrs. + */ + err = ovl_check_setxattr(ofs, upper, OVL_XATTR_ORIGIN, fh->buf, + fh ? fh->fb.len : 0, 0); ++ kfree(fh); + + /* Ignore -EPERM from setting "user.*" on symlink/special */ + return err == -EPERM ? 0 : err; +@@ -476,7 +476,7 @@ static int ovl_set_upper_fh(struct ovl_f + * + * Caller must hold i_mutex on indexdir. + */ +-static int ovl_create_index(struct dentry *dentry, const struct ovl_fh *fh, ++static int ovl_create_index(struct dentry *dentry, struct dentry *origin, + struct dentry *upper) + { + struct ovl_fs *ofs = OVL_FS(dentry->d_sb); +@@ -502,7 +502,7 @@ static int ovl_create_index(struct dentr + if (WARN_ON(ovl_test_flag(OVL_INDEX, d_inode(dentry)))) + return -EIO; + +- err = ovl_get_index_name_fh(fh, &name); ++ err = ovl_get_index_name(ofs, origin, &name); + if (err) + return err; + +@@ -541,7 +541,6 @@ struct ovl_copy_up_ctx { + struct dentry *destdir; + struct qstr destname; + struct dentry *workdir; +- const struct ovl_fh *origin_fh; + bool origin; + bool indexed; + bool metacopy; +@@ -638,7 +637,7 @@ static int ovl_copy_up_metadata(struct o + * hard link. + */ + if (c->origin) { +- err = ovl_set_origin_fh(ofs, c->origin_fh, temp); ++ err = ovl_set_origin(ofs, c->lowerpath.dentry, temp); + if (err) + return err; + } +@@ -750,7 +749,7 @@ static int ovl_copy_up_workdir(struct ov + goto cleanup; + + if (S_ISDIR(c->stat.mode) && c->indexed) { +- err = ovl_create_index(c->dentry, c->origin_fh, temp); ++ err = ovl_create_index(c->dentry, c->lowerpath.dentry, temp); + if (err) + goto cleanup; + } +@@ -862,8 +861,6 @@ static int ovl_do_copy_up(struct ovl_cop + { + int err; + struct ovl_fs *ofs = OVL_FS(c->dentry->d_sb); +- struct dentry *origin = c->lowerpath.dentry; +- struct ovl_fh *fh = NULL; + bool to_index = false; + + /* +@@ -880,25 +877,17 @@ static int ovl_do_copy_up(struct ovl_cop + to_index = true; + } + +- if (S_ISDIR(c->stat.mode) || c->stat.nlink == 1 || to_index) { +- fh = ovl_get_origin_fh(ofs, origin); +- if (IS_ERR(fh)) +- return PTR_ERR(fh); +- +- /* origin_fh may be NULL */ +- c->origin_fh = fh; ++ if (S_ISDIR(c->stat.mode) || c->stat.nlink == 1 || to_index) + c->origin = true; +- } + + if (to_index) { + c->destdir = ovl_indexdir(c->dentry->d_sb); +- err = ovl_get_index_name(ofs, origin, &c->destname); ++ err = ovl_get_index_name(ofs, c->lowerpath.dentry, &c->destname); + if (err) +- goto out_free_fh; ++ return err; + } else if (WARN_ON(!c->parent)) { + /* Disconnected dentry must be copied up to index dir */ +- err = -EIO; +- goto out_free_fh; ++ return -EIO; + } else { + /* + * Mark parent "impure" because it may now contain non-pure +@@ -906,7 +895,7 @@ static int ovl_do_copy_up(struct ovl_cop + */ + err = ovl_set_impure(c->parent, c->destdir); + if (err) +- goto out_free_fh; ++ return err; + } + + /* Should we copyup with O_TMPFILE or with workdir? */ +@@ -938,8 +927,6 @@ static int ovl_do_copy_up(struct ovl_cop + out: + if (to_index) + kfree(c->destname.name); +-out_free_fh: +- kfree(fh); + return err; + } + +--- a/fs/overlayfs/namei.c ++++ b/fs/overlayfs/namei.c +@@ -507,19 +507,6 @@ static int ovl_verify_fh(struct ovl_fs * + return err; + } + +-int ovl_verify_set_fh(struct ovl_fs *ofs, struct dentry *dentry, +- enum ovl_xattr ox, const struct ovl_fh *fh, +- bool is_upper, bool set) +-{ +- int err; +- +- err = ovl_verify_fh(ofs, dentry, ox, fh); +- if (set && err == -ENODATA) +- err = ovl_setxattr(ofs, dentry, ox, fh->buf, fh->fb.len); +- +- return err; +-} +- + /* + * Verify that @real dentry matches the file handle stored in xattr @name. + * +@@ -528,9 +515,9 @@ int ovl_verify_set_fh(struct ovl_fs *ofs + * + * Return 0 on match, -ESTALE on mismatch, -ENODATA on no xattr, < 0 on error. + */ +-int ovl_verify_origin_xattr(struct ovl_fs *ofs, struct dentry *dentry, +- enum ovl_xattr ox, struct dentry *real, +- bool is_upper, bool set) ++int ovl_verify_set_fh(struct ovl_fs *ofs, struct dentry *dentry, ++ enum ovl_xattr ox, struct dentry *real, bool is_upper, ++ bool set) + { + struct inode *inode; + struct ovl_fh *fh; +@@ -543,7 +530,9 @@ int ovl_verify_origin_xattr(struct ovl_f + goto fail; + } + +- err = ovl_verify_set_fh(ofs, dentry, ox, fh, is_upper, set); ++ err = ovl_verify_fh(ofs, dentry, ox, fh); ++ if (set && err == -ENODATA) ++ err = ovl_setxattr(ofs, dentry, ox, fh->buf, fh->fb.len); + if (err) + goto fail; + +@@ -559,7 +548,6 @@ fail: + goto out; + } + +- + /* Get upper dentry from index */ + struct dentry *ovl_index_upper(struct ovl_fs *ofs, struct dentry *index, + bool connected) +@@ -696,7 +684,7 @@ orphan: + goto out; + } + +-int ovl_get_index_name_fh(const struct ovl_fh *fh, struct qstr *name) ++static int ovl_get_index_name_fh(struct ovl_fh *fh, struct qstr *name) + { + char *n, *s; + +@@ -885,27 +873,20 @@ int ovl_path_next(int idx, struct dentry + static int ovl_fix_origin(struct ovl_fs *ofs, struct dentry *dentry, + struct dentry *lower, struct dentry *upper) + { +- const struct ovl_fh *fh; + int err; + + if (ovl_check_origin_xattr(ofs, upper)) + return 0; + +- fh = ovl_get_origin_fh(ofs, lower); +- if (IS_ERR(fh)) +- return PTR_ERR(fh); +- + err = ovl_want_write(dentry); + if (err) +- goto out; ++ return err; + +- err = ovl_set_origin_fh(ofs, fh, upper); ++ err = ovl_set_origin(ofs, lower, upper); + if (!err) + err = ovl_set_impure(dentry->d_parent, upper->d_parent); + + ovl_drop_write(dentry); +-out: +- kfree(fh); + return err; + } + +--- a/fs/overlayfs/overlayfs.h ++++ b/fs/overlayfs/overlayfs.h +@@ -632,15 +632,11 @@ struct dentry *ovl_decode_real_fh(struct + int ovl_check_origin_fh(struct ovl_fs *ofs, struct ovl_fh *fh, bool connected, + struct dentry *upperdentry, struct ovl_path **stackp); + int ovl_verify_set_fh(struct ovl_fs *ofs, struct dentry *dentry, +- enum ovl_xattr ox, const struct ovl_fh *fh, +- bool is_upper, bool set); +-int ovl_verify_origin_xattr(struct ovl_fs *ofs, struct dentry *dentry, +- enum ovl_xattr ox, struct dentry *real, +- bool is_upper, bool set); ++ enum ovl_xattr ox, struct dentry *real, bool is_upper, ++ bool set); + struct dentry *ovl_index_upper(struct ovl_fs *ofs, struct dentry *index, + bool connected); + int ovl_verify_index(struct ovl_fs *ofs, struct dentry *index); +-int ovl_get_index_name_fh(const struct ovl_fh *fh, struct qstr *name); + int ovl_get_index_name(struct ovl_fs *ofs, struct dentry *origin, + struct qstr *name); + struct dentry *ovl_get_index_fh(struct ovl_fs *ofs, struct ovl_fh *fh); +@@ -652,24 +648,17 @@ struct dentry *ovl_lookup(struct inode * + unsigned int flags); + bool ovl_lower_positive(struct dentry *dentry); + +-static inline int ovl_verify_origin_fh(struct ovl_fs *ofs, struct dentry *upper, +- const struct ovl_fh *fh, bool set) +-{ +- return ovl_verify_set_fh(ofs, upper, OVL_XATTR_ORIGIN, fh, false, set); +-} +- + static inline int ovl_verify_origin(struct ovl_fs *ofs, struct dentry *upper, + struct dentry *origin, bool set) + { +- return ovl_verify_origin_xattr(ofs, upper, OVL_XATTR_ORIGIN, origin, +- false, set); ++ return ovl_verify_set_fh(ofs, upper, OVL_XATTR_ORIGIN, origin, ++ false, set); + } + + static inline int ovl_verify_upper(struct ovl_fs *ofs, struct dentry *index, + struct dentry *upper, bool set) + { +- return ovl_verify_origin_xattr(ofs, index, OVL_XATTR_UPPER, upper, +- true, set); ++ return ovl_verify_set_fh(ofs, index, OVL_XATTR_UPPER, upper, true, set); + } + + /* readdir.c */ +@@ -834,9 +823,8 @@ int ovl_copy_xattr(struct super_block *s + int ovl_set_attr(struct ovl_fs *ofs, struct dentry *upper, struct kstat *stat); + struct ovl_fh *ovl_encode_real_fh(struct ovl_fs *ofs, struct dentry *real, + bool is_upper); +-struct ovl_fh *ovl_get_origin_fh(struct ovl_fs *ofs, struct dentry *origin); +-int ovl_set_origin_fh(struct ovl_fs *ofs, const struct ovl_fh *fh, +- struct dentry *upper); ++int ovl_set_origin(struct ovl_fs *ofs, struct dentry *lower, ++ struct dentry *upper); + + /* export.c */ + extern const struct export_operations ovl_export_operations; +--- a/fs/overlayfs/super.c ++++ b/fs/overlayfs/super.c +@@ -879,20 +879,15 @@ static int ovl_get_indexdir(struct super + { + struct vfsmount *mnt = ovl_upper_mnt(ofs); + struct dentry *indexdir; +- struct dentry *origin = ovl_lowerstack(oe)->dentry; +- const struct ovl_fh *fh; + int err; + +- fh = ovl_get_origin_fh(ofs, origin); +- if (IS_ERR(fh)) +- return PTR_ERR(fh); +- + err = mnt_want_write(mnt); + if (err) +- goto out_free_fh; ++ return err; + + /* Verify lower root is upper root origin */ +- err = ovl_verify_origin_fh(ofs, upperpath->dentry, fh, true); ++ err = ovl_verify_origin(ofs, upperpath->dentry, ++ ovl_lowerstack(oe)->dentry, true); + if (err) { + pr_err("failed to verify upper root origin\n"); + goto out; +@@ -924,10 +919,9 @@ static int ovl_get_indexdir(struct super + * directory entries. + */ + if (ovl_check_origin_xattr(ofs, ofs->indexdir)) { +- err = ovl_verify_origin_xattr(ofs, ofs->indexdir, +- OVL_XATTR_ORIGIN, +- upperpath->dentry, true, +- false); ++ err = ovl_verify_set_fh(ofs, ofs->indexdir, ++ OVL_XATTR_ORIGIN, ++ upperpath->dentry, true, false); + if (err) + pr_err("failed to verify index dir 'origin' xattr\n"); + } +@@ -945,8 +939,6 @@ static int ovl_get_indexdir(struct super + + out: + mnt_drop_write(mnt); +-out_free_fh: +- kfree(fh); + return err; + } + +--- a/fs/overlayfs/util.c ++++ b/fs/overlayfs/util.c +@@ -976,18 +976,12 @@ static void ovl_cleanup_index(struct den + struct dentry *index = NULL; + struct inode *inode; + struct qstr name = { }; +- bool got_write = false; + int err; + + err = ovl_get_index_name(ofs, lowerdentry, &name); + if (err) + goto fail; + +- err = ovl_want_write(dentry); +- if (err) +- goto fail; +- +- got_write = true; + inode = d_inode(upperdentry); + if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) { + pr_warn_ratelimited("cleanup linked index (%pd2, ino=%lu, nlink=%u)\n", +@@ -1025,8 +1019,6 @@ static void ovl_cleanup_index(struct den + goto fail; + + out: +- if (got_write) +- ovl_drop_write(dentry); + kfree(name.name); + dput(index); + return; +@@ -1097,8 +1089,6 @@ void ovl_nlink_end(struct dentry *dentry + { + struct inode *inode = d_inode(dentry); + +- ovl_drop_write(dentry); +- + if (ovl_test_flag(OVL_INDEX, inode) && inode->i_nlink == 0) { + const struct cred *old_cred; + diff --git a/queue-6.6/revert-ovl-pass-realinode-to-ovl_encode_real_fh-instead-of-realdentry.patch b/queue-6.6/revert-ovl-pass-realinode-to-ovl_encode_real_fh-instead-of-realdentry.patch new file mode 100644 index 0000000000..38f01ae5de --- /dev/null +++ b/queue-6.6/revert-ovl-pass-realinode-to-ovl_encode_real_fh-instead-of-realdentry.patch @@ -0,0 +1,126 @@ +From 58dc59cfbeb18778fab486d382b851af4cd7e264 Mon Sep 17 00:00:00 2001 +From: Greg Kroah-Hartman +Date: Tue, 21 Jan 2025 09:13:38 +0100 +Subject: Revert "ovl: pass realinode to ovl_encode_real_fh() instead of realdentry" + +From: Greg Kroah-Hartman + +This reverts commit a3f8a2b13a277d942c810d2ccc654d5bc824a430 which is +commit 07aeefae7ff44d80524375253980b1bdee2396b0 upstream. + +It is reported to part of a series that causes problems in the 6.6.y +tree, so revert it at this point in time and it can come back later if +still needed. + +Reported-by: Ignat Korchagin +Link: https://lore.kernel.org/r/ACD4D6CC-C4D5-4657-A805-03C34559046E@cloudflare.com +Cc: Dmitry Safonov +Cc: Amir Goldstein +Cc: Christian Brauner +Cc: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + fs/overlayfs/copy_up.c | 11 +++++------ + fs/overlayfs/export.c | 5 ++--- + fs/overlayfs/namei.c | 4 ++-- + fs/overlayfs/overlayfs.h | 2 +- + 4 files changed, 10 insertions(+), 12 deletions(-) + +--- a/fs/overlayfs/copy_up.c ++++ b/fs/overlayfs/copy_up.c +@@ -371,13 +371,13 @@ int ovl_set_attr(struct ovl_fs *ofs, str + return err; + } + +-struct ovl_fh *ovl_encode_real_fh(struct ovl_fs *ofs, struct inode *realinode, ++struct ovl_fh *ovl_encode_real_fh(struct ovl_fs *ofs, struct dentry *real, + bool is_upper) + { + struct ovl_fh *fh; + int fh_type, dwords; + int buflen = MAX_HANDLE_SZ; +- uuid_t *uuid = &realinode->i_sb->s_uuid; ++ uuid_t *uuid = &real->d_sb->s_uuid; + int err; + + /* Make sure the real fid stays 32bit aligned */ +@@ -394,8 +394,7 @@ struct ovl_fh *ovl_encode_real_fh(struct + * the price or reconnecting the dentry. + */ + dwords = buflen >> 2; +- fh_type = exportfs_encode_inode_fh(realinode, (void *)fh->fb.fid, +- &dwords, NULL, 0); ++ fh_type = exportfs_encode_fh(real, (void *)fh->fb.fid, &dwords, 0); + buflen = (dwords << 2); + + err = -EIO; +@@ -437,7 +436,7 @@ struct ovl_fh *ovl_get_origin_fh(struct + if (!ovl_can_decode_fh(origin->d_sb)) + return NULL; + +- return ovl_encode_real_fh(ofs, d_inode(origin), false); ++ return ovl_encode_real_fh(ofs, origin, false); + } + + int ovl_set_origin_fh(struct ovl_fs *ofs, const struct ovl_fh *fh, +@@ -462,7 +461,7 @@ static int ovl_set_upper_fh(struct ovl_f + const struct ovl_fh *fh; + int err; + +- fh = ovl_encode_real_fh(ofs, d_inode(upper), true); ++ fh = ovl_encode_real_fh(ofs, upper, true); + if (IS_ERR(fh)) + return PTR_ERR(fh); + +--- a/fs/overlayfs/export.c ++++ b/fs/overlayfs/export.c +@@ -228,7 +228,6 @@ static int ovl_check_encode_origin(struc + static int ovl_dentry_to_fid(struct ovl_fs *ofs, struct dentry *dentry, + u32 *fid, int buflen) + { +- struct inode *inode = d_inode(dentry); + struct ovl_fh *fh = NULL; + int err, enc_lower; + int len; +@@ -242,8 +241,8 @@ static int ovl_dentry_to_fid(struct ovl_ + goto fail; + + /* Encode an upper or lower file handle */ +- fh = ovl_encode_real_fh(ofs, enc_lower ? ovl_inode_lower(inode) : +- ovl_inode_upper(inode), !enc_lower); ++ fh = ovl_encode_real_fh(ofs, enc_lower ? ovl_dentry_lower(dentry) : ++ ovl_dentry_upper(dentry), !enc_lower); + if (IS_ERR(fh)) + return PTR_ERR(fh); + +--- a/fs/overlayfs/namei.c ++++ b/fs/overlayfs/namei.c +@@ -536,7 +536,7 @@ int ovl_verify_origin_xattr(struct ovl_f + struct ovl_fh *fh; + int err; + +- fh = ovl_encode_real_fh(ofs, d_inode(real), is_upper); ++ fh = ovl_encode_real_fh(ofs, real, is_upper); + err = PTR_ERR(fh); + if (IS_ERR(fh)) { + fh = NULL; +@@ -732,7 +732,7 @@ int ovl_get_index_name(struct ovl_fs *of + struct ovl_fh *fh; + int err; + +- fh = ovl_encode_real_fh(ofs, d_inode(origin), false); ++ fh = ovl_encode_real_fh(ofs, origin, false); + if (IS_ERR(fh)) + return PTR_ERR(fh); + +--- a/fs/overlayfs/overlayfs.h ++++ b/fs/overlayfs/overlayfs.h +@@ -832,7 +832,7 @@ int ovl_copy_up_with_data(struct dentry + int ovl_maybe_copy_up(struct dentry *dentry, int flags); + int ovl_copy_xattr(struct super_block *sb, const struct path *path, struct dentry *new); + int ovl_set_attr(struct ovl_fs *ofs, struct dentry *upper, struct kstat *stat); +-struct ovl_fh *ovl_encode_real_fh(struct ovl_fs *ofs, struct inode *realinode, ++struct ovl_fh *ovl_encode_real_fh(struct ovl_fs *ofs, struct dentry *real, + bool is_upper); + struct ovl_fh *ovl_get_origin_fh(struct ovl_fs *ofs, struct dentry *origin); + int ovl_set_origin_fh(struct ovl_fs *ofs, const struct ovl_fh *fh, diff --git a/queue-6.6/revert-ovl-support-encoding-fid-from-inode-with-no-alias.patch b/queue-6.6/revert-ovl-support-encoding-fid-from-inode-with-no-alias.patch new file mode 100644 index 0000000000..77be4f4655 --- /dev/null +++ b/queue-6.6/revert-ovl-support-encoding-fid-from-inode-with-no-alias.patch @@ -0,0 +1,143 @@ +From 586a642bcd12b8dd5a00d4aa896e2d2d2f8198fc Mon Sep 17 00:00:00 2001 +From: Greg Kroah-Hartman +Date: Tue, 21 Jan 2025 09:13:23 +0100 +Subject: Revert "ovl: support encoding fid from inode with no alias" + +From: Greg Kroah-Hartman + +This reverts commit a1a541fbfa7e97c1100144db34b57553d7164ce5 which is +commit c45beebfde34aa71afbc48b2c54cdda623515037 upstream. + +It is reported to part of a series that causes problems in the 6.6.y +tree, so revert it at this point in time and it can come back later if +still needed. + +Reported-by: Ignat Korchagin +Link: https://lore.kernel.org/r/ACD4D6CC-C4D5-4657-A805-03C34559046E@cloudflare.com +Cc: Dmitry Safonov +Cc: Amir Goldstein +Cc: Christian Brauner +Cc: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + fs/overlayfs/export.c | 46 +++++++++++++++++++++------------------------- + 1 file changed, 21 insertions(+), 25 deletions(-) + +--- a/fs/overlayfs/export.c ++++ b/fs/overlayfs/export.c +@@ -181,37 +181,35 @@ static int ovl_connect_layer(struct dent + * + * Return 0 for upper file handle, > 0 for lower file handle or < 0 on error. + */ +-static int ovl_check_encode_origin(struct inode *inode) ++static int ovl_check_encode_origin(struct dentry *dentry) + { +- struct ovl_fs *ofs = OVL_FS(inode->i_sb); ++ struct ovl_fs *ofs = OVL_FS(dentry->d_sb); + bool decodable = ofs->config.nfs_export; +- struct dentry *dentry; +- int err; + + /* No upper layer? */ + if (!ovl_upper_mnt(ofs)) + return 1; + + /* Lower file handle for non-upper non-decodable */ +- if (!ovl_inode_upper(inode) && !decodable) ++ if (!ovl_dentry_upper(dentry) && !decodable) + return 1; + + /* Upper file handle for pure upper */ +- if (!ovl_inode_lower(inode)) ++ if (!ovl_dentry_lower(dentry)) + return 0; + + /* + * Root is never indexed, so if there's an upper layer, encode upper for + * root. + */ +- if (inode == d_inode(inode->i_sb->s_root)) ++ if (dentry == dentry->d_sb->s_root) + return 0; + + /* + * Upper decodable file handle for non-indexed upper. + */ +- if (ovl_inode_upper(inode) && decodable && +- !ovl_test_flag(OVL_INDEX, inode)) ++ if (ovl_dentry_upper(dentry) && decodable && ++ !ovl_test_flag(OVL_INDEX, d_inode(dentry))) + return 0; + + /* +@@ -220,25 +218,17 @@ static int ovl_check_encode_origin(struc + * ovl_connect_layer() will try to make origin's layer "connected" by + * copying up a "connectable" ancestor. + */ +- if (!decodable || !S_ISDIR(inode->i_mode)) +- return 1; +- +- dentry = d_find_any_alias(inode); +- if (!dentry) +- return -ENOENT; +- +- err = ovl_connect_layer(dentry); +- dput(dentry); +- if (err < 0) +- return err; ++ if (d_is_dir(dentry) && decodable) ++ return ovl_connect_layer(dentry); + + /* Lower file handle for indexed and non-upper dir/non-dir */ + return 1; + } + +-static int ovl_dentry_to_fid(struct ovl_fs *ofs, struct inode *inode, ++static int ovl_dentry_to_fid(struct ovl_fs *ofs, struct dentry *dentry, + u32 *fid, int buflen) + { ++ struct inode *inode = d_inode(dentry); + struct ovl_fh *fh = NULL; + int err, enc_lower; + int len; +@@ -247,7 +237,7 @@ static int ovl_dentry_to_fid(struct ovl_ + * Check if we should encode a lower or upper file handle and maybe + * copy up an ancestor to make lower file handle connectable. + */ +- err = enc_lower = ovl_check_encode_origin(inode); ++ err = enc_lower = ovl_check_encode_origin(dentry); + if (enc_lower < 0) + goto fail; + +@@ -267,8 +257,8 @@ out: + return err; + + fail: +- pr_warn_ratelimited("failed to encode file handle (ino=%lu, err=%i)\n", +- inode->i_ino, err); ++ pr_warn_ratelimited("failed to encode file handle (%pd2, err=%i)\n", ++ dentry, err); + goto out; + } + +@@ -276,13 +266,19 @@ static int ovl_encode_fh(struct inode *i + struct inode *parent) + { + struct ovl_fs *ofs = OVL_FS(inode->i_sb); ++ struct dentry *dentry; + int bytes, buflen = *max_len << 2; + + /* TODO: encode connectable file handles */ + if (parent) + return FILEID_INVALID; + +- bytes = ovl_dentry_to_fid(ofs, inode, fid, buflen); ++ dentry = d_find_any_alias(inode); ++ if (!dentry) ++ return FILEID_INVALID; ++ ++ bytes = ovl_dentry_to_fid(ofs, dentry, fid, buflen); ++ dput(dentry); + if (bytes <= 0) + return FILEID_INVALID; + diff --git a/queue-6.6/series b/queue-6.6/series index 2e39acf5e2..c2ab85a07b 100644 --- a/queue-6.6/series +++ b/queue-6.6/series @@ -1,3 +1,6 @@ +revert-ovl-support-encoding-fid-from-inode-with-no-alias.patch +revert-ovl-pass-realinode-to-ovl_encode_real_fh-instead-of-realdentry.patch +revert-ovl-do-not-encode-lower-fh-with-upper-sb_writers-held.patch net-ethernet-ti-cpsw_ale-fix-cpsw_ale_get_field.patch bpf-fix-bpf_sk_select_reuseport-memory-leak.patch openvswitch-fix-lockup-on-tx-to-unregistering-netdev.patch