2 * Copyright (c) 2014 Christoph Hellwig.
4 #include <linux/iomap.h>
6 #include "xfs_format.h"
7 #include "xfs_log_format.h"
8 #include "xfs_trans_resv.h"
10 #include "xfs_mount.h"
11 #include "xfs_inode.h"
12 #include "xfs_trans.h"
15 #include "xfs_bmap_util.h"
16 #include "xfs_error.h"
17 #include "xfs_iomap.h"
18 #include "xfs_shared.h"
23 * Ensure that we do not have any outstanding pNFS layouts that can be used by
24 * clients to directly read from or write to this inode. This must be called
25 * before every operation that can remove blocks from the extent map.
26 * Additionally we call it during the write operation, where aren't concerned
27 * about exposing unallocated blocks but just want to provide basic
28 * synchronization between a local writer and pNFS clients. mmap writes would
29 * also benefit from this sort of synchronization, but due to the tricky locking
30 * rules in the page fault path we don't bother.
37 struct xfs_inode
*ip
= XFS_I(inode
);
40 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_SHARED
|XFS_IOLOCK_EXCL
));
42 while ((error
= break_layout(inode
, false) == -EWOULDBLOCK
)) {
43 xfs_iunlock(ip
, *iolock
);
44 error
= break_layout(inode
, true);
45 *iolock
= XFS_IOLOCK_EXCL
;
46 xfs_ilock(ip
, *iolock
);
53 * Get a unique ID including its location so that the client can identify
54 * the exported device.
58 struct super_block
*sb
,
63 struct xfs_mount
*mp
= XFS_M(sb
);
65 printk_once(KERN_NOTICE
66 "XFS (%s): using experimental pNFS feature, use at your own risk!\n",
69 if (*len
< sizeof(uuid_t
))
72 memcpy(buf
, &mp
->m_sb
.sb_uuid
, sizeof(uuid_t
));
73 *len
= sizeof(uuid_t
);
74 *offset
= offsetof(struct xfs_dsb
, sb_uuid
);
79 * Get a layout for the pNFS client.
88 u32
*device_generation
)
90 struct xfs_inode
*ip
= XFS_I(inode
);
91 struct xfs_mount
*mp
= ip
->i_mount
;
92 struct xfs_bmbt_irec imap
;
93 xfs_fileoff_t offset_fsb
, end_fsb
;
95 int bmapi_flags
= XFS_BMAPI_ENTIRE
;
100 if (XFS_FORCED_SHUTDOWN(mp
))
104 * We can't export inodes residing on the realtime device. The realtime
105 * device doesn't have a UUID to identify it, so the client has no way
108 if (XFS_IS_REALTIME_INODE(ip
))
112 * The pNFS block layout spec actually supports reflink like
113 * functionality, but the Linux pNFS server doesn't implement it yet.
115 if (xfs_is_reflink_inode(ip
))
119 * Lock out any other I/O before we flush and invalidate the pagecache,
120 * and then hand out a layout to the remote system. This is very
121 * similar to direct I/O, except that the synchronization is much more
122 * complicated. See the comment near xfs_break_layouts for a detailed
125 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
128 limit
= mp
->m_super
->s_maxbytes
;
130 limit
= max(limit
, round_up(i_size_read(inode
),
131 inode
->i_sb
->s_blocksize
));
134 if (offset
> limit
- length
)
135 length
= limit
- offset
;
137 error
= filemap_write_and_wait(inode
->i_mapping
);
140 error
= invalidate_inode_pages2(inode
->i_mapping
);
141 if (WARN_ON_ONCE(error
))
144 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)offset
+ length
);
145 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
147 lock_flags
= xfs_ilock_data_map_shared(ip
);
148 error
= xfs_bmapi_read(ip
, offset_fsb
, end_fsb
- offset_fsb
,
149 &imap
, &nimaps
, bmapi_flags
);
150 xfs_iunlock(ip
, lock_flags
);
156 enum xfs_prealloc_flags flags
= 0;
158 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
160 if (!nimaps
|| imap
.br_startblock
== HOLESTARTBLOCK
) {
162 * xfs_iomap_write_direct() expects to take ownership of
165 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
166 error
= xfs_iomap_write_direct(ip
, offset
, length
,
172 * Ensure the next transaction is committed
173 * synchronously so that the blocks allocated and
174 * handed out to the client are guaranteed to be
175 * present even after a server crash.
177 flags
|= XFS_PREALLOC_SET
| XFS_PREALLOC_SYNC
;
180 error
= xfs_update_prealloc_flags(ip
, flags
);
184 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
186 xfs_bmbt_to_iomap(ip
, iomap
, &imap
);
187 *device_generation
= mp
->m_generation
;
190 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
195 * Ensure the size update falls into a valid allocated block.
198 xfs_pnfs_validate_isize(
199 struct xfs_inode
*ip
,
202 struct xfs_bmbt_irec imap
;
206 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
207 error
= xfs_bmapi_read(ip
, XFS_B_TO_FSBT(ip
->i_mount
, isize
- 1), 1,
209 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
213 if (imap
.br_startblock
== HOLESTARTBLOCK
||
214 imap
.br_startblock
== DELAYSTARTBLOCK
||
215 imap
.br_state
== XFS_EXT_UNWRITTEN
)
221 * Make sure the blocks described by maps are stable on disk. This includes
222 * converting any unwritten extents, flushing the disk cache and updating the
225 * Note that we rely on the caller to always send us a timestamp update so that
226 * we always commit a transaction here. If that stops being true we will have
227 * to manually flush the cache here similar to what the fsync code path does
228 * for datasyncs on files that have no dirty metadata.
231 xfs_fs_commit_blocks(
237 struct xfs_inode
*ip
= XFS_I(inode
);
238 struct xfs_mount
*mp
= ip
->i_mount
;
239 struct xfs_trans
*tp
;
240 bool update_isize
= false;
244 ASSERT(iattr
->ia_valid
& (ATTR_ATIME
|ATTR_CTIME
|ATTR_MTIME
));
246 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
248 size
= i_size_read(inode
);
249 if ((iattr
->ia_valid
& ATTR_SIZE
) && iattr
->ia_size
> size
) {
251 size
= iattr
->ia_size
;
254 for (i
= 0; i
< nr_maps
; i
++) {
255 u64 start
, length
, end
;
257 start
= maps
[i
].offset
;
261 end
= start
+ maps
[i
].length
;
265 length
= end
- start
;
270 * Make sure reads through the pagecache see the new data.
272 error
= invalidate_inode_pages2_range(inode
->i_mapping
,
274 (end
- 1) >> PAGE_SHIFT
);
277 error
= xfs_iomap_write_unwritten(ip
, start
, length
);
279 goto out_drop_iolock
;
283 error
= xfs_pnfs_validate_isize(ip
, size
);
285 goto out_drop_iolock
;
288 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_ichange
, 0, 0, 0, &tp
);
290 goto out_drop_iolock
;
292 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
293 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
294 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
296 xfs_setattr_time(ip
, iattr
);
298 i_size_write(inode
, iattr
->ia_size
);
299 ip
->i_d
.di_size
= iattr
->ia_size
;
302 xfs_trans_set_sync(tp
);
303 error
= xfs_trans_commit(tp
);
306 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);