Commit | Line | Data |
---|---|---|
0b61f8a4 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
3993baeb DW |
2 | /* |
3 | * Copyright (C) 2016 Oracle. All Rights Reserved. | |
3993baeb | 4 | * Author: Darrick J. Wong <darrick.wong@oracle.com> |
3993baeb DW |
5 | */ |
6 | #include "xfs.h" | |
7 | #include "xfs_fs.h" | |
8 | #include "xfs_shared.h" | |
9 | #include "xfs_format.h" | |
10 | #include "xfs_log_format.h" | |
11 | #include "xfs_trans_resv.h" | |
12 | #include "xfs_mount.h" | |
13 | #include "xfs_defer.h" | |
3993baeb DW |
14 | #include "xfs_inode.h" |
15 | #include "xfs_trans.h" | |
3993baeb DW |
16 | #include "xfs_bmap.h" |
17 | #include "xfs_bmap_util.h" | |
3993baeb | 18 | #include "xfs_trace.h" |
3993baeb | 19 | #include "xfs_icache.h" |
174edb0e | 20 | #include "xfs_btree.h" |
3993baeb DW |
21 | #include "xfs_refcount_btree.h" |
22 | #include "xfs_refcount.h" | |
23 | #include "xfs_bmap_btree.h" | |
24 | #include "xfs_trans_space.h" | |
25 | #include "xfs_bit.h" | |
26 | #include "xfs_alloc.h" | |
3993baeb | 27 | #include "xfs_quota.h" |
3993baeb | 28 | #include "xfs_reflink.h" |
2a06705c | 29 | #include "xfs_iomap.h" |
6fa164b8 DW |
30 | #include "xfs_sb.h" |
31 | #include "xfs_ag_resv.h" | |
3993baeb DW |
32 | |
33 | /* | |
34 | * Copy on Write of Shared Blocks | |
35 | * | |
36 | * XFS must preserve "the usual" file semantics even when two files share | |
37 | * the same physical blocks. This means that a write to one file must not | |
38 | * alter the blocks in a different file; the way that we'll do that is | |
39 | * through the use of a copy-on-write mechanism. At a high level, that | |
40 | * means that when we want to write to a shared block, we allocate a new | |
41 | * block, write the data to the new block, and if that succeeds we map the | |
42 | * new block into the file. | |
43 | * | |
44 | * XFS provides a "delayed allocation" mechanism that defers the allocation | |
45 | * of disk blocks to dirty-but-not-yet-mapped file blocks as long as | |
46 | * possible. This reduces fragmentation by enabling the filesystem to ask | |
47 | * for bigger chunks less often, which is exactly what we want for CoW. | |
48 | * | |
49 | * The delalloc mechanism begins when the kernel wants to make a block | |
50 | * writable (write_begin or page_mkwrite). If the offset is not mapped, we | |
51 | * create a delalloc mapping, which is a regular in-core extent, but without | |
52 | * a real startblock. (For delalloc mappings, the startblock encodes both | |
53 | * a flag that this is a delalloc mapping, and a worst-case estimate of how | |
54 | * many blocks might be required to put the mapping into the BMBT.) delalloc | |
55 | * mappings are a reservation against the free space in the filesystem; | |
56 | * adjacent mappings can also be combined into fewer larger mappings. | |
57 | * | |
5eda4300 DW |
58 | * As an optimization, the CoW extent size hint (cowextsz) creates |
59 | * outsized aligned delalloc reservations in the hope of landing out of | |
60 | * order nearby CoW writes in a single extent on disk, thereby reducing | |
61 | * fragmentation and improving future performance. | |
62 | * | |
63 | * D: --RRRRRRSSSRRRRRRRR--- (data fork) | |
64 | * C: ------DDDDDDD--------- (CoW fork) | |
65 | * | |
3993baeb | 66 | * When dirty pages are being written out (typically in writepage), the |
5eda4300 DW |
67 | * delalloc reservations are converted into unwritten mappings by |
68 | * allocating blocks and replacing the delalloc mapping with real ones. | |
69 | * A delalloc mapping can be replaced by several unwritten ones if the | |
70 | * free space is fragmented. | |
71 | * | |
72 | * D: --RRRRRRSSSRRRRRRRR--- | |
73 | * C: ------UUUUUUU--------- | |
3993baeb DW |
74 | * |
75 | * We want to adapt the delalloc mechanism for copy-on-write, since the | |
76 | * write paths are similar. The first two steps (creating the reservation | |
77 | * and allocating the blocks) are exactly the same as delalloc except that | |
78 | * the mappings must be stored in a separate CoW fork because we do not want | |
79 | * to disturb the mapping in the data fork until we're sure that the write | |
80 | * succeeded. IO completion in this case is the process of removing the old | |
81 | * mapping from the data fork and moving the new mapping from the CoW fork to | |
82 | * the data fork. This will be discussed shortly. | |
83 | * | |
84 | * For now, unaligned directio writes will be bounced back to the page cache. | |
85 | * Block-aligned directio writes will use the same mechanism as buffered | |
86 | * writes. | |
87 | * | |
5eda4300 DW |
88 | * Just prior to submitting the actual disk write requests, we convert |
89 | * the extents representing the range of the file actually being written | |
90 | * (as opposed to extra pieces created for the cowextsize hint) to real | |
91 | * extents. This will become important in the next step: | |
92 | * | |
93 | * D: --RRRRRRSSSRRRRRRRR--- | |
94 | * C: ------UUrrUUU--------- | |
95 | * | |
3993baeb DW |
96 | * CoW remapping must be done after the data block write completes, |
97 | * because we don't want to destroy the old data fork map until we're sure | |
98 | * the new block has been written. Since the new mappings are kept in a | |
99 | * separate fork, we can simply iterate these mappings to find the ones | |
100 | * that cover the file blocks that we just CoW'd. For each extent, simply | |
101 | * unmap the corresponding range in the data fork, map the new range into | |
5eda4300 DW |
102 | * the data fork, and remove the extent from the CoW fork. Because of |
103 | * the presence of the cowextsize hint, however, we must be careful | |
104 | * only to remap the blocks that we've actually written out -- we must | |
105 | * never remap delalloc reservations nor CoW staging blocks that have | |
106 | * yet to be written. This corresponds exactly to the real extents in | |
107 | * the CoW fork: | |
108 | * | |
109 | * D: --RRRRRRrrSRRRRRRRR--- | |
110 | * C: ------UU--UUU--------- | |
3993baeb DW |
111 | * |
112 | * Since the remapping operation can be applied to an arbitrary file | |
113 | * range, we record the need for the remap step as a flag in the ioend | |
114 | * instead of declaring a new IO type. This is required for direct io | |
115 | * because we only have ioend for the whole dio, and we have to be able to | |
116 | * remember the presence of unwritten blocks and CoW blocks with a single | |
117 | * ioend structure. Better yet, the more ground we can cover with one | |
118 | * ioend, the better. | |
119 | */ | |
2a06705c DW |
120 | |
121 | /* | |
122 | * Given an AG extent, find the lowest-numbered run of shared blocks | |
123 | * within that range and return the range in fbno/flen. If | |
124 | * find_end_of_shared is true, return the longest contiguous extent of | |
125 | * shared blocks. If there are no shared extents, fbno and flen will | |
126 | * be set to NULLAGBLOCK and 0, respectively. | |
127 | */ | |
128 | int | |
129 | xfs_reflink_find_shared( | |
130 | struct xfs_mount *mp, | |
92ff7285 | 131 | struct xfs_trans *tp, |
2a06705c DW |
132 | xfs_agnumber_t agno, |
133 | xfs_agblock_t agbno, | |
134 | xfs_extlen_t aglen, | |
135 | xfs_agblock_t *fbno, | |
136 | xfs_extlen_t *flen, | |
137 | bool find_end_of_shared) | |
138 | { | |
139 | struct xfs_buf *agbp; | |
140 | struct xfs_btree_cur *cur; | |
141 | int error; | |
142 | ||
92ff7285 | 143 | error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp); |
2a06705c DW |
144 | if (error) |
145 | return error; | |
10479e2d DW |
146 | if (!agbp) |
147 | return -ENOMEM; | |
2a06705c | 148 | |
ed7ef8e5 | 149 | cur = xfs_refcountbt_init_cursor(mp, tp, agbp, agno); |
2a06705c DW |
150 | |
151 | error = xfs_refcount_find_shared(cur, agbno, aglen, fbno, flen, | |
152 | find_end_of_shared); | |
153 | ||
0b04b6b8 | 154 | xfs_btree_del_cursor(cur, error); |
2a06705c | 155 | |
92ff7285 | 156 | xfs_trans_brelse(tp, agbp); |
2a06705c DW |
157 | return error; |
158 | } | |
159 | ||
160 | /* | |
161 | * Trim the mapping to the next block where there's a change in the | |
162 | * shared/unshared status. More specifically, this means that we | |
163 | * find the lowest-numbered extent of shared blocks that coincides with | |
164 | * the given block mapping. If the shared extent overlaps the start of | |
165 | * the mapping, trim the mapping to the end of the shared extent. If | |
166 | * the shared region intersects the mapping, trim the mapping to the | |
167 | * start of the shared extent. If there are no shared regions that | |
168 | * overlap, just return the original extent. | |
169 | */ | |
170 | int | |
171 | xfs_reflink_trim_around_shared( | |
172 | struct xfs_inode *ip, | |
173 | struct xfs_bmbt_irec *irec, | |
d392bc81 | 174 | bool *shared) |
2a06705c DW |
175 | { |
176 | xfs_agnumber_t agno; | |
177 | xfs_agblock_t agbno; | |
178 | xfs_extlen_t aglen; | |
179 | xfs_agblock_t fbno; | |
180 | xfs_extlen_t flen; | |
181 | int error = 0; | |
182 | ||
183 | /* Holes, unwritten, and delalloc extents cannot be shared */ | |
66ae56a5 | 184 | if (!xfs_is_cow_inode(ip) || !xfs_bmap_is_real_extent(irec)) { |
2a06705c DW |
185 | *shared = false; |
186 | return 0; | |
187 | } | |
188 | ||
189 | trace_xfs_reflink_trim_around_shared(ip, irec); | |
190 | ||
191 | agno = XFS_FSB_TO_AGNO(ip->i_mount, irec->br_startblock); | |
192 | agbno = XFS_FSB_TO_AGBNO(ip->i_mount, irec->br_startblock); | |
193 | aglen = irec->br_blockcount; | |
194 | ||
92ff7285 | 195 | error = xfs_reflink_find_shared(ip->i_mount, NULL, agno, agbno, |
2a06705c DW |
196 | aglen, &fbno, &flen, true); |
197 | if (error) | |
198 | return error; | |
199 | ||
d392bc81 | 200 | *shared = false; |
2a06705c DW |
201 | if (fbno == NULLAGBLOCK) { |
202 | /* No shared blocks at all. */ | |
203 | return 0; | |
204 | } else if (fbno == agbno) { | |
205 | /* | |
206 | * The start of this extent is shared. Truncate the | |
207 | * mapping at the end of the shared region so that a | |
208 | * subsequent iteration starts at the start of the | |
209 | * unshared region. | |
210 | */ | |
211 | irec->br_blockcount = flen; | |
212 | *shared = true; | |
2a06705c DW |
213 | return 0; |
214 | } else { | |
215 | /* | |
216 | * There's a shared extent midway through this extent. | |
217 | * Truncate the mapping at the start of the shared | |
218 | * extent so that a subsequent iteration starts at the | |
219 | * start of the shared region. | |
220 | */ | |
221 | irec->br_blockcount = fbno - agbno; | |
2a06705c DW |
222 | return 0; |
223 | } | |
224 | } | |
225 | ||
66ae56a5 CH |
226 | bool |
227 | xfs_inode_need_cow( | |
228 | struct xfs_inode *ip, | |
229 | struct xfs_bmbt_irec *imap, | |
230 | bool *shared) | |
231 | { | |
232 | /* We can't update any real extents in always COW mode. */ | |
233 | if (xfs_is_always_cow_inode(ip) && | |
234 | !isnullstartblock(imap->br_startblock)) { | |
235 | *shared = true; | |
236 | return 0; | |
237 | } | |
238 | ||
239 | /* Trim the mapping to the nearest shared extent boundary. */ | |
240 | return xfs_reflink_trim_around_shared(ip, imap, shared); | |
241 | } | |
242 | ||
26b91c72 CH |
243 | static int |
244 | xfs_reflink_convert_cow_locked( | |
245 | struct xfs_inode *ip, | |
246 | xfs_fileoff_t offset_fsb, | |
247 | xfs_filblks_t count_fsb) | |
5eda4300 | 248 | { |
26b91c72 CH |
249 | struct xfs_iext_cursor icur; |
250 | struct xfs_bmbt_irec got; | |
251 | struct xfs_btree_cur *dummy_cur = NULL; | |
252 | int dummy_logflags; | |
c1a4447f | 253 | int error = 0; |
5eda4300 | 254 | |
26b91c72 | 255 | if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got)) |
5eda4300 DW |
256 | return 0; |
257 | ||
26b91c72 CH |
258 | do { |
259 | if (got.br_startoff >= offset_fsb + count_fsb) | |
260 | break; | |
261 | if (got.br_state == XFS_EXT_NORM) | |
262 | continue; | |
263 | if (WARN_ON_ONCE(isnullstartblock(got.br_startblock))) | |
264 | return -EIO; | |
265 | ||
266 | xfs_trim_extent(&got, offset_fsb, count_fsb); | |
267 | if (!got.br_blockcount) | |
268 | continue; | |
269 | ||
270 | got.br_state = XFS_EXT_NORM; | |
271 | error = xfs_bmap_add_extent_unwritten_real(NULL, ip, | |
272 | XFS_COW_FORK, &icur, &dummy_cur, &got, | |
273 | &dummy_logflags); | |
274 | if (error) | |
275 | return error; | |
276 | } while (xfs_iext_next_extent(ip->i_cowfp, &icur, &got)); | |
277 | ||
278 | return error; | |
5eda4300 DW |
279 | } |
280 | ||
281 | /* Convert all of the unwritten CoW extents in a file's range to real ones. */ | |
282 | int | |
283 | xfs_reflink_convert_cow( | |
284 | struct xfs_inode *ip, | |
285 | xfs_off_t offset, | |
286 | xfs_off_t count) | |
287 | { | |
5eda4300 | 288 | struct xfs_mount *mp = ip->i_mount; |
5eda4300 DW |
289 | xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset); |
290 | xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, offset + count); | |
b121459c | 291 | xfs_filblks_t count_fsb = end_fsb - offset_fsb; |
26b91c72 | 292 | int error; |
5eda4300 | 293 | |
b121459c | 294 | ASSERT(count != 0); |
5eda4300 | 295 | |
b121459c | 296 | xfs_ilock(ip, XFS_ILOCK_EXCL); |
26b91c72 | 297 | error = xfs_reflink_convert_cow_locked(ip, offset_fsb, count_fsb); |
5eda4300 DW |
298 | xfs_iunlock(ip, XFS_ILOCK_EXCL); |
299 | return error; | |
300 | } | |
301 | ||
df307077 DC |
302 | /* |
303 | * Find the extent that maps the given range in the COW fork. Even if the extent | |
304 | * is not shared we might have a preallocation for it in the COW fork. If so we | |
305 | * use it that rather than trigger a new allocation. | |
306 | */ | |
307 | static int | |
308 | xfs_find_trim_cow_extent( | |
309 | struct xfs_inode *ip, | |
310 | struct xfs_bmbt_irec *imap, | |
311 | bool *shared, | |
312 | bool *found) | |
313 | { | |
314 | xfs_fileoff_t offset_fsb = imap->br_startoff; | |
315 | xfs_filblks_t count_fsb = imap->br_blockcount; | |
316 | struct xfs_iext_cursor icur; | |
317 | struct xfs_bmbt_irec got; | |
df307077 DC |
318 | |
319 | *found = false; | |
320 | ||
321 | /* | |
322 | * If we don't find an overlapping extent, trim the range we need to | |
323 | * allocate to fit the hole we found. | |
324 | */ | |
032dc923 CH |
325 | if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got)) |
326 | got.br_startoff = offset_fsb + count_fsb; | |
327 | if (got.br_startoff > offset_fsb) { | |
328 | xfs_trim_extent(imap, imap->br_startoff, | |
329 | got.br_startoff - imap->br_startoff); | |
66ae56a5 | 330 | return xfs_inode_need_cow(ip, imap, shared); |
032dc923 | 331 | } |
df307077 DC |
332 | |
333 | *shared = true; | |
334 | if (isnullstartblock(got.br_startblock)) { | |
335 | xfs_trim_extent(imap, got.br_startoff, got.br_blockcount); | |
336 | return 0; | |
337 | } | |
338 | ||
339 | /* real extent found - no need to allocate */ | |
340 | xfs_trim_extent(&got, offset_fsb, count_fsb); | |
341 | *imap = got; | |
342 | *found = true; | |
343 | return 0; | |
344 | } | |
345 | ||
0613f16c | 346 | /* Allocate all CoW reservations covering a range of blocks in a file. */ |
3c68d44a CH |
347 | int |
348 | xfs_reflink_allocate_cow( | |
0613f16c | 349 | struct xfs_inode *ip, |
3c68d44a CH |
350 | struct xfs_bmbt_irec *imap, |
351 | bool *shared, | |
78f0cc9d | 352 | uint *lockmode, |
affe250a | 353 | bool convert_now) |
0613f16c DW |
354 | { |
355 | struct xfs_mount *mp = ip->i_mount; | |
3c68d44a CH |
356 | xfs_fileoff_t offset_fsb = imap->br_startoff; |
357 | xfs_filblks_t count_fsb = imap->br_blockcount; | |
df307077 | 358 | struct xfs_trans *tp; |
3c68d44a | 359 | int nimaps, error = 0; |
df307077 | 360 | bool found; |
a14234c7 | 361 | xfs_filblks_t resaligned; |
3c68d44a | 362 | xfs_extlen_t resblks = 0; |
0613f16c | 363 | |
c7dbe3f2 | 364 | ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); |
66ae56a5 CH |
365 | if (!ip->i_cowfp) { |
366 | ASSERT(!xfs_is_reflink_inode(ip)); | |
367 | xfs_ifork_init_cow(ip); | |
368 | } | |
0613f16c | 369 | |
df307077 DC |
370 | error = xfs_find_trim_cow_extent(ip, imap, shared, &found); |
371 | if (error || !*shared) | |
372 | return error; | |
373 | if (found) | |
374 | goto convert; | |
3c68d44a | 375 | |
df307077 DC |
376 | resaligned = xfs_aligned_fsb_count(imap->br_startoff, |
377 | imap->br_blockcount, xfs_get_cowextsz_hint(ip)); | |
378 | resblks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned); | |
a14234c7 | 379 | |
df307077 DC |
380 | xfs_iunlock(ip, *lockmode); |
381 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp); | |
382 | *lockmode = XFS_ILOCK_EXCL; | |
383 | xfs_ilock(ip, *lockmode); | |
3ba020be | 384 | |
df307077 DC |
385 | if (error) |
386 | return error; | |
a14234c7 | 387 | |
df307077 DC |
388 | error = xfs_qm_dqattach_locked(ip, false); |
389 | if (error) | |
390 | goto out_trans_cancel; | |
3c68d44a | 391 | |
df307077 DC |
392 | /* |
393 | * Check for an overlapping extent again now that we dropped the ilock. | |
394 | */ | |
395 | error = xfs_find_trim_cow_extent(ip, imap, shared, &found); | |
396 | if (error || !*shared) | |
397 | goto out_trans_cancel; | |
398 | if (found) { | |
399 | xfs_trans_cancel(tp); | |
400 | goto convert; | |
a14234c7 CH |
401 | } |
402 | ||
403 | error = xfs_trans_reserve_quota_nblks(tp, ip, resblks, 0, | |
404 | XFS_QMOPT_RES_REGBLKS); | |
0613f16c | 405 | if (error) |
df307077 | 406 | goto out_trans_cancel; |
0613f16c | 407 | |
a14234c7 CH |
408 | xfs_trans_ijoin(tp, ip, 0); |
409 | ||
5eda4300 | 410 | /* Allocate the entire reservation as unwritten blocks. */ |
df307077 | 411 | nimaps = 1; |
3c68d44a | 412 | error = xfs_bmapi_write(tp, ip, imap->br_startoff, imap->br_blockcount, |
650919f1 | 413 | XFS_BMAPI_COWFORK | XFS_BMAPI_PREALLOC, |
a7beabea | 414 | resblks, imap, &nimaps); |
0613f16c | 415 | if (error) |
df307077 | 416 | goto out_unreserve; |
0613f16c | 417 | |
86d692bf | 418 | xfs_inode_set_cowblocks_tag(ip); |
0613f16c | 419 | error = xfs_trans_commit(tp); |
a14234c7 | 420 | if (error) |
3c68d44a | 421 | return error; |
9f37bd11 DW |
422 | |
423 | /* | |
424 | * Allocation succeeded but the requested range was not even partially | |
425 | * satisfied? Bail out! | |
426 | */ | |
427 | if (nimaps == 0) | |
428 | return -ENOSPC; | |
3c68d44a | 429 | convert: |
26b91c72 | 430 | xfs_trim_extent(imap, offset_fsb, count_fsb); |
78f0cc9d CH |
431 | /* |
432 | * COW fork extents are supposed to remain unwritten until we're ready | |
433 | * to initiate a disk write. For direct I/O we are going to write the | |
434 | * data and need the conversion, but for buffered writes we're done. | |
435 | */ | |
affe250a | 436 | if (!convert_now || imap->br_state == XFS_EXT_NORM) |
78f0cc9d | 437 | return 0; |
26b91c72 CH |
438 | trace_xfs_reflink_convert_cow(ip, imap); |
439 | return xfs_reflink_convert_cow_locked(ip, offset_fsb, count_fsb); | |
df307077 DC |
440 | |
441 | out_unreserve: | |
a14234c7 CH |
442 | xfs_trans_unreserve_quota_nblks(tp, ip, (long)resblks, 0, |
443 | XFS_QMOPT_RES_REGBLKS); | |
df307077 DC |
444 | out_trans_cancel: |
445 | xfs_trans_cancel(tp); | |
3c68d44a | 446 | return error; |
0613f16c DW |
447 | } |
448 | ||
43caeb18 | 449 | /* |
3802a345 CH |
450 | * Cancel CoW reservations for some block range of an inode. |
451 | * | |
452 | * If cancel_real is true this function cancels all COW fork extents for the | |
453 | * inode; if cancel_real is false, real extents are not cleared. | |
c5295c6a DC |
454 | * |
455 | * Caller must have already joined the inode to the current transaction. The | |
456 | * inode will be joined to the transaction returned to the caller. | |
43caeb18 DW |
457 | */ |
458 | int | |
459 | xfs_reflink_cancel_cow_blocks( | |
460 | struct xfs_inode *ip, | |
461 | struct xfs_trans **tpp, | |
462 | xfs_fileoff_t offset_fsb, | |
3802a345 CH |
463 | xfs_fileoff_t end_fsb, |
464 | bool cancel_real) | |
43caeb18 | 465 | { |
3e0ee78f | 466 | struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK); |
df5ab1b5 | 467 | struct xfs_bmbt_irec got, del; |
b2b1712a | 468 | struct xfs_iext_cursor icur; |
df5ab1b5 | 469 | int error = 0; |
43caeb18 | 470 | |
51d62690 | 471 | if (!xfs_inode_has_cow_data(ip)) |
43caeb18 | 472 | return 0; |
41caabd0 | 473 | if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got)) |
3e0ee78f | 474 | return 0; |
43caeb18 | 475 | |
41caabd0 CH |
476 | /* Walk backwards until we're out of the I/O range... */ |
477 | while (got.br_startoff + got.br_blockcount > offset_fsb) { | |
3e0ee78f CH |
478 | del = got; |
479 | xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb); | |
41caabd0 CH |
480 | |
481 | /* Extent delete may have bumped ext forward */ | |
482 | if (!del.br_blockcount) { | |
483 | xfs_iext_prev(ifp, &icur); | |
484 | goto next_extent; | |
485 | } | |
486 | ||
3e0ee78f | 487 | trace_xfs_reflink_cancel_cow(ip, &del); |
43caeb18 | 488 | |
3e0ee78f CH |
489 | if (isnullstartblock(del.br_startblock)) { |
490 | error = xfs_bmap_del_extent_delay(ip, XFS_COW_FORK, | |
b2b1712a | 491 | &icur, &got, &del); |
43caeb18 DW |
492 | if (error) |
493 | break; | |
3802a345 | 494 | } else if (del.br_state == XFS_EXT_UNWRITTEN || cancel_real) { |
1e5ae199 | 495 | ASSERT((*tpp)->t_firstblock == NULLFSBLOCK); |
43caeb18 | 496 | |
174edb0e | 497 | /* Free the CoW orphan record. */ |
74b4c5d4 DW |
498 | xfs_refcount_free_cow_extent(*tpp, del.br_startblock, |
499 | del.br_blockcount); | |
174edb0e | 500 | |
0f37d178 BF |
501 | xfs_bmap_add_free(*tpp, del.br_startblock, |
502 | del.br_blockcount, NULL); | |
43caeb18 | 503 | |
43caeb18 | 504 | /* Roll the transaction */ |
9e28a242 | 505 | error = xfs_defer_finish(tpp); |
9b1f4e98 | 506 | if (error) |
43caeb18 | 507 | break; |
43caeb18 DW |
508 | |
509 | /* Remove the mapping from the CoW fork. */ | |
b2b1712a | 510 | xfs_bmap_del_extent_cow(ip, &icur, &got, &del); |
4b4c1326 DW |
511 | |
512 | /* Remove the quota reservation */ | |
513 | error = xfs_trans_reserve_quota_nblks(NULL, ip, | |
514 | -(long)del.br_blockcount, 0, | |
515 | XFS_QMOPT_RES_REGBLKS); | |
516 | if (error) | |
517 | break; | |
9d40fba8 DW |
518 | } else { |
519 | /* Didn't do anything, push cursor back. */ | |
520 | xfs_iext_prev(ifp, &icur); | |
43caeb18 | 521 | } |
41caabd0 CH |
522 | next_extent: |
523 | if (!xfs_iext_get_extent(ifp, &icur, &got)) | |
c17a8ef4 | 524 | break; |
43caeb18 DW |
525 | } |
526 | ||
c17a8ef4 BF |
527 | /* clear tag if cow fork is emptied */ |
528 | if (!ifp->if_bytes) | |
529 | xfs_inode_clear_cowblocks_tag(ip); | |
43caeb18 DW |
530 | return error; |
531 | } | |
532 | ||
533 | /* | |
3802a345 CH |
534 | * Cancel CoW reservations for some byte range of an inode. |
535 | * | |
536 | * If cancel_real is true this function cancels all COW fork extents for the | |
537 | * inode; if cancel_real is false, real extents are not cleared. | |
43caeb18 DW |
538 | */ |
539 | int | |
540 | xfs_reflink_cancel_cow_range( | |
541 | struct xfs_inode *ip, | |
542 | xfs_off_t offset, | |
3802a345 CH |
543 | xfs_off_t count, |
544 | bool cancel_real) | |
43caeb18 DW |
545 | { |
546 | struct xfs_trans *tp; | |
547 | xfs_fileoff_t offset_fsb; | |
548 | xfs_fileoff_t end_fsb; | |
549 | int error; | |
550 | ||
551 | trace_xfs_reflink_cancel_cow_range(ip, offset, count); | |
66ae56a5 | 552 | ASSERT(ip->i_cowfp); |
43caeb18 DW |
553 | |
554 | offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset); | |
555 | if (count == NULLFILEOFF) | |
556 | end_fsb = NULLFILEOFF; | |
557 | else | |
558 | end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count); | |
559 | ||
560 | /* Start a rolling transaction to remove the mappings */ | |
561 | error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write, | |
73d30d48 | 562 | 0, 0, 0, &tp); |
43caeb18 DW |
563 | if (error) |
564 | goto out; | |
565 | ||
566 | xfs_ilock(ip, XFS_ILOCK_EXCL); | |
567 | xfs_trans_ijoin(tp, ip, 0); | |
568 | ||
569 | /* Scrape out the old CoW reservations */ | |
3802a345 CH |
570 | error = xfs_reflink_cancel_cow_blocks(ip, &tp, offset_fsb, end_fsb, |
571 | cancel_real); | |
43caeb18 DW |
572 | if (error) |
573 | goto out_cancel; | |
574 | ||
575 | error = xfs_trans_commit(tp); | |
576 | ||
577 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
578 | return error; | |
579 | ||
580 | out_cancel: | |
581 | xfs_trans_cancel(tp); | |
582 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
583 | out: | |
584 | trace_xfs_reflink_cancel_cow_range_error(ip, error, _RET_IP_); | |
585 | return error; | |
586 | } | |
587 | ||
588 | /* | |
d6f215f3 DW |
589 | * Remap part of the CoW fork into the data fork. |
590 | * | |
591 | * We aim to remap the range starting at @offset_fsb and ending at @end_fsb | |
592 | * into the data fork; this function will remap what it can (at the end of the | |
593 | * range) and update @end_fsb appropriately. Each remap gets its own | |
594 | * transaction because we can end up merging and splitting bmbt blocks for | |
595 | * every remap operation and we'd like to keep the block reservation | |
596 | * requirements as low as possible. | |
43caeb18 | 597 | */ |
d6f215f3 DW |
598 | STATIC int |
599 | xfs_reflink_end_cow_extent( | |
600 | struct xfs_inode *ip, | |
601 | xfs_fileoff_t offset_fsb, | |
602 | xfs_fileoff_t *end_fsb) | |
43caeb18 | 603 | { |
d6f215f3 DW |
604 | struct xfs_bmbt_irec got, del; |
605 | struct xfs_iext_cursor icur; | |
606 | struct xfs_mount *mp = ip->i_mount; | |
607 | struct xfs_trans *tp; | |
608 | struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK); | |
609 | xfs_filblks_t rlen; | |
610 | unsigned int resblks; | |
611 | int error; | |
43caeb18 | 612 | |
c1112b6e | 613 | /* No COW extents? That's easy! */ |
d6f215f3 DW |
614 | if (ifp->if_bytes == 0) { |
615 | *end_fsb = offset_fsb; | |
c1112b6e | 616 | return 0; |
d6f215f3 | 617 | } |
c1112b6e | 618 | |
d6f215f3 DW |
619 | resblks = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK); |
620 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, | |
73d30d48 | 621 | XFS_TRANS_RESERVE, &tp); |
d6f215f3 DW |
622 | if (error) |
623 | return error; | |
43caeb18 | 624 | |
fe0be23e | 625 | /* |
d6f215f3 DW |
626 | * Lock the inode. We have to ijoin without automatic unlock because |
627 | * the lead transaction is the refcountbt record deletion; the data | |
628 | * fork update follows as a deferred log item. | |
fe0be23e | 629 | */ |
43caeb18 DW |
630 | xfs_ilock(ip, XFS_ILOCK_EXCL); |
631 | xfs_trans_ijoin(tp, ip, 0); | |
632 | ||
dc56015f CH |
633 | /* |
634 | * In case of racing, overlapping AIO writes no COW extents might be | |
635 | * left by the time I/O completes for the loser of the race. In that | |
636 | * case we are done. | |
637 | */ | |
d6f215f3 DW |
638 | if (!xfs_iext_lookup_extent_before(ip, ifp, end_fsb, &icur, &got) || |
639 | got.br_startoff + got.br_blockcount <= offset_fsb) { | |
640 | *end_fsb = offset_fsb; | |
dc56015f | 641 | goto out_cancel; |
d6f215f3 | 642 | } |
43caeb18 | 643 | |
d6f215f3 DW |
644 | /* |
645 | * Structure copy @got into @del, then trim @del to the range that we | |
646 | * were asked to remap. We preserve @got for the eventual CoW fork | |
647 | * deletion; from now on @del represents the mapping that we're | |
648 | * actually remapping. | |
649 | */ | |
650 | del = got; | |
651 | xfs_trim_extent(&del, offset_fsb, *end_fsb - offset_fsb); | |
c1112b6e | 652 | |
d6f215f3 | 653 | ASSERT(del.br_blockcount > 0); |
5eda4300 | 654 | |
d6f215f3 DW |
655 | /* |
656 | * Only remap real extents that contain data. With AIO, speculative | |
657 | * preallocations can leak into the range we are called upon, and we | |
658 | * need to skip them. | |
659 | */ | |
660 | if (!xfs_bmap_is_real_extent(&got)) { | |
661 | *end_fsb = del.br_startoff; | |
662 | goto out_cancel; | |
663 | } | |
43caeb18 | 664 | |
d6f215f3 DW |
665 | /* Unmap the old blocks in the data fork. */ |
666 | rlen = del.br_blockcount; | |
667 | error = __xfs_bunmapi(tp, ip, del.br_startoff, &rlen, 0, 1); | |
668 | if (error) | |
669 | goto out_cancel; | |
174edb0e | 670 | |
d6f215f3 DW |
671 | /* Trim the extent to whatever got unmapped. */ |
672 | xfs_trim_extent(&del, del.br_startoff + rlen, del.br_blockcount - rlen); | |
673 | trace_xfs_reflink_cow_remap(ip, &del); | |
43caeb18 | 674 | |
d6f215f3 | 675 | /* Free the CoW orphan record. */ |
74b4c5d4 | 676 | xfs_refcount_free_cow_extent(tp, del.br_startblock, del.br_blockcount); |
43caeb18 | 677 | |
d6f215f3 | 678 | /* Map the new blocks into the data fork. */ |
3e08f42a | 679 | xfs_bmap_map_extent(tp, ip, &del); |
4b4c1326 | 680 | |
d6f215f3 DW |
681 | /* Charge this new data fork mapping to the on-disk quota. */ |
682 | xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_DELBCOUNT, | |
683 | (long)del.br_blockcount); | |
c1112b6e | 684 | |
d6f215f3 DW |
685 | /* Remove the mapping from the CoW fork. */ |
686 | xfs_bmap_del_extent_cow(ip, &icur, &got, &del); | |
43caeb18 DW |
687 | |
688 | error = xfs_trans_commit(tp); | |
689 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
690 | if (error) | |
d6f215f3 DW |
691 | return error; |
692 | ||
693 | /* Update the caller about how much progress we made. */ | |
694 | *end_fsb = del.br_startoff; | |
43caeb18 DW |
695 | return 0; |
696 | ||
e12199f8 | 697 | out_cancel: |
43caeb18 DW |
698 | xfs_trans_cancel(tp); |
699 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
d6f215f3 DW |
700 | return error; |
701 | } | |
702 | ||
703 | /* | |
704 | * Remap parts of a file's data fork after a successful CoW. | |
705 | */ | |
706 | int | |
707 | xfs_reflink_end_cow( | |
708 | struct xfs_inode *ip, | |
709 | xfs_off_t offset, | |
710 | xfs_off_t count) | |
711 | { | |
712 | xfs_fileoff_t offset_fsb; | |
713 | xfs_fileoff_t end_fsb; | |
714 | int error = 0; | |
715 | ||
716 | trace_xfs_reflink_end_cow(ip, offset, count); | |
717 | ||
718 | offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset); | |
719 | end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count); | |
720 | ||
721 | /* | |
722 | * Walk backwards until we're out of the I/O range. The loop function | |
723 | * repeatedly cycles the ILOCK to allocate one transaction per remapped | |
724 | * extent. | |
725 | * | |
726 | * If we're being called by writeback then the the pages will still | |
727 | * have PageWriteback set, which prevents races with reflink remapping | |
728 | * and truncate. Reflink remapping prevents races with writeback by | |
729 | * taking the iolock and mmaplock before flushing the pages and | |
730 | * remapping, which means there won't be any further writeback or page | |
731 | * cache dirtying until the reflink completes. | |
732 | * | |
733 | * We should never have two threads issuing writeback for the same file | |
734 | * region. There are also have post-eof checks in the writeback | |
735 | * preparation code so that we don't bother writing out pages that are | |
736 | * about to be truncated. | |
737 | * | |
738 | * If we're being called as part of directio write completion, the dio | |
739 | * count is still elevated, which reflink and truncate will wait for. | |
740 | * Reflink remapping takes the iolock and mmaplock and waits for | |
741 | * pending dio to finish, which should prevent any directio until the | |
742 | * remap completes. Multiple concurrent directio writes to the same | |
743 | * region are handled by end_cow processing only occurring for the | |
744 | * threads which succeed; the outcome of multiple overlapping direct | |
745 | * writes is not well defined anyway. | |
746 | * | |
747 | * It's possible that a buffered write and a direct write could collide | |
748 | * here (the buffered write stumbles in after the dio flushes and | |
749 | * invalidates the page cache and immediately queues writeback), but we | |
750 | * have never supported this 100%. If either disk write succeeds the | |
751 | * blocks will be remapped. | |
752 | */ | |
753 | while (end_fsb > offset_fsb && !error) | |
754 | error = xfs_reflink_end_cow_extent(ip, offset_fsb, &end_fsb); | |
755 | ||
756 | if (error) | |
757 | trace_xfs_reflink_end_cow_error(ip, error, _RET_IP_); | |
43caeb18 DW |
758 | return error; |
759 | } | |
174edb0e DW |
760 | |
761 | /* | |
762 | * Free leftover CoW reservations that didn't get cleaned out. | |
763 | */ | |
764 | int | |
765 | xfs_reflink_recover_cow( | |
766 | struct xfs_mount *mp) | |
767 | { | |
768 | xfs_agnumber_t agno; | |
769 | int error = 0; | |
770 | ||
771 | if (!xfs_sb_version_hasreflink(&mp->m_sb)) | |
772 | return 0; | |
773 | ||
774 | for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) { | |
775 | error = xfs_refcount_recover_cow_leftovers(mp, agno); | |
776 | if (error) | |
777 | break; | |
778 | } | |
779 | ||
780 | return error; | |
781 | } | |
862bb360 DW |
782 | |
783 | /* | |
784 | * Reflinking (Block) Ranges of Two Files Together | |
785 | * | |
786 | * First, ensure that the reflink flag is set on both inodes. The flag is an | |
787 | * optimization to avoid unnecessary refcount btree lookups in the write path. | |
788 | * | |
789 | * Now we can iteratively remap the range of extents (and holes) in src to the | |
790 | * corresponding ranges in dest. Let drange and srange denote the ranges of | |
791 | * logical blocks in dest and src touched by the reflink operation. | |
792 | * | |
793 | * While the length of drange is greater than zero, | |
794 | * - Read src's bmbt at the start of srange ("imap") | |
795 | * - If imap doesn't exist, make imap appear to start at the end of srange | |
796 | * with zero length. | |
797 | * - If imap starts before srange, advance imap to start at srange. | |
798 | * - If imap goes beyond srange, truncate imap to end at the end of srange. | |
799 | * - Punch (imap start - srange start + imap len) blocks from dest at | |
800 | * offset (drange start). | |
801 | * - If imap points to a real range of pblks, | |
802 | * > Increase the refcount of the imap's pblks | |
803 | * > Map imap's pblks into dest at the offset | |
804 | * (drange start + imap start - srange start) | |
805 | * - Advance drange and srange by (imap start - srange start + imap len) | |
806 | * | |
807 | * Finally, if the reflink made dest longer, update both the in-core and | |
808 | * on-disk file sizes. | |
809 | * | |
810 | * ASCII Art Demonstration: | |
811 | * | |
812 | * Let's say we want to reflink this source file: | |
813 | * | |
814 | * ----SSSSSSS-SSSSS----SSSSSS (src file) | |
815 | * <--------------------> | |
816 | * | |
817 | * into this destination file: | |
818 | * | |
819 | * --DDDDDDDDDDDDDDDDDDD--DDD (dest file) | |
820 | * <--------------------> | |
821 | * '-' means a hole, and 'S' and 'D' are written blocks in the src and dest. | |
822 | * Observe that the range has different logical offsets in either file. | |
823 | * | |
824 | * Consider that the first extent in the source file doesn't line up with our | |
825 | * reflink range. Unmapping and remapping are separate operations, so we can | |
826 | * unmap more blocks from the destination file than we remap. | |
827 | * | |
828 | * ----SSSSSSS-SSSSS----SSSSSS | |
829 | * <-------> | |
830 | * --DDDDD---------DDDDD--DDD | |
831 | * <-------> | |
832 | * | |
833 | * Now remap the source extent into the destination file: | |
834 | * | |
835 | * ----SSSSSSS-SSSSS----SSSSSS | |
836 | * <-------> | |
837 | * --DDDDD--SSSSSSSDDDDD--DDD | |
838 | * <-------> | |
839 | * | |
840 | * Do likewise with the second hole and extent in our range. Holes in the | |
841 | * unmap range don't affect our operation. | |
842 | * | |
843 | * ----SSSSSSS-SSSSS----SSSSSS | |
844 | * <----> | |
845 | * --DDDDD--SSSSSSS-SSSSS-DDD | |
846 | * <----> | |
847 | * | |
848 | * Finally, unmap and remap part of the third extent. This will increase the | |
849 | * size of the destination file. | |
850 | * | |
851 | * ----SSSSSSS-SSSSS----SSSSSS | |
852 | * <-----> | |
853 | * --DDDDD--SSSSSSS-SSSSS----SSS | |
854 | * <-----> | |
855 | * | |
856 | * Once we update the destination file's i_size, we're done. | |
857 | */ | |
858 | ||
859 | /* | |
860 | * Ensure the reflink bit is set in both inodes. | |
861 | */ | |
862 | STATIC int | |
863 | xfs_reflink_set_inode_flag( | |
864 | struct xfs_inode *src, | |
865 | struct xfs_inode *dest) | |
866 | { | |
867 | struct xfs_mount *mp = src->i_mount; | |
868 | int error; | |
869 | struct xfs_trans *tp; | |
870 | ||
871 | if (xfs_is_reflink_inode(src) && xfs_is_reflink_inode(dest)) | |
872 | return 0; | |
873 | ||
874 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp); | |
875 | if (error) | |
876 | goto out_error; | |
877 | ||
878 | /* Lock both files against IO */ | |
879 | if (src->i_ino == dest->i_ino) | |
880 | xfs_ilock(src, XFS_ILOCK_EXCL); | |
881 | else | |
7c2d238a | 882 | xfs_lock_two_inodes(src, XFS_ILOCK_EXCL, dest, XFS_ILOCK_EXCL); |
862bb360 DW |
883 | |
884 | if (!xfs_is_reflink_inode(src)) { | |
885 | trace_xfs_reflink_set_inode_flag(src); | |
886 | xfs_trans_ijoin(tp, src, XFS_ILOCK_EXCL); | |
887 | src->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK; | |
888 | xfs_trans_log_inode(tp, src, XFS_ILOG_CORE); | |
889 | xfs_ifork_init_cow(src); | |
890 | } else | |
891 | xfs_iunlock(src, XFS_ILOCK_EXCL); | |
892 | ||
893 | if (src->i_ino == dest->i_ino) | |
894 | goto commit_flags; | |
895 | ||
896 | if (!xfs_is_reflink_inode(dest)) { | |
897 | trace_xfs_reflink_set_inode_flag(dest); | |
898 | xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL); | |
899 | dest->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK; | |
900 | xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE); | |
901 | xfs_ifork_init_cow(dest); | |
902 | } else | |
903 | xfs_iunlock(dest, XFS_ILOCK_EXCL); | |
904 | ||
905 | commit_flags: | |
906 | error = xfs_trans_commit(tp); | |
907 | if (error) | |
908 | goto out_error; | |
909 | return error; | |
910 | ||
911 | out_error: | |
912 | trace_xfs_reflink_set_inode_flag_error(dest, error, _RET_IP_); | |
913 | return error; | |
914 | } | |
915 | ||
916 | /* | |
f7ca3522 | 917 | * Update destination inode size & cowextsize hint, if necessary. |
862bb360 | 918 | */ |
3fc9f5e4 | 919 | int |
862bb360 DW |
920 | xfs_reflink_update_dest( |
921 | struct xfs_inode *dest, | |
f7ca3522 | 922 | xfs_off_t newlen, |
c5ecb423 | 923 | xfs_extlen_t cowextsize, |
a91ae49b | 924 | unsigned int remap_flags) |
862bb360 DW |
925 | { |
926 | struct xfs_mount *mp = dest->i_mount; | |
927 | struct xfs_trans *tp; | |
928 | int error; | |
929 | ||
bf4a1fcf | 930 | if (newlen <= i_size_read(VFS_I(dest)) && cowextsize == 0) |
862bb360 DW |
931 | return 0; |
932 | ||
933 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp); | |
934 | if (error) | |
935 | goto out_error; | |
936 | ||
937 | xfs_ilock(dest, XFS_ILOCK_EXCL); | |
938 | xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL); | |
939 | ||
f7ca3522 DW |
940 | if (newlen > i_size_read(VFS_I(dest))) { |
941 | trace_xfs_reflink_update_inode_size(dest, newlen); | |
942 | i_size_write(VFS_I(dest), newlen); | |
943 | dest->i_d.di_size = newlen; | |
944 | } | |
945 | ||
946 | if (cowextsize) { | |
947 | dest->i_d.di_cowextsize = cowextsize; | |
948 | dest->i_d.di_flags2 |= XFS_DIFLAG2_COWEXTSIZE; | |
949 | } | |
950 | ||
862bb360 DW |
951 | xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE); |
952 | ||
953 | error = xfs_trans_commit(tp); | |
954 | if (error) | |
955 | goto out_error; | |
956 | return error; | |
957 | ||
958 | out_error: | |
959 | trace_xfs_reflink_update_inode_size_error(dest, error, _RET_IP_); | |
960 | return error; | |
961 | } | |
962 | ||
6fa164b8 DW |
963 | /* |
964 | * Do we have enough reserve in this AG to handle a reflink? The refcount | |
965 | * btree already reserved all the space it needs, but the rmap btree can grow | |
966 | * infinitely, so we won't allow more reflinks when the AG is down to the | |
967 | * btree reserves. | |
968 | */ | |
969 | static int | |
970 | xfs_reflink_ag_has_free_space( | |
971 | struct xfs_mount *mp, | |
972 | xfs_agnumber_t agno) | |
973 | { | |
974 | struct xfs_perag *pag; | |
975 | int error = 0; | |
976 | ||
977 | if (!xfs_sb_version_hasrmapbt(&mp->m_sb)) | |
978 | return 0; | |
979 | ||
980 | pag = xfs_perag_get(mp, agno); | |
21592863 | 981 | if (xfs_ag_resv_critical(pag, XFS_AG_RESV_RMAPBT) || |
6fa164b8 DW |
982 | xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA)) |
983 | error = -ENOSPC; | |
984 | xfs_perag_put(pag); | |
985 | return error; | |
986 | } | |
987 | ||
862bb360 DW |
988 | /* |
989 | * Unmap a range of blocks from a file, then map other blocks into the hole. | |
990 | * The range to unmap is (destoff : destoff + srcioff + irec->br_blockcount). | |
991 | * The extent irec is mapped into dest at irec->br_startoff. | |
992 | */ | |
993 | STATIC int | |
994 | xfs_reflink_remap_extent( | |
995 | struct xfs_inode *ip, | |
996 | struct xfs_bmbt_irec *irec, | |
997 | xfs_fileoff_t destoff, | |
998 | xfs_off_t new_isize) | |
999 | { | |
1000 | struct xfs_mount *mp = ip->i_mount; | |
9c4f29d3 | 1001 | bool real_extent = xfs_bmap_is_real_extent(irec); |
862bb360 | 1002 | struct xfs_trans *tp; |
862bb360 | 1003 | unsigned int resblks; |
862bb360 | 1004 | struct xfs_bmbt_irec uirec; |
862bb360 DW |
1005 | xfs_filblks_t rlen; |
1006 | xfs_filblks_t unmap_len; | |
1007 | xfs_off_t newlen; | |
1008 | int error; | |
1009 | ||
1010 | unmap_len = irec->br_startoff + irec->br_blockcount - destoff; | |
1011 | trace_xfs_reflink_punch_range(ip, destoff, unmap_len); | |
1012 | ||
6fa164b8 DW |
1013 | /* No reflinking if we're low on space */ |
1014 | if (real_extent) { | |
1015 | error = xfs_reflink_ag_has_free_space(mp, | |
1016 | XFS_FSB_TO_AGNO(mp, irec->br_startblock)); | |
1017 | if (error) | |
1018 | goto out; | |
1019 | } | |
1020 | ||
862bb360 DW |
1021 | /* Start a rolling transaction to switch the mappings */ |
1022 | resblks = XFS_EXTENTADD_SPACE_RES(ip->i_mount, XFS_DATA_FORK); | |
1023 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp); | |
1024 | if (error) | |
1025 | goto out; | |
1026 | ||
1027 | xfs_ilock(ip, XFS_ILOCK_EXCL); | |
1028 | xfs_trans_ijoin(tp, ip, 0); | |
1029 | ||
1030 | /* If we're not just clearing space, then do we have enough quota? */ | |
1031 | if (real_extent) { | |
1032 | error = xfs_trans_reserve_quota_nblks(tp, ip, | |
1033 | irec->br_blockcount, 0, XFS_QMOPT_RES_REGBLKS); | |
1034 | if (error) | |
1035 | goto out_cancel; | |
1036 | } | |
1037 | ||
1038 | trace_xfs_reflink_remap(ip, irec->br_startoff, | |
1039 | irec->br_blockcount, irec->br_startblock); | |
1040 | ||
1041 | /* Unmap the old blocks in the data fork. */ | |
1042 | rlen = unmap_len; | |
1043 | while (rlen) { | |
9d9e6233 | 1044 | ASSERT(tp->t_firstblock == NULLFSBLOCK); |
2af52842 | 1045 | error = __xfs_bunmapi(tp, ip, destoff, &rlen, 0, 1); |
862bb360 | 1046 | if (error) |
c8eac49e | 1047 | goto out_cancel; |
862bb360 DW |
1048 | |
1049 | /* | |
1050 | * Trim the extent to whatever got unmapped. | |
1051 | * Remember, bunmapi works backwards. | |
1052 | */ | |
1053 | uirec.br_startblock = irec->br_startblock + rlen; | |
1054 | uirec.br_startoff = irec->br_startoff + rlen; | |
1055 | uirec.br_blockcount = unmap_len - rlen; | |
1056 | unmap_len = rlen; | |
1057 | ||
1058 | /* If this isn't a real mapping, we're done. */ | |
1059 | if (!real_extent || uirec.br_blockcount == 0) | |
1060 | goto next_extent; | |
1061 | ||
1062 | trace_xfs_reflink_remap(ip, uirec.br_startoff, | |
1063 | uirec.br_blockcount, uirec.br_startblock); | |
1064 | ||
1065 | /* Update the refcount tree */ | |
74b4c5d4 | 1066 | xfs_refcount_increase_extent(tp, &uirec); |
862bb360 DW |
1067 | |
1068 | /* Map the new blocks into the data fork. */ | |
3e08f42a | 1069 | xfs_bmap_map_extent(tp, ip, &uirec); |
862bb360 DW |
1070 | |
1071 | /* Update quota accounting. */ | |
1072 | xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, | |
1073 | uirec.br_blockcount); | |
1074 | ||
1075 | /* Update dest isize if needed. */ | |
1076 | newlen = XFS_FSB_TO_B(mp, | |
1077 | uirec.br_startoff + uirec.br_blockcount); | |
1078 | newlen = min_t(xfs_off_t, newlen, new_isize); | |
1079 | if (newlen > i_size_read(VFS_I(ip))) { | |
1080 | trace_xfs_reflink_update_inode_size(ip, newlen); | |
1081 | i_size_write(VFS_I(ip), newlen); | |
1082 | ip->i_d.di_size = newlen; | |
1083 | xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); | |
1084 | } | |
1085 | ||
1086 | next_extent: | |
1087 | /* Process all the deferred stuff. */ | |
9e28a242 | 1088 | error = xfs_defer_finish(&tp); |
862bb360 | 1089 | if (error) |
c8eac49e | 1090 | goto out_cancel; |
862bb360 DW |
1091 | } |
1092 | ||
1093 | error = xfs_trans_commit(tp); | |
1094 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
1095 | if (error) | |
1096 | goto out; | |
1097 | return 0; | |
1098 | ||
862bb360 DW |
1099 | out_cancel: |
1100 | xfs_trans_cancel(tp); | |
1101 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
1102 | out: | |
1103 | trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_); | |
1104 | return error; | |
1105 | } | |
1106 | ||
1107 | /* | |
1108 | * Iteratively remap one file's extents (and holes) to another's. | |
1109 | */ | |
3fc9f5e4 | 1110 | int |
862bb360 DW |
1111 | xfs_reflink_remap_blocks( |
1112 | struct xfs_inode *src, | |
9f04aaff | 1113 | loff_t pos_in, |
862bb360 | 1114 | struct xfs_inode *dest, |
9f04aaff | 1115 | loff_t pos_out, |
3f68c1f5 DW |
1116 | loff_t remap_len, |
1117 | loff_t *remapped) | |
862bb360 DW |
1118 | { |
1119 | struct xfs_bmbt_irec imap; | |
9f04aaff DW |
1120 | xfs_fileoff_t srcoff; |
1121 | xfs_fileoff_t destoff; | |
1122 | xfs_filblks_t len; | |
1123 | xfs_filblks_t range_len; | |
3f68c1f5 | 1124 | xfs_filblks_t remapped_len = 0; |
9f04aaff | 1125 | xfs_off_t new_isize = pos_out + remap_len; |
862bb360 DW |
1126 | int nimaps; |
1127 | int error = 0; | |
9f04aaff DW |
1128 | |
1129 | destoff = XFS_B_TO_FSBT(src->i_mount, pos_out); | |
1130 | srcoff = XFS_B_TO_FSBT(src->i_mount, pos_in); | |
1131 | len = XFS_B_TO_FSB(src->i_mount, remap_len); | |
862bb360 DW |
1132 | |
1133 | /* drange = (destoff, destoff + len); srange = (srcoff, srcoff + len) */ | |
1134 | while (len) { | |
01c2e13d DW |
1135 | uint lock_mode; |
1136 | ||
862bb360 DW |
1137 | trace_xfs_reflink_remap_blocks_loop(src, srcoff, len, |
1138 | dest, destoff); | |
01c2e13d | 1139 | |
862bb360 DW |
1140 | /* Read extent from the source file */ |
1141 | nimaps = 1; | |
01c2e13d | 1142 | lock_mode = xfs_ilock_data_map_shared(src); |
862bb360 | 1143 | error = xfs_bmapi_read(src, srcoff, len, &imap, &nimaps, 0); |
01c2e13d | 1144 | xfs_iunlock(src, lock_mode); |
862bb360 | 1145 | if (error) |
9f04aaff | 1146 | break; |
862bb360 DW |
1147 | ASSERT(nimaps == 1); |
1148 | ||
be225fec | 1149 | trace_xfs_reflink_remap_imap(src, srcoff, len, XFS_DATA_FORK, |
862bb360 DW |
1150 | &imap); |
1151 | ||
1152 | /* Translate imap into the destination file. */ | |
1153 | range_len = imap.br_startoff + imap.br_blockcount - srcoff; | |
1154 | imap.br_startoff += destoff - srcoff; | |
1155 | ||
1156 | /* Clear dest from destoff to the end of imap and map it in. */ | |
1157 | error = xfs_reflink_remap_extent(dest, &imap, destoff, | |
1158 | new_isize); | |
1159 | if (error) | |
9f04aaff | 1160 | break; |
862bb360 DW |
1161 | |
1162 | if (fatal_signal_pending(current)) { | |
1163 | error = -EINTR; | |
9f04aaff | 1164 | break; |
862bb360 DW |
1165 | } |
1166 | ||
1167 | /* Advance drange/srange */ | |
1168 | srcoff += range_len; | |
1169 | destoff += range_len; | |
1170 | len -= range_len; | |
3f68c1f5 | 1171 | remapped_len += range_len; |
862bb360 DW |
1172 | } |
1173 | ||
9f04aaff DW |
1174 | if (error) |
1175 | trace_xfs_reflink_remap_blocks_error(dest, error, _RET_IP_); | |
3f68c1f5 DW |
1176 | *remapped = min_t(loff_t, remap_len, |
1177 | XFS_FSB_TO_B(src->i_mount, remapped_len)); | |
862bb360 DW |
1178 | return error; |
1179 | } | |
1180 | ||
1364b1d4 | 1181 | /* |
5d888b48 DW |
1182 | * Grab the exclusive iolock for a data copy from src to dest, making sure to |
1183 | * abide vfs locking order (lowest pointer value goes first) and breaking the | |
1184 | * layout leases before proceeding. The loop is needed because we cannot call | |
1185 | * the blocking break_layout() with the iolocks held, and therefore have to | |
1186 | * back out both locks. | |
1364b1d4 DW |
1187 | */ |
1188 | static int | |
1189 | xfs_iolock_two_inodes_and_break_layout( | |
1190 | struct inode *src, | |
1191 | struct inode *dest) | |
1192 | { | |
1193 | int error; | |
1194 | ||
5d888b48 DW |
1195 | if (src > dest) |
1196 | swap(src, dest); | |
1364b1d4 | 1197 | |
5d888b48 DW |
1198 | retry: |
1199 | /* Wait to break both inodes' layouts before we start locking. */ | |
1200 | error = break_layout(src, true); | |
1201 | if (error) | |
1202 | return error; | |
1203 | if (src != dest) { | |
1364b1d4 DW |
1204 | error = break_layout(dest, true); |
1205 | if (error) | |
1206 | return error; | |
1364b1d4 | 1207 | } |
5d888b48 DW |
1208 | |
1209 | /* Lock one inode and make sure nobody got in and leased it. */ | |
1210 | inode_lock(src); | |
1211 | error = break_layout(src, false); | |
1364b1d4 | 1212 | if (error) { |
5d888b48 DW |
1213 | inode_unlock(src); |
1214 | if (error == -EWOULDBLOCK) | |
1215 | goto retry; | |
1216 | return error; | |
1217 | } | |
1218 | ||
1219 | if (src == dest) | |
1220 | return 0; | |
1221 | ||
1222 | /* Lock the other inode and make sure nobody got in and leased it. */ | |
1223 | inode_lock_nested(dest, I_MUTEX_NONDIR2); | |
1224 | error = break_layout(dest, false); | |
1225 | if (error) { | |
1226 | inode_unlock(src); | |
1364b1d4 | 1227 | inode_unlock(dest); |
5d888b48 DW |
1228 | if (error == -EWOULDBLOCK) |
1229 | goto retry; | |
1364b1d4 DW |
1230 | return error; |
1231 | } | |
5d888b48 | 1232 | |
1364b1d4 DW |
1233 | return 0; |
1234 | } | |
1235 | ||
0d41e1d2 | 1236 | /* Unlock both inodes after they've been prepped for a range clone. */ |
3fc9f5e4 | 1237 | void |
0d41e1d2 DW |
1238 | xfs_reflink_remap_unlock( |
1239 | struct file *file_in, | |
1240 | struct file *file_out) | |
1241 | { | |
1242 | struct inode *inode_in = file_inode(file_in); | |
1243 | struct xfs_inode *src = XFS_I(inode_in); | |
1244 | struct inode *inode_out = file_inode(file_out); | |
1245 | struct xfs_inode *dest = XFS_I(inode_out); | |
1246 | bool same_inode = (inode_in == inode_out); | |
1247 | ||
1248 | xfs_iunlock(dest, XFS_MMAPLOCK_EXCL); | |
1249 | if (!same_inode) | |
5d888b48 | 1250 | xfs_iunlock(src, XFS_MMAPLOCK_EXCL); |
0d41e1d2 DW |
1251 | inode_unlock(inode_out); |
1252 | if (!same_inode) | |
5d888b48 | 1253 | inode_unlock(inode_in); |
0d41e1d2 DW |
1254 | } |
1255 | ||
410fdc72 DW |
1256 | /* |
1257 | * If we're reflinking to a point past the destination file's EOF, we must | |
1258 | * zero any speculative post-EOF preallocations that sit between the old EOF | |
1259 | * and the destination file offset. | |
1260 | */ | |
1261 | static int | |
1262 | xfs_reflink_zero_posteof( | |
1263 | struct xfs_inode *ip, | |
1264 | loff_t pos) | |
1265 | { | |
1266 | loff_t isize = i_size_read(VFS_I(ip)); | |
1267 | ||
1268 | if (pos <= isize) | |
1269 | return 0; | |
1270 | ||
1271 | trace_xfs_zero_eof(ip, isize, pos - isize); | |
1272 | return iomap_zero_range(VFS_I(ip), isize, pos - isize, NULL, | |
1273 | &xfs_iomap_ops); | |
1274 | } | |
1275 | ||
862bb360 | 1276 | /* |
0d41e1d2 | 1277 | * Prepare two files for range cloning. Upon a successful return both inodes |
b3998900 DC |
1278 | * will have the iolock and mmaplock held, the page cache of the out file will |
1279 | * be truncated, and any leases on the out file will have been broken. This | |
1280 | * function borrows heavily from xfs_file_aio_write_checks. | |
dceeb47b DC |
1281 | * |
1282 | * The VFS allows partial EOF blocks to "match" for dedupe even though it hasn't | |
1283 | * checked that the bytes beyond EOF physically match. Hence we cannot use the | |
1284 | * EOF block in the source dedupe range because it's not a complete block match, | |
b3998900 | 1285 | * hence can introduce a corruption into the file that has it's block replaced. |
dceeb47b | 1286 | * |
b3998900 DC |
1287 | * In similar fashion, the VFS file cloning also allows partial EOF blocks to be |
1288 | * "block aligned" for the purposes of cloning entire files. However, if the | |
1289 | * source file range includes the EOF block and it lands within the existing EOF | |
1290 | * of the destination file, then we can expose stale data from beyond the source | |
1291 | * file EOF in the destination file. | |
1292 | * | |
1293 | * XFS doesn't support partial block sharing, so in both cases we have check | |
1294 | * these cases ourselves. For dedupe, we can simply round the length to dedupe | |
1295 | * down to the previous whole block and ignore the partial EOF block. While this | |
1296 | * means we can't dedupe the last block of a file, this is an acceptible | |
1297 | * tradeoff for simplicity on implementation. | |
1298 | * | |
1299 | * For cloning, we want to share the partial EOF block if it is also the new EOF | |
1300 | * block of the destination file. If the partial EOF block lies inside the | |
1301 | * existing destination EOF, then we have to abort the clone to avoid exposing | |
1302 | * stale data in the destination file. Hence we reject these clone attempts with | |
1303 | * -EINVAL in this case. | |
862bb360 | 1304 | */ |
3fc9f5e4 | 1305 | int |
0d41e1d2 | 1306 | xfs_reflink_remap_prep( |
5faaf4fa CH |
1307 | struct file *file_in, |
1308 | loff_t pos_in, | |
1309 | struct file *file_out, | |
1310 | loff_t pos_out, | |
42ec3d4c | 1311 | loff_t *len, |
a91ae49b | 1312 | unsigned int remap_flags) |
862bb360 | 1313 | { |
5faaf4fa CH |
1314 | struct inode *inode_in = file_inode(file_in); |
1315 | struct xfs_inode *src = XFS_I(inode_in); | |
1316 | struct inode *inode_out = file_inode(file_out); | |
1317 | struct xfs_inode *dest = XFS_I(inode_out); | |
5faaf4fa | 1318 | bool same_inode = (inode_in == inode_out); |
5faaf4fa | 1319 | ssize_t ret; |
862bb360 | 1320 | |
5faaf4fa | 1321 | /* Lock both files against IO */ |
1364b1d4 DW |
1322 | ret = xfs_iolock_two_inodes_and_break_layout(inode_in, inode_out); |
1323 | if (ret) | |
1324 | return ret; | |
65523218 | 1325 | if (same_inode) |
5faaf4fa | 1326 | xfs_ilock(src, XFS_MMAPLOCK_EXCL); |
65523218 | 1327 | else |
5d888b48 | 1328 | xfs_lock_two_inodes(src, XFS_MMAPLOCK_EXCL, dest, |
7c2d238a | 1329 | XFS_MMAPLOCK_EXCL); |
5faaf4fa | 1330 | |
876bec6f | 1331 | /* Check file eligibility and prepare for block sharing. */ |
5faaf4fa | 1332 | ret = -EINVAL; |
862bb360 DW |
1333 | /* Don't reflink realtime inodes */ |
1334 | if (XFS_IS_REALTIME_INODE(src) || XFS_IS_REALTIME_INODE(dest)) | |
5faaf4fa CH |
1335 | goto out_unlock; |
1336 | ||
1337 | /* Don't share DAX file data for now. */ | |
1338 | if (IS_DAX(inode_in) || IS_DAX(inode_out)) | |
1339 | goto out_unlock; | |
1340 | ||
a83ab01a | 1341 | ret = generic_remap_file_range_prep(file_in, pos_in, file_out, pos_out, |
a91ae49b | 1342 | len, remap_flags); |
8c5c836b | 1343 | if (ret < 0 || *len == 0) |
5faaf4fa CH |
1344 | goto out_unlock; |
1345 | ||
09ac8623 | 1346 | /* Attach dquots to dest inode before changing block map */ |
c14cfcca | 1347 | ret = xfs_qm_dqattach(dest); |
09ac8623 DW |
1348 | if (ret) |
1349 | goto out_unlock; | |
1350 | ||
5c989a0e | 1351 | /* |
410fdc72 DW |
1352 | * Zero existing post-eof speculative preallocations in the destination |
1353 | * file. | |
5c989a0e | 1354 | */ |
410fdc72 DW |
1355 | ret = xfs_reflink_zero_posteof(dest, pos_out); |
1356 | if (ret) | |
1357 | goto out_unlock; | |
5c989a0e | 1358 | |
876bec6f | 1359 | /* Set flags and remap blocks. */ |
5faaf4fa CH |
1360 | ret = xfs_reflink_set_inode_flag(src, dest); |
1361 | if (ret) | |
1362 | goto out_unlock; | |
862bb360 | 1363 | |
2c307174 DC |
1364 | /* |
1365 | * If pos_out > EOF, we may have dirtied blocks between EOF and | |
1366 | * pos_out. In that case, we need to extend the flush and unmap to cover | |
1367 | * from EOF to the end of the copy length. | |
1368 | */ | |
1369 | if (pos_out > XFS_ISIZE(dest)) { | |
1370 | loff_t flen = *len + (pos_out - XFS_ISIZE(dest)); | |
1371 | ret = xfs_flush_unmap_range(dest, XFS_ISIZE(dest), flen); | |
1372 | } else { | |
1373 | ret = xfs_flush_unmap_range(dest, pos_out, *len); | |
1374 | } | |
1375 | if (ret) | |
1376 | goto out_unlock; | |
7debbf01 | 1377 | |
0d41e1d2 DW |
1378 | return 1; |
1379 | out_unlock: | |
1380 | xfs_reflink_remap_unlock(file_in, file_out); | |
1381 | return ret; | |
1382 | } | |
1383 | ||
98cc2db5 DW |
1384 | /* |
1385 | * The user wants to preemptively CoW all shared blocks in this file, | |
1386 | * which enables us to turn off the reflink flag. Iterate all | |
1387 | * extents which are not prealloc/delalloc to see which ranges are | |
1388 | * mentioned in the refcount tree, then read those blocks into the | |
1389 | * pagecache, dirty them, fsync them back out, and then we can update | |
1390 | * the inode flag. What happens if we run out of memory? :) | |
1391 | */ | |
1392 | STATIC int | |
1393 | xfs_reflink_dirty_extents( | |
1394 | struct xfs_inode *ip, | |
1395 | xfs_fileoff_t fbno, | |
1396 | xfs_filblks_t end, | |
1397 | xfs_off_t isize) | |
1398 | { | |
1399 | struct xfs_mount *mp = ip->i_mount; | |
1400 | xfs_agnumber_t agno; | |
1401 | xfs_agblock_t agbno; | |
1402 | xfs_extlen_t aglen; | |
1403 | xfs_agblock_t rbno; | |
1404 | xfs_extlen_t rlen; | |
1405 | xfs_off_t fpos; | |
1406 | xfs_off_t flen; | |
1407 | struct xfs_bmbt_irec map[2]; | |
1408 | int nmaps; | |
9780643c | 1409 | int error = 0; |
98cc2db5 DW |
1410 | |
1411 | while (end - fbno > 0) { | |
1412 | nmaps = 1; | |
1413 | /* | |
1414 | * Look for extents in the file. Skip holes, delalloc, or | |
1415 | * unwritten extents; they can't be reflinked. | |
1416 | */ | |
1417 | error = xfs_bmapi_read(ip, fbno, end - fbno, map, &nmaps, 0); | |
1418 | if (error) | |
1419 | goto out; | |
1420 | if (nmaps == 0) | |
1421 | break; | |
9c4f29d3 | 1422 | if (!xfs_bmap_is_real_extent(&map[0])) |
98cc2db5 DW |
1423 | goto next; |
1424 | ||
1425 | map[1] = map[0]; | |
1426 | while (map[1].br_blockcount) { | |
1427 | agno = XFS_FSB_TO_AGNO(mp, map[1].br_startblock); | |
1428 | agbno = XFS_FSB_TO_AGBNO(mp, map[1].br_startblock); | |
1429 | aglen = map[1].br_blockcount; | |
1430 | ||
92ff7285 DW |
1431 | error = xfs_reflink_find_shared(mp, NULL, agno, agbno, |
1432 | aglen, &rbno, &rlen, true); | |
98cc2db5 DW |
1433 | if (error) |
1434 | goto out; | |
1435 | if (rbno == NULLAGBLOCK) | |
1436 | break; | |
1437 | ||
1438 | /* Dirty the pages */ | |
1439 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
1440 | fpos = XFS_FSB_TO_B(mp, map[1].br_startoff + | |
1441 | (rbno - agbno)); | |
1442 | flen = XFS_FSB_TO_B(mp, rlen); | |
1443 | if (fpos + flen > isize) | |
1444 | flen = isize - fpos; | |
1445 | error = iomap_file_dirty(VFS_I(ip), fpos, flen, | |
1446 | &xfs_iomap_ops); | |
1447 | xfs_ilock(ip, XFS_ILOCK_EXCL); | |
1448 | if (error) | |
1449 | goto out; | |
1450 | ||
1451 | map[1].br_blockcount -= (rbno - agbno + rlen); | |
1452 | map[1].br_startoff += (rbno - agbno + rlen); | |
1453 | map[1].br_startblock += (rbno - agbno + rlen); | |
1454 | } | |
1455 | ||
1456 | next: | |
1457 | fbno = map[0].br_startoff + map[0].br_blockcount; | |
1458 | } | |
1459 | out: | |
1460 | return error; | |
1461 | } | |
1462 | ||
ea7cdd7b | 1463 | /* Does this inode need the reflink flag? */ |
98cc2db5 | 1464 | int |
ea7cdd7b DW |
1465 | xfs_reflink_inode_has_shared_extents( |
1466 | struct xfs_trans *tp, | |
1467 | struct xfs_inode *ip, | |
1468 | bool *has_shared) | |
98cc2db5 | 1469 | { |
ea7cdd7b DW |
1470 | struct xfs_bmbt_irec got; |
1471 | struct xfs_mount *mp = ip->i_mount; | |
1472 | struct xfs_ifork *ifp; | |
1473 | xfs_agnumber_t agno; | |
1474 | xfs_agblock_t agbno; | |
1475 | xfs_extlen_t aglen; | |
1476 | xfs_agblock_t rbno; | |
1477 | xfs_extlen_t rlen; | |
b2b1712a | 1478 | struct xfs_iext_cursor icur; |
ea7cdd7b DW |
1479 | bool found; |
1480 | int error; | |
98cc2db5 | 1481 | |
ea7cdd7b DW |
1482 | ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); |
1483 | if (!(ifp->if_flags & XFS_IFEXTENTS)) { | |
1484 | error = xfs_iread_extents(tp, ip, XFS_DATA_FORK); | |
98cc2db5 DW |
1485 | if (error) |
1486 | return error; | |
ea7cdd7b | 1487 | } |
98cc2db5 | 1488 | |
ea7cdd7b | 1489 | *has_shared = false; |
b2b1712a | 1490 | found = xfs_iext_lookup_extent(ip, ifp, 0, &icur, &got); |
ea7cdd7b DW |
1491 | while (found) { |
1492 | if (isnullstartblock(got.br_startblock) || | |
1493 | got.br_state != XFS_EXT_NORM) | |
1494 | goto next; | |
1495 | agno = XFS_FSB_TO_AGNO(mp, got.br_startblock); | |
1496 | agbno = XFS_FSB_TO_AGBNO(mp, got.br_startblock); | |
1497 | aglen = got.br_blockcount; | |
98cc2db5 | 1498 | |
ea7cdd7b | 1499 | error = xfs_reflink_find_shared(mp, tp, agno, agbno, aglen, |
024adf48 DW |
1500 | &rbno, &rlen, false); |
1501 | if (error) | |
1502 | return error; | |
1503 | /* Is there still a shared block here? */ | |
ea7cdd7b DW |
1504 | if (rbno != NULLAGBLOCK) { |
1505 | *has_shared = true; | |
024adf48 | 1506 | return 0; |
ea7cdd7b | 1507 | } |
98cc2db5 | 1508 | next: |
b2b1712a | 1509 | found = xfs_iext_next_extent(ifp, &icur, &got); |
98cc2db5 DW |
1510 | } |
1511 | ||
ea7cdd7b DW |
1512 | return 0; |
1513 | } | |
1514 | ||
844e5e74 DC |
1515 | /* |
1516 | * Clear the inode reflink flag if there are no shared extents. | |
1517 | * | |
1518 | * The caller is responsible for joining the inode to the transaction passed in. | |
1519 | * The inode will be joined to the transaction that is returned to the caller. | |
1520 | */ | |
ea7cdd7b DW |
1521 | int |
1522 | xfs_reflink_clear_inode_flag( | |
1523 | struct xfs_inode *ip, | |
1524 | struct xfs_trans **tpp) | |
1525 | { | |
1526 | bool needs_flag; | |
1527 | int error = 0; | |
1528 | ||
1529 | ASSERT(xfs_is_reflink_inode(ip)); | |
1530 | ||
1531 | error = xfs_reflink_inode_has_shared_extents(*tpp, ip, &needs_flag); | |
1532 | if (error || needs_flag) | |
1533 | return error; | |
1534 | ||
98cc2db5 DW |
1535 | /* |
1536 | * We didn't find any shared blocks so turn off the reflink flag. | |
1537 | * First, get rid of any leftover CoW mappings. | |
1538 | */ | |
3802a345 | 1539 | error = xfs_reflink_cancel_cow_blocks(ip, tpp, 0, NULLFILEOFF, true); |
98cc2db5 DW |
1540 | if (error) |
1541 | return error; | |
1542 | ||
1543 | /* Clear the inode flag. */ | |
1544 | trace_xfs_reflink_unset_inode_flag(ip); | |
1545 | ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK; | |
83104d44 | 1546 | xfs_inode_clear_cowblocks_tag(ip); |
98cc2db5 DW |
1547 | xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE); |
1548 | ||
1549 | return error; | |
1550 | } | |
1551 | ||
1552 | /* | |
1553 | * Clear the inode reflink flag if there are no shared extents and the size | |
1554 | * hasn't changed. | |
1555 | */ | |
1556 | STATIC int | |
1557 | xfs_reflink_try_clear_inode_flag( | |
97a1b87e | 1558 | struct xfs_inode *ip) |
98cc2db5 DW |
1559 | { |
1560 | struct xfs_mount *mp = ip->i_mount; | |
1561 | struct xfs_trans *tp; | |
1562 | int error = 0; | |
1563 | ||
1564 | /* Start a rolling transaction to remove the mappings */ | |
1565 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp); | |
1566 | if (error) | |
1567 | return error; | |
1568 | ||
1569 | xfs_ilock(ip, XFS_ILOCK_EXCL); | |
1570 | xfs_trans_ijoin(tp, ip, 0); | |
1571 | ||
98cc2db5 DW |
1572 | error = xfs_reflink_clear_inode_flag(ip, &tp); |
1573 | if (error) | |
1574 | goto cancel; | |
1575 | ||
1576 | error = xfs_trans_commit(tp); | |
1577 | if (error) | |
1578 | goto out; | |
1579 | ||
1580 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
1581 | return 0; | |
1582 | cancel: | |
1583 | xfs_trans_cancel(tp); | |
1584 | out: | |
1585 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
1586 | return error; | |
1587 | } | |
1588 | ||
1589 | /* | |
1590 | * Pre-COW all shared blocks within a given byte range of a file and turn off | |
1591 | * the reflink flag if we unshare all of the file's blocks. | |
1592 | */ | |
1593 | int | |
1594 | xfs_reflink_unshare( | |
1595 | struct xfs_inode *ip, | |
1596 | xfs_off_t offset, | |
1597 | xfs_off_t len) | |
1598 | { | |
1599 | struct xfs_mount *mp = ip->i_mount; | |
1600 | xfs_fileoff_t fbno; | |
1601 | xfs_filblks_t end; | |
1602 | xfs_off_t isize; | |
1603 | int error; | |
1604 | ||
1605 | if (!xfs_is_reflink_inode(ip)) | |
1606 | return 0; | |
1607 | ||
1608 | trace_xfs_reflink_unshare(ip, offset, len); | |
1609 | ||
1610 | inode_dio_wait(VFS_I(ip)); | |
1611 | ||
1612 | /* Try to CoW the selected ranges */ | |
1613 | xfs_ilock(ip, XFS_ILOCK_EXCL); | |
97a1b87e | 1614 | fbno = XFS_B_TO_FSBT(mp, offset); |
98cc2db5 DW |
1615 | isize = i_size_read(VFS_I(ip)); |
1616 | end = XFS_B_TO_FSB(mp, offset + len); | |
1617 | error = xfs_reflink_dirty_extents(ip, fbno, end, isize); | |
1618 | if (error) | |
1619 | goto out_unlock; | |
1620 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
1621 | ||
1622 | /* Wait for the IO to finish */ | |
1623 | error = filemap_write_and_wait(VFS_I(ip)->i_mapping); | |
1624 | if (error) | |
1625 | goto out; | |
1626 | ||
97a1b87e DW |
1627 | /* Turn off the reflink flag if possible. */ |
1628 | error = xfs_reflink_try_clear_inode_flag(ip); | |
1629 | if (error) | |
1630 | goto out; | |
98cc2db5 DW |
1631 | |
1632 | return 0; | |
1633 | ||
1634 | out_unlock: | |
1635 | xfs_iunlock(ip, XFS_ILOCK_EXCL); | |
1636 | out: | |
1637 | trace_xfs_reflink_unshare_error(ip, error, _RET_IP_); | |
1638 | return error; | |
1639 | } |