[PATCH v2 0/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[PATCH v2 0/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Ethan Ferguson]

Add support for reading / writing to the exfat volume label from the
FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls.

Implemented in similar ways to other fs drivers, namely btrfs and ext4,
where the ioctls are performed on file inodes.

v2:
Fix endianness conversion as reported by kernel test robot
v1:
Link: https://lore.kernel.org/all/20250815171056.103751-1-ethan.ferguson@zetier.com/

Ethan Ferguson (1):
  exfat: Add support for FS_IOC_{GET,SET}FSLABEL
  exfat: Fix endian conversion

 fs/exfat/exfat_fs.h  |  2 +
 fs/exfat/exfat_raw.h |  6 +++
 fs/exfat/file.c      | 56 +++++++++++++++++++++++++
 fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 163 insertions(+)

-- 
2.50.1

[PATCH v2 1/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Ethan Ferguson]

Add support for reading / writing to the exfat volume label from the
FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls

Signed-off-by: Ethan Ferguson <ethan.ferguson@zetier.com>

---
 fs/exfat/exfat_fs.h  |  2 +
 fs/exfat/exfat_raw.h |  6 +++
 fs/exfat/file.c      | 56 +++++++++++++++++++++++++
 fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 163 insertions(+)

diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h
index f8ead4d47ef0..a764e6362172 100644
--- a/fs/exfat/exfat_fs.h
+++ b/fs/exfat/exfat_fs.h
@@ -267,6 +267,7 @@ struct exfat_sb_info {
 	struct buffer_head **vol_amap; /* allocation bitmap */
 
 	unsigned short *vol_utbl; /* upcase table */
+	unsigned short volume_label[EXFAT_VOLUME_LABEL_LEN]; /* volume name */
 
 	unsigned int clu_srch_ptr; /* cluster search pointer */
 	unsigned int used_clusters; /* number of used clusters */
@@ -431,6 +432,7 @@ static inline loff_t exfat_ondisk_size(const struct inode *inode)
 /* super.c */
 int exfat_set_volume_dirty(struct super_block *sb);
 int exfat_clear_volume_dirty(struct super_block *sb);
+int exfat_write_volume_label(struct super_block *sb);
 
 /* fatent.c */
 #define exfat_get_next_cluster(sb, pclu) exfat_ent_get(sb, *(pclu), pclu)
diff --git a/fs/exfat/exfat_raw.h b/fs/exfat/exfat_raw.h
index 971a1ccd0e89..af04cef81c0c 100644
--- a/fs/exfat/exfat_raw.h
+++ b/fs/exfat/exfat_raw.h
@@ -80,6 +80,7 @@
 #define BOOTSEC_OLDBPB_LEN		53
 
 #define EXFAT_FILE_NAME_LEN		15
+#define EXFAT_VOLUME_LABEL_LEN		11
 
 #define EXFAT_MIN_SECT_SIZE_BITS		9
 #define EXFAT_MAX_SECT_SIZE_BITS		12
@@ -159,6 +160,11 @@ struct exfat_dentry {
 			__le32 start_clu;
 			__le64 size;
 		} __packed upcase; /* up-case table directory entry */
+		struct {
+			__u8 char_count;
+			__le16 volume_label[EXFAT_VOLUME_LABEL_LEN];
+			__u8 reserved[8];
+		} __packed volume_label;
 		struct {
 			__u8 flags;
 			__u8 vendor_guid[16];
diff --git a/fs/exfat/file.c b/fs/exfat/file.c
index 538d2b6ac2ec..c57d266aae3d 100644
--- a/fs/exfat/file.c
+++ b/fs/exfat/file.c
@@ -12,6 +12,7 @@
 #include <linux/security.h>
 #include <linux/msdos_fs.h>
 #include <linux/writeback.h>
+#include "../nls/nls_ucs2_utils.h"
 
 #include "exfat_raw.h"
 #include "exfat_fs.h"
@@ -486,6 +487,57 @@ static int exfat_ioctl_shutdown(struct super_block *sb, unsigned long arg)
 	return exfat_force_shutdown(sb, flags);
 }
 
+static int exfat_ioctl_get_volume_label(struct super_block *sb, unsigned long arg)
+{
+	int ret;
+	char utf8[FSLABEL_MAX] = {0};
+	struct exfat_sb_info *sbi = EXFAT_SB(sb);
+	size_t len = UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
+
+	mutex_lock(&sbi->s_lock);
+	ret = utf16s_to_utf8s(sbi->volume_label, len,
+				UTF16_HOST_ENDIAN, utf8, FSLABEL_MAX);
+	mutex_unlock(&sbi->s_lock);
+
+	if (ret < 0)
+		return ret;
+
+	if (copy_to_user((char __user *)arg, utf8, FSLABEL_MAX))
+		return -EFAULT;
+
+	return 0;
+}
+
+static int exfat_ioctl_set_volume_label(struct super_block *sb, unsigned long arg)
+{
+	int ret = 0;
+	char utf8[FSLABEL_MAX];
+	size_t len;
+	unsigned short utf16[EXFAT_VOLUME_LABEL_LEN] = {0};
+	struct exfat_sb_info *sbi = EXFAT_SB(sb);
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;
+
+	if (copy_from_user(utf8, (char __user *)arg, FSLABEL_MAX))
+		return -EFAULT;
+
+	len = strnlen(utf8, FSLABEL_MAX);
+	if (len > EXFAT_VOLUME_LABEL_LEN)
+		exfat_info(sb, "Volume label length too long, truncating");
+
+	mutex_lock(&sbi->s_lock);
+	ret = utf8s_to_utf16s(utf8, len, UTF16_HOST_ENDIAN, utf16, EXFAT_VOLUME_LABEL_LEN);
+	mutex_unlock(&sbi->s_lock);
+
+	if (ret < 0)
+		return ret;
+
+	memcpy(sbi->volume_label, utf16, sizeof(sbi->volume_label));
+
+	return exfat_write_volume_label(sb);
+}
+
 long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
 	struct inode *inode = file_inode(filp);
@@ -500,6 +552,10 @@ long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 		return exfat_ioctl_shutdown(inode->i_sb, arg);
 	case FITRIM:
 		return exfat_ioctl_fitrim(inode, arg);
+	case FS_IOC_GETFSLABEL:
+		return exfat_ioctl_get_volume_label(inode->i_sb, arg);
+	case FS_IOC_SETFSLABEL:
+		return exfat_ioctl_set_volume_label(inode->i_sb, arg);
 	default:
 		return -ENOTTY;
 	}
diff --git a/fs/exfat/super.c b/fs/exfat/super.c
index 8926e63f5bb7..96cd4bb7cb19 100644
--- a/fs/exfat/super.c
+++ b/fs/exfat/super.c
@@ -18,6 +18,7 @@
 #include <linux/nls.h>
 #include <linux/buffer_head.h>
 #include <linux/magic.h>
+#include "../nls/nls_ucs2_utils.h"
 
 #include "exfat_raw.h"
 #include "exfat_fs.h"
@@ -573,6 +574,98 @@ static int exfat_verify_boot_region(struct super_block *sb)
 	return 0;
 }
 
