Commit d01579d5 authored by Ethan Ferguson's avatar Ethan Ferguson Committed by Namjae Jeon
Browse files

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



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

Co-developed-by: default avatarYuezhang Mo <Yuezhang.Mo@sony.com>
Signed-off-by: default avatarYuezhang Mo <Yuezhang.Mo@sony.com>
Signed-off-by: default avatarEthan Ferguson <ethan.ferguson@zetier.com>
Reviewed-by: default avatarSungjong Seo <sj1557.seo@samsung.com>
Signed-off-by: default avatarNamjae Jeon <linkinjeon@kernel.org>
parent 29c06365

fs/exfat/dir.c

+160 −0
Original line number Diff line number Diff line
@@ -1244,3 +1244,163 @@ int exfat_count_dir_entries(struct super_block *sb, struct exfat_chain *p_dir) 


	return count;

}



static int exfat_get_volume_label_dentry(struct super_block *sb,

		struct exfat_entry_set_cache *es)

{

	int i;

	int dentry = 0;

	unsigned int type;

	struct exfat_sb_info *sbi = EXFAT_SB(sb);

	struct exfat_hint_femp hint_femp;

	struct exfat_inode_info *ei = EXFAT_I(sb->s_root->d_inode);

	struct exfat_chain clu;

	struct exfat_dentry *ep;

	struct buffer_head *bh;



	hint_femp.eidx = EXFAT_HINT_NONE;

	exfat_chain_set(&clu, sbi->root_dir, 0, ALLOC_FAT_CHAIN);



	while (clu.dir != EXFAT_EOF_CLUSTER) {

		for (i = 0; i < sbi->dentries_per_clu; i++, dentry++) {

			ep = exfat_get_dentry(sb, &clu, i, &bh);

			if (!ep)

				return -EIO;



			type = exfat_get_entry_type(ep);

			if (hint_femp.eidx == EXFAT_HINT_NONE) {

				if (type == TYPE_DELETED || type == TYPE_UNUSED) {

					hint_femp.cur = clu;

					hint_femp.eidx = dentry;

					hint_femp.count = 1;

				}

			}



			if (type == TYPE_UNUSED) {

				brelse(bh);

				goto not_found;

			}



			if (type != TYPE_VOLUME) {

				brelse(bh);

				continue;

			}



			memset(es, 0, sizeof(*es));

			es->sb = sb;

			es->bh = es->__bh;

			es->bh[0] = bh;

			es->num_bh = 1;

			es->start_off = EXFAT_DEN_TO_B(i) % sb->s_blocksize;



			return 0;

		}



		if (exfat_get_next_cluster(sb, &(clu.dir)))

			return -EIO;

	}



not_found:

	if (hint_femp.eidx == EXFAT_HINT_NONE) {

		hint_femp.cur.dir = EXFAT_EOF_CLUSTER;

		hint_femp.eidx = dentry;

		hint_femp.count = 0;

	}



	ei->hint_femp = hint_femp;



	return -ENOENT;

}



int exfat_read_volume_label(struct super_block *sb, struct exfat_uni_name *label_out)

{

	int ret, i;

	struct exfat_sb_info *sbi = EXFAT_SB(sb);

	struct exfat_entry_set_cache es;

	struct exfat_dentry *ep;



	mutex_lock(&sbi->s_lock);



	memset(label_out, 0, sizeof(*label_out));

	ret = exfat_get_volume_label_dentry(sb, &es);

	if (ret < 0) {

		/*

		 * ENOENT signifies that a volume label dentry doesn't exist

		 * We will treat this as an empty volume label and not fail.

		 */

		if (ret == -ENOENT)

			ret = 0;



		goto unlock;

	}



	ep = exfat_get_dentry_cached(&es, 0);

	label_out->name_len = ep->dentry.volume_label.char_count;

	if (label_out->name_len > EXFAT_VOLUME_LABEL_LEN) {

		ret = -EIO;

		exfat_put_dentry_set(&es, false);

		goto unlock;

	}



	for (i = 0; i < label_out->name_len; i++)

		label_out->name[i] = le16_to_cpu(ep->dentry.volume_label.volume_label[i]);



	exfat_put_dentry_set(&es, false);

unlock:

	mutex_unlock(&sbi->s_lock);

	return ret;

}



int exfat_write_volume_label(struct super_block *sb,

			     struct exfat_uni_name *label)

{

	int ret, i;

	struct exfat_sb_info *sbi = EXFAT_SB(sb);

	struct inode *root_inode = sb->s_root->d_inode;

	struct exfat_entry_set_cache es;

	struct exfat_chain clu;

	struct exfat_dentry *ep;



