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 * Get a unique ID including its location so that the client can identify
23 * the exported device.
27 struct super_block
*sb
,
32 struct xfs_mount
*mp
= XFS_M(sb
);
34 printk_once(KERN_NOTICE
35 "XFS (%s): using experimental pNFS feature, use at your own risk!\n",
38 if (*len
< sizeof(uuid_t
))
41 memcpy(buf
, &mp
->m_sb
.sb_uuid
, sizeof(uuid_t
));
42 *len
= sizeof(uuid_t
);
43 *offset
= offsetof(struct xfs_dsb
, sb_uuid
);
51 struct xfs_bmbt_irec
*imap
)
53 struct xfs_mount
*mp
= ip
->i_mount
;
55 if (imap
->br_startblock
== HOLESTARTBLOCK
) {
56 iomap
->blkno
= IOMAP_NULL_BLOCK
;
57 iomap
->type
= IOMAP_HOLE
;
58 } else if (imap
->br_startblock
== DELAYSTARTBLOCK
) {
59 iomap
->blkno
= IOMAP_NULL_BLOCK
;
60 iomap
->type
= IOMAP_DELALLOC
;
63 XFS_FSB_TO_DADDR(ip
->i_mount
, imap
->br_startblock
);
64 if (imap
->br_state
== XFS_EXT_UNWRITTEN
)
65 iomap
->type
= IOMAP_UNWRITTEN
;
67 iomap
->type
= IOMAP_MAPPED
;
69 iomap
->offset
= XFS_FSB_TO_B(mp
, imap
->br_startoff
);
70 iomap
->length
= XFS_FSB_TO_B(mp
, imap
->br_blockcount
);
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 * Lock out any other I/O before we flush and invalidate the pagecache,
108 * and then hand out a layout to the remote system. This is very
109 * similar to direct I/O, except that the synchronization is much more
110 * complicated. See the comment near xfs_break_layouts for a detailed
113 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
116 limit
= mp
->m_super
->s_maxbytes
;
118 limit
= max(limit
, round_up(i_size_read(inode
),
119 inode
->i_sb
->s_blocksize
));
122 if (offset
> limit
- length
)
123 length
= limit
- offset
;
125 error
= filemap_write_and_wait(inode
->i_mapping
);
128 error
= invalidate_inode_pages2(inode
->i_mapping
);
129 if (WARN_ON_ONCE(error
))
132 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)offset
+ length
);
133 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
135 lock_flags
= xfs_ilock_data_map_shared(ip
);
136 error
= xfs_bmapi_read(ip
, offset_fsb
, end_fsb
- offset_fsb
,
137 &imap
, &nimaps
, bmapi_flags
);
138 xfs_iunlock(ip
, lock_flags
);
144 enum xfs_prealloc_flags flags
= 0;
146 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
148 if (!nimaps
|| imap
.br_startblock
== HOLESTARTBLOCK
) {
149 error
= xfs_iomap_write_direct(ip
, offset
, length
,
155 * Ensure the next transaction is committed
156 * synchronously so that the blocks allocated and
157 * handed out to the client are guaranteed to be
158 * present even after a server crash.
160 flags
|= XFS_PREALLOC_SET
| XFS_PREALLOC_SYNC
;
163 error
= xfs_update_prealloc_flags(ip
, flags
);
167 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
169 xfs_bmbt_to_iomap(ip
, iomap
, &imap
);
170 *device_generation
= mp
->m_generation
;
173 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
178 * Ensure the size update falls into a valid allocated block.
181 xfs_pnfs_validate_isize(
182 struct xfs_inode
*ip
,
185 struct xfs_bmbt_irec imap
;
189 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
190 error
= xfs_bmapi_read(ip
, XFS_B_TO_FSBT(ip
->i_mount
, isize
- 1), 1,
192 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
196 if (imap
.br_startblock
== HOLESTARTBLOCK
||
197 imap
.br_startblock
== DELAYSTARTBLOCK
||
198 imap
.br_state
== XFS_EXT_UNWRITTEN
)
204 * Make sure the blocks described by maps are stable on disk. This includes
205 * converting any unwritten extents, flushing the disk cache and updating the
208 * Note that we rely on the caller to always send us a timestamp update so that
209 * we always commit a transaction here. If that stops being true we will have
210 * to manually flush the cache here similar to what the fsync code path does
211 * for datasyncs on files that have no dirty metadata.
214 xfs_fs_commit_blocks(
220 struct xfs_inode
*ip
= XFS_I(inode
);
221 struct xfs_mount
*mp
= ip
->i_mount
;
222 struct xfs_trans
*tp
;
223 bool update_isize
= false;
227 ASSERT(iattr
->ia_valid
& (ATTR_ATIME
|ATTR_CTIME
|ATTR_MTIME
));
229 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
231 size
= i_size_read(inode
);
232 if ((iattr
->ia_valid
& ATTR_SIZE
) && iattr
->ia_size
> size
) {
234 size
= iattr
->ia_size
;
237 for (i
= 0; i
< nr_maps
; i
++) {
238 u64 start
, length
, end
;
240 start
= maps
[i
].offset
;
244 end
= start
+ maps
[i
].length
;
248 length
= end
- start
;
253 * Make sure reads through the pagecache see the new data.
255 error
= invalidate_inode_pages2_range(inode
->i_mapping
,
256 start
>> PAGE_CACHE_SHIFT
,
257 (end
- 1) >> PAGE_CACHE_SHIFT
);
260 error
= xfs_iomap_write_unwritten(ip
, start
, length
);
262 goto out_drop_iolock
;
266 error
= xfs_pnfs_validate_isize(ip
, size
);
268 goto out_drop_iolock
;
271 tp
= xfs_trans_alloc(mp
, XFS_TRANS_SETATTR_NOT_SIZE
);
272 error
= xfs_trans_reserve(tp
, &M_RES(mp
)->tr_ichange
, 0, 0);
274 goto out_drop_iolock
;
276 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
277 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
278 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
280 xfs_setattr_time(ip
, iattr
);
282 i_size_write(inode
, iattr
->ia_size
);
283 ip
->i_d
.di_size
= iattr
->ia_size
;
286 xfs_trans_set_sync(tp
);
287 error
= xfs_trans_commit(tp
, 0);
290 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);