1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2014 Christoph Hellwig.
  4 */
  5#include "xfs.h"
  6#include "xfs_shared.h"
  7#include "xfs_format.h"
  8#include "xfs_log_format.h"
  9#include "xfs_trans_resv.h"
 10#include "xfs_mount.h"
 11#include "xfs_inode.h"
 12#include "xfs_trans.h"
 13#include "xfs_bmap.h"
 14#include "xfs_iomap.h"
 15#include "xfs_pnfs.h"
 16
 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 */
 27int
 28xfs_break_leased_layouts(
 29	struct inode		*inode,
 30	uint			*iolock,
 31	bool			*did_unlock)
 32{
 33	struct xfs_inode	*ip = XFS_I(inode);
 34	int			error;
 35
 36	while ((error = break_layout(inode, false)) == -EWOULDBLOCK) {
 37		xfs_iunlock(ip, *iolock);
 38		*did_unlock = true;
 39		error = break_layout(inode, true);
 40		*iolock &= ~XFS_IOLOCK_SHARED;
 41		*iolock |= XFS_IOLOCK_EXCL;
 42		xfs_ilock(ip, *iolock);
 43	}
 44
 45	return error;
 46}
 47
 48/*
 49 * Get a unique ID including its location so that the client can identify
 50 * the exported device.
 51 */
 52int
 53xfs_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
 61	xfs_warn_experimental(mp, XFS_EXPERIMENTAL_PNFS);
 62
 63	if (*len < sizeof(uuid_t))
 64		return -EINVAL;
 65
 66	memcpy(buf, &mp->m_sb.sb_uuid, sizeof(uuid_t));
 67	*len = sizeof(uuid_t);
 68	*offset = offsetof(struct xfs_dsb, sb_uuid);
 69	return 0;
 70}
 71
 72/*
 73 * We cannot use file based VFS helpers such as file_modified() to update
 74 * inode state as we modify the data/metadata in the inode here. Hence we have
 75 * to open code the timestamp updates and SUID/SGID stripping. We also need
 76 * to set the inode prealloc flag to ensure that the extents we allocate are not
 77 * removed if the inode is reclaimed from memory before xfs_fs_block_commit()
 78 * is from the client to indicate that data has been written and the file size
 79 * can be extended.
 80 */
 81static int
 82xfs_fs_map_update_inode(
 83	struct xfs_inode	*ip)
 84{
 85	struct xfs_trans	*tp;
 86	int			error;
 87
 88	error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_writeid,
 89			0, 0, 0, &tp);
 90	if (error)
 91		return error;
 92
 93	xfs_ilock(ip, XFS_ILOCK_EXCL);
 94	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 95
 96	VFS_I(ip)->i_mode &= ~S_ISUID;
 97	if (VFS_I(ip)->i_mode & S_IXGRP)
 98		VFS_I(ip)->i_mode &= ~S_ISGID;
 99	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
