[mirror_ubuntu-jammy-kernel.git] / fs / exfat / fatent.c

// 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(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;
}

/* This function must be called with bitmap_lock held */
static int __exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain)
{
	struct super_block *sb = inode->i_sb;
	struct exfat_sb_info *sbi = EXFAT_SB(sb);
	int cur_cmap_i, next_cmap_i;
	unsigned int num_clusters = 0;
	unsigned int clu;

	/* 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 (!is_valid_cluster(sbi, p_chain->dir)) {
		exfat_err(sb, "invalid start cluster (%u)", p_chain->dir);
		return -EIO;
	}

	clu = p_chain->dir;

	cur_cmap_i = next_cmap_i =
		BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(clu));

	if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
		unsigned int last_cluster = p_chain->dir + p_chain->size - 1;
		do {
			bool sync = false;

			if (clu < last_cluster)
				next_cmap_i =
				  BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(clu+1));

			/* flush bitmap only if index would be changed or for last cluster */
			if (clu == last_cluster || cur_cmap_i != next_cmap_i) {
				sync = true;
				cur_cmap_i = next_cmap_i;
			}

			exfat_clear_bitmap(inode, clu, (sync && IS_DIRSYNC(inode)));
			clu++;
			num_clusters++;
		} while (num_clusters < p_chain->size);
	} else {
		do {
			bool sync = false;
			unsigned int n_clu = clu;
			int err = exfat_get_next_cluster(sb, &n_clu);

			if (err || n_clu == EXFAT_EOF_CLUSTER)
				sync = true;
			else
				next_cmap_i =
				  BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(n_clu));

			if (cur_cmap_i != next_cmap_i) {
				sync = true;
				cur_cmap_i = next_cmap_i;
			}

			exfat_clear_bitmap(inode, clu, (sync && IS_DIRSYNC(inode)));
			clu = n_clu;
			num_clusters++;

			if (err)
				goto dec_used_clus;
		} while (clu != EXFAT_EOF_CLUSTER);
	}

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

int exfat_free_cluster(struct inode *inode, struct exfat_chain *p_chain)
{
	int ret = 0;

	mutex_lock(&EXFAT_SB(inode->i_sb)->bitmap_lock);
	ret = __exfat_free_cluster(inode, p_chain);
	mutex_unlock(&EXFAT_SB(inode->i_sb)->bitmap_lock);

	return ret;
}

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;
}

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 */
	while (blknr < last_blknr) {
		for (n = 0; n < nr_bhs && blknr < last_blknr; n++, blknr++) {
			bhs[n] = sb_getblk(sb, blknr);
			if (!bhs[n]) {
				err = -ENOMEM;
				goto release_bhs;
			}
			memset(bhs[n]->b_data, 0, sb->s_blocksize);
		}

		err = exfat_update_bhs(bhs, n, IS_DIRSYNC(dir));
		if (err)
			goto release_bhs;

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

release_bhs:
	exfat_err(sb, "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, bool sync_bmap)
{
	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;

	mutex_lock(&sbi->bitmap_lock);

	hint_clu = p_chain->dir;
	/* find new cluster */
	if (hint_clu == EXFAT_EOF_CLUSTER) {
		if (sbi->clu_srch_ptr < EXFAT_FIRST_CLUSTER) {
			exfat_err(sb, "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) {
			ret = -ENOSPC;
			goto unlock;
		}
	}

	/* check cluster validation */
	if (!is_valid_cluster(sbi, hint_clu)) {
		exfat_err(sb, "hint_cluster is invalid (%u)",
			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)) {
				ret = -EIO;
				goto unlock;
			}
			p_chain->flags = ALLOC_FAT_CHAIN;
		}
	}

	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, sync_bmap)) {
			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;
			mutex_unlock(&sbi->bitmap_lock);
			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);