+static int exfat_get_volume_label_ptrs(struct super_block *sb,
+				       struct buffer_head **out_bh,
+				       struct exfat_dentry **out_dentry)
+{
+	int i;
+	unsigned int type;
+	struct exfat_sb_info *sbi = EXFAT_SB(sb);
+	struct exfat_chain clu;
+	struct exfat_dentry *ep;
+	struct buffer_head *bh;
+
+	clu.dir = sbi->root_dir;
+	clu.flags = ALLOC_FAT_CHAIN;
+
+	while (clu.dir != EXFAT_EOF_CLUSTER) {
+		for (i = 0; i < sbi->dentries_per_clu; i++) {
+			ep = exfat_get_dentry(sb, &clu, i, &bh);
+
+			if (!ep)
+				return -EIO;
+
+			type = exfat_get_entry_type(ep);
+			if (type == TYPE_UNUSED) {
+				brelse(bh);
+				return -EIO;
+			}
+
+			if (type == TYPE_VOLUME) {
+				*out_bh = bh;
+				*out_dentry = ep;
+				return 0;
+			}
+
+			brelse(bh);
+		}
+
+		if (exfat_get_next_cluster(sb, &(clu.dir)))
+			return -EIO;
+	}
+
+	return -EIO;
+}
+
+static int exfat_read_volume_label(struct super_block *sb)
+{
+	int ret, i;
+	struct exfat_sb_info *sbi = EXFAT_SB(sb);
+	struct buffer_head *bh;
+	struct exfat_dentry *ep;
+
+	ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
+	if (ret < 0)
+		goto cleanup;
+
+	for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
+		sbi->volume_label[i] = le16_to_cpu(ep->dentry.volume_label.volume_label[i]);
+
+cleanup:
+	if (bh)
+		brelse(bh);
+
+	return ret;
+}
+
+int exfat_write_volume_label(struct super_block *sb)
+{
+	int ret, i;
+	struct exfat_sb_info *sbi = EXFAT_SB(sb);
+	struct buffer_head *bh;
+	struct exfat_dentry *ep;
+
+	ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
+	if (ret < 0)
+		goto cleanup;
+
+	mutex_lock(&sbi->s_lock);
+	for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
+		ep->dentry.volume_label.volume_label[i] = cpu_to_le16(sbi->volume_label[i]);
+
+	ep->dentry.volume_label.char_count =
+		UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
+	mutex_unlock(&sbi->s_lock);
+
+cleanup:
+	if (bh) {
+		exfat_update_bh(bh, true);
+		brelse(bh);
+	}
+
+	return ret;
+}
+
 /* mount the file system volume */
 static int __exfat_fill_super(struct super_block *sb,
 		struct exfat_chain *root_clu)
@@ -616,6 +709,12 @@ static int __exfat_fill_super(struct super_block *sb,
 		goto free_bh;
 	}
 