	if (label->name_len > EXFAT_VOLUME_LABEL_LEN)

		return -EINVAL;



	mutex_lock(&sbi->s_lock);



	ret = exfat_get_volume_label_dentry(sb, &es);

	if (ret == -ENOENT) {

		if (label->name_len == 0) {

			/* No volume label dentry, no need to clear */

			ret = 0;

			goto unlock;

		}



		ret = exfat_find_empty_entry(root_inode, &clu, 1, &es);

	}



	if (ret < 0)

		goto unlock;



	ep = exfat_get_dentry_cached(&es, 0);



	if (label->name_len == 0 && ep->dentry.volume_label.char_count == 0) {

		/* volume label had been cleared */

		exfat_put_dentry_set(&es, 0);

		goto unlock;

	}



	memset(ep, 0, sizeof(*ep));

	ep->type = EXFAT_VOLUME;



	for (i = 0; i < label->name_len; i++)

		ep->dentry.volume_label.volume_label[i] =

			cpu_to_le16(label->name[i]);



	ep->dentry.volume_label.char_count = label->name_len;

	es.modified = true;



	ret = exfat_put_dentry_set(&es, IS_DIRSYNC(root_inode));



unlock:

	mutex_unlock(&sbi->s_lock);

	return ret;

}

fs/exfat/exfat_fs.h

+7 −0
Original line number Diff line number Diff line
@@ -477,6 +477,9 @@ int exfat_force_shutdown(struct super_block *sb, u32 flags); 
/* namei.c */

extern const struct dentry_operations exfat_dentry_ops;

extern const struct dentry_operations exfat_utf8_dentry_ops;

int exfat_find_empty_entry(struct inode *inode,

		struct exfat_chain *p_dir, int num_entries,

			   struct exfat_entry_set_cache *es);



/* cache.c */

int exfat_cache_init(void);
@@ -517,6 +520,10 @@ int exfat_get_empty_dentry_set(struct exfat_entry_set_cache *es, 
		unsigned int num_entries);

int exfat_put_dentry_set(struct exfat_entry_set_cache *es, int sync);

int exfat_count_dir_entries(struct super_block *sb, struct exfat_chain *p_dir);

int exfat_read_volume_label(struct super_block *sb,

			    struct exfat_uni_name *label_out);

int exfat_write_volume_label(struct super_block *sb,

			     struct exfat_uni_name *label);



/* inode.c */

extern const struct inode_operations exfat_file_inode_operations;

fs/exfat/exfat_raw.h

+6 −0
Original line number Diff line number Diff line
@@ -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; /* volume label directory entry */

		struct {

			__u8 flags;

			__u8 vendor_guid[16];

fs/exfat/file.c

+52 −0
Original line number Diff line number Diff line
@@ -486,6 +486,54 @@ 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 label[FSLABEL_MAX] = {0};

	struct exfat_uni_name uniname;



	ret = exfat_read_volume_label(sb, &uniname);

	if (ret < 0)

		return ret;



	ret = exfat_utf16_to_nls(sb, &uniname, label, uniname.name_len);

	if (ret < 0)

		return ret;



	if (copy_to_user((char __user *)arg, label, ret + 1))

		return -EFAULT;



	return 0;

}



static int exfat_ioctl_set_volume_label(struct super_block *sb,

					unsigned long arg)

{

	int ret = 0, lossy;

	char label[FSLABEL_MAX];

	struct exfat_uni_name uniname;



	if (!capable(CAP_SYS_ADMIN))

		return -EPERM;



	if (copy_from_user(label, (char __user *)arg, FSLABEL_MAX))

		return -EFAULT;



	memset(&uniname, 0, sizeof(uniname));

	if (label[0]) {

		ret = exfat_nls_to_utf16(sb, label, FSLABEL_MAX,

					 &uniname, &lossy);

		if (ret < 0)

			return ret;

		else if (lossy & NLS_NAME_LOSSY)

			return -EINVAL;

	}



	uniname.name_len = ret;



	return exfat_write_volume_label(sb, &uniname);

}



long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

	struct inode *inode = file_inode(filp);
@@ -500,6 +548,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;

	}

fs/exfat/namei.c

+1 −1
Original line number Diff line number Diff line
@@ -300,7 +300,7 @@ static int exfat_check_max_dentries(struct inode *inode) 
 *   the directory entry index in p_dir is returned on succeeds

 *   -error code is returned on failure

 */

static int exfat_find_empty_entry(struct inode *inode,

int exfat_find_empty_entry(struct inode *inode,

		struct exfat_chain *p_dir, int num_entries,

		struct exfat_entry_set_cache *es)

{