[linux-block.git] / fs / xfs / xfs_pnfs.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2014 Christoph Hellwig.
 */
#include "xfs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
#include "xfs_trans.h"
#include "xfs_bmap.h"
#include "xfs_iomap.h"
#include "xfs_pnfs.h"

/*
 * Ensure that we do not have any outstanding pNFS layouts that can be used by
 * clients to directly read from or write to this inode.  This must be called
 * before every operation that can remove blocks from the extent map.
 * Additionally we call it during the write operation, where aren't concerned
 * about exposing unallocated blocks but just want to provide basic
 * synchronization between a local writer and pNFS clients.  mmap writes would
 * also benefit from this sort of synchronization, but due to the tricky locking
 * rules in the page fault path we don't bother.
 */
int
xfs_break_leased_layouts(
	struct inode		*inode,
	uint			*iolock,
	bool			*did_unlock)
{
	struct xfs_inode	*ip = XFS_I(inode);
	int			error;

	while ((error = break_layout(inode, false)) == -EWOULDBLOCK) {
		xfs_iunlock(ip, *iolock);
		*did_unlock = true;
		error = break_layout(inode, true);
		*iolock &= ~XFS_IOLOCK_SHARED;
		*iolock |= XFS_IOLOCK_EXCL;
		xfs_ilock(ip, *iolock);
	}

	return error;
}

/*
 * Get a unique ID including its location so that the client can identify
 * the exported device.
 */
int
xfs_fs_get_uuid(
	struct super_block	*sb,
	u8			*buf,
	u32			*len,
	u64			*offset)
{
	struct xfs_mount	*mp = XFS_M(sb);

	xfs_notice_once(mp,
"Using experimental pNFS feature, use at your own risk!");

	if (*len < sizeof(uuid_t))
		return -EINVAL;

	memcpy(buf, &mp->m_sb.sb_uuid, sizeof(uuid_t));
	*len = sizeof(uuid_t);
	*offset = offsetof(struct xfs_dsb, sb_uuid);
	return 0;
}

/*
 * We cannot use file based VFS helpers such as file_modified() to update
 * inode state as we modify the data/metadata in the inode here. Hence we have
 * to open code the timestamp updates and SUID/SGID stripping. We also need
 * to set the inode prealloc flag to ensure that the extents we allocate are not
 * removed if the inode is reclaimed from memory before xfs_fs_block_commit()
 * is from the client to indicate that data has been written and the file size
 * can be extended.
 */
static int
xfs_fs_map_update_inode(
	struct xfs_inode	*ip)
{
	struct xfs_trans	*tp;
	int			error;

	error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
			0, 0, 0, &tp);
	if (error)
		return error;

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);

	VFS_I(ip)->i_mode &= ~S_ISUID;
	if (VFS_I(ip)->i_mode & S_IXGRP)
		VFS_I(ip)->i_mode &= ~S_ISGID;
	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
	ip->i_diflags |= XFS_DIFLAG_PREALLOC;

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	return xfs_trans_commit(tp);
}

/*
 * Get a layout for the pNFS client.
 */