unlock:
	mutex_unlock(&sbi->bitmap_lock);
	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;
}
Commit	Line	Data
31023864 NJ	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
	4	*/
	5
	6	#include <linux/slab.h>
	7	#include <asm/unaligned.h>
	8	#include <linux/buffer_head.h>
	9
	10	#include "exfat_raw.h"
	11	#include "exfat_fs.h"
	12
	13	static int exfat_mirror_bh(struct super_block *sb, sector_t sec,
	14	struct buffer_head *bh)
	15	{
	16	struct buffer_head *c_bh;
	17	struct exfat_sb_info *sbi = EXFAT_SB(sb);
	18	sector_t sec2;
	19	int err = 0;
	20
	21	if (sbi->FAT2_start_sector != sbi->FAT1_start_sector) {
	22	sec2 = sec - sbi->FAT1_start_sector + sbi->FAT2_start_sector;
	23	c_bh = sb_getblk(sb, sec2);
	24	if (!c_bh)
	25	return -ENOMEM;
	26	memcpy(c_bh->b_data, bh->b_data, sb->s_blocksize);
	27	set_buffer_uptodate(c_bh);
	28	mark_buffer_dirty(c_bh);
	29	if (sb->s_flags & SB_SYNCHRONOUS)
	30	err = sync_dirty_buffer(c_bh);
	31	brelse(c_bh);
	32	}
	33
	34	return err;
	35	}
	36
	37	static int __exfat_ent_get(struct super_block *sb, unsigned int loc,
	38	unsigned int *content)
	39	{
	40	unsigned int off;
	41	sector_t sec;
	42	struct buffer_head *bh;
	43
	44	sec = FAT_ENT_OFFSET_SECTOR(sb, loc);
	45	off = FAT_ENT_OFFSET_BYTE_IN_SECTOR(sb, loc);
	46
	47	bh = sb_bread(sb, sec);
	48	if (!bh)
	49	return -EIO;
	50
	51	content = le32_to_cpu((__le32 *)(&bh->b_data[off]));
	52
	53	/* remap reserved clusters to simplify code */
	54	if (*content > EXFAT_BAD_CLUSTER)
	55	*content = EXFAT_EOF_CLUSTER;
	56
	57	brelse(bh);
	58	return 0;
	59	}
	60
	61	int exfat_ent_set(struct super_block *sb, unsigned int loc,
	62	unsigned int content)
	63	{
	64	unsigned int off;
65	sector_t sec;
66	__le32 *fat_entry;
67	struct buffer_head *bh;
68
69	sec = FAT_ENT_OFFSET_SECTOR(sb, loc);
70	off = FAT_ENT_OFFSET_BYTE_IN_SECTOR(sb, loc);
71
72	bh = sb_bread(sb, sec);
73	if (!bh)
74	return -EIO;
75
76	fat_entry = (__le32 *)&(bh->b_data[off]);
77	*fat_entry = cpu_to_le32(content);
2c7f8937	78	exfat_update_bh(bh, sb->s_flags & SB_SYNCHRONOUS);
31023864 NJ	79	exfat_mirror_bh(sb, sec, bh);
	80	brelse(bh);
	81	return 0;
	82	}
	83
	84	static inline bool is_valid_cluster(struct exfat_sb_info *sbi,
	85	unsigned int clus)
	86	{
	87	if (clus < EXFAT_FIRST_CLUSTER \|\| sbi->num_clusters <= clus)
	88	return false;
	89	return true;
	90	}
	91
	92	int exfat_ent_get(struct super_block *sb, unsigned int loc,
	93	unsigned int *content)
	94	{
	95	struct exfat_sb_info *sbi = EXFAT_SB(sb);
	96	int err;
	97
	98	if (!is_valid_cluster(sbi, loc)) {
	99	exfat_fs_error(sb, "invalid access to FAT (entry 0x%08x)",
	100	loc);
	101	return -EIO;
	102	}
	103
	104	err = __exfat_ent_get(sb, loc, content);
	105	if (err) {
	106	exfat_fs_error(sb,
	107	"failed to access to FAT (entry 0x%08x, err:%d)",
	108	loc, err);
	109	return err;
	110	}
	111
	112	if (*content == EXFAT_FREE_CLUSTER) {
	113	exfat_fs_error(sb,
	114	"invalid access to FAT free cluster (entry 0x%08x)",
	115	loc);
	116	return -EIO;
	117	}
	118
	119	if (*content == EXFAT_BAD_CLUSTER) {
	120	exfat_fs_error(sb,
	121	"invalid access to FAT bad cluster (entry 0x%08x)",
	122	loc);
	123	return -EIO;
	124	}
	125
	126	if (content != EXFAT_EOF_CLUSTER && !is_valid_cluster(sbi, content)) {
	127	exfat_fs_error(sb,
	128	"invalid access to FAT (entry 0x%08x) bogus content (0x%08x)",
	129	loc, *content);
	130	return -EIO;
	131	}
	132
	133	return 0;
	134	}
	135
	136	int exfat_chain_cont_cluster(struct super_block *sb, unsigned int chain,
	137	unsigned int len)
	138	{
	139	if (!len)
	140	return 0;
	141
	142	while (len > 1) {
143	if (exfat_ent_set(sb, chain, chain + 1))
144	return -EIO;
145	chain++;
146	len--;
147	}
148
149	if (exfat_ent_set(sb, chain, EXFAT_EOF_CLUSTER))
150	return -EIO;
151	return 0;
152	}
153
5c2d7285 HK	154	/* This function must be called with bitmap_lock held */
5c2d7285 HK	155	static int __exfat_free_cluster(struct inode inode, struct exfat_chain p_chain)
31023864	156	{
31023864 NJ	157	struct super_block *sb = inode->i_sb;
31023864 NJ	158	struct exfat_sb_info *sbi = EXFAT_SB(sb);
f728760a	159	int cur_cmap_i, next_cmap_i;
5c2d7285 HK	160	unsigned int num_clusters = 0;
5c2d7285 HK	161	unsigned int clu;
31023864 NJ	162
	163	/* invalid cluster number */
	164	if (p_chain->dir == EXFAT_FREE_CLUSTER \|\|
	165	p_chain->dir == EXFAT_EOF_CLUSTER \|\|
	166	p_chain->dir < EXFAT_FIRST_CLUSTER)
	167	return 0;
	168
	169	/* no cluster to truncate */
	170	if (p_chain->size == 0)
	171	return 0;
	172
	173	/* check cluster validation */
a949824f	174	if (!is_valid_cluster(sbi, p_chain->dir)) {
d1727d55	175	exfat_err(sb, "invalid start cluster (%u)", p_chain->dir);
31023864 NJ	176	return -EIO;
	177	}
	178
31023864 NJ	179	clu = p_chain->dir;
31023864 NJ	180
f728760a HK	181	cur_cmap_i = next_cmap_i =
	182	BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(clu));
	183
