Merge "exfat: add super block operations" (b8bfad92) · Commits · e / devices / android_kernel_fairphone_FP5

fs/exfat/fatent.c

0 → 100644

+463 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/*
		* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
		*/

		#include <linux/slab.h>
		#include <asm/unaligned.h>
		#include <linux/buffer_head.h>

		#include "exfat_raw.h"
		#include "exfat_fs.h"

		static int exfat_mirror_bh(struct super_block *sb, sector_t sec,
		struct buffer_head *bh)
		{
		struct buffer_head *c_bh;
		struct exfat_sb_info *sbi = EXFAT_SB(sb);
		sector_t sec2;
		int err = 0;

		if (sbi->FAT2_start_sector != sbi->FAT1_start_sector) {
		sec2 = sec - sbi->FAT1_start_sector + sbi->FAT2_start_sector;
		c_bh = sb_getblk(sb, sec2);
		if (!c_bh)
		return -ENOMEM;
		memcpy(c_bh->b_data, bh->b_data, sb->s_blocksize);
		set_buffer_uptodate(c_bh);
		mark_buffer_dirty(c_bh);
		if (sb->s_flags & SB_SYNCHRONOUS)
		err = sync_dirty_buffer(c_bh);
		brelse(c_bh);
		}

		return err;
		}

		static int __exfat_ent_get(struct super_block *sb, unsigned int loc,
		unsigned int *content)
		{
		unsigned int off;
		sector_t sec;
		struct buffer_head *bh;

		sec = FAT_ENT_OFFSET_SECTOR(sb, loc);
		off = FAT_ENT_OFFSET_BYTE_IN_SECTOR(sb, loc);

		bh = sb_bread(sb, sec);
		if (!bh)
		return -EIO;

		content = le32_to_cpu((__le32 *)(&bh->b_data[off]));

		/* remap reserved clusters to simplify code */
		if (*content > EXFAT_BAD_CLUSTER)
		*content = EXFAT_EOF_CLUSTER;

		brelse(bh);
		return 0;
		}

		int exfat_ent_set(struct super_block *sb, unsigned int loc,
		unsigned int content)
		{
		unsigned int off;
		sector_t sec;
		__le32 *fat_entry;
		struct buffer_head *bh;

		sec = FAT_ENT_OFFSET_SECTOR(sb, loc);
		off = FAT_ENT_OFFSET_BYTE_IN_SECTOR(sb, loc);

		bh = sb_bread(sb, sec);
		if (!bh)
		return -EIO;

		fat_entry = (__le32 *)&(bh->b_data[off]);
		*fat_entry = cpu_to_le32(content);
		exfat_update_bh(sb, bh, sb->s_flags & SB_SYNCHRONOUS);
		exfat_mirror_bh(sb, sec, bh);
		brelse(bh);
		return 0;
		}

		static inline bool is_valid_cluster(struct exfat_sb_info *sbi,
		unsigned int clus)
		{
		if (clus < EXFAT_FIRST_CLUSTER \|\| sbi->num_clusters <= clus)
		return false;
		return true;
		}

		int exfat_ent_get(struct super_block *sb, unsigned int loc,
		unsigned int *content)
		{
		struct exfat_sb_info *sbi = EXFAT_SB(sb);
		int err;

		if (!is_valid_cluster(sbi, loc)) {
		exfat_fs_error(sb, "invalid access to FAT (entry 0x%08x)",
		loc);
		return -EIO;
		}

		err = __exfat_ent_get(sb, loc, content);
		if (err) {
		exfat_fs_error(sb,
		"failed to access to FAT (entry 0x%08x, err:%d)",
		loc, err);
		return err;
		}

		if (*content == EXFAT_FREE_CLUSTER) {
		exfat_fs_error(sb,
		"invalid access to FAT free cluster (entry 0x%08x)",
		loc);
		return -EIO;
		}

		if (*content == EXFAT_BAD_CLUSTER) {
		exfat_fs_error(sb,
		"invalid access to FAT bad cluster (entry 0x%08x)",
		loc);
		return -EIO;
		}

		if (content != EXFAT_EOF_CLUSTER && !is_valid_cluster(sbi, content)) {
		exfat_fs_error(sb,
		"invalid access to FAT (entry 0x%08x) bogus content (0x%08x)",
		loc, *content);
		return -EIO;
		}

		return 0;
		}

		int exfat_chain_cont_cluster(struct super_block *sb, unsigned int chain,
		unsigned int len)
		{
		if (!len)
		return 0;

		while (len > 1) {
		if (exfat_ent_set(sb, chain, chain + 1))
		return -EIO;
		chain++;
		len--;
		}

		if (exfat_ent_set(sb, chain, EXFAT_EOF_CLUSTER))
		return -EIO;
		return 0;
		}

		int exfat_free_cluster(struct inode inode, struct exfat_chain p_chain)
		{
		unsigned int num_clusters = 0;
		unsigned int clu;
		struct super_block *sb = inode->i_sb;
		struct exfat_sb_info *sbi = EXFAT_SB(sb);

		/* invalid cluster number */
		if (p_chain->dir == EXFAT_FREE_CLUSTER \|\|
		p_chain->dir == EXFAT_EOF_CLUSTER \|\|
		p_chain->dir < EXFAT_FIRST_CLUSTER)
		return 0;

		/* no cluster to truncate */
		if (p_chain->size == 0)
		return 0;

		/* check cluster validation */
		if (p_chain->dir < 2 && p_chain->dir >= sbi->num_clusters) {
		exfat_msg(sb, KERN_ERR, "invalid start cluster (%u)",
		p_chain->dir);
		return -EIO;
		}

		set_bit(EXFAT_SB_DIRTY, &sbi->s_state);
		clu = p_chain->dir;

		if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
		do {
		exfat_clear_bitmap(inode, clu);
		clu++;

		num_clusters++;
		} while (num_clusters < p_chain->size);
		} else {
		do {
		exfat_clear_bitmap(inode, clu);

		if (exfat_get_next_cluster(sb, &clu))
		goto dec_used_clus;

		num_clusters++;
		} while (clu != EXFAT_EOF_CLUSTER);
		}

		dec_used_clus:
		sbi->used_clusters -= num_clusters;
		return 0;
		}

		int exfat_find_last_cluster(struct super_block sb, struct exfat_chain p_chain,
		unsigned int *ret_clu)
		{
		unsigned int clu, next;
		unsigned int count = 0;

		next = p_chain->dir;
		if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
		*ret_clu = next + p_chain->size - 1;
		return 0;
		}

		do {
		count++;
		clu = next;
		if (exfat_ent_get(sb, clu, &next))
		return -EIO;
		} while (next != EXFAT_EOF_CLUSTER);

		if (p_chain->size != count) {
		exfat_fs_error(sb,
		"bogus directory size (clus : ondisk(%d) != counted(%d))",
		p_chain->size, count);
		return -EIO;
		}

		*ret_clu = clu;
		return 0;
		}

		static inline int exfat_sync_bhs(struct buffer_head **bhs, int nr_bhs)
		{
		int i, err = 0;

		for (i = 0; i < nr_bhs; i++)
		write_dirty_buffer(bhs[i], 0);

		for (i = 0; i < nr_bhs; i++) {
		wait_on_buffer(bhs[i]);
		if (!err && !buffer_uptodate(bhs[i]))
		err = -EIO;
		}
		return err;
		}

		int exfat_zeroed_cluster(struct inode *dir, unsigned int clu)
		{
		struct super_block *sb = dir->i_sb;
		struct exfat_sb_info *sbi = EXFAT_SB(sb);
		struct buffer_head *bhs[MAX_BUF_PER_PAGE];
		int nr_bhs = MAX_BUF_PER_PAGE;
		sector_t blknr, last_blknr;
		int err, i, n;

		blknr = exfat_cluster_to_sector(sbi, clu);
		last_blknr = blknr + sbi->sect_per_clus;

		if (last_blknr > sbi->num_sectors && sbi->num_sectors > 0) {
		exfat_fs_error_ratelimit(sb,
		"%s: out of range(sect:%llu len:%u)",
		__func__, (unsigned long long)blknr,
		sbi->sect_per_clus);
		return -EIO;
		}

		/* Zeroing the unused blocks on this cluster */
		n = 0;
		while (blknr < last_blknr) {
		bhs[n] = sb_getblk(sb, blknr);
		if (!bhs[n]) {
		err = -ENOMEM;
		goto release_bhs;
		}
		memset(bhs[n]->b_data, 0, sb->s_blocksize);
		exfat_update_bh(sb, bhs[n], 0);

		n++;
		blknr++;

		if (n == nr_bhs) {
		if (IS_DIRSYNC(dir)) {
		err = exfat_sync_bhs(bhs, n);
		if (err)
		goto release_bhs;
		}

		for (i = 0; i < n; i++)
		brelse(bhs[i]);
		n = 0;
		}
		}

		if (IS_DIRSYNC(dir)) {
		err = exfat_sync_bhs(bhs, n);
		if (err)
		goto release_bhs;
		}

		for (i = 0; i < n; i++)
		brelse(bhs[i]);

		return 0;

		release_bhs:
		exfat_msg(sb, KERN_ERR, "failed zeroed sect %llu\n",
		(unsigned long long)blknr);
		for (i = 0; i < n; i++)
		bforget(bhs[i]);
		return err;
		}

		int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
		struct exfat_chain *p_chain)
		{
		int ret = -ENOSPC;
		unsigned int num_clusters = 0, total_cnt;
		unsigned int hint_clu, new_clu, last_clu = EXFAT_EOF_CLUSTER;
		struct super_block *sb = inode->i_sb;
		struct exfat_sb_info *sbi = EXFAT_SB(sb);

		total_cnt = EXFAT_DATA_CLUSTER_COUNT(sbi);

		if (unlikely(total_cnt < sbi->used_clusters)) {
		exfat_fs_error_ratelimit(sb,
		"%s: invalid used clusters(t:%u,u:%u)\n",
		__func__, total_cnt, sbi->used_clusters);
		return -EIO;
		}

		if (num_alloc > total_cnt - sbi->used_clusters)
		return -ENOSPC;

		hint_clu = p_chain->dir;
		/* find new cluster */
		if (hint_clu == EXFAT_EOF_CLUSTER) {
		if (sbi->clu_srch_ptr < EXFAT_FIRST_CLUSTER) {
		exfat_msg(sb, KERN_ERR,
		"sbi->clu_srch_ptr is invalid (%u)\n",
		sbi->clu_srch_ptr);
		sbi->clu_srch_ptr = EXFAT_FIRST_CLUSTER;
		}

		hint_clu = exfat_find_free_bitmap(sb, sbi->clu_srch_ptr);
		if (hint_clu == EXFAT_EOF_CLUSTER)
		return -ENOSPC;
		}

		/* check cluster validation */
		if (hint_clu < EXFAT_FIRST_CLUSTER && hint_clu >= sbi->num_clusters) {
		exfat_msg(sb, KERN_ERR, "hint_cluster is invalid (%u)\n",
		hint_clu);
		hint_clu = EXFAT_FIRST_CLUSTER;
		if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
		if (exfat_chain_cont_cluster(sb, p_chain->dir,
		num_clusters))
		return -EIO;
		p_chain->flags = ALLOC_FAT_CHAIN;
		}
		}

		set_bit(EXFAT_SB_DIRTY, &sbi->s_state);

		p_chain->dir = EXFAT_EOF_CLUSTER;

		while ((new_clu = exfat_find_free_bitmap(sb, hint_clu)) !=
		EXFAT_EOF_CLUSTER) {
		if (new_clu != hint_clu &&
		p_chain->flags == ALLOC_NO_FAT_CHAIN) {
		if (exfat_chain_cont_cluster(sb, p_chain->dir,
		num_clusters)) {
		ret = -EIO;
		goto free_cluster;
		}
		p_chain->flags = ALLOC_FAT_CHAIN;
		}

		/* update allocation bitmap */
		if (exfat_set_bitmap(inode, new_clu)) {
		ret = -EIO;
		goto free_cluster;
		}

		num_clusters++;

		/* update FAT table */
		if (p_chain->flags == ALLOC_FAT_CHAIN) {
		if (exfat_ent_set(sb, new_clu, EXFAT_EOF_CLUSTER)) {
		ret = -EIO;
		goto free_cluster;
		}
		}

		if (p_chain->dir == EXFAT_EOF_CLUSTER) {
		p_chain->dir = new_clu;
		} else if (p_chain->flags == ALLOC_FAT_CHAIN) {
		if (exfat_ent_set(sb, last_clu, new_clu)) {
		ret = -EIO;
		goto free_cluster;
		}
		}
		last_clu = new_clu;

		if (--num_alloc == 0) {
		sbi->clu_srch_ptr = hint_clu;
		sbi->used_clusters += num_clusters;

		p_chain->size += num_clusters;
		return 0;
		}

		hint_clu = new_clu + 1;
		if (hint_clu >= sbi->num_clusters) {
		hint_clu = EXFAT_FIRST_CLUSTER;

		if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
		if (exfat_chain_cont_cluster(sb, p_chain->dir,
		num_clusters)) {
		ret = -EIO;
		goto free_cluster;
		}
		p_chain->flags = ALLOC_FAT_CHAIN;
		}
		}
		}
		free_cluster:
		if (num_clusters)
		exfat_free_cluster(inode, p_chain);
		return ret;
		}

		int exfat_count_num_clusters(struct super_block *sb,
		struct exfat_chain p_chain, unsigned int ret_count)
		{
		unsigned int i, count;
		unsigned int clu;
		struct exfat_sb_info *sbi = EXFAT_SB(sb);

		if (!p_chain->dir \|\| p_chain->dir == EXFAT_EOF_CLUSTER) {
		*ret_count = 0;
		return 0;
		}

		if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
		*ret_count = p_chain->size;
		return 0;
		}

		clu = p_chain->dir;
		count = 0;
		for (i = EXFAT_FIRST_CLUSTER; i < sbi->num_clusters; i++) {
		count++;
		if (exfat_ent_get(sb, clu, &clu))
		return -EIO;
		if (clu == EXFAT_EOF_CLUSTER)
		break;
		}

		*ret_count = count;
		return 0;
		}
		No newline at end of file