int
xfs_fs_map_blocks(
	struct inode		*inode,
	loff_t			offset,
	u64			length,
	struct iomap		*iomap,
	bool			write,
	u32			*device_generation)
{
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_bmbt_irec	imap;
	xfs_fileoff_t		offset_fsb, end_fsb;
	loff_t			limit;
	int			bmapi_flags = XFS_BMAPI_ENTIRE;
	int			nimaps = 1;
	uint			lock_flags;
	int			error = 0;

	if (xfs_is_shutdown(mp))
		return -EIO;

	/*
	 * We can't export inodes residing on the realtime device.  The realtime
	 * device doesn't have a UUID to identify it, so the client has no way
	 * to find it.
	 */
	if (XFS_IS_REALTIME_INODE(ip))
		return -ENXIO;

	/*
	 * The pNFS block layout spec actually supports reflink like
	 * functionality, but the Linux pNFS server doesn't implement it yet.
	 */
	if (xfs_is_reflink_inode(ip))
		return -ENXIO;

	/*
	 * Lock out any other I/O before we flush and invalidate the pagecache,
	 * and then hand out a layout to the remote system.  This is very
	 * similar to direct I/O, except that the synchronization is much more
	 * complicated.  See the comment near xfs_break_leased_layouts
	 * for a detailed explanation.
	 */
	xfs_ilock(ip, XFS_IOLOCK_EXCL);

	error = -EINVAL;
	limit = mp->m_super->s_maxbytes;
	if (!write)
		limit = max(limit, round_up(i_size_read(inode),
				     inode->i_sb->s_blocksize));
	if (offset > limit)
		goto out_unlock;
	if (offset > limit - length)
		length = limit - offset;

	error = filemap_write_and_wait(inode->i_mapping);
	if (error)
		goto out_unlock;
	error = invalidate_inode_pages2(inode->i_mapping);
	if (WARN_ON_ONCE(error))
		goto out_unlock;

	end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + length);
	offset_fsb = XFS_B_TO_FSBT(mp, offset);

	lock_flags = xfs_ilock_data_map_shared(ip);
	error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
				&imap, &nimaps, bmapi_flags);

	ASSERT(!nimaps || imap.br_startblock != DELAYSTARTBLOCK);

	if (!error && write &&
	    (!nimaps || imap.br_startblock == HOLESTARTBLOCK)) {
		if (offset + length > XFS_ISIZE(ip))
			end_fsb = xfs_iomap_eof_align_last_fsb(ip, end_fsb);
		else if (nimaps && imap.br_startblock == HOLESTARTBLOCK)
			end_fsb = min(end_fsb, imap.br_startoff +
					       imap.br_blockcount);
		xfs_iunlock(ip, lock_flags);

		error = xfs_iomap_write_direct(ip, offset_fsb,
				end_fsb - offset_fsb, 0, &imap);
		if (error)
			goto out_unlock;

		/*
		 * Ensure the next transaction is committed synchronously so
		 * that the blocks allocated and handed out to the client are
		 * guaranteed to be present even after a server crash.
		 */
		error = xfs_fs_map_update_inode(ip);
		if (!error)
			error = xfs_log_force_inode(ip);
		if (error)
			goto out_unlock;

	} else {
		xfs_iunlock(ip, lock_flags);
	}
	xfs_iunlock(ip, XFS_IOLOCK_EXCL);

	error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0, 0);
	*device_generation = mp->m_generation;
	return error;
out_unlock:
	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
	return error;
}

/*
 * Ensure the size update falls into a valid allocated block.
 */
static int
xfs_pnfs_validate_isize(
	struct xfs_inode	*ip,
	xfs_off_t		isize)
{
	struct xfs_bmbt_irec	imap;
	int			nimaps = 1;
	int			error = 0;

	xfs_ilock(ip, XFS_ILOCK_SHARED);
	error = xfs_bmapi_read(ip, XFS_B_TO_FSBT(ip->i_mount, isize - 1), 1,
				&imap, &nimaps, 0);
	xfs_iunlock(ip, XFS_ILOCK_SHARED);
	if (error)
		return error;

	if (imap.br_startblock == HOLESTARTBLOCK ||
	    imap.br_startblock == DELAYSTARTBLOCK ||
	    imap.br_state == XFS_EXT_UNWRITTEN)
		return -EIO;
	return 0;
}

/*
 * Make sure the blocks described by maps are stable on disk.  This includes
 * converting any unwritten extents, flushing the disk cache and updating the
 * time stamps.
 *
 * Note that we rely on the caller to always send us a timestamp update so that
 * we always commit a transaction here.  If that stops being true we will have
 * to manually flush the cache here similar to what the fsync code path does
 * for datasyncs on files that have no dirty metadata.
 */
int
xfs_fs_commit_blocks(
	struct inode		*inode,
	struct iomap		*maps,
	int			nr_maps,
	struct iattr		*iattr)
{
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_trans	*tp;
	bool			update_isize = false;
	int			error, i;
	loff_t			size;

	ASSERT(iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME));

	xfs_ilock(ip, XFS_IOLOCK_EXCL);

	size = i_size_read(inode);
	if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size > size) {
		update_isize = true;
		size = iattr->ia_size;
	}

	for (i = 0; i < nr_maps; i++) {
		u64 start, length, end;

		start = maps[i].offset;
		if (start > size)
			continue;

		end = start + maps[i].length;
		if (end > size)
			end = size;

		length = end - start;
		if (!length)
			continue;

		/*
		 * Make sure reads through the pagecache see the new data.
		 */
		error = invalidate_inode_pages2_range(inode->i_mapping,
					start >> PAGE_SHIFT,
					(end - 1) >> PAGE_SHIFT);
		WARN_ON_ONCE(error);

		error = xfs_iomap_write_unwritten(ip, start, length, false);
		if (error)
			goto out_drop_iolock;
	}

	if (update_isize) {
		error = xfs_pnfs_validate_isize(ip, size);
		if (error)
			goto out_drop_iolock;
	}

	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
	if (error)
		goto out_drop_iolock;

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

	ASSERT(!(iattr->ia_valid & (ATTR_UID | ATTR_GID)));
	setattr_copy(&init_user_ns, inode, iattr);
	if (update_isize) {
		i_size_write(inode, iattr->ia_size);
		ip->i_disk_size = iattr->ia_size;
	}

	xfs_trans_set_sync(tp);
	error = xfs_trans_commit(tp);