31023864	184	if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
f728760a	185	unsigned int last_cluster = p_chain->dir + p_chain->size - 1;
31023864	186	do {
f728760a HK	187	bool sync = false;
	188
	189	if (clu < last_cluster)
	190	next_cmap_i =
	191	BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(clu+1));
	192
	193	/* flush bitmap only if index would be changed or for last cluster */
	194	if (clu == last_cluster \|\| cur_cmap_i != next_cmap_i) {
	195	sync = true;
	196	cur_cmap_i = next_cmap_i;
	197	}
31023864	198
f728760a HK	199	exfat_clear_bitmap(inode, clu, (sync && IS_DIRSYNC(inode)));
f728760a HK	200	clu++;
31023864 NJ	201	num_clusters++;
	202	} while (num_clusters < p_chain->size);
	203	} else {
	204	do {
f728760a HK	205	bool sync = false;
	206	unsigned int n_clu = clu;
	207	int err = exfat_get_next_cluster(sb, &n_clu);
	208
	209	if (err \|\| n_clu == EXFAT_EOF_CLUSTER)
	210	sync = true;
	211	else
	212	next_cmap_i =
	213	BITMAP_OFFSET_SECTOR_INDEX(sb, CLUSTER_TO_BITMAP_ENT(n_clu));
	214
	215	if (cur_cmap_i != next_cmap_i) {
	216	sync = true;
	217	cur_cmap_i = next_cmap_i;
	218	}
	219
	220	exfat_clear_bitmap(inode, clu, (sync && IS_DIRSYNC(inode)));
	221	clu = n_clu;
	222	num_clusters++;
31023864	223
f728760a	224	if (err)
31023864	225	goto dec_used_clus;
31023864 NJ	226	} while (clu != EXFAT_EOF_CLUSTER);
	227	}
	228
	229	dec_used_clus:
	230	sbi->used_clusters -= num_clusters;
	231	return 0;
	232	}
	233
5c2d7285 HK	234	int exfat_free_cluster(struct inode inode, struct exfat_chain p_chain)
	235	{
	236	int ret = 0;
	237
	238	mutex_lock(&EXFAT_SB(inode->i_sb)->bitmap_lock);
	239	ret = __exfat_free_cluster(inode, p_chain);
	240	mutex_unlock(&EXFAT_SB(inode->i_sb)->bitmap_lock);
	241
	242	return ret;
	243	}
	244
31023864 NJ	245	int exfat_find_last_cluster(struct super_block sb, struct exfat_chain p_chain,
	246	unsigned int *ret_clu)
	247	{
	248	unsigned int clu, next;
	249	unsigned int count = 0;
	250
	251	next = p_chain->dir;
	252	if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
	253	*ret_clu = next + p_chain->size - 1;
	254	return 0;
	255	}
	256
	257	do {
	258	count++;
	259	clu = next;
	260	if (exfat_ent_get(sb, clu, &next))
	261	return -EIO;
	262	} while (next != EXFAT_EOF_CLUSTER);
	263
	264	if (p_chain->size != count) {
	265	exfat_fs_error(sb,
	266	"bogus directory size (clus : ondisk(%d) != counted(%d))",
	267	p_chain->size, count);
	268	return -EIO;
	269	}
	270
	271	*ret_clu = clu;
	272	return 0;
	273	}
	274
