2 * Copyright (c) 2014 Christoph Hellwig.
5 #include "xfs_format.h"
6 #include "xfs_log_format.h"
7 #include "xfs_trans_resv.h"
10 #include "xfs_inode.h"
11 #include "xfs_trans.h"
14 #include "xfs_bmap_util.h"
15 #include "xfs_error.h"
16 #include "xfs_iomap.h"
17 #include "xfs_shared.h"
22 * Ensure that we do not have any outstanding pNFS layouts that can be used by
23 * clients to directly read from or write to this inode. This must be called
24 * before every operation that can remove blocks from the extent map.
25 * Additionally we call it during the write operation, where aren't concerned
26 * about exposing unallocated blocks but just want to provide basic
27 * synchronization between a local writer and pNFS clients. mmap writes would
28 * also benefit from this sort of synchronization, but due to the tricky locking
29 * rules in the page fault path we don't bother.
36 struct xfs_inode
*ip
= XFS_I(inode
);
39 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_SHARED
|XFS_IOLOCK_EXCL
));
41 while ((error
= break_layout(inode
, false) == -EWOULDBLOCK
)) {
42 xfs_iunlock(ip
, *iolock
);
43 error
= break_layout(inode
, true);
44 *iolock
= XFS_IOLOCK_EXCL
;
45 xfs_ilock(ip
, *iolock
);
52 * Get a unique ID including its location so that the client can identify
53 * the exported device.
57 struct super_block
*sb
,
62 struct xfs_mount
*mp
= XFS_M(sb
);
64 printk_once(KERN_NOTICE
65 "XFS (%s): using experimental pNFS feature, use at your own risk!\n",
68 if (*len
< sizeof(uuid_t
))
71 memcpy(buf
, &mp
->m_sb
.sb_uuid
, sizeof(uuid_t
));
72 *len
= sizeof(uuid_t
);
73 *offset
= offsetof(struct xfs_dsb
, sb_uuid
);
81 struct xfs_bmbt_irec
*imap
)
83 struct xfs_mount
*mp
= ip
->i_mount
;
85 if (imap
->br_startblock
== HOLESTARTBLOCK
) {
86 iomap
->blkno
= IOMAP_NULL_BLOCK
;
87 iomap
->type
= IOMAP_HOLE
;
88 } else if (imap
->br_startblock
== DELAYSTARTBLOCK
) {
89 iomap
->blkno
= IOMAP_NULL_BLOCK
;
90 iomap
->type
= IOMAP_DELALLOC
;
93 XFS_FSB_TO_DADDR(ip
->i_mount
, imap
->br_startblock
);
94 if (imap
->br_state
== XFS_EXT_UNWRITTEN
)
95 iomap
->type
= IOMAP_UNWRITTEN
;
97 iomap
->type
= IOMAP_MAPPED
;
99 iomap
->offset
= XFS_FSB_TO_B(mp
, imap
->br_startoff
);
100 iomap
->length
= XFS_FSB_TO_B(mp
, imap
->br_blockcount
);
104 * Get a layout for the pNFS client.
113 u32
*device_generation
)
115 struct xfs_inode
*ip
= XFS_I(inode
);
116 struct xfs_mount
*mp
= ip
->i_mount
;
117 struct xfs_bmbt_irec imap
;
118 xfs_fileoff_t offset_fsb
, end_fsb
;
120 int bmapi_flags
= XFS_BMAPI_ENTIRE
;
125 if (XFS_FORCED_SHUTDOWN(mp
))
129 * We can't export inodes residing on the realtime device. The realtime
130 * device doesn't have a UUID to identify it, so the client has no way
133 if (XFS_IS_REALTIME_INODE(ip
))
137 * Lock out any other I/O before we flush and invalidate the pagecache,
138 * and then hand out a layout to the remote system. This is very
139 * similar to direct I/O, except that the synchronization is much more
140 * complicated. See the comment near xfs_break_layouts for a detailed
143 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
146 limit
= mp
->m_super
->s_maxbytes
;
148 limit
= max(limit
, round_up(i_size_read(inode
),
149 inode
->i_sb
->s_blocksize
));
152 if (offset
> limit
- length
)
153 length
= limit
- offset
;
155 error
= filemap_write_and_wait(inode
->i_mapping
);
158 error
= invalidate_inode_pages2(inode
->i_mapping
);
159 if (WARN_ON_ONCE(error
))
162 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)offset
+ length
);
163 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
165 lock_flags
= xfs_ilock_data_map_shared(ip
);
166 error
= xfs_bmapi_read(ip
, offset_fsb
, end_fsb
- offset_fsb
,
167 &imap
, &nimaps
, bmapi_flags
);
168 xfs_iunlock(ip
, lock_flags
);
174 enum xfs_prealloc_flags flags
= 0;
176 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
178 if (!nimaps
|| imap
.br_startblock
== HOLESTARTBLOCK
) {
179 error
= xfs_iomap_write_direct(ip
, offset
, length
,
185 * Ensure the next transaction is committed
186 * synchronously so that the blocks allocated and
187 * handed out to the client are guaranteed to be
188 * present even after a server crash.
190 flags
|= XFS_PREALLOC_SET
| XFS_PREALLOC_SYNC
;
193 error
= xfs_update_prealloc_flags(ip
, flags
);
197 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
199 xfs_bmbt_to_iomap(ip
, iomap
, &imap
);
200 *device_generation
= mp
->m_generation
;
203 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
208 * Ensure the size update falls into a valid allocated block.
211 xfs_pnfs_validate_isize(
212 struct xfs_inode
*ip
,
215 struct xfs_bmbt_irec imap
;
219 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
220 error
= xfs_bmapi_read(ip
, XFS_B_TO_FSBT(ip
->i_mount
, isize
- 1), 1,
222 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
226 if (imap
.br_startblock
== HOLESTARTBLOCK
||
227 imap
.br_startblock
== DELAYSTARTBLOCK
||
228 imap
.br_state
== XFS_EXT_UNWRITTEN
)
234 * Make sure the blocks described by maps are stable on disk. This includes
235 * converting any unwritten extents, flushing the disk cache and updating the
238 * Note that we rely on the caller to always send us a timestamp update so that
239 * we always commit a transaction here. If that stops being true we will have
240 * to manually flush the cache here similar to what the fsync code path does
241 * for datasyncs on files that have no dirty metadata.
244 xfs_fs_commit_blocks(
250 struct xfs_inode
*ip
= XFS_I(inode
);
251 struct xfs_mount
*mp
= ip
->i_mount
;
252 struct xfs_trans
*tp
;
253 bool update_isize
= false;
257 ASSERT(iattr
->ia_valid
& (ATTR_ATIME
|ATTR_CTIME
|ATTR_MTIME
));
259 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
261 size
= i_size_read(inode
);
262 if ((iattr
->ia_valid
& ATTR_SIZE
) && iattr
->ia_size
> size
) {
264 size
= iattr
->ia_size
;
267 for (i
= 0; i
< nr_maps
; i
++) {
268 u64 start
, length
, end
;
270 start
= maps
[i
].offset
;
274 end
= start
+ maps
[i
].length
;
278 length
= end
- start
;
283 * Make sure reads through the pagecache see the new data.
285 error
= invalidate_inode_pages2_range(inode
->i_mapping
,
286 start
>> PAGE_CACHE_SHIFT
,
287 (end
- 1) >> PAGE_CACHE_SHIFT
);
290 error
= xfs_iomap_write_unwritten(ip
, start
, length
);
292 goto out_drop_iolock
;
296 error
= xfs_pnfs_validate_isize(ip
, size
);
298 goto out_drop_iolock
;
301 tp
= xfs_trans_alloc(mp
, XFS_TRANS_SETATTR_NOT_SIZE
);
302 error
= xfs_trans_reserve(tp
, &M_RES(mp
)->tr_ichange
, 0, 0);
304 xfs_trans_cancel(tp
, 0);
305 goto out_drop_iolock
;
308 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
309 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
310 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
312 xfs_setattr_time(ip
, iattr
);
314 i_size_write(inode
, iattr
->ia_size
);
315 ip
->i_d
.di_size
= iattr
->ia_size
;
318 xfs_trans_set_sync(tp
);
319 error
= xfs_trans_commit(tp
, 0);
322 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);