out_drop_iolock:
	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
	return error;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
52785112 CH	2	/*
	3	* Copyright (c) 2014 Christoph Hellwig.
	4	*/
	5	#include "xfs.h"
5467b34b	6	#include "xfs_shared.h"
52785112 CH	7	#include "xfs_format.h"
	8	#include "xfs_log_format.h"
	9	#include "xfs_trans_resv.h"
52785112 CH	10	#include "xfs_mount.h"
	11	#include "xfs_inode.h"
	12	#include "xfs_trans.h"
52785112	13	#include "xfs_bmap.h"
52785112	14	#include "xfs_iomap.h"
1aa63006	15	#include "xfs_pnfs.h"
52785112	16
781355c6 CH	17	/*
	18	* Ensure that we do not have any outstanding pNFS layouts that can be used by
	19	* clients to directly read from or write to this inode. This must be called
	20	* before every operation that can remove blocks from the extent map.
	21	* Additionally we call it during the write operation, where aren't concerned
	22	* about exposing unallocated blocks but just want to provide basic
	23	* synchronization between a local writer and pNFS clients. mmap writes would
	24	* also benefit from this sort of synchronization, but due to the tricky locking
	25	* rules in the page fault path we don't bother.
	26	*/
	27	int
69eb5fa1	28	xfs_break_leased_layouts(
781355c6	29	struct inode *inode,
69eb5fa1 DW	30	uint *iolock,
69eb5fa1 DW	31	bool *did_unlock)
781355c6 CH	32	{
	33	struct xfs_inode *ip = XFS_I(inode);
	34	int error;
	35
b6827160	36	while ((error = break_layout(inode, false)) == -EWOULDBLOCK) {
781355c6	37	xfs_iunlock(ip, *iolock);
69eb5fa1	38	*did_unlock = true;
781355c6	39	error = break_layout(inode, true);
c63a8eae DW	40	*iolock &= ~XFS_IOLOCK_SHARED;
c63a8eae DW	41	*iolock \|= XFS_IOLOCK_EXCL;
781355c6 CH	42	xfs_ilock(ip, *iolock);
	43	}
	44
	45	return error;
	46	}
	47
52785112 CH	48	/*
	49	* Get a unique ID including its location so that the client can identify
	50	* the exported device.
	51	*/
	52	int
	53	xfs_fs_get_uuid(
	54	struct super_block *sb,
	55	u8 *buf,
	56	u32 *len,
	57	u64 *offset)
	58	{
	59	struct xfs_mount *mp = XFS_M(sb);
	60
ec43f6da ES	61	xfs_notice_once(mp,
ec43f6da ES	62	"Using experimental pNFS feature, use at your own risk!");
52785112 CH	63
	64	if (*len < sizeof(uuid_t))
	65	return -EINVAL;
	66
	67	memcpy(buf, &mp->m_sb.sb_uuid, sizeof(uuid_t));
	68	*len = sizeof(uuid_t);
	69	*offset = offsetof(struct xfs_dsb, sb_uuid);
	70	return 0;
	71	}
	72
b39a0463 DC	73	/*
	74	* We cannot use file based VFS helpers such as file_modified() to update
	75	* inode state as we modify the data/metadata in the inode here. Hence we have
	76	* to open code the timestamp updates and SUID/SGID stripping. We also need
	77	* to set the inode prealloc flag to ensure that the extents we allocate are not
	78	* removed if the inode is reclaimed from memory before xfs_fs_block_commit()
	79	* is from the client to indicate that data has been written and the file size
	80	* can be extended.
	81	*/
	82	static int
	83	xfs_fs_map_update_inode(
	84	struct xfs_inode *ip)
	85	{
	86	struct xfs_trans *tp;
	87	int error;
	88
	89	error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
	90	0, 0, 0, &tp);
	91	if (error)
	92	return error;
	93
	94	xfs_ilock(ip, XFS_ILOCK_EXCL);
	95	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
	96
	97	VFS_I(ip)->i_mode &= ~S_ISUID;
	98	if (VFS_I(ip)->i_mode & S_IXGRP)
	99	VFS_I(ip)->i_mode &= ~S_ISGID;
	100	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD \| XFS_ICHGTIME_CHG);
	101	ip->i_diflags \|= XFS_DIFLAG_PREALLOC;
	102
	103	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	104	return xfs_trans_commit(tp);
	105	}
	106
