]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/xfs/xfs_pnfs.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2014 Christoph Hellwig.
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"
14 #include "xfs_iomap.h"
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.
28 xfs_break_leased_layouts(
33 struct xfs_inode
*ip
= XFS_I(inode
);
36 while ((error
= break_layout(inode
, false)) == -EWOULDBLOCK
) {
37 xfs_iunlock(ip
, *iolock
);
39 error
= break_layout(inode
, true);
40 *iolock
&= ~XFS_IOLOCK_SHARED
;
41 *iolock
|= XFS_IOLOCK_EXCL
;
42 xfs_ilock(ip
, *iolock
);
49 * Get a unique ID including its location so that the client can identify
50 * the exported device.
54 struct super_block
*sb
,
59 struct xfs_mount
*mp
= XFS_M(sb
);
62 "Using experimental pNFS feature, use at your own risk!");
64 if (*len
< sizeof(uuid_t
))
67 memcpy(buf
, &mp
->m_sb
.sb_uuid
, sizeof(uuid_t
));
68 *len
= sizeof(uuid_t
);
69 *offset
= offsetof(struct xfs_dsb
, sb_uuid
);
74 * Get a layout for the pNFS client.
83 u32
*device_generation
)
85 struct xfs_inode
*ip
= XFS_I(inode
);
86 struct xfs_mount
*mp
= ip
->i_mount
;
87 struct xfs_bmbt_irec imap
;
88 xfs_fileoff_t offset_fsb
, end_fsb
;
90 int bmapi_flags
= XFS_BMAPI_ENTIRE
;
95 if (XFS_FORCED_SHUTDOWN(mp
))
99 * We can't export inodes residing on the realtime device. The realtime
100 * device doesn't have a UUID to identify it, so the client has no way
103 if (XFS_IS_REALTIME_INODE(ip
))
107 * The pNFS block layout spec actually supports reflink like
108 * functionality, but the Linux pNFS server doesn't implement it yet.
110 if (xfs_is_reflink_inode(ip
))
114 * Lock out any other I/O before we flush and invalidate the pagecache,
115 * and then hand out a layout to the remote system. This is very
116 * similar to direct I/O, except that the synchronization is much more
117 * complicated. See the comment near xfs_break_leased_layouts
118 * for a detailed explanation.
120 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
123 limit
= mp
->m_super
->s_maxbytes
;
125 limit
= max(limit
, round_up(i_size_read(inode
),
126 inode
->i_sb
->s_blocksize
));
129 if (offset
> limit
- length
)
130 length
= limit
- offset
;
132 error
= filemap_write_and_wait(inode
->i_mapping
);
135 error
= invalidate_inode_pages2(inode
->i_mapping
);
136 if (WARN_ON_ONCE(error
))
139 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)offset
+ length
);
140 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
142 lock_flags
= xfs_ilock_data_map_shared(ip
);
143 error
= xfs_bmapi_read(ip
, offset_fsb
, end_fsb
- offset_fsb
,
144 &imap
, &nimaps
, bmapi_flags
);
146 ASSERT(!nimaps
|| imap
.br_startblock
!= DELAYSTARTBLOCK
);
148 if (!error
&& write
&&
149 (!nimaps
|| imap
.br_startblock
== HOLESTARTBLOCK
)) {
150 if (offset
+ length
> XFS_ISIZE(ip
))
151 end_fsb
= xfs_iomap_eof_align_last_fsb(ip
, end_fsb
);
152 else if (nimaps
&& imap
.br_startblock
== HOLESTARTBLOCK
)
153 end_fsb
= min(end_fsb
, imap
.br_startoff
+
155 xfs_iunlock(ip
, lock_flags
);
157 error
= xfs_iomap_write_direct(ip
, offset_fsb
,
158 end_fsb
- offset_fsb
, &imap
);
163 * Ensure the next transaction is committed synchronously so
164 * that the blocks allocated and handed out to the client are
165 * guaranteed to be present even after a server crash.
167 error
= xfs_update_prealloc_flags(ip
,
168 XFS_PREALLOC_SET
| XFS_PREALLOC_SYNC
);
172 xfs_iunlock(ip
, lock_flags
);
174 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
176 error
= xfs_bmbt_to_iomap(ip
, iomap
, &imap
, 0);
177 *device_generation
= mp
->m_generation
;
180 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
185 * Ensure the size update falls into a valid allocated block.
188 xfs_pnfs_validate_isize(
189 struct xfs_inode
*ip
,
192 struct xfs_bmbt_irec imap
;
196 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
197 error
= xfs_bmapi_read(ip
, XFS_B_TO_FSBT(ip
->i_mount
, isize
- 1), 1,
199 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
203 if (imap
.br_startblock
== HOLESTARTBLOCK
||
204 imap
.br_startblock
== DELAYSTARTBLOCK
||
205 imap
.br_state
== XFS_EXT_UNWRITTEN
)
211 * Make sure the blocks described by maps are stable on disk. This includes
212 * converting any unwritten extents, flushing the disk cache and updating the
215 * Note that we rely on the caller to always send us a timestamp update so that
216 * we always commit a transaction here. If that stops being true we will have
217 * to manually flush the cache here similar to what the fsync code path does
218 * for datasyncs on files that have no dirty metadata.
221 xfs_fs_commit_blocks(
227 struct xfs_inode
*ip
= XFS_I(inode
);
228 struct xfs_mount
*mp
= ip
->i_mount
;
229 struct xfs_trans
*tp
;
230 bool update_isize
= false;
234 ASSERT(iattr
->ia_valid
& (ATTR_ATIME
|ATTR_CTIME
|ATTR_MTIME
));
236 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
238 size
= i_size_read(inode
);
239 if ((iattr
->ia_valid
& ATTR_SIZE
) && iattr
->ia_size
> size
) {
241 size
= iattr
->ia_size
;
244 for (i
= 0; i
< nr_maps
; i
++) {
245 u64 start
, length
, end
;
247 start
= maps
[i
].offset
;
251 end
= start
+ maps
[i
].length
;
255 length
= end
- start
;
260 * Make sure reads through the pagecache see the new data.
262 error
= invalidate_inode_pages2_range(inode
->i_mapping
,
264 (end
- 1) >> PAGE_SHIFT
);
267 error
= xfs_iomap_write_unwritten(ip
, start
, length
, false);
269 goto out_drop_iolock
;
273 error
= xfs_pnfs_validate_isize(ip
, size
);
275 goto out_drop_iolock
;
278 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_ichange
, 0, 0, 0, &tp
);
280 goto out_drop_iolock
;
282 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
283 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
284 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
286 xfs_setattr_time(ip
, iattr
);
288 i_size_write(inode
, iattr
->ia_size
);
289 ip
->i_disk_size
= iattr
->ia_size
;
292 xfs_trans_set_sync(tp
);
293 error
= xfs_trans_commit(tp
);
296 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);