xfs: always use iget in bulkstat (7dce11db) · Commits · 戴 / test

fs/xfs/linux-2.6/xfs_ioctl.c

+3 −4

Original line number	Original line	Diff line number	Diff line
	@@ -679,10 +679,9 @@ xfs_ioc_bulkstat(
	error = xfs_bulkstat_single(mp, &inlast,		error = xfs_bulkstat_single(mp, &inlast,
	bulkreq.ubuffer, &done);		bulkreq.ubuffer, &done);
	else /* XFS_IOC_FSBULKSTAT */		else /* XFS_IOC_FSBULKSTAT */
	error = xfs_bulkstat(mp, &inlast, &count,		error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
	(bulkstat_one_pf)xfs_bulkstat_one, NULL,
	sizeof(xfs_bstat_t), bulkreq.ubuffer,		sizeof(xfs_bstat_t), bulkreq.ubuffer,
	BULKSTAT_FG_QUICK, &done);		&done);

	if (error)		if (error)
	return -error;		return -error;

fs/xfs/linux-2.6/xfs_ioctl32.c

+4 −8

Original line number	Original line	Diff line number	Diff line
	@@ -237,15 +237,13 @@ xfs_bulkstat_one_compat(
	xfs_ino_t ino, /* inode number to get data for */		xfs_ino_t ino, /* inode number to get data for */
	void __user buffer, / buffer to place output in */		void __user buffer, / buffer to place output in */
	int ubsize, /* size of buffer */		int ubsize, /* size of buffer */
	void private_data, / my private data */
	xfs_daddr_t bno, /* starting bno of inode cluster */		xfs_daddr_t bno, /* starting bno of inode cluster */
	int ubused, / bytes used by me */		int ubused, / bytes used by me */
	void dibuff, / on-disk inode buffer */
	int stat) / BULKSTAT_RV_... */		int stat) / BULKSTAT_RV_... */
	{		{
	return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,		return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,
	xfs_bulkstat_one_fmt_compat, bno,		xfs_bulkstat_one_fmt_compat, bno,
	ubused, dibuff, stat);		ubused, stat);
	}		}

	/* copied from xfs_ioctl.c */		/* copied from xfs_ioctl.c */
	@@ -298,13 +296,11 @@ xfs_compat_ioc_bulkstat(
	int res;		int res;

	error = xfs_bulkstat_one_compat(mp, inlast, bulkreq.ubuffer,		error = xfs_bulkstat_one_compat(mp, inlast, bulkreq.ubuffer,
	sizeof(compat_xfs_bstat_t),		sizeof(compat_xfs_bstat_t), 0, NULL, &res);
	NULL, 0, NULL, NULL, &res);
	} else if (cmd == XFS_IOC_FSBULKSTAT_32) {		} else if (cmd == XFS_IOC_FSBULKSTAT_32) {
	error = xfs_bulkstat(mp, &inlast, &count,		error = xfs_bulkstat(mp, &inlast, &count,
	xfs_bulkstat_one_compat, NULL,		xfs_bulkstat_one_compat, sizeof(compat_xfs_bstat_t),
	sizeof(compat_xfs_bstat_t), bulkreq.ubuffer,		bulkreq.ubuffer, &done);
	BULKSTAT_FG_QUICK, &done);
	} else		} else
	error = XFS_ERROR(EINVAL);		error = XFS_ERROR(EINVAL);
	if (error)		if (error)

fs/xfs/quota/xfs_qm.c

+5 −6