100	ip->i_diflags |= XFS_DIFLAG_PREALLOC;
101
102	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
103	return xfs_trans_commit(tp);
104}
105
106/*
107 * Get a layout for the pNFS client.
108 */
109int
110xfs_fs_map_blocks(
111	struct inode		*inode,
112	loff_t			offset,
113	u64			length,
114	struct iomap		*iomap,
115	bool			write,
116	u32			*device_generation)
117{
118	struct xfs_inode	*ip = XFS_I(inode);
119	struct xfs_mount	*mp = ip->i_mount;
120	struct xfs_bmbt_irec	imap;
121	xfs_fileoff_t		offset_fsb, end_fsb;
122	loff_t			limit;
123	int			bmapi_flags = XFS_BMAPI_ENTIRE;
124	int			nimaps = 1;
125	uint			lock_flags;
126	int			error = 0;
127	u64			seq;
128
129	if (xfs_is_shutdown(mp))
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
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
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
151	 * complicated.  See the comment near xfs_break_leased_layouts
152	 * for a detailed explanation.
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))
171		goto out_unlock;
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);
179	seq = xfs_iomap_inode_sequence(ip, 0);
180
181	ASSERT(!nimaps || imap.br_startblock != DELAYSTARTBLOCK);
182
183	if (!error && write &&
184	    (!nimaps || imap.br_startblock == HOLESTARTBLOCK)) {
185		if (offset + length > XFS_ISIZE(ip))
186			end_fsb = xfs_iomap_eof_align_last_fsb(ip, end_fsb);
187		else if (nimaps && imap.br_startblock == HOLESTARTBLOCK)
188			end_fsb = min(end_fsb, imap.br_startoff +
189					       imap.br_blockcount);
190		xfs_iunlock(ip, lock_flags);
191
192		error = xfs_iomap_write_direct(ip, offset_fsb,
193				end_fsb - offset_fsb, 0, &imap, &seq);
194		if (error)
195			goto out_unlock;
196
197		/*
198		 * Ensure the next transaction is committed synchronously so
199		 * that the blocks allocated and handed out to the client are
200		 * guaranteed to be present even after a server crash.
201		 */
202		error = xfs_fs_map_update_inode(ip);
203		if (!error)
204			error = xfs_log_force_inode(ip);
205		if (error)
206			goto out_unlock;
207
208	} else {
209		xfs_iunlock(ip, lock_flags);
210	}
211	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
212
213	error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0, 0, seq);
214	*device_generation = mp->m_generation;
215	return error;
216out_unlock:
217	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
218	return error;
219}
220
221/*
222 * Ensure the size update falls into a valid allocated block.
223 */
224static int
225xfs_pnfs_validate_isize(
226	struct xfs_inode	*ip,
227	xfs_off_t		isize)
228{
229	struct xfs_bmbt_irec	imap;
230	int			nimaps = 1;
231	int			error = 0;
232
233	xfs_ilock(ip, XFS_ILOCK_SHARED);
234	error = xfs_bmapi_read(ip, XFS_B_TO_FSBT(ip->i_mount, isize - 1), 1,
235				&imap, &nimaps, 0);
236	xfs_iunlock(ip, XFS_ILOCK_SHARED);
237	if (error)
238		return error;
239
240	if (imap.br_startblock == HOLESTARTBLOCK ||
241	    imap.br_startblock == DELAYSTARTBLOCK ||
242	    imap.br_state == XFS_EXT_UNWRITTEN)
243		return -EIO;
244	return 0;
245}
246
247/*
248 * Make sure the blocks described by maps are stable on disk.  This includes
249 * converting any unwritten extents, flushing the disk cache and updating the
250 * time stamps.
251 *
252 * Note that we rely on the caller to always send us a timestamp update so that
253 * we always commit a transaction here.  If that stops being true we will have
254 * to manually flush the cache here similar to what the fsync code path does
255 * for datasyncs on files that have no dirty metadata.
256 */
257int
258xfs_fs_commit_blocks(
259	struct inode		*inode,
260	struct iomap		*maps,
261	int			nr_maps,
262	struct iattr		*iattr)
263{
264	struct xfs_inode	*ip = XFS_I(inode);
265	struct xfs_mount	*mp = ip->i_mount;
266	struct xfs_trans	*tp;
267	bool			update_isize = false;
268	int			error, i;
269	loff_t			size;
270
271	ASSERT(iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME));
272
273	xfs_ilock(ip, XFS_IOLOCK_EXCL);
274
275	size = i_size_read(inode);
276	if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size > size) {
277		update_isize = true;
278		size = iattr->ia_size;
279	}
280
281	for (i = 0; i < nr_maps; i++) {
282		u64 start, length, end;
283
284		start = maps[i].offset;
285		if (start > size)
286			continue;
287
288		end = start + maps[i].length;
289		if (end > size)
290			end = size;
291
292		length = end - start;
293		if (!length)
294			continue;
295
296		/*
297		 * Make sure reads through the pagecache see the new data.
298		 */
299		error = invalidate_inode_pages2_range(inode->i_mapping,
300					start >> PAGE_SHIFT,
301					(end - 1) >> PAGE_SHIFT);
302		WARN_ON_ONCE(error);
303
304		error = xfs_iomap_write_unwritten(ip, start, length, false);
305		if (error)
306			goto out_drop_iolock;
307	}
308
309	if (update_isize) {
310		error = xfs_pnfs_validate_isize(ip, size);
311		if (error)
312			goto out_drop_iolock;
313	}
314
315	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
316	if (error)
317		goto out_drop_iolock;
318
319	xfs_ilock(ip, XFS_ILOCK_EXCL);
320	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
321	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
322
323	ASSERT(!(iattr->ia_valid & (ATTR_UID | ATTR_GID)));
324	setattr_copy(&nop_mnt_idmap, inode, iattr);
325	if (update_isize) {
326		i_size_write(inode, iattr->ia_size);
327		ip->i_disk_size = iattr->ia_size;
328	}
329
330	xfs_trans_set_sync(tp);
331	error = xfs_trans_commit(tp);
332
333out_drop_iolock:
334	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
335	return error;
336}