31023864 NJ	275	int exfat_zeroed_cluster(struct inode *dir, unsigned int clu)
	276	{
	277	struct super_block *sb = dir->i_sb;
	278	struct exfat_sb_info *sbi = EXFAT_SB(sb);
	279	struct buffer_head *bhs[MAX_BUF_PER_PAGE];
	280	int nr_bhs = MAX_BUF_PER_PAGE;
	281	sector_t blknr, last_blknr;
	282	int err, i, n;
	283
	284	blknr = exfat_cluster_to_sector(sbi, clu);
	285	last_blknr = blknr + sbi->sect_per_clus;
	286
	287	if (last_blknr > sbi->num_sectors && sbi->num_sectors > 0) {
	288	exfat_fs_error_ratelimit(sb,
	289	"%s: out of range(sect:%llu len:%u)",
	290	__func__, (unsigned long long)blknr,
	291	sbi->sect_per_clus);
	292	return -EIO;
	293	}
	294
	295	/* Zeroing the unused blocks on this cluster */
31023864	296	while (blknr < last_blknr) {
4dc7d35e TK	297	for (n = 0; n < nr_bhs && blknr < last_blknr; n++, blknr++) {
	298	bhs[n] = sb_getblk(sb, blknr);
	299	if (!bhs[n]) {
	300	err = -ENOMEM;
	301	goto release_bhs;
31023864	302	}
4dc7d35e	303	memset(bhs[n]->b_data, 0, sb->s_blocksize);
31023864	304	}
31023864	305
4dc7d35e	306	err = exfat_update_bhs(bhs, n, IS_DIRSYNC(dir));
31023864 NJ	307	if (err)
31023864 NJ	308	goto release_bhs;
31023864	309
4dc7d35e TK	310	for (i = 0; i < n; i++)
	311	brelse(bhs[i]);
	312	}
31023864 NJ	313	return 0;
	314
	315	release_bhs:
d1727d55	316	exfat_err(sb, "failed zeroed sect %llu\n", (unsigned long long)blknr);
31023864 NJ	317	for (i = 0; i < n; i++)
	318	bforget(bhs[i]);
	319	return err;
	320	}
	321
	322	int exfat_alloc_cluster(struct inode *inode, unsigned int num_alloc,
23befe49	323	struct exfat_chain *p_chain, bool sync_bmap)
31023864 NJ	324	{
	325	int ret = -ENOSPC;
	326	unsigned int num_clusters = 0, total_cnt;
	327	unsigned int hint_clu, new_clu, last_clu = EXFAT_EOF_CLUSTER;
	328	struct super_block *sb = inode->i_sb;
	329	struct exfat_sb_info *sbi = EXFAT_SB(sb);
	330
	331	total_cnt = EXFAT_DATA_CLUSTER_COUNT(sbi);
	332
	333	if (unlikely(total_cnt < sbi->used_clusters)) {
	334	exfat_fs_error_ratelimit(sb,
	335	"%s: invalid used clusters(t:%u,u:%u)\n",
	336	__func__, total_cnt, sbi->used_clusters);
	337	return -EIO;
	338	}
	339
	340	if (num_alloc > total_cnt - sbi->used_clusters)
	341	return -ENOSPC;
	342
5c2d7285 HK	343	mutex_lock(&sbi->bitmap_lock);
5c2d7285 HK	344
31023864 NJ	345	hint_clu = p_chain->dir;
	346	/* find new cluster */
	347	if (hint_clu == EXFAT_EOF_CLUSTER) {
	348	if (sbi->clu_srch_ptr < EXFAT_FIRST_CLUSTER) {
d1727d55 JP	349	exfat_err(sb, "sbi->clu_srch_ptr is invalid (%u)\n",
d1727d55 JP	350	sbi->clu_srch_ptr);
31023864 NJ	351	sbi->clu_srch_ptr = EXFAT_FIRST_CLUSTER;
	352	}
	353
	354	hint_clu = exfat_find_free_bitmap(sb, sbi->clu_srch_ptr);
5c2d7285 HK	355	if (hint_clu == EXFAT_EOF_CLUSTER) {
	356	ret = -ENOSPC;
	357	goto unlock;
	358	}
31023864 NJ	359	}
	360
	361	/* check cluster validation */
a949824f	362	if (!is_valid_cluster(sbi, hint_clu)) {
d1727d55	363	exfat_err(sb, "hint_cluster is invalid (%u)",
31023864 NJ	364	hint_clu);
	365	hint_clu = EXFAT_FIRST_CLUSTER;
	366	if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
	367	if (exfat_chain_cont_cluster(sb, p_chain->dir,
5c2d7285 HK	368	num_clusters)) {
	369	ret = -EIO;
	370	goto unlock;
	371	}
31023864 NJ	372	p_chain->flags = ALLOC_FAT_CHAIN;
	373	}
	374	}
	375
