[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / fs / sdfat / statistics.c

#include "sdfat.h"

#define SDFAT_VF_CLUS_MAX	7	/* 512 Byte ~ 32 KByte */
#define SDFAT_EF_CLUS_MAX	17	/* 512 Byte ~ 32 MByte */

enum {
	SDFAT_MNT_FAT12,
	SDFAT_MNT_FAT16,
	SDFAT_MNT_FAT32,
	SDFAT_MNT_EXFAT,
	SDFAT_MNT_RO,
	SDFAT_MNT_MAX
};

enum {
	SDFAT_OP_EXFAT_MNT,
	SDFAT_OP_MKDIR,
	SDFAT_OP_CREATE,
	SDFAT_OP_READ,
	SDFAT_OP_WRITE,
	SDFAT_OP_TRUNC,
	SDFAT_OP_MAX
};

enum {
	SDFAT_VOL_4G,
	SDFAT_VOL_8G,
	SDFAT_VOL_16G,
	SDFAT_VOL_32G,
	SDFAT_VOL_64G,
	SDFAT_VOL_128G,
	SDFAT_VOL_256G,
	SDFAT_VOL_512G,
	SDFAT_VOL_XTB,
	SDFAT_VOL_MAX
};

static struct sdfat_statistics {
	u32 clus_vfat[SDFAT_VF_CLUS_MAX];
	u32 clus_exfat[SDFAT_EF_CLUS_MAX];
	u32 mnt_cnt[SDFAT_MNT_MAX];
	u32 nofat_op[SDFAT_OP_MAX];
	u32 vol_size[SDFAT_VOL_MAX];
} statistics;

static struct kset *sdfat_statistics_kset;

static ssize_t vfat_cl_show(struct kobject *kobj,
				struct kobj_attribute *attr, char *buff)
{
	return snprintf(buff, PAGE_SIZE, "\"VCL_512B_I\":\"%u\","
			"\"VCL_1K_I\":\"%u\",\"VCL_2K_I\":\"%u\","
			"\"VCL_4K_I\":\"%u\",\"VCL_8K_I\":\"%u\","
			"\"VCL_16K_I\":\"%u\",\"VCL_32K_I\":\"%u\"\n",
			statistics.clus_vfat[0], statistics.clus_vfat[1],
			statistics.clus_vfat[2], statistics.clus_vfat[3],
			statistics.clus_vfat[4], statistics.clus_vfat[5],
			statistics.clus_vfat[6]);
}

static ssize_t exfat_cl_show(struct kobject *kobj,
				struct kobj_attribute *attr, char *buff)
{
	return snprintf(buff, PAGE_SIZE, "\"ECL_512B_I\":\"%u\","
			"\"ECL_1K_I\":\"%u\",\"ECL_2K_I\":\"%u\","
			"\"ECL_4K_I\":\"%u\",\"ECL_8K_I\":\"%u\","
			"\"ECL_16K_I\":\"%u\",\"ECL_32K_I\":\"%u\","
			"\"ECL_64K_I\":\"%u\",\"ECL_128K_I\":\"%u\","
			"\"ECL_256K_I\":\"%u\",\"ECL_512K_I\":\"%u\","
			"\"ECL_1M_I\":\"%u\",\"ECL_2M_I\":\"%u\","
			"\"ECL_4M_I\":\"%u\",\"ECL_8M_I\":\"%u\","
			"\"ECL_16M_I\":\"%u\",\"ECL_32M_I\":\"%u\"\n",
			statistics.clus_exfat[0], statistics.clus_exfat[1],
			statistics.clus_exfat[2], statistics.clus_exfat[3],
			statistics.clus_exfat[4], statistics.clus_exfat[5],
			statistics.clus_exfat[6], statistics.clus_exfat[7],
			statistics.clus_exfat[8], statistics.clus_exfat[9],
			statistics.clus_exfat[10], statistics.clus_exfat[11],
			statistics.clus_exfat[12], statistics.clus_exfat[13],
			statistics.clus_exfat[14], statistics.clus_exfat[15],
			statistics.clus_exfat[16]);
}

static ssize_t mount_show(struct kobject *kobj,
				struct kobj_attribute *attr, char *buff)
{
	return snprintf(buff, PAGE_SIZE, "\"FAT12_MNT_I\":\"%u\","
			"\"FAT16_MNT_I\":\"%u\",\"FAT32_MNT_I\":\"%u\","
			"\"EXFAT_MNT_I\":\"%u\",\"RO_MNT_I\":\"%u\"\n",
			statistics.mnt_cnt[SDFAT_MNT_FAT12],
			statistics.mnt_cnt[SDFAT_MNT_FAT16],
			statistics.mnt_cnt[SDFAT_MNT_FAT32],
			statistics.mnt_cnt[SDFAT_MNT_EXFAT],
			statistics.mnt_cnt[SDFAT_MNT_RO]);
}

static ssize_t nofat_op_show(struct kobject *kobj,
				struct kobj_attribute *attr, char *buff)
{
	return snprintf(buff, PAGE_SIZE, "\"NOFAT_MOUNT_I\":\"%u\","
			"\"NOFAT_MKDIR_I\":\"%u\",\"NOFAT_CREATE_I\":\"%u\","
			"\"NOFAT_READ_I\":\"%u\",\"NOFAT_WRITE_I\":\"%u\","
			"\"NOFAT_TRUNC_I\":\"%u\"\n",
			statistics.nofat_op[SDFAT_OP_EXFAT_MNT],
			statistics.nofat_op[SDFAT_OP_MKDIR],
			statistics.nofat_op[SDFAT_OP_CREATE],
			statistics.nofat_op[SDFAT_OP_READ],
			statistics.nofat_op[SDFAT_OP_WRITE],
			statistics.nofat_op[SDFAT_OP_TRUNC]);
}

static ssize_t vol_size_show(struct kobject *kobj,
				struct kobj_attribute *attr, char *buff)
{
	return snprintf(buff, PAGE_SIZE, "\"VOL_4G_I\":\"%u\","
			"\"VOL_8G_I\":\"%u\",\"VOL_16G_I\":\"%u\","
			"\"VOL_32G_I\":\"%u\",\"VOL_64G_I\":\"%u\","
			"\"VOL_128G_I\":\"%u\",\"VOL_256G_I\":\"%u\","
			"\"VOL_512G_I\":\"%u\",\"VOL_XTB_I\":\"%u\"\n",
			statistics.vol_size[SDFAT_VOL_4G],
			statistics.vol_size[SDFAT_VOL_8G],
			statistics.vol_size[SDFAT_VOL_16G],
			statistics.vol_size[SDFAT_VOL_32G],
			statistics.vol_size[SDFAT_VOL_64G],
			statistics.vol_size[SDFAT_VOL_128G],
			statistics.vol_size[SDFAT_VOL_256G],
			statistics.vol_size[SDFAT_VOL_512G],
			statistics.vol_size[SDFAT_VOL_XTB]);
}

static struct kobj_attribute vfat_cl_attr = __ATTR_RO(vfat_cl);
static struct kobj_attribute exfat_cl_attr = __ATTR_RO(exfat_cl);
static struct kobj_attribute mount_attr = __ATTR_RO(mount);
static struct kobj_attribute nofat_op_attr = __ATTR_RO(nofat_op);
static struct kobj_attribute vol_size_attr = __ATTR_RO(vol_size);

static struct attribute *attributes_statistics[] = {
	&vfat_cl_attr.attr,
	&exfat_cl_attr.attr,
	&mount_attr.attr,
	&nofat_op_attr.attr,
	&vol_size_attr.attr,
	NULL,
};

static struct attribute_group attr_group_statistics = {
		.attrs = attributes_statistics,
};

int sdfat_statistics_init(struct kset *sdfat_kset)
{
	int err;

	sdfat_statistics_kset = kset_create_and_add("statistics", NULL, &sdfat_kset->kobj);
	if (!sdfat_statistics_kset) {
		pr_err("[SDFAT] failed to create sdfat statistics kobj\n");
		return -ENOMEM;
	}

	err = sysfs_create_group(&sdfat_statistics_kset->kobj, &attr_group_statistics);
	if (err) {
		pr_err("[SDFAT] failed to create sdfat statistics attributes\n");
		kset_unregister(sdfat_statistics_kset);
		sdfat_statistics_kset = NULL;
		return err;
	}

	return 0;
}

void sdfat_statistics_uninit(void)
{
	if (sdfat_statistics_kset) {
		sysfs_remove_group(&sdfat_statistics_kset->kobj, &attr_group_statistics);
		kset_unregister(sdfat_statistics_kset);
		sdfat_statistics_kset = NULL;
	}
	memset(&statistics, 0, sizeof(struct sdfat_statistics));
}

void sdfat_statistics_set_mnt(FS_INFO_T *fsi)
{
	if (fsi->vol_type == EXFAT) {
		statistics.mnt_cnt[SDFAT_MNT_EXFAT]++;
		statistics.nofat_op[SDFAT_OP_EXFAT_MNT] = 1;
		if (fsi->sect_per_clus_bits < SDFAT_EF_CLUS_MAX)
			statistics.clus_exfat[fsi->sect_per_clus_bits]++;
		else
			statistics.clus_exfat[SDFAT_EF_CLUS_MAX - 1]++;
		return;
	}

	if (fsi->vol_type == FAT32)
		statistics.mnt_cnt[SDFAT_MNT_FAT32]++;
	else if (fsi->vol_type == FAT16)
		statistics.mnt_cnt[SDFAT_MNT_FAT16]++;
	else if (fsi->vol_type == FAT12)
		statistics.mnt_cnt[SDFAT_MNT_FAT12]++;

	if (fsi->sect_per_clus_bits < SDFAT_VF_CLUS_MAX)
		statistics.clus_vfat[fsi->sect_per_clus_bits]++;
	else
		statistics.clus_vfat[SDFAT_VF_CLUS_MAX - 1]++;
}

void sdfat_statistics_set_mnt_ro(void)
{
	statistics.mnt_cnt[SDFAT_MNT_RO]++;
}

void sdfat_statistics_set_mkdir(u8 flags)
{
	if (flags != 0x03)
		return;
	statistics.nofat_op[SDFAT_OP_MKDIR] = 1;
}

void sdfat_statistics_set_create(u8 flags)
{
	if (flags != 0x03)
		return;
	statistics.nofat_op[SDFAT_OP_CREATE] = 1;
}

/* flags : file or dir flgas, 0x03 means no fat-chain.
 * clu_offset : file or dir logical cluster offset
 * create : BMAP_ADD_CLUSTER or not
 *
 * File or dir have BMAP_ADD_CLUSTER is no fat-chain write
 * when they have 0x03 flag and two or more clusters.
 * And don`t have BMAP_ADD_CLUSTER is no fat-chain read
 * when above same condition.
 */
void sdfat_statistics_set_rw(u8 flags, u32 clu_offset, s32 create)
{
	if ((flags == 0x03) && (clu_offset > 1)) {
		if (create)
			statistics.nofat_op[SDFAT_OP_WRITE] = 1;
		else
			statistics.nofat_op[SDFAT_OP_READ] = 1;
	}
}

/* flags : file or dir flgas, 0x03 means no fat-chain.
 * clu : cluster chain
 *
 * Set no fat-chain trunc when file or dir have 0x03 flag
 * and two or more clusters.
 */
void sdfat_statistics_set_trunc(u8 flags, CHAIN_T *clu)
{
	if ((flags == 0x03) && (clu->size > 1))
		statistics.nofat_op[SDFAT_OP_TRUNC] = 1;
}

void sdfat_statistics_set_vol_size(struct super_block *sb)
{
	u64 vol_size;
	FS_INFO_T *fsi = &(SDFAT_SB(sb)->fsi);

	vol_size = (u64)fsi->num_sectors << sb->s_blocksize_bits;

	if (vol_size <= ((u64)1 << 32))
		statistics.vol_size[SDFAT_VOL_4G]++;
	else if (vol_size <= ((u64)1 << 33))
		statistics.vol_size[SDFAT_VOL_8G]++;
	else if (vol_size <= ((u64)1 << 34))
		statistics.vol_size[SDFAT_VOL_16G]++;
	else if (vol_size <= ((u64)1 << 35))
		statistics.vol_size[SDFAT_VOL_32G]++;
	else if (vol_size <= ((u64)1 << 36))
		statistics.vol_size[SDFAT_VOL_64G]++;
	else if (vol_size <= ((u64)1 << 37))
		statistics.vol_size[SDFAT_VOL_128G]++;
	else if (vol_size <= ((u64)1 << 38))
		statistics.vol_size[SDFAT_VOL_256G]++;
	else if (vol_size <= ((u64)1 << 39))
		statistics.vol_size[SDFAT_VOL_512G]++;
	else
		statistics.vol_size[SDFAT_VOL_XTB]++;
}
Commit	Line	Data
00a9ab8c BM	1	#include "sdfat.h"
	2
	3	#define SDFAT_VF_CLUS_MAX 7 /* 512 Byte ~ 32 KByte */
	4	#define SDFAT_EF_CLUS_MAX 17 /* 512 Byte ~ 32 MByte */
	5
	6	enum {
	7	SDFAT_MNT_FAT12,
	8	SDFAT_MNT_FAT16,
	9	SDFAT_MNT_FAT32,
	10	SDFAT_MNT_EXFAT,
	11	SDFAT_MNT_RO,
	12	SDFAT_MNT_MAX
	13	};
	14
	15	enum {
	16	SDFAT_OP_EXFAT_MNT,
	17	SDFAT_OP_MKDIR,
	18	SDFAT_OP_CREATE,
	19	SDFAT_OP_READ,
	20	SDFAT_OP_WRITE,
	21	SDFAT_OP_TRUNC,
	22	SDFAT_OP_MAX
	23	};
	24
	25	enum {
	26	SDFAT_VOL_4G,
	27	SDFAT_VOL_8G,
	28	SDFAT_VOL_16G,
	29	SDFAT_VOL_32G,
	30	SDFAT_VOL_64G,
	31	SDFAT_VOL_128G,
	32	SDFAT_VOL_256G,
	33	SDFAT_VOL_512G,
	34	SDFAT_VOL_XTB,
	35	SDFAT_VOL_MAX
	36	};
	37
	38	static struct sdfat_statistics {
	39	u32 clus_vfat[SDFAT_VF_CLUS_MAX];
	40	u32 clus_exfat[SDFAT_EF_CLUS_MAX];
	41	u32 mnt_cnt[SDFAT_MNT_MAX];
	42	u32 nofat_op[SDFAT_OP_MAX];
	43	u32 vol_size[SDFAT_VOL_MAX];
	44	} statistics;
	45
	46	static struct kset *sdfat_statistics_kset;
	47
	48	static ssize_t vfat_cl_show(struct kobject *kobj,
	49	struct kobj_attribute attr, char buff)
	50	{
	51	return snprintf(buff, PAGE_SIZE, "\"VCL_512B_I\":\"%u\","
	52	"\"VCL_1K_I\":\"%u\",\"VCL_2K_I\":\"%u\","
	53	"\"VCL_4K_I\":\"%u\",\"VCL_8K_I\":\"%u\","
	54	"\"VCL_16K_I\":\"%u\",\"VCL_32K_I\":\"%u\"\n",
	55	statistics.clus_vfat[0], statistics.clus_vfat[1],
	56	statistics.clus_vfat[2], statistics.clus_vfat[3],
	57	statistics.clus_vfat[4], statistics.clus_vfat[5],
	58	statistics.clus_vfat[6]);
	59	}
	60
	61	static ssize_t exfat_cl_show(struct kobject *kobj,
	62	struct kobj_attribute attr, char buff)
	63	{
	64	return snprintf(buff, PAGE_SIZE, "\"ECL_512B_I\":\"%u\","
65	"\"ECL_1K_I\":\"%u\",\"ECL_2K_I\":\"%u\","
66	"\"ECL_4K_I\":\"%u\",\"ECL_8K_I\":\"%u\","
67	"\"ECL_16K_I\":\"%u\",\"ECL_32K_I\":\"%u\","
68	"\"ECL_64K_I\":\"%u\",\"ECL_128K_I\":\"%u\","
69	"\"ECL_256K_I\":\"%u\",\"ECL_512K_I\":\"%u\","
70	"\"ECL_1M_I\":\"%u\",\"ECL_2M_I\":\"%u\","
71	"\"ECL_4M_I\":\"%u\",\"ECL_8M_I\":\"%u\","
72	"\"ECL_16M_I\":\"%u\",\"ECL_32M_I\":\"%u\"\n",
73	statistics.clus_exfat[0], statistics.clus_exfat[1],
74	statistics.clus_exfat[2], statistics.clus_exfat[3],
75	statistics.clus_exfat[4], statistics.clus_exfat[5],
76	statistics.clus_exfat[6], statistics.clus_exfat[7],
77	statistics.clus_exfat[8], statistics.clus_exfat[9],
78	statistics.clus_exfat[10], statistics.clus_exfat[11],
79	statistics.clus_exfat[12], statistics.clus_exfat[13],
80	statistics.clus_exfat[14], statistics.clus_exfat[15],
81	statistics.clus_exfat[16]);
82	}
83
84	static ssize_t mount_show(struct kobject *kobj,
85	struct kobj_attribute attr, char buff)
86	{
87	return snprintf(buff, PAGE_SIZE, "\"FAT12_MNT_I\":\"%u\","
88	"\"FAT16_MNT_I\":\"%u\",\"FAT32_MNT_I\":\"%u\","
89	"\"EXFAT_MNT_I\":\"%u\",\"RO_MNT_I\":\"%u\"\n",
90	statistics.mnt_cnt[SDFAT_MNT_FAT12],
91	statistics.mnt_cnt[SDFAT_MNT_FAT16],
92	statistics.mnt_cnt[SDFAT_MNT_FAT32],
93	statistics.mnt_cnt[SDFAT_MNT_EXFAT],
94	statistics.mnt_cnt[SDFAT_MNT_RO]);
95	}
96
97	static ssize_t nofat_op_show(struct kobject *kobj,
98	struct kobj_attribute attr, char buff)
99	{
100	return snprintf(buff, PAGE_SIZE, "\"NOFAT_MOUNT_I\":\"%u\","
101	"\"NOFAT_MKDIR_I\":\"%u\",\"NOFAT_CREATE_I\":\"%u\","
102	"\"NOFAT_READ_I\":\"%u\",\"NOFAT_WRITE_I\":\"%u\","
103	"\"NOFAT_TRUNC_I\":\"%u\"\n",
104	statistics.nofat_op[SDFAT_OP_EXFAT_MNT],
105	statistics.nofat_op[SDFAT_OP_MKDIR],
106	statistics.nofat_op[SDFAT_OP_CREATE],
107	statistics.nofat_op[SDFAT_OP_READ],
108	statistics.nofat_op[SDFAT_OP_WRITE],
109	statistics.nofat_op[SDFAT_OP_TRUNC]);
110	}
111
112	static ssize_t vol_size_show(struct kobject *kobj,
113	struct kobj_attribute attr, char buff)
114	{
115	return snprintf(buff, PAGE_SIZE, "\"VOL_4G_I\":\"%u\","
116	"\"VOL_8G_I\":\"%u\",\"VOL_16G_I\":\"%u\","
117	"\"VOL_32G_I\":\"%u\",\"VOL_64G_I\":\"%u\","
118	"\"VOL_128G_I\":\"%u\",\"VOL_256G_I\":\"%u\","
119	"\"VOL_512G_I\":\"%u\",\"VOL_XTB_I\":\"%u\"\n",
120	statistics.vol_size[SDFAT_VOL_4G],
121	statistics.vol_size[SDFAT_VOL_8G],
122	statistics.vol_size[SDFAT_VOL_16G],
123	statistics.vol_size[SDFAT_VOL_32G],
124	statistics.vol_size[SDFAT_VOL_64G],
125	statistics.vol_size[SDFAT_VOL_128G],
126	statistics.vol_size[SDFAT_VOL_256G],
127	statistics.vol_size[SDFAT_VOL_512G],
128	statistics.vol_size[SDFAT_VOL_XTB]);
129	}
130
131	static struct kobj_attribute vfat_cl_attr = __ATTR_RO(vfat_cl);
132	static struct kobj_attribute exfat_cl_attr = __ATTR_RO(exfat_cl);
133	static struct kobj_attribute mount_attr = __ATTR_RO(mount);
134	static struct kobj_attribute nofat_op_attr = __ATTR_RO(nofat_op);
135	static struct kobj_attribute vol_size_attr = __ATTR_RO(vol_size);
136
137	static struct attribute *attributes_statistics[] = {
138	&vfat_cl_attr.attr,
139	&exfat_cl_attr.attr,
140	&mount_attr.attr,
141	&nofat_op_attr.attr,
142	&vol_size_attr.attr,
143	NULL,
144	};
145
146	static struct attribute_group attr_group_statistics = {
147	.attrs = attributes_statistics,
148	};
149
150	int sdfat_statistics_init(struct kset *sdfat_kset)
151	{
152	int err;
153
154	sdfat_statistics_kset = kset_create_and_add("statistics", NULL, &sdfat_kset->kobj);
155	if (!sdfat_statistics_kset) {
156	pr_err("[SDFAT] failed to create sdfat statistics kobj\n");
157	return -ENOMEM;
158	}
159
160	err = sysfs_create_group(&sdfat_statistics_kset->kobj, &attr_group_statistics);
161	if (err) {
162	pr_err("[SDFAT] failed to create sdfat statistics attributes\n");
163	kset_unregister(sdfat_statistics_kset);
164	sdfat_statistics_kset = NULL;
165	return err;
166	}
167
168	return 0;
169	}
170
171	void sdfat_statistics_uninit(void)
172	{
173	if (sdfat_statistics_kset) {
174	sysfs_remove_group(&sdfat_statistics_kset->kobj, &attr_group_statistics);
175	kset_unregister(sdfat_statistics_kset);
176	sdfat_statistics_kset = NULL;
177	}
178	memset(&statistics, 0, sizeof(struct sdfat_statistics));
179	}
180
181	void sdfat_statistics_set_mnt(FS_INFO_T *fsi)
182	{
183	if (fsi->vol_type == EXFAT) {
184	statistics.mnt_cnt[SDFAT_MNT_EXFAT]++;
185	statistics.nofat_op[SDFAT_OP_EXFAT_MNT] = 1;
186	if (fsi->sect_per_clus_bits < SDFAT_EF_CLUS_MAX)
187	statistics.clus_exfat[fsi->sect_per_clus_bits]++;
188	else
189	statistics.clus_exfat[SDFAT_EF_CLUS_MAX - 1]++;
190	return;
191	}
192
193	if (fsi->vol_type == FAT32)
194	statistics.mnt_cnt[SDFAT_MNT_FAT32]++;
195	else if (fsi->vol_type == FAT16)
196	statistics.mnt_cnt[SDFAT_MNT_FAT16]++;
197	else if (fsi->vol_type == FAT12)
198	statistics.mnt_cnt[SDFAT_MNT_FAT12]++;
199
200	if (fsi->sect_per_clus_bits < SDFAT_VF_CLUS_MAX)
201	statistics.clus_vfat[fsi->sect_per_clus_bits]++;
202	else
203	statistics.clus_vfat[SDFAT_VF_CLUS_MAX - 1]++;
204	}
205
206	void sdfat_statistics_set_mnt_ro(void)
207	{
208	statistics.mnt_cnt[SDFAT_MNT_RO]++;
209	}
210
211	void sdfat_statistics_set_mkdir(u8 flags)
212	{
213	if (flags != 0x03)
214	return;
215	statistics.nofat_op[SDFAT_OP_MKDIR] = 1;
216	}
217
218	void sdfat_statistics_set_create(u8 flags)
219	{
220	if (flags != 0x03)
221	return;
222	statistics.nofat_op[SDFAT_OP_CREATE] = 1;
223	}
224
225	/* flags : file or dir flgas, 0x03 means no fat-chain.
226	* clu_offset : file or dir logical cluster offset
227	* create : BMAP_ADD_CLUSTER or not
228	*
229	* File or dir have BMAP_ADD_CLUSTER is no fat-chain write
230	* when they have 0x03 flag and two or more clusters.
231	* And don`t have BMAP_ADD_CLUSTER is no fat-chain read
232	* when above same condition.
233	*/
234	void sdfat_statistics_set_rw(u8 flags, u32 clu_offset, s32 create)
235	{
236	if ((flags == 0x03) && (clu_offset > 1)) {
237	if (create)
238	statistics.nofat_op[SDFAT_OP_WRITE] = 1;
239	else
240	statistics.nofat_op[SDFAT_OP_READ] = 1;
241	}
242	}
243
244	/* flags : file or dir flgas, 0x03 means no fat-chain.
245	* clu : cluster chain
246	*
247	* Set no fat-chain trunc when file or dir have 0x03 flag
248	* and two or more clusters.
249	*/
250	void sdfat_statistics_set_trunc(u8 flags, CHAIN_T *clu)
251	{
252	if ((flags == 0x03) && (clu->size > 1))
253	statistics.nofat_op[SDFAT_OP_TRUNC] = 1;
254	}
255
256	void sdfat_statistics_set_vol_size(struct super_block *sb)
257	{
258	u64 vol_size;
259	FS_INFO_T *fsi = &(SDFAT_SB(sb)->fsi);
260
261	vol_size = (u64)fsi->num_sectors << sb->s_blocksize_bits;
262
263	if (vol_size <= ((u64)1 << 32))
264	statistics.vol_size[SDFAT_VOL_4G]++;
265	else if (vol_size <= ((u64)1 << 33))
266	statistics.vol_size[SDFAT_VOL_8G]++;
267	else if (vol_size <= ((u64)1 << 34))
268	statistics.vol_size[SDFAT_VOL_16G]++;
269	else if (vol_size <= ((u64)1 << 35))
270	statistics.vol_size[SDFAT_VOL_32G]++;
271	else if (vol_size <= ((u64)1 << 36))
272	statistics.vol_size[SDFAT_VOL_64G]++;
273	else if (vol_size <= ((u64)1 << 37))
274	statistics.vol_size[SDFAT_VOL_128G]++;
275	else if (vol_size <= ((u64)1 << 38))
276	statistics.vol_size[SDFAT_VOL_256G]++;
277	else if (vol_size <= ((u64)1 << 39))
278	statistics.vol_size[SDFAT_VOL_512G]++;
279	else
280	statistics.vol_size[SDFAT_VOL_XTB]++;
281	}