52785112 CH	107	/*
	108	* Get a layout for the pNFS client.
	109	*/
	110	int
	111	xfs_fs_map_blocks(
	112	struct inode *inode,
	113	loff_t offset,
	114	u64 length,
	115	struct iomap *iomap,
	116	bool write,
	117	u32 *device_generation)
	118	{
	119	struct xfs_inode *ip = XFS_I(inode);
	120	struct xfs_mount *mp = ip->i_mount;
	121	struct xfs_bmbt_irec imap;
	122	xfs_fileoff_t offset_fsb, end_fsb;
	123	loff_t limit;
	124	int bmapi_flags = XFS_BMAPI_ENTIRE;
	125	int nimaps = 1;
	126	uint lock_flags;
	127	int error = 0;
	128
75c8c50f	129	if (xfs_is_shutdown(mp))
52785112 CH	130	return -EIO;
	131
	132	/*
	133	* We can't export inodes residing on the realtime device. The realtime
	134	* device doesn't have a UUID to identify it, so the client has no way
	135	* to find it.
	136	*/
	137	if (XFS_IS_REALTIME_INODE(ip))
	138	return -ENXIO;
	139
46eeb521 DW	140	/*
	141	* The pNFS block layout spec actually supports reflink like
	142	* functionality, but the Linux pNFS server doesn't implement it yet.
	143	*/
	144	if (xfs_is_reflink_inode(ip))
	145	return -ENXIO;
	146
52785112 CH	147	/*
	148	* Lock out any other I/O before we flush and invalidate the pagecache,
	149	* and then hand out a layout to the remote system. This is very
	150	* similar to direct I/O, except that the synchronization is much more
69eb5fa1 DW	151	* complicated. See the comment near xfs_break_leased_layouts
69eb5fa1 DW	152	* for a detailed explanation.
52785112 CH	153	*/
	154	xfs_ilock(ip, XFS_IOLOCK_EXCL);
	155
	156	error = -EINVAL;
	157	limit = mp->m_super->s_maxbytes;
	158	if (!write)
	159	limit = max(limit, round_up(i_size_read(inode),
	160	inode->i_sb->s_blocksize));
	161	if (offset > limit)
	162	goto out_unlock;
	163	if (offset > limit - length)
	164	length = limit - offset;
	165
	166	error = filemap_write_and_wait(inode->i_mapping);
	167	if (error)
	168	goto out_unlock;
	169	error = invalidate_inode_pages2(inode->i_mapping);
	170	if (WARN_ON_ONCE(error))
2bd3fa79	171	goto out_unlock;
52785112 CH	172
	173	end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + length);
	174	offset_fsb = XFS_B_TO_FSBT(mp, offset);
	175
	176	lock_flags = xfs_ilock_data_map_shared(ip);
	177	error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
	178	&imap, &nimaps, bmapi_flags);
52785112	179
88cdb714 CH	180	ASSERT(!nimaps \|\| imap.br_startblock != DELAYSTARTBLOCK);
88cdb714 CH	181
e696663a CH	182	if (!error && write &&
	183	(!nimaps \|\| imap.br_startblock == HOLESTARTBLOCK)) {
	184	if (offset + length > XFS_ISIZE(ip))
	185	end_fsb = xfs_iomap_eof_align_last_fsb(ip, end_fsb);
	186	else if (nimaps && imap.br_startblock == HOLESTARTBLOCK)
	187	end_fsb = min(end_fsb, imap.br_startoff +
	188	imap.br_blockcount);
	189	xfs_iunlock(ip, lock_flags);
	190
	191	error = xfs_iomap_write_direct(ip, offset_fsb,
952da063	192	end_fsb - offset_fsb, 0, &imap);
307cdb54 CH	193	if (error)
	194	goto out_unlock;
	195
	196	/*
	197	* Ensure the next transaction is committed synchronously so
	198	* that the blocks allocated and handed out to the client are
	199	* guaranteed to be present even after a server crash.
	200	*/
b39a0463	201	error = xfs_fs_map_update_inode(ip);
472c6e46 DC	202	if (!error)
472c6e46 DC	203	error = xfs_log_force_inode(ip);
52785112 CH	204	if (error)
52785112 CH	205	goto out_unlock;
472c6e46	206
e696663a CH	207	} else {
e696663a CH	208	xfs_iunlock(ip, lock_flags);
52785112 CH	209	}
	210	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
	211