Original line number	Original line	Diff line number	Diff line
	@@ -1632,10 +1632,8 @@ xfs_qm_dqusage_adjust(
	xfs_ino_t ino, /* inode number to get data for */		xfs_ino_t ino, /* inode number to get data for */
	void __user buffer, / not used */		void __user buffer, / not used */
	int ubsize, /* not used */		int ubsize, /* not used */
	void private_data, / not used */
	xfs_daddr_t bno, /* starting block of inode cluster */		xfs_daddr_t bno, /* starting block of inode cluster */
	int ubused, / not used */		int ubused, / not used */
	void dip, / on-disk inode pointer (not used) */
	int res) / result code value */		int res) / result code value */
	{		{
	xfs_inode_t *ip;		xfs_inode_t *ip;
	@@ -1796,9 +1794,10 @@ xfs_qm_quotacheck(
	* Iterate thru all the inodes in the file system,		* Iterate thru all the inodes in the file system,
	* adjusting the corresponding dquot counters in core.		* adjusting the corresponding dquot counters in core.
	*/		*/
	if ((error = xfs_bulkstat(mp, &lastino, &count,		error = xfs_bulkstat(mp, &lastino, &count,
	xfs_qm_dqusage_adjust, NULL,		xfs_qm_dqusage_adjust,
	structsz, NULL, BULKSTAT_FG_IGET, &done)))		structsz, NULL, &done);
			if (error)
	break;		break;

	} while (!done);		} while (!done);

fs/xfs/quota/xfs_qm_syscalls.c

+7 −9

Original line number	Original line	Diff line number	Diff line
	@@ -1109,10 +1109,8 @@ xfs_qm_internalqcheck_adjust(
	xfs_ino_t ino, /* inode number to get data for */		xfs_ino_t ino, /* inode number to get data for */
	void __user buffer, / not used */		void __user buffer, / not used */
	int ubsize, /* not used */		int ubsize, /* not used */
	void private_data, / not used */
	xfs_daddr_t bno, /* starting block of inode cluster */		xfs_daddr_t bno, /* starting block of inode cluster */
	int ubused, / not used */		int ubused, / not used */
	void dip, / not used */
	int res) / bulkstat result code */		int res) / bulkstat result code */
	{		{
	xfs_inode_t *ip;		xfs_inode_t *ip;
	@@ -1205,15 +1203,15 @@ xfs_qm_internalqcheck(
	* Iterate thru all the inodes in the file system,		* Iterate thru all the inodes in the file system,
	* adjusting the corresponding dquot counters		* adjusting the corresponding dquot counters
	*/		*/
	if ((error = xfs_bulkstat(mp, &lastino, &count,		error = xfs_bulkstat(mp, &lastino, &count,
	xfs_qm_internalqcheck_adjust, NULL,		xfs_qm_internalqcheck_adjust,
	0, NULL, BULKSTAT_FG_IGET, &done))) {		0, NULL, &done);
	break;
	}
	} while (! done);
	if (error) {		if (error) {
	cmn_err(CE_DEBUG, "Bulkstat returned error 0x%x", error);		cmn_err(CE_DEBUG, "Bulkstat returned error 0x%x", error);
			break;
	}		}
			} while (!done);

	cmn_err(CE_DEBUG, "Checking results against system dquots");		cmn_err(CE_DEBUG, "Checking results against system dquots");
	for (i = 0; i < qmtest_hashmask; i++) {		for (i = 0; i < qmtest_hashmask; i++) {
	xfs_dqtest_t d, n;		xfs_dqtest_t d, n;

fs/xfs/xfs_itable.c

+40 −241

Original line number	Original line	Diff line number	Diff line
	@@ -49,24 +49,41 @@ xfs_internal_inum(
	(ino == mp->m_sb.sb_uquotino \|\| ino == mp->m_sb.sb_gquotino)));		(ino == mp->m_sb.sb_uquotino \|\| ino == mp->m_sb.sb_gquotino)));
	}		}

	STATIC int		/*
	xfs_bulkstat_one_iget(		* Return stat information for one inode.
	xfs_mount_t mp, / mount point for filesystem */		* Return 0 if ok, else errno.
	xfs_ino_t ino, /* inode number to get data for */		*/
	xfs_daddr_t bno, /* starting bno of inode cluster */		int
	xfs_bstat_t buf, / return buffer */		xfs_bulkstat_one_int(
			struct xfs_mount mp, / mount point for filesystem */
			xfs_ino_t ino, /* inode to get data for */
			void __user buffer, / buffer to place output in */
			int ubsize, /* size of buffer */
			bulkstat_one_fmt_pf formatter, /* formatter, copy to user */
			xfs_daddr_t bno, /* starting bno of cluster */
			int ubused, / bytes used by me */
	int stat) / BULKSTAT_RV_... */		int stat) / BULKSTAT_RV_... */
	{		{
	xfs_icdinode_t dic; / dinode core info pointer */		struct xfs_icdinode dic; / dinode core info pointer */
	xfs_inode_t ip; / incore inode pointer */		struct xfs_inode ip; / incore inode pointer */
	struct inode *inode;		struct inode *inode;
	int error;		struct xfs_bstat buf; / return buffer */
			int error = 0; /* error value */

			*stat = BULKSTAT_RV_NOTHING;

			if (!buffer \|\| xfs_internal_inum(mp, ino))
			return XFS_ERROR(EINVAL);

			buf = kmem_alloc(sizeof(*buf), KM_SLEEP \| KM_MAYFAIL);
			if (!buf)
			return XFS_ERROR(ENOMEM);

	error = xfs_iget(mp, NULL, ino,		error = xfs_iget(mp, NULL, ino,
	XFS_IGET_BULKSTAT, XFS_ILOCK_SHARED, &ip, bno);		XFS_IGET_BULKSTAT, XFS_ILOCK_SHARED, &ip, bno);
	if (error) {		if (error) {
	*stat = BULKSTAT_RV_NOTHING;		*stat = BULKSTAT_RV_NOTHING;
	return error;		goto out_free;
	}		}

	ASSERT(ip != NULL);		ASSERT(ip != NULL);
	@@ -127,77 +144,16 @@ xfs_bulkstat_one_iget(
	buf->bs_blocks = dic->di_nblocks + ip->i_delayed_blks;		buf->bs_blocks = dic->di_nblocks + ip->i_delayed_blks;
	break;		break;
	}		}

	xfs_iput(ip, XFS_ILOCK_SHARED);		xfs_iput(ip, XFS_ILOCK_SHARED);
	return error;
	}

	STATIC void		error = formatter(buffer, ubsize, ubused, buf);
	xfs_bulkstat_one_dinode(
	xfs_mount_t mp, / mount point for filesystem */
	xfs_ino_t ino, /* inode number to get data for */
	xfs_dinode_t dic, / dinode inode pointer */
	xfs_bstat_t buf) / return buffer */
	{
	/*
	* The inode format changed when we moved the link count and
	* made it 32 bits long. If this is an old format inode,
	* convert it in memory to look like a new one. If it gets
	* flushed to disk we will convert back before flushing or
	* logging it. We zero out the new projid field and the old link
	* count field. We'll handle clearing the pad field (the remains
	* of the old uuid field) when we actually convert the inode to
	* the new format. We don't change the version number so that we
	* can distinguish this from a real new format inode.
	*/
	if (dic->di_version == 1) {
	buf->bs_nlink = be16_to_cpu(dic->di_onlink);
	buf->bs_projid = 0;
	} else {
	buf->bs_nlink = be32_to_cpu(dic->di_nlink);
	buf->bs_projid = be16_to_cpu(dic->di_projid);
	}

	buf->bs_ino = ino;		if (!error)
	buf->bs_mode = be16_to_cpu(dic->di_mode);		*stat = BULKSTAT_RV_DIDONE;
	buf->bs_uid = be32_to_cpu(dic->di_uid);
	buf->bs_gid = be32_to_cpu(dic->di_gid);
	buf->bs_size = be64_to_cpu(dic->di_size);
	buf->bs_atime.tv_sec = be32_to_cpu(dic->di_atime.t_sec);
	buf->bs_atime.tv_nsec = be32_to_cpu(dic->di_atime.t_nsec);
	buf->bs_mtime.tv_sec = be32_to_cpu(dic->di_mtime.t_sec);
	buf->bs_mtime.tv_nsec = be32_to_cpu(dic->di_mtime.t_nsec);
	buf->bs_ctime.tv_sec = be32_to_cpu(dic->di_ctime.t_sec);
	buf->bs_ctime.tv_nsec = be32_to_cpu(dic->di_ctime.t_nsec);
	buf->bs_xflags = xfs_dic2xflags(dic);
	buf->bs_extsize = be32_to_cpu(dic->di_extsize) << mp->m_sb.sb_blocklog;
	buf->bs_extents = be32_to_cpu(dic->di_nextents);
	buf->bs_gen = be32_to_cpu(dic->di_gen);
	memset(buf->bs_pad, 0, sizeof(buf->bs_pad));
	buf->bs_dmevmask = be32_to_cpu(dic->di_dmevmask);
	buf->bs_dmstate = be16_to_cpu(dic->di_dmstate);
	buf->bs_aextents = be16_to_cpu(dic->di_anextents);
	buf->bs_forkoff = XFS_DFORK_BOFF(dic);

	switch (dic->di_format) {		out_free:
	case XFS_DINODE_FMT_DEV:		kmem_free(buf);
	buf->bs_rdev = xfs_dinode_get_rdev(dic);		return error;
	buf->bs_blksize = BLKDEV_IOSIZE;
	buf->bs_blocks = 0;
	break;
	case XFS_DINODE_FMT_LOCAL:
	case XFS_DINODE_FMT_UUID:
	buf->bs_rdev = 0;
	buf->bs_blksize = mp->m_sb.sb_blocksize;
	buf->bs_blocks = 0;
	break;
	case XFS_DINODE_FMT_EXTENTS:
	case XFS_DINODE_FMT_BTREE:
	buf->bs_rdev = 0;
	buf->bs_blksize = mp->m_sb.sb_blocksize;
	buf->bs_blocks = be64_to_cpu(dic->di_nblocks);
	break;
	}
	}		}

	/* Return 0 on success or positive error */		/* Return 0 on success or positive error */
	@@ -217,118 +173,19 @@ xfs_bulkstat_one_fmt(
	return 0;		return 0;
	}		}

	/*
	* Return stat information for one inode.
	* Return 0 if ok, else errno.
	*/
	int /* error status */
	xfs_bulkstat_one_int(
	xfs_mount_t mp, / mount point for filesystem */
	xfs_ino_t ino, /* inode number to get data for */
	void __user buffer, / buffer to place output in */
	int ubsize, /* size of buffer */
	bulkstat_one_fmt_pf formatter, /* formatter, copy to user */
	xfs_daddr_t bno, /* starting bno of inode cluster */
	int ubused, / bytes used by me */
	void dibuff, / on-disk inode buffer */
	int stat) / BULKSTAT_RV_... */
	{
	xfs_bstat_t buf; / return buffer */
	int error = 0; /* error value */
	xfs_dinode_t dip; / dinode inode pointer */

	dip = (xfs_dinode_t *)dibuff;
	*stat = BULKSTAT_RV_NOTHING;

	if (!buffer \|\| xfs_internal_inum(mp, ino))
	return XFS_ERROR(EINVAL);

	buf = kmem_alloc(sizeof(*buf), KM_SLEEP);

	if (dip == NULL) {
	/* We're not being passed a pointer to a dinode. This happens
	* if BULKSTAT_FG_IGET is selected. Do the iget.
	*/
	error = xfs_bulkstat_one_iget(mp, ino, bno, buf, stat);
	if (error)
	goto out_free;
	} else {
	xfs_bulkstat_one_dinode(mp, ino, dip, buf);
	}

	error = formatter(buffer, ubsize, ubused, buf);
	if (error)
	goto out_free;

	*stat = BULKSTAT_RV_DIDONE;

	out_free:
	kmem_free(buf);
	return error;
	}

	int		int
	xfs_bulkstat_one(		xfs_bulkstat_one(
	xfs_mount_t mp, / mount point for filesystem */		xfs_mount_t mp, / mount point for filesystem */
	xfs_ino_t ino, /* inode number to get data for */		xfs_ino_t ino, /* inode number to get data for */
	void __user buffer, / buffer to place output in */		void __user buffer, / buffer to place output in */
	int ubsize, /* size of buffer */		int ubsize, /* size of buffer */
	void private_data, / my private data */
	xfs_daddr_t bno, /* starting bno of inode cluster */		xfs_daddr_t bno, /* starting bno of inode cluster */
	int ubused, / bytes used by me */		int ubused, / bytes used by me */
	void dibuff, / on-disk inode buffer */
	int stat) / BULKSTAT_RV_... */		int stat) / BULKSTAT_RV_... */
	{		{
	return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,		return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,
	xfs_bulkstat_one_fmt, bno,		xfs_bulkstat_one_fmt, bno,
	ubused, dibuff, stat);		ubused, stat);
	}

	/*
	* Test to see whether we can use the ondisk inode directly, based
	* on the given bulkstat flags, filling in dipp accordingly.
	* Returns zero if the inode is dodgey.
	*/
	STATIC int
	xfs_bulkstat_use_dinode(
	xfs_mount_t *mp,
	int flags,
	xfs_buf_t *bp,
	int clustidx,
	xfs_dinode_t **dipp)
	{
	xfs_dinode_t *dip;
	unsigned int aformat;

	*dipp = NULL;
	if (!bp \|\| (flags & BULKSTAT_FG_IGET))
	return 1;
	dip = (xfs_dinode_t *)
	xfs_buf_offset(bp, clustidx << mp->m_sb.sb_inodelog);
	/*
	* Check the buffer containing the on-disk inode for di_mode == 0.
	* This is to prevent xfs_bulkstat from picking up just reclaimed
	* inodes that have their in-core state initialized but not flushed
	* to disk yet. This is a temporary hack that would require a proper
	* fix in the future.
	*/
	if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC \|\|
	!XFS_DINODE_GOOD_VERSION(dip->di_version) \|\|
	!dip->di_mode)
	return 0;
	if (flags & BULKSTAT_FG_QUICK) {
	*dipp = dip;
	return 1;
	}
	/* BULKSTAT_FG_INLINE: if attr fork is local, or not there, use it */
	aformat = dip->di_aformat;
	if ((XFS_DFORK_Q(dip) == 0) \|\|
	(aformat == XFS_DINODE_FMT_LOCAL) \|\|
	(aformat == XFS_DINODE_FMT_EXTENTS && !dip->di_anextents)) {
	*dipp = dip;
	return 1;
	}
	return 1;
	}		}

	#define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size)		#define XFS_BULKSTAT_UBLEFT(ubleft) ((ubleft) >= statstruct_size)
	@@ -342,10 +199,8 @@ xfs_bulkstat(
	xfs_ino_t lastinop, / last inode returned */		xfs_ino_t lastinop, / last inode returned */
	int ubcountp, / size of buffer/count returned */		int ubcountp, / size of buffer/count returned */
	bulkstat_one_pf formatter, /* func that'd fill a single buf */		bulkstat_one_pf formatter, /* func that'd fill a single buf */
	void private_data,/ private data for formatter */
	size_t statstruct_size, /* sizeof struct filling */		size_t statstruct_size, /* sizeof struct filling */
	char __user ubuffer, / buffer with inode stats */		char __user ubuffer, / buffer with inode stats */
	int flags, /* defined in xfs_itable.h */
	int done) / 1 if there are more stats to get */		int done) / 1 if there are more stats to get */
	{		{
	xfs_agblock_t agbno=0;/* allocation group block number */		xfs_agblock_t agbno=0;/* allocation group block number */
	@@ -380,14 +235,12 @@ xfs_bulkstat(
	int ubelem; /* spaces used in user's buffer */		int ubelem; /* spaces used in user's buffer */
	int ubused; /* bytes used by formatter */		int ubused; /* bytes used by formatter */
	xfs_buf_t bp; / ptr to on-disk inode cluster buf */		xfs_buf_t bp; / ptr to on-disk inode cluster buf */
	xfs_dinode_t dip; / ptr into bp for specific inode */

	/*		/*
	* Get the last inode value, see if there's nothing to do.		* Get the last inode value, see if there's nothing to do.
	*/		*/
	ino = (xfs_ino_t)*lastinop;		ino = (xfs_ino_t)*lastinop;
	lastino = ino;		lastino = ino;
	dip = NULL;
	agno = XFS_INO_TO_AGNO(mp, ino);		agno = XFS_INO_TO_AGNO(mp, ino);
	agino = XFS_INO_TO_AGINO(mp, ino);		agino = XFS_INO_TO_AGINO(mp, ino);
	if (agno >= mp->m_sb.sb_agcount \|\|		if (agno >= mp->m_sb.sb_agcount \|\|
	@@ -612,37 +465,6 @@ xfs_bulkstat(
	irbp->ir_startino) +		irbp->ir_startino) +
	((chunkidx & nimask) >>		((chunkidx & nimask) >>
	mp->m_sb.sb_inopblog);		mp->m_sb.sb_inopblog);

	if (flags & (BULKSTAT_FG_QUICK \|
	BULKSTAT_FG_INLINE)) {
	int offset;

	ino = XFS_AGINO_TO_INO(mp, agno,
	agino);
	bno = XFS_AGB_TO_DADDR(mp, agno,
	agbno);

	/*
	* Get the inode cluster buffer
	*/
	if (bp)
	xfs_buf_relse(bp);

	error = xfs_inotobp(mp, NULL, ino, &dip,
	&bp, &offset,
	XFS_IGET_BULKSTAT);

	if (!error)
	clustidx = offset / mp->m_sb.sb_inodesize;
	if (XFS_TEST_ERROR(error != 0,
	mp, XFS_ERRTAG_BULKSTAT_READ_CHUNK,
	XFS_RANDOM_BULKSTAT_READ_CHUNK)) {
	bp = NULL;
	ubleft = 0;
	rval = error;
	break;
	}
	}
	}		}
	ino = XFS_AGINO_TO_INO(mp, agno, agino);		ino = XFS_AGINO_TO_INO(mp, agno, agino);
	bno = XFS_AGB_TO_DADDR(mp, agno, agbno);		bno = XFS_AGB_TO_DADDR(mp, agno, agbno);
	@@ -658,35 +480,13 @@ xfs_bulkstat(
	* when the chunk is used up.		* when the chunk is used up.
	*/		*/
	irbp->ir_freecount++;		irbp->ir_freecount++;
	if (!xfs_bulkstat_use_dinode(mp, flags, bp,
	clustidx, &dip)) {
	lastino = ino;
	continue;
	}
	/*
	* If we need to do an iget, cannot hold bp.
	* Drop it, until starting the next cluster.
	*/
	if ((flags & BULKSTAT_FG_INLINE) && !dip) {
	if (bp)
	xfs_buf_relse(bp);
	bp = NULL;
	}

	/*		/*
	* Get the inode and fill in a single buffer.		* Get the inode and fill in a single buffer.
	* BULKSTAT_FG_QUICK uses dip to fill it in.
	* BULKSTAT_FG_IGET uses igets.
	* BULKSTAT_FG_INLINE uses dip if we have an
	* inline attr fork, else igets.
	* See: xfs_bulkstat_one & xfs_dm_bulkstat_one.
	* This is also used to count inodes/blks, etc
	* in xfs_qm_quotacheck.
	*/		*/
	ubused = statstruct_size;		ubused = statstruct_size;
	error = formatter(mp, ino, ubufp,		error = formatter(mp, ino, ubufp, ubleft, bno,
	ubleft, private_data,		&ubused, &fmterror);
	bno, &ubused, dip, &fmterror);
	if (fmterror == BULKSTAT_RV_NOTHING) {		if (fmterror == BULKSTAT_RV_NOTHING) {
	if (error && error != ENOENT &&		if (error && error != ENOENT &&
	error != EINVAL) {		error != EINVAL) {
	@@ -779,7 +579,7 @@ xfs_bulkstat_single(

	ino = (xfs_ino_t)*lastinop;		ino = (xfs_ino_t)*lastinop;
	error = xfs_bulkstat_one(mp, ino, buffer, sizeof(xfs_bstat_t),		error = xfs_bulkstat_one(mp, ino, buffer, sizeof(xfs_bstat_t),
	NULL, 0, NULL, NULL, &res);		0, NULL, &res);
	if (error) {		if (error) {
	/*		/*
	* Special case way failed, do it the "long" way		* Special case way failed, do it the "long" way
	@@ -788,8 +588,7 @@ xfs_bulkstat_single(
	(*lastinop)--;		(*lastinop)--;
	count = 1;		count = 1;
	if (xfs_bulkstat(mp, lastinop, &count, xfs_bulkstat_one,		if (xfs_bulkstat(mp, lastinop, &count, xfs_bulkstat_one,
	NULL, sizeof(xfs_bstat_t), buffer,		sizeof(xfs_bstat_t), buffer, done))
	BULKSTAT_FG_IGET, done))
	return error;		return error;
	if (count == 0 \|\| (xfs_ino_t)*lastinop != ino)		if (count == 0 \|\| (xfs_ino_t)*lastinop != ino)
	return error == EFSCORRUPTED ?		return error == EFSCORRUPTED ?

Admin message