+	ret = exfat_read_volume_label(sb);
+	if (ret) {
+		exfat_err(sb, "failed to read volume label");
+		goto free_bh;
+	}
+
 	ret = exfat_count_used_clusters(sb, &sbi->used_clusters);
 	if (ret) {
 		exfat_err(sb, "failed to scan clusters");
-- 
2.50.1

Re: [PATCH v2 0/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Namjae Jeon]

On Sun, Aug 17, 2025 at 9:31 AM Ethan Ferguson
<ethan.ferguson@zetier.com> wrote:
>
> Add support for reading / writing to the exfat volume label from the
> FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls.
>
> Implemented in similar ways to other fs drivers, namely btrfs and ext4,
> where the ioctls are performed on file inodes.
We can load and store a volume label using tune.exfat in exfatprogs.
Is there any usage that requires this, even though there are utils
that can do it?

Thanks.
>
> v2:
> Fix endianness conversion as reported by kernel test robot
> v1:
> Link: https://lore.kernel.org/all/20250815171056.103751-1-ethan.ferguson@zetier.com/
>
> Ethan Ferguson (1):
>   exfat: Add support for FS_IOC_{GET,SET}FSLABEL
>   exfat: Fix endian conversion
>
>  fs/exfat/exfat_fs.h  |  2 +
>  fs/exfat/exfat_raw.h |  6 +++
>  fs/exfat/file.c      | 56 +++++++++++++++++++++++++
>  fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 163 insertions(+)
>
> --
> 2.50.1
>

[PATCH v2 1/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Ethan Ferguson]

On 8/17/25 08:30, Namjae Jeon wrote:
> On Sun, Aug 17, 2025 at 9:31 AM Ethan Ferguson
> <ethan.ferguson@zetier.com> wrote:
>>
>> Add support for reading / writing to the exfat volume label from the
>> FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls.
>>
>> Implemented in similar ways to other fs drivers, namely btrfs and ext4,
>> where the ioctls are performed on file inodes.
> We can load and store a volume label using tune.exfat in exfatprogs.
> Is there any usage that requires this, even though there are utils
> that can do it?
> 
> Thanks.
Both e2fsprogs and btrfs-progs now use the FS_IOC_{GET,SET}FSLABEL
ioctls to change the label on a mounted filesystem.

As for me, personally, I ran into this while developing on an
embedded device that does not have, and cannot have, exfatprogs.
Having this be a kernel feature would (I believe) bring the exfat driver
more in line with other fs drivers in the mainline tree.

Thank you for your consideration!

>>
>> v2:
>> Fix endianness conversion as reported by kernel test robot
>> v1:
>> Link: https://lore.kernel.org/all/20250815171056.103751-1-ethan.ferguson@zetier.com/
>>
>> Ethan Ferguson (1):
>>   exfat: Add support for FS_IOC_{GET,SET}FSLABEL
>>   exfat: Fix endian conversion
>>
>>  fs/exfat/exfat_fs.h  |  2 +
>>  fs/exfat/exfat_raw.h |  6 +++
>>  fs/exfat/file.c      | 56 +++++++++++++++++++++++++
>>  fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
>>  4 files changed, 163 insertions(+)
>>
>> --
>> 2.50.1
>>

Re: [PATCH v2 1/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Christoph Hellwig]

On Sun, Aug 17, 2025 at 10:32:00AM -0400, Ethan Ferguson wrote:
> Both e2fsprogs and btrfs-progs now use the FS_IOC_{GET,SET}FSLABEL
> ioctls to change the label on a mounted filesystem.

Additionally userspace writes to blocks on mounted file systems are
dangerous.  They can easily corrupt data when racing with updates
performed by the kernel, and are impossible when the the
CONFIG_BLK_DEV_WRITE_MOUNTED config option is disabled.

[PATCH v2 0/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Ethan Ferguson]

On 8/18/25 01:52, Christoph Hellwig wrote:
> On Sun, Aug 17, 2025 at 10:32:00AM -0400, Ethan Ferguson wrote:
>> Both e2fsprogs and btrfs-progs now use the FS_IOC_{GET,SET}FSLABEL
>> ioctls to change the label on a mounted filesystem.
> 
> Additionally userspace writes to blocks on mounted file systems are
> dangerous.  They can easily corrupt data when racing with updates
> performed by the kernel, and are impossible when the the
> CONFIG_BLK_DEV_WRITE_MOUNTED config option is disabled.

That's fair. I took a look at how btrfs guards against this, it seems
as if they use mnt_want_write_file to guard against bad writes, and
only write to the in-memory superblock, and commit the transaction
afterwards. However, this (during my testing with
CONFIG_BLK_DEV_WRITE_MOUNTED both on and off) still results in an
immediate disk flush.

My changes from this thread also seem to work with
CONFIG_BLK_DEV_WRITE_MOUNTED both disabled and enabled.

Maybe an alternative would be to only write to sbi->volume_label (with
mutex guarding), and only flush to disk on exfat_put_super? And to use
mnt_want_write_file as well.

Unfortunately, given that I'm pretty new to kernel development, I
wouldn't know that the best way to approach this. Any thoughts, or
pointers in the right direction, would be appreciated.

Thank you for the feedback!

Re: [PATCH v2 1/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Namjae Jeon]

On Sun, Aug 17, 2025 at 9:31 AM Ethan Ferguson
<ethan.ferguson@zetier.com> wrote:
>
> Add support for reading / writing to the exfat volume label from the
> FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls
>
> Signed-off-by: Ethan Ferguson <ethan.ferguson@zetier.com>
>
> ---
>  fs/exfat/exfat_fs.h  |  2 +
>  fs/exfat/exfat_raw.h |  6 +++
>  fs/exfat/file.c      | 56 +++++++++++++++++++++++++
>  fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 163 insertions(+)
>
> diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h
> index f8ead4d47ef0..a764e6362172 100644
> --- a/fs/exfat/exfat_fs.h
> +++ b/fs/exfat/exfat_fs.h
> @@ -267,6 +267,7 @@ struct exfat_sb_info {
>         struct buffer_head **vol_amap; /* allocation bitmap */
>
>         unsigned short *vol_utbl; /* upcase table */
> +       unsigned short volume_label[EXFAT_VOLUME_LABEL_LEN]; /* volume name */
There's no reason to have this in sbi. I think it's better to read the
volume name in ioctl fslabel and return it.

>
>         unsigned int clu_srch_ptr; /* cluster search pointer */
>         unsigned int used_clusters; /* number of used clusters */
> @@ -431,6 +432,7 @@ static inline loff_t exfat_ondisk_size(const struct inode *inode)
>  /* super.c */
>  int exfat_set_volume_dirty(struct super_block *sb);
>  int exfat_clear_volume_dirty(struct super_block *sb);
> +int exfat_write_volume_label(struct super_block *sb);
>
>  /* fatent.c */
>  #define exfat_get_next_cluster(sb, pclu) exfat_ent_get(sb, *(pclu), pclu)
> diff --git a/fs/exfat/exfat_raw.h b/fs/exfat/exfat_raw.h
> index 971a1ccd0e89..af04cef81c0c 100644
> --- a/fs/exfat/exfat_raw.h
> +++ b/fs/exfat/exfat_raw.h
> @@ -80,6 +80,7 @@
>  #define BOOTSEC_OLDBPB_LEN             53
>
>  #define EXFAT_FILE_NAME_LEN            15
> +#define EXFAT_VOLUME_LABEL_LEN         11
>
>  #define EXFAT_MIN_SECT_SIZE_BITS               9
>  #define EXFAT_MAX_SECT_SIZE_BITS               12
> @@ -159,6 +160,11 @@ struct exfat_dentry {
>                         __le32 start_clu;
>                         __le64 size;
>                 } __packed upcase; /* up-case table directory entry */
> +               struct {
> +                       __u8 char_count;
> +                       __le16 volume_label[EXFAT_VOLUME_LABEL_LEN];
> +                       __u8 reserved[8];
> +               } __packed volume_label;
>                 struct {
>                         __u8 flags;
>                         __u8 vendor_guid[16];
> diff --git a/fs/exfat/file.c b/fs/exfat/file.c
> index 538d2b6ac2ec..c57d266aae3d 100644
> --- a/fs/exfat/file.c
> +++ b/fs/exfat/file.c
> @@ -12,6 +12,7 @@
>  #include <linux/security.h>
>  #include <linux/msdos_fs.h>
>  #include <linux/writeback.h>
> +#include "../nls/nls_ucs2_utils.h"
>
>  #include "exfat_raw.h"
>  #include "exfat_fs.h"
> @@ -486,6 +487,57 @@ static int exfat_ioctl_shutdown(struct super_block *sb, unsigned long arg)
>         return exfat_force_shutdown(sb, flags);
>  }
>
> +static int exfat_ioctl_get_volume_label(struct super_block *sb, unsigned long arg)
> +{
> +       int ret;
> +       char utf8[FSLABEL_MAX] = {0};
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       size_t len = UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
> +
> +       mutex_lock(&sbi->s_lock);
> +       ret = utf16s_to_utf8s(sbi->volume_label, len,
> +                               UTF16_HOST_ENDIAN, utf8, FSLABEL_MAX);
> +       mutex_unlock(&sbi->s_lock);
> +
> +       if (ret < 0)
> +               return ret;
> +
> +       if (copy_to_user((char __user *)arg, utf8, FSLABEL_MAX))
> +               return -EFAULT;
> +
> +       return 0;
> +}
> +
> +static int exfat_ioctl_set_volume_label(struct super_block *sb, unsigned long arg)
> +{
> +       int ret = 0;
> +       char utf8[FSLABEL_MAX];
> +       size_t len;
> +       unsigned short utf16[EXFAT_VOLUME_LABEL_LEN] = {0};
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +
> +       if (!capable(CAP_SYS_ADMIN))
> +               return -EPERM;
> +
> +       if (copy_from_user(utf8, (char __user *)arg, FSLABEL_MAX))
> +               return -EFAULT;
> +
> +       len = strnlen(utf8, FSLABEL_MAX);
> +       if (len > EXFAT_VOLUME_LABEL_LEN)
Is FSLABEL_MAX in bytes or the number of characters ?

> +               exfat_info(sb, "Volume label length too long, truncating");
> +
> +       mutex_lock(&sbi->s_lock);
> +       ret = utf8s_to_utf16s(utf8, len, UTF16_HOST_ENDIAN, utf16, EXFAT_VOLUME_LABEL_LEN);
> +       mutex_unlock(&sbi->s_lock);
> +
> +       if (ret < 0)
> +               return ret;
> +
> +       memcpy(sbi->volume_label, utf16, sizeof(sbi->volume_label));
> +
> +       return exfat_write_volume_label(sb);
> +}
> +
>  long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>  {
>         struct inode *inode = file_inode(filp);
> @@ -500,6 +552,10 @@ long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>                 return exfat_ioctl_shutdown(inode->i_sb, arg);
>         case FITRIM:
>                 return exfat_ioctl_fitrim(inode, arg);
> +       case FS_IOC_GETFSLABEL:
> +               return exfat_ioctl_get_volume_label(inode->i_sb, arg);
> +       case FS_IOC_SETFSLABEL:
> +               return exfat_ioctl_set_volume_label(inode->i_sb, arg);
>         default:
>                 return -ENOTTY;
>         }
> diff --git a/fs/exfat/super.c b/fs/exfat/super.c
> index 8926e63f5bb7..96cd4bb7cb19 100644
> --- a/fs/exfat/super.c
> +++ b/fs/exfat/super.c
> @@ -18,6 +18,7 @@
>  #include <linux/nls.h>
>  #include <linux/buffer_head.h>
>  #include <linux/magic.h>
> +#include "../nls/nls_ucs2_utils.h"
>
>  #include "exfat_raw.h"
>  #include "exfat_fs.h"
> @@ -573,6 +574,98 @@ static int exfat_verify_boot_region(struct super_block *sb)
>         return 0;
>  }
>
> +static int exfat_get_volume_label_ptrs(struct super_block *sb,
> +                                      struct buffer_head **out_bh,
> +                                      struct exfat_dentry **out_dentry)
> +{
> +       int i;
> +       unsigned int type;
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       struct exfat_chain clu;
> +       struct exfat_dentry *ep;
> +       struct buffer_head *bh;
> +
> +       clu.dir = sbi->root_dir;
> +       clu.flags = ALLOC_FAT_CHAIN;
> +
> +       while (clu.dir != EXFAT_EOF_CLUSTER) {
> +               for (i = 0; i < sbi->dentries_per_clu; i++) {
> +                       ep = exfat_get_dentry(sb, &clu, i, &bh);
> +
> +                       if (!ep)
> +                               return -EIO;
> +
> +                       type = exfat_get_entry_type(ep);
> +                       if (type == TYPE_UNUSED) {
> +                               brelse(bh);
> +                               return -EIO;
> +                       }
> +
> +                       if (type == TYPE_VOLUME) {
> +                               *out_bh = bh;
> +                               *out_dentry = ep;
> +                               return 0;
> +                       }
> +
> +                       brelse(bh);
> +               }
> +
> +               if (exfat_get_next_cluster(sb, &(clu.dir)))
> +                       return -EIO;
> +       }
> +
> +       return -EIO;
> +}
> +
> +static int exfat_read_volume_label(struct super_block *sb)
> +{
> +       int ret, i;
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       struct buffer_head *bh;
> +       struct exfat_dentry *ep;
> +
> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
> +       if (ret < 0)
> +               goto cleanup;
> +
> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
> +               sbi->volume_label[i] = le16_to_cpu(ep->dentry.volume_label.volume_label[i]);
> +
> +cleanup:
> +       if (bh)
> +               brelse(bh);
> +
> +       return ret;
> +}
> +
> +int exfat_write_volume_label(struct super_block *sb)
> +{
> +       int ret, i;
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       struct buffer_head *bh;
> +       struct exfat_dentry *ep;
> +
> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
> +       if (ret < 0)
> +               goto cleanup;
> +
> +       mutex_lock(&sbi->s_lock);
> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
> +               ep->dentry.volume_label.volume_label[i] = cpu_to_le16(sbi->volume_label[i]);
> +
> +       ep->dentry.volume_label.char_count =
> +               UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
> +       mutex_unlock(&sbi->s_lock);
> +
> +cleanup:
> +       if (bh) {
> +               exfat_update_bh(bh, true);
> +               brelse(bh);
> +       }
> +
> +       return ret;
> +}
> +
>  /* mount the file system volume */
>  static int __exfat_fill_super(struct super_block *sb,
>                 struct exfat_chain *root_clu)
> @@ -616,6 +709,12 @@ static int __exfat_fill_super(struct super_block *sb,
>                 goto free_bh;
>         }
>
> +       ret = exfat_read_volume_label(sb);
It will affect mount time if volume label entry is located at the end.
So, we can read it in ioctl fslabel as I said above.
> +       if (ret) {
> +               exfat_err(sb, "failed to read volume label");
> +               goto free_bh;
> +       }
> +
>         ret = exfat_count_used_clusters(sb, &sbi->used_clusters);
>         if (ret) {
>                 exfat_err(sb, "failed to scan clusters");
> --
> 2.50.1
>

Re: [PATCH v2 1/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Yuezhang.Mo]

On Sun, Aug 17, 2025 at 9:31 AM Ethan Ferguson <ethan.ferguson@zetier.com> wrote:
> Add support for reading / writing to the exfat volume label from the
> FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls
> 
> Signed-off-by: Ethan Ferguson <ethan.ferguson@zetier.com>
> 
> ---
>  fs/exfat/exfat_fs.h  |  2 +
>  fs/exfat/exfat_raw.h |  6 +++
>  fs/exfat/file.c      | 56 +++++++++++++++++++++++++
>  fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 163 insertions(+)
> 
> diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h
> index f8ead4d47ef0..a764e6362172 100644
> --- a/fs/exfat/exfat_fs.h
> +++ b/fs/exfat/exfat_fs.h
> @@ -267,6 +267,7 @@ struct exfat_sb_info {
>         struct buffer_head **vol_amap; /* allocation bitmap */
> 
>         unsigned short *vol_utbl; /* upcase table */
> +       unsigned short volume_label[EXFAT_VOLUME_LABEL_LEN]; /* volume name */
> 
>         unsigned int clu_srch_ptr; /* cluster search pointer */
>         unsigned int used_clusters; /* number of used clusters */
> @@ -431,6 +432,7 @@ static inline loff_t exfat_ondisk_size(const struct inode *inode)
>  /* super.c */
>  int exfat_set_volume_dirty(struct super_block *sb);
>  int exfat_clear_volume_dirty(struct super_block *sb);
> +int exfat_write_volume_label(struct super_block *sb);
> 
>  /* fatent.c */
>  #define exfat_get_next_cluster(sb, pclu) exfat_ent_get(sb, *(pclu), pclu)
> diff --git a/fs/exfat/exfat_raw.h b/fs/exfat/exfat_raw.h
> index 971a1ccd0e89..af04cef81c0c 100644
> --- a/fs/exfat/exfat_raw.h
> +++ b/fs/exfat/exfat_raw.h
> @@ -80,6 +80,7 @@
>  #define BOOTSEC_OLDBPB_LEN             53
> 
>  #define EXFAT_FILE_NAME_LEN            15
> +#define EXFAT_VOLUME_LABEL_LEN         11
> 
>  #define EXFAT_MIN_SECT_SIZE_BITS               9
>  #define EXFAT_MAX_SECT_SIZE_BITS               12
> @@ -159,6 +160,11 @@ struct exfat_dentry {
>                         __le32 start_clu;
>                         __le64 size;
>                 } __packed upcase; /* up-case table directory entry */
> +               struct {
> +                       __u8 char_count;
> +                       __le16 volume_label[EXFAT_VOLUME_LABEL_LEN];
> +                       __u8 reserved[8];
> +               } __packed volume_label;
>                 struct {
>                         __u8 flags;
>                         __u8 vendor_guid[16];
> diff --git a/fs/exfat/file.c b/fs/exfat/file.c
> index 538d2b6ac2ec..c57d266aae3d 100644
> --- a/fs/exfat/file.c
> +++ b/fs/exfat/file.c
> @@ -12,6 +12,7 @@
>  #include <linux/security.h>
>  #include <linux/msdos_fs.h>
>  #include <linux/writeback.h>
> +#include "../nls/nls_ucs2_utils.h"
> 
>  #include "exfat_raw.h"
>  #include "exfat_fs.h"
> @@ -486,6 +487,57 @@ static int exfat_ioctl_shutdown(struct super_block *sb, unsigned long arg)
>         return exfat_force_shutdown(sb, flags);
>  }
> 
> +static int exfat_ioctl_get_volume_label(struct super_block *sb, unsigned long arg)
> +{
> +       int ret;
> +       char utf8[FSLABEL_MAX] = {0};
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       size_t len = UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
> +
> +       mutex_lock(&sbi->s_lock);
> +       ret = utf16s_to_utf8s(sbi->volume_label, len,
> +                               UTF16_HOST_ENDIAN, utf8, FSLABEL_MAX);

The iocharset specified by the mount option should be used instead of always using utf8.

> +       mutex_unlock(&sbi->s_lock);
> +
> +       if (ret < 0)
> +               return ret;
> +
> +       if (copy_to_user((char __user *)arg, utf8, FSLABEL_MAX))
> +               return -EFAULT;
> +
> +       return 0;
> +}
> +
> +static int exfat_ioctl_set_volume_label(struct super_block *sb, unsigned long arg)
> +{
> +       int ret = 0;
> +       char utf8[FSLABEL_MAX];
> +       size_t len;
> +       unsigned short utf16[EXFAT_VOLUME_LABEL_LEN] = {0};
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +
> +       if (!capable(CAP_SYS_ADMIN))
> +               return -EPERM;
> +
> +       if (copy_from_user(utf8, (char __user *)arg, FSLABEL_MAX))
> +               return -EFAULT;
> +
> +       len = strnlen(utf8, FSLABEL_MAX);
> +       if (len > EXFAT_VOLUME_LABEL_LEN)
> +               exfat_info(sb, "Volume label length too long, truncating");
> +
> +       mutex_lock(&sbi->s_lock);
> +       ret = utf8s_to_utf16s(utf8, len, UTF16_HOST_ENDIAN, utf16, EXFAT_VOLUME_LABEL_LEN);

If the new volume label contains invalid characters, an error should be returned.

Invalid characters are defined at
https://learn.microsoft.com/en-us/windows/win32/fileio/exfat-specification#table-35-invalid-filename-characters

> +       mutex_unlock(&sbi->s_lock);
> +
> +       if (ret < 0)
> +               return ret;
> +
> +       memcpy(sbi->volume_label, utf16, sizeof(sbi->volume_label));
> +
> +       return exfat_write_volume_label(sb);
> +}
> +
>  long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>  {
>         struct inode *inode = file_inode(filp);
> @@ -500,6 +552,10 @@ long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>                 return exfat_ioctl_shutdown(inode->i_sb, arg);
>         case FITRIM:
>                 return exfat_ioctl_fitrim(inode, arg);
> +       case FS_IOC_GETFSLABEL:
> +               return exfat_ioctl_get_volume_label(inode->i_sb, arg);
> +       case FS_IOC_SETFSLABEL:
> +               return exfat_ioctl_set_volume_label(inode->i_sb, arg);
>         default:
>                 return -ENOTTY;
>         }
> diff --git a/fs/exfat/super.c b/fs/exfat/super.c
> index 8926e63f5bb7..96cd4bb7cb19 100644
> --- a/fs/exfat/super.c
> +++ b/fs/exfat/super.c
> @@ -18,6 +18,7 @@
>  #include <linux/nls.h>
>  #include <linux/buffer_head.h>
>  #include <linux/magic.h>
> +#include "../nls/nls_ucs2_utils.h"
> 
>  #include "exfat_raw.h"
>  #include "exfat_fs.h"
> @@ -573,6 +574,98 @@ static int exfat_verify_boot_region(struct super_block *sb)
>         return 0;
>  }
> 
> +static int exfat_get_volume_label_ptrs(struct super_block *sb,
> +                                      struct buffer_head **out_bh,
> +                                      struct exfat_dentry **out_dentry)
> +{
> +       int i;
> +       unsigned int type;
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       struct exfat_chain clu;
> +       struct exfat_dentry *ep;
> +       struct buffer_head *bh;
> +
> +       clu.dir = sbi->root_dir;
> +       clu.flags = ALLOC_FAT_CHAIN;
> +
> +       while (clu.dir != EXFAT_EOF_CLUSTER) {
> +               for (i = 0; i < sbi->dentries_per_clu; i++) {
> +                       ep = exfat_get_dentry(sb, &clu, i, &bh);
> +
> +                       if (!ep)
> +                               return -EIO;
> +
> +                       type = exfat_get_entry_type(ep);
> +                       if (type == TYPE_UNUSED) {
> +                               brelse(bh);
> +                               return -EIO;
> +                       }
> +

When formatting a partition, exfatprogs's mkfs will create a label directory
entry regardless of whether the user specifies a label.
 
However, on Windows or when using other mkfs, no label directory entry
may be created. In this case, if we want to set a volume label, should we 
create it with an empty directory entry (TYPE_DELETED or TYPE_UNUSED)?
Should we even allocate a new cluster if there's no empty directory entry?

> +                       if (type == TYPE_VOLUME) {
> +                               *out_bh = bh;
> +                               *out_dentry = ep;
> +                               return 0;
> +                       }
> +
> +                       brelse(bh);
> +               }
> +
> +               if (exfat_get_next_cluster(sb, &(clu.dir)))
> +                       return -EIO;
> +       }
> +
> +       return -EIO;
> +}
> +
> +static int exfat_read_volume_label(struct super_block *sb)
> +{
> +       int ret, i;
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       struct buffer_head *bh;
> +       struct exfat_dentry *ep;
> +
> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
> +       if (ret < 0)
> +               goto cleanup;
> +
> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
> +               sbi->volume_label[i] = le16_to_cpu(ep->dentry.volume_label.volume_label[i]);
> +
> +cleanup:
> +       if (bh)
> +               brelse(bh);
> +
> +       return ret;
> +}
> +
> +int exfat_write_volume_label(struct super_block *sb)
> +{
> +       int ret, i;
> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> +       struct buffer_head *bh;
> +       struct exfat_dentry *ep;
> +
> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
> +       if (ret < 0)
> +               goto cleanup;
> +
> +       mutex_lock(&sbi->s_lock);
> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
> +               ep->dentry.volume_label.volume_label[i] = cpu_to_le16(sbi->volume_label[i]);
> +
> +       ep->dentry.volume_label.char_count =
> +               UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
> +       mutex_unlock(&sbi->s_lock);
> +
> +cleanup:
> +       if (bh) {
> +               exfat_update_bh(bh, true);
> +               brelse(bh);
> +       }
> +
> +       return ret;
> +}
> +
>  /* mount the file system volume */
>  static int __exfat_fill_super(struct super_block *sb,
>                 struct exfat_chain *root_clu)
> @@ -616,6 +709,12 @@ static int __exfat_fill_super(struct super_block *sb,
>                 goto free_bh;
>         }
> 
> +       ret = exfat_read_volume_label(sb);
> +       if (ret) {
> +               exfat_err(sb, "failed to read volume label");
> +               goto free_bh;
> +       }
> +
>         ret = exfat_count_used_clusters(sb, &sbi->used_clusters);
>         if (ret) {
>                 exfat_err(sb, "failed to scan clusters");
> --
> 2.50.1

Re: [PATCH v2 0/1] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Christoph Hellwig]

On Mon, Aug 18, 2025 at 01:49:11PM -0400, Ethan Ferguson wrote:
> That's fair. I took a look at how btrfs guards against this, it seems
> as if they use mnt_want_write_file to guard against bad writes, and
> only write to the in-memory superblock, and commit the transaction
> afterwards. However, this (during my testing with
> CONFIG_BLK_DEV_WRITE_MOUNTED both on and off) still results in an
> immediate disk flush.
> 
> My changes from this thread also seem to work with
> CONFIG_BLK_DEV_WRITE_MOUNTED both disabled and enabled.

What I meant to say is that we actually need your change to work with
CONFIG_BLK_DEV_WRITE_MOUNTED, as the current way in tunefs is broken,
even if that's something a few Linux file systems have historically
done.

> Maybe an alternative would be to only write to sbi->volume_label (with
> mutex guarding), and only flush to disk on exfat_put_super? And to use
> mnt_want_write_file as well.

I think your patch is fine as-is.  I've just been trying to give you
additional ammunition.

[PATCH] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Ethan Ferguson]

On 8/18/25 21:45, Namjae Jeon wrote:
> On Sun, Aug 17, 2025 at 9:31 AM Ethan Ferguson
> <ethan.ferguson@zetier.com> wrote:
>>
>> Add support for reading / writing to the exfat volume label from the
>> FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls
>>
>> Signed-off-by: Ethan Ferguson <ethan.ferguson@zetier.com>
>>
>> ---
>>  fs/exfat/exfat_fs.h  |  2 +
>>  fs/exfat/exfat_raw.h |  6 +++
>>  fs/exfat/file.c      | 56 +++++++++++++++++++++++++
>>  fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
>>  4 files changed, 163 insertions(+)
>>
>> diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h
>> index f8ead4d47ef0..a764e6362172 100644
>> --- a/fs/exfat/exfat_fs.h
>> +++ b/fs/exfat/exfat_fs.h
>> @@ -267,6 +267,7 @@ struct exfat_sb_info {
>>         struct buffer_head **vol_amap; /* allocation bitmap */
>>
>>         unsigned short *vol_utbl; /* upcase table */
>> +       unsigned short volume_label[EXFAT_VOLUME_LABEL_LEN]; /* volume name */
> There's no reason to have this in sbi. I think it's better to read the
> volume name in ioctl fslabel and return it.
>
That's fair. I wrote it this way because the volume label is stored in
the sbi in btrfs, but there it's (as far as I understand) part of the
fs header on disk, and not (as is the case in exfat) a directory entry
that could be arbitrarily far from the start of the disk. Maybe we could
cache it in the sbi after the first read? I'm open to either.

>>
>>         unsigned int clu_srch_ptr; /* cluster search pointer */
>>         unsigned int used_clusters; /* number of used clusters */
>> @@ -431,6 +432,7 @@ static inline loff_t exfat_ondisk_size(const struct inode *inode)
>>  /* super.c */
>>  int exfat_set_volume_dirty(struct super_block *sb);
>>  int exfat_clear_volume_dirty(struct super_block *sb);
>> +int exfat_write_volume_label(struct super_block *sb);
>>
>>  /* fatent.c */
>>  #define exfat_get_next_cluster(sb, pclu) exfat_ent_get(sb, *(pclu), pclu)
>> diff --git a/fs/exfat/exfat_raw.h b/fs/exfat/exfat_raw.h
>> index 971a1ccd0e89..af04cef81c0c 100644
>> --- a/fs/exfat/exfat_raw.h
>> +++ b/fs/exfat/exfat_raw.h
>> @@ -80,6 +80,7 @@
>>  #define BOOTSEC_OLDBPB_LEN             53
>>
>>  #define EXFAT_FILE_NAME_LEN            15
>> +#define EXFAT_VOLUME_LABEL_LEN         11
>>
>>  #define EXFAT_MIN_SECT_SIZE_BITS               9
>>  #define EXFAT_MAX_SECT_SIZE_BITS               12
>> @@ -159,6 +160,11 @@ struct exfat_dentry {
>>                         __le32 start_clu;
>>                         __le64 size;
>>                 } __packed upcase; /* up-case table directory entry */
>> +               struct {
>> +                       __u8 char_count;
>> +                       __le16 volume_label[EXFAT_VOLUME_LABEL_LEN];
>> +                       __u8 reserved[8];
>> +               } __packed volume_label;
>>                 struct {
>>                         __u8 flags;
>>                         __u8 vendor_guid[16];
>> diff --git a/fs/exfat/file.c b/fs/exfat/file.c
>> index 538d2b6ac2ec..c57d266aae3d 100644
>> --- a/fs/exfat/file.c
>> +++ b/fs/exfat/file.c
>> @@ -12,6 +12,7 @@
>>  #include <linux/security.h>
>>  #include <linux/msdos_fs.h>
>>  #include <linux/writeback.h>
>> +#include "../nls/nls_ucs2_utils.h"
>>
>>  #include "exfat_raw.h"
>>  #include "exfat_fs.h"
>> @@ -486,6 +487,57 @@ static int exfat_ioctl_shutdown(struct super_block *sb, unsigned long arg)
>>         return exfat_force_shutdown(sb, flags);
>>  }
>>
>> +static int exfat_ioctl_get_volume_label(struct super_block *sb, unsigned long arg)
>> +{
>> +       int ret;
>> +       char utf8[FSLABEL_MAX] = {0};
>> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
>> +       size_t len = UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
>> +
>> +       mutex_lock(&sbi->s_lock);
>> +       ret = utf16s_to_utf8s(sbi->volume_label, len,
>> +                               UTF16_HOST_ENDIAN, utf8, FSLABEL_MAX);
>> +       mutex_unlock(&sbi->s_lock);
>> +
>> +       if (ret < 0)
>> +               return ret;
>> +
>> +       if (copy_to_user((char __user *)arg, utf8, FSLABEL_MAX))
>> +               return -EFAULT;
>> +
>> +       return 0;
>> +}
>> +
>> +static int exfat_ioctl_set_volume_label(struct super_block *sb, unsigned long arg)
>> +{
>> +       int ret = 0;
>> +       char utf8[FSLABEL_MAX];
>> +       size_t len;
>> +       unsigned short utf16[EXFAT_VOLUME_LABEL_LEN] = {0};
>> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
>> +
>> +       if (!capable(CAP_SYS_ADMIN))
>> +               return -EPERM;
>> +
>> +       if (copy_from_user(utf8, (char __user *)arg, FSLABEL_MAX))
>> +               return -EFAULT;
>> +
>> +       len = strnlen(utf8, FSLABEL_MAX);
>> +       if (len > EXFAT_VOLUME_LABEL_LEN)
> Is FSLABEL_MAX in bytes or the number of characters ?
>
the definition mentions chars, and everywhere else it's used it's in
terms of chars, so I'd say it's in terms of bytes. The
FS_IOC_{GET,SET}FSLABEL ioctls are in terms of char[FSLABEL_MAX], so
I think it's reasonable to use it as a number of bytes.

>> +               exfat_info(sb, "Volume label length too long, truncating");
>> +
>> +       mutex_lock(&sbi->s_lock);
>> +       ret = utf8s_to_utf16s(utf8, len, UTF16_HOST_ENDIAN, utf16, EXFAT_VOLUME_LABEL_LEN);
>> +       mutex_unlock(&sbi->s_lock);
>> +
>> +       if (ret < 0)
>> +               return ret;
>> +
>> +       memcpy(sbi->volume_label, utf16, sizeof(sbi->volume_label));
>> +
>> +       return exfat_write_volume_label(sb);
>> +}
>> +
>>  long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>>  {
>>         struct inode *inode = file_inode(filp);
>> @@ -500,6 +552,10 @@ long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>>                 return exfat_ioctl_shutdown(inode->i_sb, arg);
>>         case FITRIM:
>>                 return exfat_ioctl_fitrim(inode, arg);
>> +       case FS_IOC_GETFSLABEL:
>> +               return exfat_ioctl_get_volume_label(inode->i_sb, arg);
>> +       case FS_IOC_SETFSLABEL:
>> +               return exfat_ioctl_set_volume_label(inode->i_sb, arg);
>>         default:
>>                 return -ENOTTY;
>>         }
>> diff --git a/fs/exfat/super.c b/fs/exfat/super.c
>> index 8926e63f5bb7..96cd4bb7cb19 100644
>> --- a/fs/exfat/super.c
>> +++ b/fs/exfat/super.c
>> @@ -18,6 +18,7 @@
>>  #include <linux/nls.h>
>>  #include <linux/buffer_head.h>
>>  #include <linux/magic.h>
>> +#include "../nls/nls_ucs2_utils.h"
>>
>>  #include "exfat_raw.h"
>>  #include "exfat_fs.h"
>> @@ -573,6 +574,98 @@ static int exfat_verify_boot_region(struct super_block *sb)
>>         return 0;
>>  }
>>
>> +static int exfat_get_volume_label_ptrs(struct super_block *sb,
>> +                                      struct buffer_head **out_bh,
>> +                                      struct exfat_dentry **out_dentry)
>> +{
>> +       int i;
>> +       unsigned int type;
>> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
>> +       struct exfat_chain clu;
>> +       struct exfat_dentry *ep;
>> +       struct buffer_head *bh;
>> +
>> +       clu.dir = sbi->root_dir;
>> +       clu.flags = ALLOC_FAT_CHAIN;
>> +
>> +       while (clu.dir != EXFAT_EOF_CLUSTER) {
>> +               for (i = 0; i < sbi->dentries_per_clu; i++) {
>> +                       ep = exfat_get_dentry(sb, &clu, i, &bh);
>> +
>> +                       if (!ep)
>> +                               return -EIO;
>> +
>> +                       type = exfat_get_entry_type(ep);
>> +                       if (type == TYPE_UNUSED) {
>> +                               brelse(bh);
>> +                               return -EIO;
>> +                       }
>> +
>> +                       if (type == TYPE_VOLUME) {
>> +                               *out_bh = bh;
>> +                               *out_dentry = ep;
>> +                               return 0;
>> +                       }
>> +
>> +                       brelse(bh);
>> +               }
>> +
>> +               if (exfat_get_next_cluster(sb, &(clu.dir)))
>> +                       return -EIO;
>> +       }
>> +
>> +       return -EIO;
>> +}
>> +
>> +static int exfat_read_volume_label(struct super_block *sb)
>> +{
>> +       int ret, i;
>> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
>> +       struct buffer_head *bh;
>> +       struct exfat_dentry *ep;
>> +
>> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
>> +       if (ret < 0)
>> +               goto cleanup;
>> +
>> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
>> +               sbi->volume_label[i] = le16_to_cpu(ep->dentry.volume_label.volume_label[i]);
>> +
>> +cleanup:
>> +       if (bh)
>> +               brelse(bh);
>> +
>> +       return ret;
>> +}
>> +
>> +int exfat_write_volume_label(struct super_block *sb)
>> +{
>> +       int ret, i;
>> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
>> +       struct buffer_head *bh;
>> +       struct exfat_dentry *ep;
>> +
>> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
>> +       if (ret < 0)
>> +               goto cleanup;
>> +
>> +       mutex_lock(&sbi->s_lock);
>> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
>> +               ep->dentry.volume_label.volume_label[i] = cpu_to_le16(sbi->volume_label[i]);
>> +
>> +       ep->dentry.volume_label.char_count =
>> +               UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
>> +       mutex_unlock(&sbi->s_lock);
>> +
>> +cleanup:
>> +       if (bh) {
>> +               exfat_update_bh(bh, true);
>> +               brelse(bh);
>> +       }
>> +
>> +       return ret;
>> +}
>> +
>>  /* mount the file system volume */
>>  static int __exfat_fill_super(struct super_block *sb,
>>                 struct exfat_chain *root_clu)
>> @@ -616,6 +709,12 @@ static int __exfat_fill_super(struct super_block *sb,
>>                 goto free_bh;
>>         }
>>
>> +       ret = exfat_read_volume_label(sb);
> It will affect mount time if volume label entry is located at the end.
> So, we can read it in ioctl fslabel as I said above.
Sounds good. I'll incorporate your changes, and those of
yuezhang.mo@sony.com, and submit version 3 of the patch soon.

>> +       if (ret) {
>> +               exfat_err(sb, "failed to read volume label");
>> +               goto free_bh;
>> +       }
>> +
>>         ret = exfat_count_used_clusters(sb, &sbi->used_clusters);
>>         if (ret) {
>>                 exfat_err(sb, "failed to scan clusters");
>> --
>> 2.50.1
>>

Re: [PATCH] exfat: Add support for FS_IOC_{GET,SET}FSLABEL

[Namjae Jeon]

On Tue, Aug 19, 2025 at 10:22 PM Ethan Ferguson
<ethan.ferguson@zetier.com> wrote:
>
> On 8/18/25 21:45, Namjae Jeon wrote:
> > On Sun, Aug 17, 2025 at 9:31 AM Ethan Ferguson
> > <ethan.ferguson@zetier.com> wrote:
> >>
> >> Add support for reading / writing to the exfat volume label from the
> >> FS_IOC_GETFSLABEL and FS_IOC_SETFSLABEL ioctls
> >>
> >> Signed-off-by: Ethan Ferguson <ethan.ferguson@zetier.com>
> >>
> >> ---
> >>  fs/exfat/exfat_fs.h  |  2 +
> >>  fs/exfat/exfat_raw.h |  6 +++
> >>  fs/exfat/file.c      | 56 +++++++++++++++++++++++++
> >>  fs/exfat/super.c     | 99 ++++++++++++++++++++++++++++++++++++++++++++
> >>  4 files changed, 163 insertions(+)
> >>
> >> diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h
> >> index f8ead4d47ef0..a764e6362172 100644
> >> --- a/fs/exfat/exfat_fs.h
> >> +++ b/fs/exfat/exfat_fs.h
> >> @@ -267,6 +267,7 @@ struct exfat_sb_info {
> >>         struct buffer_head **vol_amap; /* allocation bitmap */
> >>
> >>         unsigned short *vol_utbl; /* upcase table */
> >> +       unsigned short volume_label[EXFAT_VOLUME_LABEL_LEN]; /* volume name */
> > There's no reason to have this in sbi. I think it's better to read the
> > volume name in ioctl fslabel and return it.
> >
> That's fair. I wrote it this way because the volume label is stored in
> the sbi in btrfs, but there it's (as far as I understand) part of the
> fs header on disk, and not (as is the case in exfat) a directory entry
> that could be arbitrarily far from the start of the disk. Maybe we could
> cache it in the sbi after the first read? I'm open to either.
I agree to cache it in sbi after the first read.
>
> >>
> >>         unsigned int clu_srch_ptr; /* cluster search pointer */
> >>         unsigned int used_clusters; /* number of used clusters */
> >> @@ -431,6 +432,7 @@ static inline loff_t exfat_ondisk_size(const struct inode *inode)
> >>  /* super.c */
> >>  int exfat_set_volume_dirty(struct super_block *sb);
> >>  int exfat_clear_volume_dirty(struct super_block *sb);
> >> +int exfat_write_volume_label(struct super_block *sb);
> >>
> >>  /* fatent.c */
> >>  #define exfat_get_next_cluster(sb, pclu) exfat_ent_get(sb, *(pclu), pclu)
> >> diff --git a/fs/exfat/exfat_raw.h b/fs/exfat/exfat_raw.h
> >> index 971a1ccd0e89..af04cef81c0c 100644
> >> --- a/fs/exfat/exfat_raw.h
> >> +++ b/fs/exfat/exfat_raw.h
> >> @@ -80,6 +80,7 @@
> >>  #define BOOTSEC_OLDBPB_LEN             53
> >>
> >>  #define EXFAT_FILE_NAME_LEN            15
> >> +#define EXFAT_VOLUME_LABEL_LEN         11
> >>
> >>  #define EXFAT_MIN_SECT_SIZE_BITS               9
> >>  #define EXFAT_MAX_SECT_SIZE_BITS               12
> >> @@ -159,6 +160,11 @@ struct exfat_dentry {
> >>                         __le32 start_clu;
> >>                         __le64 size;
> >>                 } __packed upcase; /* up-case table directory entry */
> >> +               struct {
> >> +                       __u8 char_count;
> >> +                       __le16 volume_label[EXFAT_VOLUME_LABEL_LEN];
> >> +                       __u8 reserved[8];
> >> +               } __packed volume_label;
> >>                 struct {
> >>                         __u8 flags;
> >>                         __u8 vendor_guid[16];
> >> diff --git a/fs/exfat/file.c b/fs/exfat/file.c
> >> index 538d2b6ac2ec..c57d266aae3d 100644
> >> --- a/fs/exfat/file.c
> >> +++ b/fs/exfat/file.c
> >> @@ -12,6 +12,7 @@
> >>  #include <linux/security.h>
> >>  #include <linux/msdos_fs.h>
> >>  #include <linux/writeback.h>
> >> +#include "../nls/nls_ucs2_utils.h"
> >>
> >>  #include "exfat_raw.h"
> >>  #include "exfat_fs.h"
> >> @@ -486,6 +487,57 @@ static int exfat_ioctl_shutdown(struct super_block *sb, unsigned long arg)
> >>         return exfat_force_shutdown(sb, flags);
> >>  }
> >>
> >> +static int exfat_ioctl_get_volume_label(struct super_block *sb, unsigned long arg)
> >> +{
> >> +       int ret;
> >> +       char utf8[FSLABEL_MAX] = {0};
> >> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> >> +       size_t len = UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
> >> +
> >> +       mutex_lock(&sbi->s_lock);
> >> +       ret = utf16s_to_utf8s(sbi->volume_label, len,
> >> +                               UTF16_HOST_ENDIAN, utf8, FSLABEL_MAX);
> >> +       mutex_unlock(&sbi->s_lock);
> >> +
> >> +       if (ret < 0)
> >> +               return ret;
> >> +
> >> +       if (copy_to_user((char __user *)arg, utf8, FSLABEL_MAX))
> >> +               return -EFAULT;
> >> +
> >> +       return 0;
> >> +}
> >> +
> >> +static int exfat_ioctl_set_volume_label(struct super_block *sb, unsigned long arg)
> >> +{
> >> +       int ret = 0;
> >> +       char utf8[FSLABEL_MAX];
> >> +       size_t len;
> >> +       unsigned short utf16[EXFAT_VOLUME_LABEL_LEN] = {0};
> >> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> >> +
> >> +       if (!capable(CAP_SYS_ADMIN))
> >> +               return -EPERM;
> >> +
> >> +       if (copy_from_user(utf8, (char __user *)arg, FSLABEL_MAX))
> >> +               return -EFAULT;
> >> +
> >> +       len = strnlen(utf8, FSLABEL_MAX);
> >> +       if (len > EXFAT_VOLUME_LABEL_LEN)
> > Is FSLABEL_MAX in bytes or the number of characters ?
> >
> the definition mentions chars, and everywhere else it's used it's in
> terms of chars, so I'd say it's in terms of bytes. The
> FS_IOC_{GET,SET}FSLABEL ioctls are in terms of char[FSLABEL_MAX], so
> I think it's reasonable to use it as a number of bytes.
Okay.
>
> >> +               exfat_info(sb, "Volume label length too long, truncating");
> >> +
> >> +       mutex_lock(&sbi->s_lock);
> >> +       ret = utf8s_to_utf16s(utf8, len, UTF16_HOST_ENDIAN, utf16, EXFAT_VOLUME_LABEL_LEN);
> >> +       mutex_unlock(&sbi->s_lock);
> >> +
> >> +       if (ret < 0)
> >> +               return ret;
> >> +
> >> +       memcpy(sbi->volume_label, utf16, sizeof(sbi->volume_label));
> >> +
> >> +       return exfat_write_volume_label(sb);
> >> +}
> >> +
> >>  long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
> >>  {
> >>         struct inode *inode = file_inode(filp);
> >> @@ -500,6 +552,10 @@ long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
> >>                 return exfat_ioctl_shutdown(inode->i_sb, arg);
> >>         case FITRIM:
> >>                 return exfat_ioctl_fitrim(inode, arg);
> >> +       case FS_IOC_GETFSLABEL:
> >> +               return exfat_ioctl_get_volume_label(inode->i_sb, arg);
> >> +       case FS_IOC_SETFSLABEL:
> >> +               return exfat_ioctl_set_volume_label(inode->i_sb, arg);
> >>         default:
> >>                 return -ENOTTY;
> >>         }
> >> diff --git a/fs/exfat/super.c b/fs/exfat/super.c
> >> index 8926e63f5bb7..96cd4bb7cb19 100644
> >> --- a/fs/exfat/super.c
> >> +++ b/fs/exfat/super.c
> >> @@ -18,6 +18,7 @@
> >>  #include <linux/nls.h>
> >>  #include <linux/buffer_head.h>
> >>  #include <linux/magic.h>
> >> +#include "../nls/nls_ucs2_utils.h"
> >>
> >>  #include "exfat_raw.h"
> >>  #include "exfat_fs.h"
> >> @@ -573,6 +574,98 @@ static int exfat_verify_boot_region(struct super_block *sb)
> >>         return 0;
> >>  }
> >>
> >> +static int exfat_get_volume_label_ptrs(struct super_block *sb,
> >> +                                      struct buffer_head **out_bh,
> >> +                                      struct exfat_dentry **out_dentry)
> >> +{
> >> +       int i;
> >> +       unsigned int type;
> >> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> >> +       struct exfat_chain clu;
> >> +       struct exfat_dentry *ep;
> >> +       struct buffer_head *bh;
> >> +
> >> +       clu.dir = sbi->root_dir;
> >> +       clu.flags = ALLOC_FAT_CHAIN;
> >> +
> >> +       while (clu.dir != EXFAT_EOF_CLUSTER) {
> >> +               for (i = 0; i < sbi->dentries_per_clu; i++) {
> >> +                       ep = exfat_get_dentry(sb, &clu, i, &bh);
> >> +
> >> +                       if (!ep)
> >> +                               return -EIO;
> >> +
> >> +                       type = exfat_get_entry_type(ep);
> >> +                       if (type == TYPE_UNUSED) {
> >> +                               brelse(bh);
> >> +                               return -EIO;
> >> +                       }
> >> +
> >> +                       if (type == TYPE_VOLUME) {
> >> +                               *out_bh = bh;
> >> +                               *out_dentry = ep;
> >> +                               return 0;
> >> +                       }
> >> +
> >> +                       brelse(bh);
> >> +               }
> >> +
> >> +               if (exfat_get_next_cluster(sb, &(clu.dir)))
> >> +                       return -EIO;
> >> +       }
> >> +
> >> +       return -EIO;
> >> +}
> >> +
> >> +static int exfat_read_volume_label(struct super_block *sb)
> >> +{
> >> +       int ret, i;
> >> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> >> +       struct buffer_head *bh;
> >> +       struct exfat_dentry *ep;
> >> +
> >> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
> >> +       if (ret < 0)
> >> +               goto cleanup;
> >> +
> >> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
> >> +               sbi->volume_label[i] = le16_to_cpu(ep->dentry.volume_label.volume_label[i]);
> >> +
> >> +cleanup:
> >> +       if (bh)
> >> +               brelse(bh);
> >> +
> >> +       return ret;
> >> +}
> >> +
> >> +int exfat_write_volume_label(struct super_block *sb)
> >> +{
> >> +       int ret, i;
> >> +       struct exfat_sb_info *sbi = EXFAT_SB(sb);
> >> +       struct buffer_head *bh;
> >> +       struct exfat_dentry *ep;
> >> +
> >> +       ret = exfat_get_volume_label_ptrs(sb, &bh, &ep);
> >> +       if (ret < 0)
> >> +               goto cleanup;
> >> +
> >> +       mutex_lock(&sbi->s_lock);
> >> +       for (i = 0; i < EXFAT_VOLUME_LABEL_LEN; i++)
> >> +               ep->dentry.volume_label.volume_label[i] = cpu_to_le16(sbi->volume_label[i]);
> >> +
> >> +       ep->dentry.volume_label.char_count =
> >> +               UniStrnlen(sbi->volume_label, EXFAT_VOLUME_LABEL_LEN);
> >> +       mutex_unlock(&sbi->s_lock);
> >> +
> >> +cleanup:
> >> +       if (bh) {
> >> +               exfat_update_bh(bh, true);
> >> +               brelse(bh);
> >> +       }
> >> +
> >> +       return ret;
> >> +}
> >> +
> >>  /* mount the file system volume */
> >>  static int __exfat_fill_super(struct super_block *sb,
> >>                 struct exfat_chain *root_clu)
> >> @@ -616,6 +709,12 @@ static int __exfat_fill_super(struct super_block *sb,
> >>                 goto free_bh;
> >>         }
> >>
> >> +       ret = exfat_read_volume_label(sb);
> > It will affect mount time if volume label entry is located at the end.
> > So, we can read it in ioctl fslabel as I said above.
> Sounds good. I'll incorporate your changes, and those of
> yuezhang.mo@sony.com, and submit version 3 of the patch soon.
As Yuezhang pointed out, You need to consider the case where there
is no volume label entry. Some mkfs implementations, though not
Windows, don't create a volume entry. So, if FS_IOC_SETFSLABEL
doesn't find a volume label entry, it should either look for an empty entry,
or, if that's not available, allocate a cluster to get a entry.

Thanks for your work!
>
> >> +       if (ret) {
> >> +               exfat_err(sb, "failed to read volume label");
> >> +               goto free_bh;
> >> +       }
> >> +
> >>         ret = exfat_count_used_clusters(sb, &sbi->used_clusters);
> >>         if (ret) {
> >>                 exfat_err(sb, "failed to scan clusters");
> >> --
> >> 2.50.1
> >>