exfat: preserve benign secondary entries during rename and move

Commit 8258ef28001a ("exfat: handle unreconized benign secondary
entries") added cluster freeing for benign secondary entries inside
exfat_remove_entries().  However, exfat_remove_entries() is also called
from the rename and move paths (exfat_rename_file and exfat_move_file),
where the old entry set is being relocated rather than deleted.  This
causes benign secondary entries such as vendor extension entries to be
silently destroyed on rename or cross-directory move, violating the
exFAT spec requirement (section 8.2) that implementations preserve
unrecognized benign secondary entries.

Fix this by adding a free_benign parameter to exfat_remove_entries()
so callers can suppress cluster freeing during relocation, and
extending exfat_init_ext_entry() to copy trailing benign secondary
entries from the old entry set into the new one internally.  Also
clean up the error paths to delete newly allocated entries on failure.

Fixes: 8258ef28001a ("exfat: handle unreconized benign secondary entries")
Cc: stable@vger.kernel.org
Link: https://lore.kernel.org/linux-fsdevel/CAG7tbBV--waov7XVu2FHQEc6paR92dufS=em9DW5Kzsrpu3iQg@mail.gmail.com/
Signed-off-by: Rochan Avlur <rochan.avlur@gmail.com>
Reviewed-by: Yuezhang Mo <Yuezhang.Mo@sony.com>
Signed-off-by: Namjae Jeon <linkinjeon@kernel.org>

diff --git a/fs/exfat/dir.c b/fs/exfat/dir.c
index 8b8f6bc0c233c8bfb1fa4a3a24610a8d719725c4..5a85a8ec0cc0735c196b61f05bc0818cb2a26f81 100644 (file)
--- a/fs/exfat/dir.c
+++ b/fs/exfat/dir.c
@@ -470,32 +470,70 @@ static void exfat_free_benign_secondary_clusters(struct inode *inode,
        exfat_free_cluster(inode, &dir);
 }
 
+/*
+ * exfat_init_ext_entry - initialize extension entries in a directory entry set
+ * @es:          target entry set
+ * @num_entries: number of entries excluding benign secondary entries
+ * @p_uniname:   filename to store
+ * @old_es:      optional source entry set with benign secondary entries, or NULL
+ * @num_extra:   number of benign secondary entries to copy from @old_es
+ *
+ * Set up the file, stream extension, and filename entries in @es, optionally
+ * preserving @num_extra benign secondary entries from @old_es.  @es and @old_es
+ * may refer to the same entry set; excess entries are marked as deleted.
+ */
 void exfat_init_ext_entry(struct exfat_entry_set_cache *es, int num_entries,
-               struct exfat_uni_name *p_uniname)
+               struct exfat_uni_name *p_uniname,
+               struct exfat_entry_set_cache *old_es, int num_extra)
 {
-       int i;
+       int i, src_start = 0, old_num;
        unsigned short *uniname = p_uniname->name;
        struct exfat_dentry *ep;
 
-       es->num_entries = num_entries;
+       if (WARN_ON(num_extra < 0 || (num_extra && (!old_es ||
+                   old_es->num_entries < ES_IDX_FIRST_FILENAME + num_extra))))
+               num_extra = 0;
+
+       /*
+        * Save old entry count and source position before modifying
+        * es->num_entries, since old_es and es may point to the same
+        * entry set.
+        */
+       old_num = es->num_entries;
+       if (old_es && num_extra > 0)
+               src_start = old_es->num_entries - num_extra;
+
+       es->num_entries = num_entries + num_extra;
        ep = exfat_get_dentry_cached(es, ES_IDX_FILE);
-       ep->dentry.file.num_ext = (unsigned char)(num_entries - 1);
+       ep->dentry.file.num_ext = (unsigned char)(num_entries - 1 + num_extra);
 
        ep = exfat_get_dentry_cached(es, ES_IDX_STREAM);
        ep->dentry.stream.name_len = p_uniname->name_len;
        ep->dentry.stream.name_hash = cpu_to_le16(p_uniname->name_hash);
 
+       if (old_es && num_extra > 0) {
+               for (i = 0; i < num_extra; i++)
+                       *exfat_get_dentry_cached(es, num_entries + i) =
+                               *exfat_get_dentry_cached(old_es, src_start + i);
+       }
+
        for (i = ES_IDX_FIRST_FILENAME; i < num_entries; i++) {
                ep = exfat_get_dentry_cached(es, i);
                exfat_init_name_entry(ep, uniname);
                uniname += EXFAT_FILE_NAME_LEN;
        }
 
+       /* Mark excess old entries as deleted (in-place shrink) */
+       for (i = num_entries + num_extra; i < old_num; i++) {
+               ep = exfat_get_dentry_cached(es, i);
+               exfat_set_entry_type(ep, TYPE_DELETED);
+       }
+
        exfat_update_dir_chksum(es);
 }
 
 void exfat_remove_entries(struct inode *inode, struct exfat_entry_set_cache *es,
-               int order)
+               int order, bool free_benign)
 {
        int i;
        struct exfat_dentry *ep;
@@ -503,7 +541,7 @@ void exfat_remove_entries(struct inode *inode, struct exfat_entry_set_cache *es,
        for (i = order; i < es->num_entries; i++) {
                ep = exfat_get_dentry_cached(es, i);
 
-               if (exfat_get_entry_type(ep) & TYPE_BENIGN_SEC)
+               if (free_benign && (exfat_get_entry_type(ep) & TYPE_BENIGN_SEC))
                        exfat_free_benign_secondary_clusters(inode, ep);
 
                exfat_set_entry_type(ep, TYPE_DELETED);

diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h
index 2607e51804b25f90d865e48726dcdca8ccb9d028..9be50949ce34f5be822223b207baac49d9b1db8e 100644 (file)
--- a/fs/exfat/exfat_fs.h
+++ b/fs/exfat/exfat_fs.h
@@ -592,9 +592,10 @@ void exfat_init_dir_entry(struct exfat_entry_set_cache *es,
                unsigned int type, unsigned int start_clu,
                unsigned long long size, struct timespec64 *ts);
 void exfat_init_ext_entry(struct exfat_entry_set_cache *es, int num_entries,
-               struct exfat_uni_name *p_uniname);
+               struct exfat_uni_name *p_uniname,
+               struct exfat_entry_set_cache *old_es, int num_extra);
 void exfat_remove_entries(struct inode *inode, struct exfat_entry_set_cache *es,
-               int order);
+               int order, bool free_benign);
 void exfat_update_dir_chksum(struct exfat_entry_set_cache *es);
 int exfat_calc_num_entries(struct exfat_uni_name *p_uniname);
 int exfat_find_dir_entry(struct super_block *sb, struct exfat_inode_info *ei,

diff --git a/fs/exfat/namei.c b/fs/exfat/namei.c
index 78f861f23246ff19749bc2bae455f03a004a5241..b7d5e44ad38eeedf46f6247a26555b6875d22f77 100644 (file)
--- a/fs/exfat/namei.c
+++ b/fs/exfat/namei.c
@@ -504,7 +504,7 @@ static int exfat_add_entry(struct inode *inode, const char *path,
         * the first cluster is not determined yet. (0)
         */
        exfat_init_dir_entry(&es, type, start_clu, clu_size, &ts);
-       exfat_init_ext_entry(&es, num_entries, &uniname);
+       exfat_init_ext_entry(&es, num_entries, &uniname, NULL, 0);
 
        ret = exfat_put_dentry_set(&es, IS_DIRSYNC(inode));
        if (ret)
@@ -786,7 +786,7 @@ static int exfat_unlink(struct inode *dir, struct dentry *dentry)
        exfat_set_volume_dirty(sb);
 
        /* update the directory entry */
-       exfat_remove_entries(inode, &es, ES_IDX_FILE);
+       exfat_remove_entries(inode, &es, ES_IDX_FILE, true);
 
        err = exfat_put_dentry_set(&es, IS_DIRSYNC(inode));
        if (err)
@@ -941,7 +941,7 @@ static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
 
        exfat_set_volume_dirty(sb);
 
-       exfat_remove_entries(inode, &es, ES_IDX_FILE);
+       exfat_remove_entries(inode, &es, ES_IDX_FILE, true);
 
        err = exfat_put_dentry_set(&es, IS_DIRSYNC(dir));
        if (err)
@@ -968,6 +968,23 @@ unlock:
        return err;
 }
 
+/*
+ * Count benign secondary entries beyond the filename entries.
+ * Returns the count, or -EIO if the entry set is inconsistent.
+ */
+static int exfat_count_extra_entries(struct exfat_entry_set_cache *es)
+{
+       struct exfat_dentry *stream;
+       unsigned int name_entries;
+       int extra;
+
+       stream = exfat_get_dentry_cached(es, ES_IDX_STREAM);
+       name_entries = EXFAT_FILENAME_ENTRY_NUM(stream->dentry.stream.name_len);
+       extra = es->num_entries - (ES_IDX_FIRST_FILENAME + name_entries);
+
+       return extra >= 0 ? extra : -EIO;
+}
+
 static int exfat_rename_file(struct inode *parent_inode,
                struct exfat_uni_name *p_uniname, struct exfat_inode_info *ei)
 {
@@ -976,6 +993,7 @@ static int exfat_rename_file(struct inode *parent_inode,
        struct super_block *sb = parent_inode->i_sb;
        struct exfat_entry_set_cache old_es, new_es;
        int sync = IS_DIRSYNC(parent_inode);
+       unsigned int num_extra_entries, num_total_entries;
 
        if (unlikely(exfat_forced_shutdown(sb)))
                return -EIO;
@@ -985,19 +1003,23 @@ static int exfat_rename_file(struct inode *parent_inode,
                return num_new_entries;
 
        ret = exfat_get_dentry_set_by_ei(&old_es, sb, ei);
-       if (ret) {
-               ret = -EIO;
-               return ret;
-       }
+       if (ret)
+               return -EIO;
 
        epold = exfat_get_dentry_cached(&old_es, ES_IDX_FILE);
 
-       if (old_es.num_entries < num_new_entries) {
+       ret = exfat_count_extra_entries(&old_es);
+       if (ret < 0)
+               goto put_old_es;
+       num_extra_entries = ret;
+       num_total_entries = num_new_entries + num_extra_entries;
+
+       if (old_es.num_entries < num_total_entries) {
                int newentry;
                struct exfat_chain dir;
 
                newentry = exfat_find_empty_entry(parent_inode, &dir,
-                               num_new_entries, &new_es);
+                               num_total_entries, &new_es);
                if (newentry < 0) {
                        ret = newentry; /* -EIO or -ENOSPC */
                        goto put_old_es;
@@ -1014,13 +1036,23 @@ static int exfat_rename_file(struct inode *parent_inode,
                epnew = exfat_get_dentry_cached(&new_es, ES_IDX_STREAM);
                *epnew = *epold;
 
-               exfat_init_ext_entry(&new_es, num_new_entries, p_uniname);
+               exfat_init_ext_entry(&new_es, num_new_entries, p_uniname,
+                                    &old_es, num_extra_entries);
 
                ret = exfat_put_dentry_set(&new_es, sync);
-               if (ret)
+               if (ret) {
+                       /* Best-effort delete to avoid duplicate entries */
+                       if (!exfat_get_dentry_set(&new_es, sb,
+                                                 &dir, newentry,
+                                                 ES_ALL_ENTRIES)) {
+                               exfat_remove_entries(parent_inode, &new_es,
+                                                   ES_IDX_FILE, false);
+                               exfat_put_dentry_set(&new_es, false);
+                       }
                        goto put_old_es;
+               }
 
-               exfat_remove_entries(parent_inode, &old_es, ES_IDX_FILE);
+               exfat_remove_entries(parent_inode, &old_es, ES_IDX_FILE, false);
                ei->dir = dir;
                ei->entry = newentry;
        } else {
@@ -1029,8 +1061,8 @@ static int exfat_rename_file(struct inode *parent_inode,
                        ei->attr |= EXFAT_ATTR_ARCHIVE;
                }
 
-               exfat_remove_entries(parent_inode, &old_es, ES_IDX_FIRST_FILENAME + 1);
-               exfat_init_ext_entry(&old_es, num_new_entries, p_uniname);
+               exfat_init_ext_entry(&old_es, num_new_entries, p_uniname,
+                                    &old_es, num_extra_entries);
        }
        return exfat_put_dentry_set(&old_es, sync);
 
@@ -1046,6 +1078,7 @@ static int exfat_move_file(struct inode *parent_inode,
        struct exfat_dentry *epmov, *epnew;
        struct exfat_entry_set_cache mov_es, new_es;
        struct exfat_chain newdir;
+       unsigned int num_extra_entries, num_total_entries;
 
        num_new_entries = exfat_calc_num_entries(p_uniname);
        if (num_new_entries < 0)
@@ -1055,8 +1088,14 @@ static int exfat_move_file(struct inode *parent_inode,
        if (ret)
                return -EIO;
 
+       ret = exfat_count_extra_entries(&mov_es);
+       if (ret < 0)
+               goto put_mov_es;
+       num_extra_entries = ret;
+       num_total_entries = num_new_entries + num_extra_entries;
+
        newentry = exfat_find_empty_entry(parent_inode, &newdir,
-                       num_new_entries, &new_es);
+                       num_total_entries, &new_es);
        if (newentry < 0) {
                ret = newentry; /* -EIO or -ENOSPC */
                goto put_mov_es;
@@ -1074,21 +1113,31 @@ static int exfat_move_file(struct inode *parent_inode,
        epnew = exfat_get_dentry_cached(&new_es, ES_IDX_STREAM);
        *epnew = *epmov;
 
-       exfat_init_ext_entry(&new_es, num_new_entries, p_uniname);
-       exfat_remove_entries(parent_inode, &mov_es, ES_IDX_FILE);
+       exfat_init_ext_entry(&new_es, num_new_entries, p_uniname,
+                            &mov_es, num_extra_entries);
+
+       exfat_remove_entries(parent_inode, &mov_es, ES_IDX_FILE, false);
 
        ei->dir = newdir;
        ei->entry = newentry;
 
        ret = exfat_put_dentry_set(&new_es, IS_DIRSYNC(parent_inode));
-       if (ret)
+       if (ret) {
+               /* Best-effort delete to avoid duplicate entries */
+               if (!exfat_get_dentry_set(&new_es, parent_inode->i_sb,
+                                         &newdir, newentry,
+                                         ES_ALL_ENTRIES)) {
+                       exfat_remove_entries(parent_inode, &new_es,
+                                           ES_IDX_FILE, false);
+                       exfat_put_dentry_set(&new_es, false);
+               }
                goto put_mov_es;
+       }
 
        return exfat_put_dentry_set(&mov_es, IS_DIRSYNC(parent_inode));
 
 put_mov_es:
        exfat_put_dentry_set(&mov_es, false);
-
        return ret;
 }
 
@@ -1162,7 +1211,7 @@ static int __exfat_rename(struct inode *old_parent_inode,
                        goto del_out;
                }
 
-               exfat_remove_entries(new_inode, &es, ES_IDX_FILE);
+               exfat_remove_entries(new_inode, &es, ES_IDX_FILE, true);
 
                ret = exfat_put_dentry_set(&es, IS_DIRSYNC(new_inode));
                if (ret)