fs/exfat/file.c

0 → 100644

+360 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/*
		* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
		*/

		#include <linux/slab.h>
		#include <linux/cred.h>
		#include <linux/buffer_head.h>

		#include "exfat_raw.h"
		#include "exfat_fs.h"

		static int exfat_cont_expand(struct inode *inode, loff_t size)
		{
		struct address_space *mapping = inode->i_mapping;
		loff_t start = i_size_read(inode), count = size - i_size_read(inode);
		int err, err2;

		err = generic_cont_expand_simple(inode, size);
		if (err)
		return err;

		inode->i_ctime = inode->i_mtime = current_time(inode);
		mark_inode_dirty(inode);

		if (!IS_SYNC(inode))
		return 0;

		err = filemap_fdatawrite_range(mapping, start, start + count - 1);
		err2 = sync_mapping_buffers(mapping);
		if (!err)
		err = err2;
		err2 = write_inode_now(inode, 1);
		if (!err)
		err = err2;
		if (err)
		return err;

		return filemap_fdatawait_range(mapping, start, start + count - 1);
		}

		static bool exfat_allow_set_time(struct exfat_sb_info sbi, struct inode inode)
		{
		mode_t allow_utime = sbi->options.allow_utime;

		if (!uid_eq(current_fsuid(), inode->i_uid)) {
		if (in_group_p(inode->i_gid))
		allow_utime >>= 3;
		if (allow_utime & MAY_WRITE)
		return true;
		}

		/* use a default check */
		return false;
		}

		static int exfat_sanitize_mode(const struct exfat_sb_info *sbi,
		struct inode inode, umode_t mode_ptr)
		{
		mode_t i_mode, mask, perm;

		i_mode = inode->i_mode;

		mask = (S_ISREG(i_mode) \|\| S_ISLNK(i_mode)) ?
		sbi->options.fs_fmask : sbi->options.fs_dmask;
		perm = *mode_ptr & ~(S_IFMT \| mask);

		/* Of the r and x bits, all (subject to umask) must be present.*/
		if ((perm & 0555) != (i_mode & 0555))
		return -EPERM;

		if (exfat_mode_can_hold_ro(inode)) {
		/*
		* Of the w bits, either all (subject to umask) or none must
		* be present.
		*/
		if ((perm & 0222) && ((perm & 0222) != (0222 & ~mask)))
		return -EPERM;
		} else {
		/*
		* If exfat_mode_can_hold_ro(inode) is false, can't change
		* w bits.
		*/
		if ((perm & 0222) != (0222 & ~mask))
		return -EPERM;
		}

		*mode_ptr &= S_IFMT \| perm;

		return 0;
		}

		/* resize the file length */
		int __exfat_truncate(struct inode *inode, loff_t new_size)
		{
		unsigned int num_clusters_new, num_clusters_phys;
		unsigned int last_clu = EXFAT_FREE_CLUSTER;
		struct exfat_chain clu;
		struct exfat_dentry ep, ep2;
		struct super_block *sb = inode->i_sb;
		struct exfat_sb_info *sbi = EXFAT_SB(sb);
		struct exfat_inode_info *ei = EXFAT_I(inode);
		struct exfat_entry_set_cache *es = NULL;
		int evict = (ei->dir.dir == DIR_DELETED) ? 1 : 0;

		/* check if the given file ID is opened */
		if (ei->type != TYPE_FILE && ei->type != TYPE_DIR)
		return -EPERM;

		exfat_set_vol_flags(sb, VOL_DIRTY);

		num_clusters_new = EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi);
		num_clusters_phys =
		EXFAT_B_TO_CLU_ROUND_UP(EXFAT_I(inode)->i_size_ondisk, sbi);

		exfat_chain_set(&clu, ei->start_clu, num_clusters_phys, ei->flags);

		if (new_size > 0) {
		/*
		* Truncate FAT chain num_clusters after the first cluster
		* num_clusters = min(new, phys);
		*/
		unsigned int num_clusters =
		min(num_clusters_new, num_clusters_phys);

		/*
		* Follow FAT chain
		* (defensive coding - works fine even with corrupted FAT table
		*/
		if (clu.flags == ALLOC_NO_FAT_CHAIN) {
		clu.dir += num_clusters;
		clu.size -= num_clusters;
		} else {
		while (num_clusters > 0) {
		last_clu = clu.dir;
		if (exfat_get_next_cluster(sb, &(clu.dir)))
		return -EIO;

		num_clusters--;
		clu.size--;
		}
		}
		} else {
		ei->flags = ALLOC_NO_FAT_CHAIN;
		ei->start_clu = EXFAT_EOF_CLUSTER;
		}

		i_size_write(inode, new_size);

		if (ei->type == TYPE_FILE)
		ei->attr \|= ATTR_ARCHIVE;

		/* update the directory entry */
		if (!evict) {
		struct timespec64 ts;

		es = exfat_get_dentry_set(sb, &(ei->dir), ei->entry,
		ES_ALL_ENTRIES, &ep);
		if (!es)
		return -EIO;
		ep2 = ep + 1;

		ts = current_time(inode);
		exfat_set_entry_time(sbi, &ts,
		&ep->dentry.file.modify_tz,
		&ep->dentry.file.modify_time,
		&ep->dentry.file.modify_date,
		&ep->dentry.file.modify_time_ms);
		ep->dentry.file.attr = cpu_to_le16(ei->attr);

		/* File size should be zero if there is no cluster allocated */
		if (ei->start_clu == EXFAT_EOF_CLUSTER) {
		ep->dentry.stream.valid_size = 0;
		ep->dentry.stream.size = 0;
		} else {
		ep->dentry.stream.valid_size = cpu_to_le64(new_size);
		ep->dentry.stream.size = ep->dentry.stream.valid_size;
		}

		if (new_size == 0) {
		/* Any directory can not be truncated to zero */
		WARN_ON(ei->type != TYPE_FILE);

		ep2->dentry.stream.flags = ALLOC_FAT_CHAIN;
		ep2->dentry.stream.start_clu = EXFAT_FREE_CLUSTER;
		}

		if (exfat_update_dir_chksum_with_entry_set(sb, es,
		inode_needs_sync(inode)))
		return -EIO;
		kfree(es);
		}

		/* cut off from the FAT chain */
		if (ei->flags == ALLOC_FAT_CHAIN && last_clu != EXFAT_FREE_CLUSTER &&
		last_clu != EXFAT_EOF_CLUSTER) {
		if (exfat_ent_set(sb, last_clu, EXFAT_EOF_CLUSTER))
		return -EIO;
		}

		/* invalidate cache and free the clusters */
		/* clear exfat cache */
		exfat_cache_inval_inode(inode);

		/* hint information */
		ei->hint_bmap.off = EXFAT_EOF_CLUSTER;
		ei->hint_bmap.clu = EXFAT_EOF_CLUSTER;
		if (ei->rwoffset > new_size)
		ei->rwoffset = new_size;

		/* hint_stat will be used if this is directory. */
		ei->hint_stat.eidx = 0;
		ei->hint_stat.clu = ei->start_clu;
		ei->hint_femp.eidx = EXFAT_HINT_NONE;

		/* free the clusters */
		if (exfat_free_cluster(inode, &clu))
		return -EIO;

		exfat_set_vol_flags(sb, VOL_CLEAN);

		return 0;
		}

		void exfat_truncate(struct inode *inode, loff_t size)
		{
		struct super_block *sb = inode->i_sb;
		struct exfat_sb_info *sbi = EXFAT_SB(sb);
		unsigned int blocksize = 1 << inode->i_blkbits;
		loff_t aligned_size;
		int err;

		mutex_lock(&sbi->s_lock);
		if (EXFAT_I(inode)->start_clu == 0) {
		/*
		* Empty start_clu != ~0 (not allocated)
		*/
		exfat_fs_error(sb, "tried to truncate zeroed cluster.");
		goto write_size;
		}

		err = __exfat_truncate(inode, i_size_read(inode));
		if (err)
		goto write_size;

		inode->i_ctime = inode->i_mtime = current_time(inode);
		if (IS_DIRSYNC(inode))
		exfat_sync_inode(inode);
		else
		mark_inode_dirty(inode);

		inode->i_blocks = ((i_size_read(inode) + (sbi->cluster_size - 1)) &
		~(sbi->cluster_size - 1)) >> inode->i_blkbits;
		write_size:
		aligned_size = i_size_read(inode);
		if (aligned_size & (blocksize - 1)) {
		aligned_size \|= (blocksize - 1);
		aligned_size++;
		}

		if (EXFAT_I(inode)->i_size_ondisk > i_size_read(inode))
		EXFAT_I(inode)->i_size_ondisk = aligned_size;

		if (EXFAT_I(inode)->i_size_aligned > i_size_read(inode))
		EXFAT_I(inode)->i_size_aligned = aligned_size;
		mutex_unlock(&sbi->s_lock);
		}

		int exfat_getattr(const struct path path, struct kstat stat,
		unsigned int request_mask, unsigned int query_flags)
		{
		struct inode *inode = d_backing_inode(path->dentry);
		struct exfat_inode_info *ei = EXFAT_I(inode);

		generic_fillattr(inode, stat);
		stat->result_mask \|= STATX_BTIME;
		stat->btime.tv_sec = ei->i_crtime.tv_sec;
		stat->btime.tv_nsec = ei->i_crtime.tv_nsec;
		stat->blksize = EXFAT_SB(inode->i_sb)->cluster_size;
		return 0;
		}

		int exfat_setattr(struct dentry dentry, struct iattr attr)
		{
		struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb);
		struct inode *inode = dentry->d_inode;
		unsigned int ia_valid;
		int error;

		if ((attr->ia_valid & ATTR_SIZE) &&
		attr->ia_size > i_size_read(inode)) {
		error = exfat_cont_expand(inode, attr->ia_size);
		if (error \|\| attr->ia_valid == ATTR_SIZE)
		return error;
		attr->ia_valid &= ~ATTR_SIZE;
		}

		/* Check for setting the inode time. */
		ia_valid = attr->ia_valid;
		if ((ia_valid & (ATTR_MTIME_SET \| ATTR_ATIME_SET \| ATTR_TIMES_SET)) &&
		exfat_allow_set_time(sbi, inode)) {
		attr->ia_valid &= ~(ATTR_MTIME_SET \| ATTR_ATIME_SET \|
		ATTR_TIMES_SET);
		}

		error = setattr_prepare(dentry, attr);
		attr->ia_valid = ia_valid;
		if (error)
		goto out;

		if (((attr->ia_valid & ATTR_UID) &&
		!uid_eq(attr->ia_uid, sbi->options.fs_uid)) \|\|
		((attr->ia_valid & ATTR_GID) &&
		!gid_eq(attr->ia_gid, sbi->options.fs_gid)) \|\|
		((attr->ia_valid & ATTR_MODE) &&
		(attr->ia_mode & ~(S_IFREG \| S_IFLNK \| S_IFDIR \| 0777)))) {
		error = -EPERM;
		goto out;
		}

		/*
		* We don't return -EPERM here. Yes, strange, but this is too
		* old behavior.
		*/
		if (attr->ia_valid & ATTR_MODE) {
		if (exfat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
		attr->ia_valid &= ~ATTR_MODE;
		}

		if (attr->ia_valid & ATTR_SIZE) {
		error = exfat_block_truncate_page(inode, attr->ia_size);
		if (error)
		goto out;

		down_write(&EXFAT_I(inode)->truncate_lock);
		truncate_setsize(inode, attr->ia_size);
		exfat_truncate(inode, attr->ia_size);
		up_write(&EXFAT_I(inode)->truncate_lock);
		}

		setattr_copy(inode, attr);
		mark_inode_dirty(inode);

		out:
		return error;
		}

		const struct file_operations exfat_file_operations = {
		.llseek = generic_file_llseek,
		.read_iter = generic_file_read_iter,
		.write_iter = generic_file_write_iter,
		.mmap = generic_file_mmap,
		.fsync = generic_file_fsync,
		.splice_read = generic_file_splice_read,
		};

		const struct inode_operations exfat_file_inode_operations = {
		.setattr = exfat_setattr,
		.getattr = exfat_getattr,
		};
		No newline at end of file