740fd671	212	error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0, 0);
52785112 CH	213	*device_generation = mp->m_generation;
	214	return error;
	215	out_unlock:
	216	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
	217	return error;
	218	}
	219
	220	/*
	221	* Ensure the size update falls into a valid allocated block.
	222	*/
	223	static int
	224	xfs_pnfs_validate_isize(
	225	struct xfs_inode *ip,
	226	xfs_off_t isize)
	227	{
	228	struct xfs_bmbt_irec imap;
	229	int nimaps = 1;
	230	int error = 0;
	231
	232	xfs_ilock(ip, XFS_ILOCK_SHARED);
	233	error = xfs_bmapi_read(ip, XFS_B_TO_FSBT(ip->i_mount, isize - 1), 1,
	234	&imap, &nimaps, 0);
	235	xfs_iunlock(ip, XFS_ILOCK_SHARED);
	236	if (error)
	237	return error;
	238
	239	if (imap.br_startblock == HOLESTARTBLOCK \|\|
	240	imap.br_startblock == DELAYSTARTBLOCK \|\|
	241	imap.br_state == XFS_EXT_UNWRITTEN)
	242	return -EIO;
	243	return 0;
	244	}
	245
	246	/*
	247	* Make sure the blocks described by maps are stable on disk. This includes
	248	* converting any unwritten extents, flushing the disk cache and updating the
	249	* time stamps.
	250	*
	251	* Note that we rely on the caller to always send us a timestamp update so that
	252	* we always commit a transaction here. If that stops being true we will have
	253	* to manually flush the cache here similar to what the fsync code path does
	254	* for datasyncs on files that have no dirty metadata.
	255	*/
	256	int
	257	xfs_fs_commit_blocks(
	258	struct inode *inode,
	259	struct iomap *maps,
	260	int nr_maps,
	261	struct iattr *iattr)
	262	{
	263	struct xfs_inode *ip = XFS_I(inode);
	264	struct xfs_mount *mp = ip->i_mount;
	265	struct xfs_trans *tp;
	266	bool update_isize = false;
	267	int error, i;
	268	loff_t size;
	269
	270	ASSERT(iattr->ia_valid & (ATTR_ATIME\|ATTR_CTIME\|ATTR_MTIME));
	271
	272	xfs_ilock(ip, XFS_IOLOCK_EXCL);
	273
	274	size = i_size_read(inode);
	275	if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size > size) {
	276	update_isize = true;
277	size = iattr->ia_size;
278	}
279
280	for (i = 0; i < nr_maps; i++) {
281	u64 start, length, end;
282
283	start = maps[i].offset;
284	if (start > size)
285	continue;
286
287	end = start + maps[i].length;
288	if (end > size)
289	end = size;
290
291	length = end - start;
292	if (!length)
293	continue;
b39a0463	294
52785112 CH	295	/*
	296	* Make sure reads through the pagecache see the new data.
	297	*/
	298	error = invalidate_inode_pages2_range(inode->i_mapping,
09cbfeaf KS	299	start >> PAGE_SHIFT,
09cbfeaf KS	300	(end - 1) >> PAGE_SHIFT);
52785112 CH	301	WARN_ON_ONCE(error);
52785112 CH	302
ee70daab	303	error = xfs_iomap_write_unwritten(ip, start, length, false);
52785112 CH	304	if (error)
	305	goto out_drop_iolock;
	306	}
	307
	308	if (update_isize) {
	309	error = xfs_pnfs_validate_isize(ip, size);
	310	if (error)
	311	goto out_drop_iolock;
	312	}
	313
253f4911 CH	314	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
253f4911 CH	315	if (error)
52785112 CH	316	goto out_drop_iolock;
	317
	318	xfs_ilock(ip, XFS_ILOCK_EXCL);
	319	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
	320	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	321
e014f37d DW	322	ASSERT(!(iattr->ia_valid & (ATTR_UID \| ATTR_GID)));
e014f37d DW	323	setattr_copy(&init_user_ns, inode, iattr);
52785112 CH	324	if (update_isize) {
52785112 CH	325	i_size_write(inode, iattr->ia_size);
13d2c10b	326	ip->i_disk_size = iattr->ia_size;
52785112 CH	327	}
	328
	329	xfs_trans_set_sync(tp);
70393313	330	error = xfs_trans_commit(tp);
52785112 CH	331
	332	out_drop_iolock:
	333	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
	334	return error;
	335	}