31023864 NJ	376	p_chain->dir = EXFAT_EOF_CLUSTER;
	377
	378	while ((new_clu = exfat_find_free_bitmap(sb, hint_clu)) !=
	379	EXFAT_EOF_CLUSTER) {
	380	if (new_clu != hint_clu &&
	381	p_chain->flags == ALLOC_NO_FAT_CHAIN) {
	382	if (exfat_chain_cont_cluster(sb, p_chain->dir,
	383	num_clusters)) {
	384	ret = -EIO;
	385	goto free_cluster;
	386	}
	387	p_chain->flags = ALLOC_FAT_CHAIN;
	388	}
	389
	390	/* update allocation bitmap */
23befe49	391	if (exfat_set_bitmap(inode, new_clu, sync_bmap)) {
31023864 NJ	392	ret = -EIO;
	393	goto free_cluster;
	394	}
	395
	396	num_clusters++;
	397
	398	/* update FAT table */
	399	if (p_chain->flags == ALLOC_FAT_CHAIN) {
	400	if (exfat_ent_set(sb, new_clu, EXFAT_EOF_CLUSTER)) {
	401	ret = -EIO;
	402	goto free_cluster;
	403	}
	404	}
	405
	406	if (p_chain->dir == EXFAT_EOF_CLUSTER) {
	407	p_chain->dir = new_clu;
	408	} else if (p_chain->flags == ALLOC_FAT_CHAIN) {
	409	if (exfat_ent_set(sb, last_clu, new_clu)) {
	410	ret = -EIO;
	411	goto free_cluster;
	412	}
	413	}
	414	last_clu = new_clu;
	415
	416	if (--num_alloc == 0) {
	417	sbi->clu_srch_ptr = hint_clu;
	418	sbi->used_clusters += num_clusters;
	419
	420	p_chain->size += num_clusters;
5c2d7285	421	mutex_unlock(&sbi->bitmap_lock);
31023864 NJ	422	return 0;
	423	}
	424
	425	hint_clu = new_clu + 1;
	426	if (hint_clu >= sbi->num_clusters) {
	427	hint_clu = EXFAT_FIRST_CLUSTER;
	428
	429	if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
	430	if (exfat_chain_cont_cluster(sb, p_chain->dir,
	431	num_clusters)) {
	432	ret = -EIO;
	433	goto free_cluster;
	434	}
	435	p_chain->flags = ALLOC_FAT_CHAIN;
	436	}
	437	}
	438	}
	439	free_cluster:
	440	if (num_clusters)
5c2d7285 HK	441	__exfat_free_cluster(inode, p_chain);
	442	unlock:
	443	mutex_unlock(&sbi->bitmap_lock);
31023864 NJ	444	return ret;
	445	}
	446
	447	int exfat_count_num_clusters(struct super_block *sb,
	448	struct exfat_chain p_chain, unsigned int ret_count)
	449	{
	450	unsigned int i, count;
	451	unsigned int clu;
	452	struct exfat_sb_info *sbi = EXFAT_SB(sb);
	453
	454	if (!p_chain->dir \|\| p_chain->dir == EXFAT_EOF_CLUSTER) {
	455	*ret_count = 0;
	456	return 0;
	457	}
	458
	459	if (p_chain->flags == ALLOC_NO_FAT_CHAIN) {
	460	*ret_count = p_chain->size;
	461	return 0;
	462	}
	463
	464	clu = p_chain->dir;
	465	count = 0;
	466	for (i = EXFAT_FIRST_CLUSTER; i < sbi->num_clusters; i++) {
	467	count++;
	468	if (exfat_ent_get(sb, clu, &clu))
	469	return -EIO;
	470	if (clu == EXFAT_EOF_CLUSTER)
	471	break;
	472	}
	473
	474	*ret_count = count;
	475	return 0;
	476	}