Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0+
2 : /*
3 : * Copyright (C) 2016 Oracle. All Rights Reserved.
4 : * Author: Darrick J. Wong <darrick.wong@oracle.com>
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"
14 : #include "xfs_inode.h"
15 : #include "xfs_trans.h"
16 : #include "xfs_bmap.h"
17 : #include "xfs_bmap_util.h"
18 : #include "xfs_trace.h"
19 : #include "xfs_icache.h"
20 : #include "xfs_btree.h"
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"
27 : #include "xfs_quota.h"
28 : #include "xfs_reflink.h"
29 : #include "xfs_iomap.h"
30 : #include "xfs_ag.h"
31 : #include "xfs_ag_resv.h"
32 : #include "xfs_health.h"
33 :
34 : /*
35 : * Copy on Write of Shared Blocks
36 : *
37 : * XFS must preserve "the usual" file semantics even when two files share
38 : * the same physical blocks. This means that a write to one file must not
39 : * alter the blocks in a different file; the way that we'll do that is
40 : * through the use of a copy-on-write mechanism. At a high level, that
41 : * means that when we want to write to a shared block, we allocate a new
42 : * block, write the data to the new block, and if that succeeds we map the
43 : * new block into the file.
44 : *
45 : * XFS provides a "delayed allocation" mechanism that defers the allocation
46 : * of disk blocks to dirty-but-not-yet-mapped file blocks as long as
47 : * possible. This reduces fragmentation by enabling the filesystem to ask
48 : * for bigger chunks less often, which is exactly what we want for CoW.
49 : *
50 : * The delalloc mechanism begins when the kernel wants to make a block
51 : * writable (write_begin or page_mkwrite). If the offset is not mapped, we
52 : * create a delalloc mapping, which is a regular in-core extent, but without
53 : * a real startblock. (For delalloc mappings, the startblock encodes both
54 : * a flag that this is a delalloc mapping, and a worst-case estimate of how
55 : * many blocks might be required to put the mapping into the BMBT.) delalloc
56 : * mappings are a reservation against the free space in the filesystem;
57 : * adjacent mappings can also be combined into fewer larger mappings.
58 : *
59 : * As an optimization, the CoW extent size hint (cowextsz) creates
60 : * outsized aligned delalloc reservations in the hope of landing out of
61 : * order nearby CoW writes in a single extent on disk, thereby reducing
62 : * fragmentation and improving future performance.
63 : *
64 : * D: --RRRRRRSSSRRRRRRRR--- (data fork)
65 : * C: ------DDDDDDD--------- (CoW fork)
66 : *
67 : * When dirty pages are being written out (typically in writepage), the
68 : * delalloc reservations are converted into unwritten mappings by
69 : * allocating blocks and replacing the delalloc mapping with real ones.
70 : * A delalloc mapping can be replaced by several unwritten ones if the
71 : * free space is fragmented.
72 : *
73 : * D: --RRRRRRSSSRRRRRRRR---
74 : * C: ------UUUUUUU---------
75 : *
76 : * We want to adapt the delalloc mechanism for copy-on-write, since the
77 : * write paths are similar. The first two steps (creating the reservation
78 : * and allocating the blocks) are exactly the same as delalloc except that
79 : * the mappings must be stored in a separate CoW fork because we do not want
80 : * to disturb the mapping in the data fork until we're sure that the write
81 : * succeeded. IO completion in this case is the process of removing the old
82 : * mapping from the data fork and moving the new mapping from the CoW fork to
83 : * the data fork. This will be discussed shortly.
84 : *
85 : * For now, unaligned directio writes will be bounced back to the page cache.
86 : * Block-aligned directio writes will use the same mechanism as buffered
87 : * writes.
88 : *
89 : * Just prior to submitting the actual disk write requests, we convert
90 : * the extents representing the range of the file actually being written
91 : * (as opposed to extra pieces created for the cowextsize hint) to real
92 : * extents. This will become important in the next step:
93 : *
94 : * D: --RRRRRRSSSRRRRRRRR---
95 : * C: ------UUrrUUU---------
96 : *
97 : * CoW remapping must be done after the data block write completes,
98 : * because we don't want to destroy the old data fork map until we're sure
99 : * the new block has been written. Since the new mappings are kept in a
100 : * separate fork, we can simply iterate these mappings to find the ones
101 : * that cover the file blocks that we just CoW'd. For each extent, simply
102 : * unmap the corresponding range in the data fork, map the new range into
103 : * the data fork, and remove the extent from the CoW fork. Because of
104 : * the presence of the cowextsize hint, however, we must be careful
105 : * only to remap the blocks that we've actually written out -- we must
106 : * never remap delalloc reservations nor CoW staging blocks that have
107 : * yet to be written. This corresponds exactly to the real extents in
108 : * the CoW fork:
109 : *
110 : * D: --RRRRRRrrSRRRRRRRR---
111 : * C: ------UU--UUU---------
112 : *
113 : * Since the remapping operation can be applied to an arbitrary file
114 : * range, we record the need for the remap step as a flag in the ioend
115 : * instead of declaring a new IO type. This is required for direct io
116 : * because we only have ioend for the whole dio, and we have to be able to
117 : * remember the presence of unwritten blocks and CoW blocks with a single
118 : * ioend structure. Better yet, the more ground we can cover with one
119 : * ioend, the better.
120 : */
121 :
122 : /*
123 : * Given an AG extent, find the lowest-numbered run of shared blocks
124 : * within that range and return the range in fbno/flen. If
125 : * find_end_of_shared is true, return the longest contiguous extent of
126 : * shared blocks. If there are no shared extents, fbno and flen will
127 : * be set to NULLAGBLOCK and 0, respectively.
128 : */
129 : static int
130 262410659 : xfs_reflink_find_shared(
131 : struct xfs_perag *pag,
132 : struct xfs_trans *tp,
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 262410659 : struct xfs_buf *agbp;
140 262410659 : struct xfs_btree_cur *cur;
141 262410659 : int error;
142 :
143 262410659 : error = xfs_alloc_read_agf(pag, tp, 0, &agbp);
144 262410596 : if (error)
145 : return error;
146 :
147 262412076 : cur = xfs_refcountbt_init_cursor(pag->pag_mount, tp, agbp, pag);
148 :
149 262472337 : error = xfs_refcount_find_shared(cur, agbno, aglen, fbno, flen,
150 : find_end_of_shared);
151 :
152 262410476 : xfs_btree_del_cursor(cur, error);
153 :
154 262461035 : xfs_trans_brelse(tp, agbp);
155 262461035 : return error;
156 : }
157 :
158 : /*
159 : * Trim the mapping to the next block where there's a change in the
160 : * shared/unshared status. More specifically, this means that we
161 : * find the lowest-numbered extent of shared blocks that coincides with
162 : * the given block mapping. If the shared extent overlaps the start of
163 : * the mapping, trim the mapping to the end of the shared extent. If
164 : * the shared region intersects the mapping, trim the mapping to the
165 : * start of the shared extent. If there are no shared regions that
166 : * overlap, just return the original extent.
167 : */
168 : int
169 44988845 : xfs_reflink_trim_around_shared(
170 : struct xfs_inode *ip,
171 : struct xfs_bmbt_irec *irec,
172 : bool *shared)
173 : {
174 44988845 : struct xfs_mount *mp = ip->i_mount;
175 44988845 : struct xfs_perag *pag;
176 44988845 : xfs_agblock_t agbno;
177 44988845 : xfs_extlen_t aglen;
178 44988845 : xfs_agblock_t fbno;
179 44988845 : xfs_extlen_t flen;
180 44988845 : int error = 0;
181 :
182 : /* Holes, unwritten, and delalloc extents cannot be shared */
183 44988845 : if (!xfs_is_cow_inode(ip) || !xfs_bmap_is_written_extent(irec)) {
184 22793923 : *shared = false;
185 22793923 : return 0;
186 : }
187 :
188 22194801 : trace_xfs_reflink_trim_around_shared(ip, irec);
189 :
190 22194816 : pag = xfs_perag_get(mp, XFS_FSB_TO_AGNO(mp, irec->br_startblock));
191 22195057 : agbno = XFS_FSB_TO_AGBNO(mp, irec->br_startblock);
192 22194982 : aglen = irec->br_blockcount;
193 :
194 22194982 : error = xfs_reflink_find_shared(pag, NULL, agbno, aglen, &fbno, &flen,
195 : true);
196 22195052 : xfs_perag_put(pag);
197 22195101 : if (error)
198 : return error;
199 :
200 22194919 : *shared = false;
201 22194919 : if (fbno == NULLAGBLOCK) {
202 : /* No shared blocks at all. */
203 : return 0;
204 : }
205 :
206 2139032 : if (fbno == agbno) {
207 : /*
208 : * The start of this extent is shared. Truncate the
209 : * mapping at the end of the shared region so that a
210 : * subsequent iteration starts at the start of the
211 : * unshared region.
212 : */
213 2080455 : irec->br_blockcount = flen;
214 2080455 : *shared = true;
215 2080455 : return 0;
216 : }
217 :
218 : /*
219 : * There's a shared extent midway through this extent.
220 : * Truncate the mapping at the start of the shared
221 : * extent so that a subsequent iteration starts at the
222 : * start of the shared region.
223 : */
224 58577 : irec->br_blockcount = fbno - agbno;
225 58577 : return 0;
226 : }
227 :
228 : int
229 31884863 : xfs_bmap_trim_cow(
230 : struct xfs_inode *ip,
231 : struct xfs_bmbt_irec *imap,
232 : bool *shared)
233 : {
234 : /* We can't update any real extents in always COW mode. */
235 31884863 : if (xfs_is_always_cow_inode(ip) &&
236 1165398 : !isnullstartblock(imap->br_startblock)) {
237 950346 : *shared = true;
238 950346 : return 0;
239 : }
240 :
241 : /* Trim the mapping to the nearest shared extent boundary. */
242 30934407 : return xfs_reflink_trim_around_shared(ip, imap, shared);
243 : }
244 :
245 : static int
246 9140149 : xfs_reflink_convert_cow_locked(
247 : struct xfs_inode *ip,
248 : xfs_fileoff_t offset_fsb,
249 : xfs_filblks_t count_fsb)
250 : {
251 9140149 : struct xfs_iext_cursor icur;
252 9140149 : struct xfs_bmbt_irec got;
253 9140149 : struct xfs_btree_cur *dummy_cur = NULL;
254 9140149 : int dummy_logflags;
255 9140149 : int error = 0;
256 :
257 9140149 : if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got))
258 : return 0;
259 :
260 17183751 : do {
261 17183751 : if (got.br_startoff >= offset_fsb + count_fsb)
262 : break;
263 9149253 : if (got.br_state == XFS_EXT_NORM)
264 568 : continue;
265 9148685 : if (WARN_ON_ONCE(isnullstartblock(got.br_startblock)))
266 : return -EIO;
267 :
268 9148685 : xfs_trim_extent(&got, offset_fsb, count_fsb);
269 9148615 : if (!got.br_blockcount)
270 0 : continue;
271 :
272 9148615 : got.br_state = XFS_EXT_NORM;
273 9148615 : error = xfs_bmap_add_extent_unwritten_real(NULL, ip,
274 : XFS_COW_FORK, &icur, &dummy_cur, &got,
275 : &dummy_logflags);
276 9148539 : if (error)
277 0 : return error;
278 9149107 : } while (xfs_iext_next_extent(ip->i_cowfp, &icur, &got));
279 :
280 : return error;
281 : }
282 :
283 : /* Convert all of the unwritten CoW extents in a file's range to real ones. */
284 : int
285 4889107 : xfs_reflink_convert_cow(
286 : struct xfs_inode *ip,
287 : xfs_off_t offset,
288 : xfs_off_t count)
289 : {
290 4889107 : struct xfs_mount *mp = ip->i_mount;
291 4889107 : xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
292 4889107 : xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, offset + count);
293 4889107 : xfs_filblks_t count_fsb = end_fsb - offset_fsb;
294 4889107 : int error;
295 :
296 4889107 : ASSERT(count != 0);
297 :
298 4889107 : xfs_ilock(ip, XFS_ILOCK_EXCL);
299 4889082 : error = xfs_reflink_convert_cow_locked(ip, offset_fsb, count_fsb);
300 4889057 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
301 4889087 : return error;
302 : }
303 :
304 : /*
305 : * Find the extent that maps the given range in the COW fork. Even if the extent
306 : * is not shared we might have a preallocation for it in the COW fork. If so we
307 : * use it that rather than trigger a new allocation.
308 : */
309 : static int
310 8977637 : xfs_find_trim_cow_extent(
311 : struct xfs_inode *ip,
312 : struct xfs_bmbt_irec *imap,
313 : struct xfs_bmbt_irec *cmap,
314 : bool *shared,
315 : bool *found)
316 : {
317 8977637 : xfs_fileoff_t offset_fsb = imap->br_startoff;
318 8977637 : xfs_filblks_t count_fsb = imap->br_blockcount;
319 8977637 : struct xfs_iext_cursor icur;
320 :
321 8977637 : *found = false;
322 :
323 : /*
324 : * If we don't find an overlapping extent, trim the range we need to
325 : * allocate to fit the hole we found.
326 : */
327 8977637 : if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, cmap))
328 1112515 : cmap->br_startoff = offset_fsb + count_fsb;
329 8977644 : if (cmap->br_startoff > offset_fsb) {
330 5050657 : xfs_trim_extent(imap, imap->br_startoff,
331 5050657 : cmap->br_startoff - imap->br_startoff);
332 5050631 : return xfs_bmap_trim_cow(ip, imap, shared);
333 : }
334 :
335 3926987 : *shared = true;
336 3926987 : if (isnullstartblock(cmap->br_startblock)) {
337 11289 : xfs_trim_extent(imap, cmap->br_startoff, cmap->br_blockcount);
338 11289 : return 0;
339 : }
340 :
341 : /* real extent found - no need to allocate */
342 3915698 : xfs_trim_extent(cmap, offset_fsb, count_fsb);
343 3915699 : *found = true;
344 3915699 : return 0;
345 : }
346 :
347 : static int
348 4281465 : xfs_reflink_convert_unwritten(
349 : struct xfs_inode *ip,
350 : struct xfs_bmbt_irec *imap,
351 : struct xfs_bmbt_irec *cmap,
352 : bool convert_now)
353 : {
354 4281465 : xfs_fileoff_t offset_fsb = imap->br_startoff;
355 4281465 : xfs_filblks_t count_fsb = imap->br_blockcount;
356 4281465 : int error;
357 :
358 : /*
359 : * cmap might larger than imap due to cowextsize hint.
360 : */
361 4281465 : xfs_trim_extent(cmap, offset_fsb, count_fsb);
362 :
363 : /*
364 : * COW fork extents are supposed to remain unwritten until we're ready
365 : * to initiate a disk write. For direct I/O we are going to write the
366 : * data and need the conversion, but for buffered writes we're done.
367 : */
368 4281467 : if (!convert_now || cmap->br_state == XFS_EXT_NORM)
369 : return 0;
370 :
371 4251045 : trace_xfs_reflink_convert_cow(ip, cmap);
372 :
373 4251044 : error = xfs_reflink_convert_cow_locked(ip, offset_fsb, count_fsb);
374 4251044 : if (!error)
375 4251044 : cmap->br_state = XFS_EXT_NORM;
376 :
377 : return error;
378 : }
379 :
380 : static int
381 360272 : xfs_reflink_fill_cow_hole(
382 : struct xfs_inode *ip,
383 : struct xfs_bmbt_irec *imap,
384 : struct xfs_bmbt_irec *cmap,
385 : bool *shared,
386 : uint *lockmode,
387 : bool convert_now)
388 : {
389 360272 : struct xfs_mount *mp = ip->i_mount;
390 360272 : struct xfs_trans *tp;
391 360272 : xfs_filblks_t resaligned;
392 360272 : xfs_extlen_t resblks;
393 360272 : int nimaps;
394 360272 : int error;
395 360272 : bool found;
396 :
397 360272 : resaligned = xfs_aligned_fsb_count(imap->br_startoff,
398 : imap->br_blockcount, xfs_get_cowextsz_hint(ip));
399 360273 : resblks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
400 :
401 360273 : xfs_iunlock(ip, *lockmode);
402 360272 : *lockmode = 0;
403 :
404 360272 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks, 0,
405 : false, &tp);
406 360275 : if (error)
407 : return error;
408 :
409 360200 : *lockmode = XFS_ILOCK_EXCL;
410 :
411 360200 : error = xfs_find_trim_cow_extent(ip, imap, cmap, shared, &found);
412 360199 : if (error || !*shared)
413 1 : goto out_trans_cancel;
414 :
415 360198 : if (found) {
416 51 : xfs_trans_cancel(tp);
417 51 : goto convert;
418 : }
419 :
420 : /* Allocate the entire reservation as unwritten blocks. */
421 360147 : nimaps = 1;
422 360147 : error = xfs_bmapi_write(tp, ip, imap->br_startoff, imap->br_blockcount,
423 : XFS_BMAPI_COWFORK | XFS_BMAPI_PREALLOC, 0, cmap,
424 : &nimaps);
425 360144 : if (error)
426 8 : goto out_trans_cancel;
427 :
428 360136 : xfs_inode_set_cowblocks_tag(ip);
429 360125 : error = xfs_trans_commit(tp);
430 360140 : if (error)
431 : return error;
432 :
433 : /*
434 : * Allocation succeeded but the requested range was not even partially
435 : * satisfied? Bail out!
436 : */
437 360139 : if (nimaps == 0)
438 : return -ENOSPC;
439 :
440 360139 : convert:
441 360190 : return xfs_reflink_convert_unwritten(ip, imap, cmap, convert_now);
442 :
443 9 : out_trans_cancel:
444 9 : xfs_trans_cancel(tp);
445 9 : return error;
446 : }
447 :
448 : static int
449 5631 : xfs_reflink_fill_delalloc(
450 : struct xfs_inode *ip,
451 : struct xfs_bmbt_irec *imap,
452 : struct xfs_bmbt_irec *cmap,
453 : bool *shared,
454 : uint *lockmode,
455 : bool convert_now)
456 : {
457 5631 : struct xfs_mount *mp = ip->i_mount;
458 5657 : struct xfs_trans *tp;
459 5657 : int nimaps;
460 5657 : int error;
461 5657 : bool found;
462 :
463 5657 : do {
464 5657 : xfs_iunlock(ip, *lockmode);
465 5657 : *lockmode = 0;
466 :
467 5657 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, 0, 0,
468 : false, &tp);
469 5657 : if (error)
470 0 : return error;
471 :
472 5657 : *lockmode = XFS_ILOCK_EXCL;
473 :
474 5657 : error = xfs_find_trim_cow_extent(ip, imap, cmap, shared,
475 : &found);
476 5657 : if (error || !*shared)
477 0 : goto out_trans_cancel;
478 :
479 5657 : if (found) {
480 1 : xfs_trans_cancel(tp);
481 1 : break;
482 : }
483 :
484 5656 : ASSERT(isnullstartblock(cmap->br_startblock) ||
485 : cmap->br_startblock == DELAYSTARTBLOCK);
486 :
487 : /*
488 : * Replace delalloc reservation with an unwritten extent.
489 : */
490 5656 : nimaps = 1;
491 5656 : error = xfs_bmapi_write(tp, ip, cmap->br_startoff,
492 : cmap->br_blockcount,
493 : XFS_BMAPI_COWFORK | XFS_BMAPI_PREALLOC, 0,
494 : cmap, &nimaps);
495 5656 : if (error)
496 0 : goto out_trans_cancel;
497 :
498 5656 : xfs_inode_set_cowblocks_tag(ip);
499 5656 : error = xfs_trans_commit(tp);
500 5656 : if (error)
501 0 : return error;
502 :
503 : /*
504 : * Allocation succeeded but the requested range was not even
505 : * partially satisfied? Bail out!
506 : */
507 5656 : if (nimaps == 0)
508 : return -ENOSPC;
509 5656 : } while (cmap->br_startoff + cmap->br_blockcount <= imap->br_startoff);
510 :
511 5631 : return xfs_reflink_convert_unwritten(ip, imap, cmap, convert_now);
512 :
513 0 : out_trans_cancel:
514 0 : xfs_trans_cancel(tp);
515 0 : return error;
516 : }
517 :
518 : /* Allocate all CoW reservations covering a range of blocks in a file. */
519 : int
520 8611766 : xfs_reflink_allocate_cow(
521 : struct xfs_inode *ip,
522 : struct xfs_bmbt_irec *imap,
523 : struct xfs_bmbt_irec *cmap,
524 : bool *shared,
525 : uint *lockmode,
526 : bool convert_now)
527 : {
528 8611766 : int error;
529 8611766 : bool found;
530 :
531 8611766 : ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
532 8611743 : if (!ip->i_cowfp) {
533 5182 : ASSERT(!xfs_is_reflink_inode(ip));
534 5182 : xfs_ifork_init_cow(ip);
535 : }
536 :
537 8611743 : error = xfs_find_trim_cow_extent(ip, imap, cmap, shared, &found);
538 8611780 : if (error || !*shared)
539 4330231 : return error;
540 :
541 : /* CoW fork has a real extent */
542 4281549 : if (found)
543 3915646 : return xfs_reflink_convert_unwritten(ip, imap, cmap,
544 : convert_now);
545 :
546 : /*
547 : * CoW fork does not have an extent and data extent is shared.
548 : * Allocate a real extent in the CoW fork.
549 : */
550 365903 : if (cmap->br_startoff > imap->br_startoff)
551 360272 : return xfs_reflink_fill_cow_hole(ip, imap, cmap, shared,
552 : lockmode, convert_now);
553 :
554 : /*
555 : * CoW fork has a delalloc reservation. Replace it with a real extent.
556 : * There may or may not be a data fork mapping.
557 : */
558 5631 : if (isnullstartblock(cmap->br_startblock) ||
559 : cmap->br_startblock == DELAYSTARTBLOCK)
560 5631 : return xfs_reflink_fill_delalloc(ip, imap, cmap, shared,
561 : lockmode, convert_now);
562 :
563 : /* Shouldn't get here. */
564 0 : ASSERT(0);
565 0 : return -EFSCORRUPTED;
566 : }
567 :
568 : /*
569 : * Cancel CoW reservations for some block range of an inode.
570 : *
571 : * If cancel_real is true this function cancels all COW fork extents for the
572 : * inode; if cancel_real is false, real extents are not cleared.
573 : *
574 : * Caller must have already joined the inode to the current transaction. The
575 : * inode will be joined to the transaction returned to the caller.
576 : */
577 : int
578 36048717 : xfs_reflink_cancel_cow_blocks(
579 : struct xfs_inode *ip,
580 : struct xfs_trans **tpp,
581 : xfs_fileoff_t offset_fsb,
582 : xfs_fileoff_t end_fsb,
583 : bool cancel_real)
584 : {
585 36048717 : struct xfs_ifork *ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);
586 36048717 : struct xfs_bmbt_irec got, del;
587 36048717 : struct xfs_iext_cursor icur;
588 36048717 : int error = 0;
589 :
590 72097434 : if (!xfs_inode_has_cow_data(ip))
591 : return 0;
592 8441552 : if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
593 : return 0;
594 :
595 : /* Walk backwards until we're out of the I/O range... */
596 14407240 : while (got.br_startoff + got.br_blockcount > offset_fsb) {
597 7605792 : del = got;
598 7605792 : xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
599 :
600 : /* Extent delete may have bumped ext forward */
601 7593802 : if (!del.br_blockcount) {
602 176797 : xfs_iext_prev(ifp, &icur);
603 176797 : goto next_extent;
604 : }
605 :
606 7417005 : trace_xfs_reflink_cancel_cow(ip, &del);
607 :
608 7415807 : if (isnullstartblock(del.br_startblock)) {
609 2736891 : error = xfs_bmap_del_extent_delay(ip, XFS_COW_FORK,
610 : &icur, &got, &del);
611 2754287 : if (error)
612 : break;
613 4678916 : } else if (del.br_state == XFS_EXT_UNWRITTEN || cancel_real) {
614 4612197 : ASSERT((*tpp)->t_highest_agno == NULLAGNUMBER);
615 :
616 : /* Free the CoW orphan record. */
617 4612197 : xfs_refcount_free_cow_extent(*tpp, del.br_startblock,
618 4612197 : del.br_blockcount);
619 :
620 4613755 : error = xfs_free_extent_later(*tpp, del.br_startblock,
621 : del.br_blockcount, NULL,
622 : XFS_AG_RESV_NONE);
623 4613856 : if (error)
624 : break;
625 :
626 : /* Roll the transaction */
627 4613856 : error = xfs_defer_finish(tpp);
628 4612363 : if (error)
629 : break;
630 :
631 : /* Remove the mapping from the CoW fork. */
632 4612350 : xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
633 :
634 : /* Remove the quota reservation */
635 4612963 : error = xfs_quota_unreserve_blkres(ip,
636 4612963 : del.br_blockcount);
637 4614632 : if (error)
638 : break;
639 : } else {
640 : /* Didn't do anything, push cursor back. */
641 66719 : xfs_iext_prev(ifp, &icur);
642 : }
643 7612435 : next_extent:
644 7612435 : if (!xfs_iext_get_extent(ifp, &icur, &got))
645 : break;
646 : }
647 :
648 : /* clear tag if cow fork is emptied */
649 8371878 : if (!ifp->if_bytes)
650 1474659 : xfs_inode_clear_cowblocks_tag(ip);
651 : return error;
652 : }
653 :
654 : /*
655 : * Cancel CoW reservations for some byte range of an inode.
656 : *
657 : * If cancel_real is true this function cancels all COW fork extents for the
658 : * inode; if cancel_real is false, real extents are not cleared.
659 : */
660 : int
661 4074310 : xfs_reflink_cancel_cow_range(
662 : struct xfs_inode *ip,
663 : xfs_off_t offset,
664 : xfs_off_t count,
665 : bool cancel_real)
666 : {
667 4074310 : struct xfs_trans *tp;
668 4074310 : xfs_fileoff_t offset_fsb;
669 4074310 : xfs_fileoff_t end_fsb;
670 4074310 : int error;
671 :
672 4074310 : trace_xfs_reflink_cancel_cow_range(ip, offset, count);
673 4074251 : ASSERT(ip->i_cowfp);
674 :
675 4074251 : offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
676 4074251 : if (count == NULLFILEOFF)
677 : end_fsb = NULLFILEOFF;
678 : else
679 1430175 : end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
680 :
681 : /* Start a rolling transaction to remove the mappings */
682 4074251 : error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
683 : 0, 0, 0, &tp);
684 4071486 : if (error)
685 9 : goto out;
686 :
687 4071477 : xfs_ilock(ip, XFS_ILOCK_EXCL);
688 4073006 : xfs_trans_ijoin(tp, ip, 0);
689 :
690 : /* Scrape out the old CoW reservations */
691 4073904 : error = xfs_reflink_cancel_cow_blocks(ip, &tp, offset_fsb, end_fsb,
692 : cancel_real);
693 4074649 : if (error)
694 12 : goto out_cancel;
695 :
696 4074637 : error = xfs_trans_commit(tp);
697 :
698 4074463 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
699 4074463 : return error;
700 :
701 : out_cancel:
702 12 : xfs_trans_cancel(tp);
703 12 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
704 21 : out:
705 21 : trace_xfs_reflink_cancel_cow_range_error(ip, error, _RET_IP_);
706 21 : return error;
707 : }
708 :
709 : /*
710 : * Remap part of the CoW fork into the data fork.
711 : *
712 : * We aim to remap the range starting at @offset_fsb and ending at @end_fsb
713 : * into the data fork; this function will remap what it can (at the end of the
714 : * range) and update @end_fsb appropriately. Each remap gets its own
715 : * transaction because we can end up merging and splitting bmbt blocks for
716 : * every remap operation and we'd like to keep the block reservation
717 : * requirements as low as possible.
718 : */
719 : STATIC int
720 10699739 : xfs_reflink_end_cow_extent(
721 : struct xfs_inode *ip,
722 : xfs_fileoff_t *offset_fsb,
723 : xfs_fileoff_t end_fsb)
724 : {
725 10699739 : struct xfs_iext_cursor icur;
726 10699739 : struct xfs_bmbt_irec got, del, data;
727 10699739 : struct xfs_mount *mp = ip->i_mount;
728 10699739 : struct xfs_trans *tp;
729 10699739 : struct xfs_ifork *ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);
730 10699739 : unsigned int resblks;
731 10699739 : int nmaps;
732 10699739 : int error;
733 :
734 : /* No COW extents? That's easy! */
735 10699739 : if (ifp->if_bytes == 0) {
736 1869 : *offset_fsb = end_fsb;
737 1869 : return 0;
738 : }
739 :
740 10697870 : resblks = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
741 10697870 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
742 : XFS_TRANS_RESERVE, &tp);
743 10697860 : if (error)
744 : return error;
745 :
746 : /*
747 : * Lock the inode. We have to ijoin without automatic unlock because
748 : * the lead transaction is the refcountbt record deletion; the data
749 : * fork update follows as a deferred log item.
750 : */
751 10697861 : xfs_ilock(ip, XFS_ILOCK_EXCL);
752 10697872 : xfs_trans_ijoin(tp, ip, 0);
753 :
754 10697873 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
755 : XFS_IEXT_REFLINK_END_COW_CNT);
756 10697872 : if (error == -EFBIG)
757 12 : error = xfs_iext_count_upgrade(tp, ip,
758 : XFS_IEXT_REFLINK_END_COW_CNT);
759 10697872 : if (error)
760 12 : goto out_cancel;
761 :
762 : /*
763 : * In case of racing, overlapping AIO writes no COW extents might be
764 : * left by the time I/O completes for the loser of the race. In that
765 : * case we are done.
766 : */
767 10697860 : if (!xfs_iext_lookup_extent(ip, ifp, *offset_fsb, &icur, &got) ||
768 10678036 : got.br_startoff >= end_fsb) {
769 54390 : *offset_fsb = end_fsb;
770 54390 : goto out_cancel;
771 : }
772 :
773 : /*
774 : * Only remap real extents that contain data. With AIO, speculative
775 : * preallocations can leak into the range we are called upon, and we
776 : * need to skip them. Preserve @got for the eventual CoW fork
777 : * deletion; from now on @del represents the mapping that we're
778 : * actually remapping.
779 : */
780 10687760 : while (!xfs_bmap_is_written_extent(&got)) {
781 44820 : if (!xfs_iext_next_extent(ifp, &icur, &got) ||
782 44765 : got.br_startoff >= end_fsb) {
783 531 : *offset_fsb = end_fsb;
784 531 : goto out_cancel;
785 : }
786 : }
787 10642940 : del = got;
788 :
789 : /* Grab the corresponding mapping in the data fork. */
790 10642940 : nmaps = 1;
791 10642940 : error = xfs_bmapi_read(ip, del.br_startoff, del.br_blockcount, &data,
792 : &nmaps, 0);
793 10642940 : if (error)
794 15 : goto out_cancel;
795 :
796 : /* We can only remap the smaller of the two extent sizes. */
797 10642925 : data.br_blockcount = min(data.br_blockcount, del.br_blockcount);
798 10642925 : del.br_blockcount = data.br_blockcount;
799 :
800 10642925 : trace_xfs_reflink_cow_remap_from(ip, &del);
801 10642925 : trace_xfs_reflink_cow_remap_to(ip, &data);
802 :
803 17887178 : if (xfs_bmap_is_real_extent(&data)) {
804 : /*
805 : * If the extent we're remapping is backed by storage (written
806 : * or not), unmap the extent and drop its refcount.
807 : */
808 7244253 : xfs_bmap_unmap_extent(tp, ip, XFS_DATA_FORK, &data);
809 7244253 : xfs_refcount_decrease_extent(tp, &data);
810 7244253 : xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT,
811 7244253 : -data.br_blockcount);
812 3398672 : } else if (data.br_startblock == DELAYSTARTBLOCK) {
813 230164 : int done;
814 :
815 : /*
816 : * If the extent we're remapping is a delalloc reservation,
817 : * we can use the regular bunmapi function to release the
818 : * incore state. Dropping the delalloc reservation takes care
819 : * of the quota reservation for us.
820 : */
821 230164 : error = xfs_bunmapi(NULL, ip, data.br_startoff,
822 : data.br_blockcount, 0, 1, &done);
823 230164 : if (error)
824 0 : goto out_cancel;
825 230164 : ASSERT(done);
826 : }
827 :
828 : /* Free the CoW orphan record. */
829 10642925 : xfs_refcount_free_cow_extent(tp, del.br_startblock, del.br_blockcount);
830 :
831 : /* Map the new blocks into the data fork. */
832 10642925 : xfs_bmap_map_extent(tp, ip, XFS_DATA_FORK, &del);
833 :
834 : /* Charge this new data fork mapping to the on-disk quota. */
835 10642925 : xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_DELBCOUNT,
836 10642925 : (long)del.br_blockcount);
837 :
838 : /* Remove the mapping from the CoW fork. */
839 10642925 : xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
840 :
841 10642925 : error = xfs_trans_commit(tp);
842 10642925 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
843 10642925 : if (error)
844 : return error;
845 :
846 : /* Update the caller about how much progress we made. */
847 10642901 : *offset_fsb = del.br_startoff + del.br_blockcount;
848 10642901 : return 0;
849 :
850 54948 : out_cancel:
851 54948 : xfs_trans_cancel(tp);
852 54948 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
853 54948 : return error;
854 : }
855 :
856 : /*
857 : * Remap parts of a file's data fork after a successful CoW.
858 : */
859 : int
860 8368164 : xfs_reflink_end_cow(
861 : struct xfs_inode *ip,
862 : xfs_off_t offset,
863 : xfs_off_t count)
864 : {
865 8368164 : xfs_fileoff_t offset_fsb;
866 8368164 : xfs_fileoff_t end_fsb;
867 8368164 : int error = 0;
868 :
869 8368164 : trace_xfs_reflink_end_cow(ip, offset, count);
870 :
871 8368164 : offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
872 8368164 : end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
873 :
874 : /*
875 : * Walk forwards until we've remapped the I/O range. The loop function
876 : * repeatedly cycles the ILOCK to allocate one transaction per remapped
877 : * extent.
878 : *
879 : * If we're being called by writeback then the pages will still
880 : * have PageWriteback set, which prevents races with reflink remapping
881 : * and truncate. Reflink remapping prevents races with writeback by
882 : * taking the iolock and mmaplock before flushing the pages and
883 : * remapping, which means there won't be any further writeback or page
884 : * cache dirtying until the reflink completes.
885 : *
886 : * We should never have two threads issuing writeback for the same file
887 : * region. There are also have post-eof checks in the writeback
888 : * preparation code so that we don't bother writing out pages that are
889 : * about to be truncated.
890 : *
891 : * If we're being called as part of directio write completion, the dio
892 : * count is still elevated, which reflink and truncate will wait for.
893 : * Reflink remapping takes the iolock and mmaplock and waits for
894 : * pending dio to finish, which should prevent any directio until the
895 : * remap completes. Multiple concurrent directio writes to the same
896 : * region are handled by end_cow processing only occurring for the
897 : * threads which succeed; the outcome of multiple overlapping direct
898 : * writes is not well defined anyway.
899 : *
900 : * It's possible that a buffered write and a direct write could collide
901 : * here (the buffered write stumbles in after the dio flushes and
902 : * invalidates the page cache and immediately queues writeback), but we
903 : * have never supported this 100%. If either disk write succeeds the
904 : * blocks will be remapped.
905 : */
906 19067906 : while (end_fsb > offset_fsb && !error)
907 10699740 : error = xfs_reflink_end_cow_extent(ip, &offset_fsb, end_fsb);
908 :
909 8368166 : if (error)
910 51 : trace_xfs_reflink_end_cow_error(ip, error, _RET_IP_);
911 8368166 : return error;
912 : }
913 :
914 : /*
915 : * Free all CoW staging blocks that are still referenced by the ondisk refcount
916 : * metadata. The ondisk metadata does not track which inode created the
917 : * staging extent, so callers must ensure that there are no cached inodes with
918 : * live CoW staging extents.
919 : */
920 : int
921 13807 : xfs_reflink_recover_cow(
922 : struct xfs_mount *mp)
923 : {
924 13807 : struct xfs_perag *pag;
925 13807 : xfs_agnumber_t agno;
926 13807 : int error = 0;
927 :
928 13807 : if (!xfs_has_reflink(mp))
929 : return 0;
930 :
931 64606 : for_each_perag(mp, agno, pag) {
932 52422 : error = xfs_refcount_recover_cow_leftovers(mp, pag);
933 52422 : if (error) {
934 22 : xfs_perag_rele(pag);
935 22 : break;
936 : }
937 : }
938 :
939 : return error;
940 : }
941 :
942 : /*
943 : * Reflinking (Block) Ranges of Two Files Together
944 : *
945 : * First, ensure that the reflink flag is set on both inodes. The flag is an
946 : * optimization to avoid unnecessary refcount btree lookups in the write path.
947 : *
948 : * Now we can iteratively remap the range of extents (and holes) in src to the
949 : * corresponding ranges in dest. Let drange and srange denote the ranges of
950 : * logical blocks in dest and src touched by the reflink operation.
951 : *
952 : * While the length of drange is greater than zero,
953 : * - Read src's bmbt at the start of srange ("imap")
954 : * - If imap doesn't exist, make imap appear to start at the end of srange
955 : * with zero length.
956 : * - If imap starts before srange, advance imap to start at srange.
957 : * - If imap goes beyond srange, truncate imap to end at the end of srange.
958 : * - Punch (imap start - srange start + imap len) blocks from dest at
959 : * offset (drange start).
960 : * - If imap points to a real range of pblks,
961 : * > Increase the refcount of the imap's pblks
962 : * > Map imap's pblks into dest at the offset
963 : * (drange start + imap start - srange start)
964 : * - Advance drange and srange by (imap start - srange start + imap len)
965 : *
966 : * Finally, if the reflink made dest longer, update both the in-core and
967 : * on-disk file sizes.
968 : *
969 : * ASCII Art Demonstration:
970 : *
971 : * Let's say we want to reflink this source file:
972 : *
973 : * ----SSSSSSS-SSSSS----SSSSSS (src file)
974 : * <-------------------->
975 : *
976 : * into this destination file:
977 : *
978 : * --DDDDDDDDDDDDDDDDDDD--DDD (dest file)
979 : * <-------------------->
980 : * '-' means a hole, and 'S' and 'D' are written blocks in the src and dest.
981 : * Observe that the range has different logical offsets in either file.
982 : *
983 : * Consider that the first extent in the source file doesn't line up with our
984 : * reflink range. Unmapping and remapping are separate operations, so we can
985 : * unmap more blocks from the destination file than we remap.
986 : *
987 : * ----SSSSSSS-SSSSS----SSSSSS
988 : * <------->
989 : * --DDDDD---------DDDDD--DDD
990 : * <------->
991 : *
992 : * Now remap the source extent into the destination file:
993 : *
994 : * ----SSSSSSS-SSSSS----SSSSSS
995 : * <------->
996 : * --DDDDD--SSSSSSSDDDDD--DDD
997 : * <------->
998 : *
999 : * Do likewise with the second hole and extent in our range. Holes in the
1000 : * unmap range don't affect our operation.
1001 : *
1002 : * ----SSSSSSS-SSSSS----SSSSSS
1003 : * <---->
1004 : * --DDDDD--SSSSSSS-SSSSS-DDD
1005 : * <---->
1006 : *
1007 : * Finally, unmap and remap part of the third extent. This will increase the
1008 : * size of the destination file.
1009 : *
1010 : * ----SSSSSSS-SSSSS----SSSSSS
1011 : * <----->
1012 : * --DDDDD--SSSSSSS-SSSSS----SSS
1013 : * <----->
1014 : *
1015 : * Once we update the destination file's i_size, we're done.
1016 : */
1017 :
1018 : /*
1019 : * Ensure the reflink bit is set in both inodes.
1020 : */
1021 : STATIC int
1022 116707811 : xfs_reflink_set_inode_flag(
1023 : struct xfs_inode *src,
1024 : struct xfs_inode *dest)
1025 : {
1026 116707811 : struct xfs_mount *mp = src->i_mount;
1027 116707811 : int error;
1028 116707811 : struct xfs_trans *tp;
1029 :
1030 116707811 : if (xfs_is_reflink_inode(src) && xfs_is_reflink_inode(dest))
1031 : return 0;
1032 :
1033 3441900 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
1034 3442052 : if (error)
1035 0 : goto out_error;
1036 :
1037 : /* Lock both files against IO */
1038 3442052 : if (src->i_ino == dest->i_ino)
1039 87266 : xfs_ilock(src, XFS_ILOCK_EXCL);
1040 : else
1041 3354786 : xfs_lock_two_inodes(src, XFS_ILOCK_EXCL, dest, XFS_ILOCK_EXCL);
1042 :
1043 3442038 : if (!xfs_is_reflink_inode(src)) {
1044 376096 : trace_xfs_reflink_set_inode_flag(src);
1045 376096 : xfs_trans_ijoin(tp, src, XFS_ILOCK_EXCL);
1046 376095 : src->i_diflags2 |= XFS_DIFLAG2_REFLINK;
1047 376095 : xfs_trans_log_inode(tp, src, XFS_ILOG_CORE);
1048 376095 : xfs_ifork_init_cow(src);
1049 : } else
1050 3065942 : xfs_iunlock(src, XFS_ILOCK_EXCL);
1051 :
1052 3442042 : if (src->i_ino == dest->i_ino)
1053 87266 : goto commit_flags;
1054 :
1055 3354776 : if (!xfs_is_reflink_inode(dest)) {
1056 3133172 : trace_xfs_reflink_set_inode_flag(dest);
1057 3133156 : xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
1058 3133178 : dest->i_diflags2 |= XFS_DIFLAG2_REFLINK;
1059 3133178 : xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
1060 3133188 : xfs_ifork_init_cow(dest);
1061 : } else
1062 221604 : xfs_iunlock(dest, XFS_ILOCK_EXCL);
1063 :
1064 3442036 : commit_flags:
1065 3442036 : error = xfs_trans_commit(tp);
1066 3442050 : if (error)
1067 4 : goto out_error;
1068 : return error;
1069 :
1070 4 : out_error:
1071 4 : trace_xfs_reflink_set_inode_flag_error(dest, error, _RET_IP_);
1072 4 : return error;
1073 : }
1074 :
1075 : /*
1076 : * Update destination inode size & cowextsize hint, if necessary.
1077 : */
1078 : int
1079 115849525 : xfs_reflink_update_dest(
1080 : struct xfs_inode *dest,
1081 : xfs_off_t newlen,
1082 : xfs_extlen_t cowextsize,
1083 : unsigned int remap_flags)
1084 : {
1085 115849525 : struct xfs_mount *mp = dest->i_mount;
1086 115849525 : struct xfs_trans *tp;
1087 115849525 : int error;
1088 :
1089 115849525 : if (newlen <= i_size_read(VFS_I(dest)) && cowextsize == 0)
1090 : return 0;
1091 :
1092 2099366 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
1093 2094783 : if (error)
1094 0 : goto out_error;
1095 :
1096 2094783 : xfs_ilock(dest, XFS_ILOCK_EXCL);
1097 2094771 : xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
1098 :
1099 2094762 : if (newlen > i_size_read(VFS_I(dest))) {
1100 2094757 : trace_xfs_reflink_update_inode_size(dest, newlen);
1101 2094728 : i_size_write(VFS_I(dest), newlen);
1102 2094728 : dest->i_disk_size = newlen;
1103 : }
1104 :
1105 2094733 : if (cowextsize) {
1106 18 : dest->i_cowextsize = cowextsize;
1107 18 : dest->i_diflags2 |= XFS_DIFLAG2_COWEXTSIZE;
1108 : }
1109 :
1110 2094733 : xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
1111 :
1112 2094781 : error = xfs_trans_commit(tp);
1113 2094784 : if (error)
1114 0 : goto out_error;
1115 : return error;
1116 :
1117 0 : out_error:
1118 0 : trace_xfs_reflink_update_inode_size_error(dest, error, _RET_IP_);
1119 0 : return error;
1120 : }
1121 :
1122 : /*
1123 : * Do we have enough reserve in this AG to handle a reflink? The refcount
1124 : * btree already reserved all the space it needs, but the rmap btree can grow
1125 : * infinitely, so we won't allow more reflinks when the AG is down to the
1126 : * btree reserves.
1127 : */
1128 : static int
1129 78045087 : xfs_reflink_ag_has_free_space(
1130 : struct xfs_mount *mp,
1131 : xfs_agnumber_t agno)
1132 : {
1133 78045087 : struct xfs_perag *pag;
1134 78045087 : int error = 0;
1135 :
1136 78045087 : if (!xfs_has_rmapbt(mp))
1137 : return 0;
1138 :
1139 78045083 : pag = xfs_perag_get(mp, agno);
1140 156088910 : if (xfs_ag_resv_critical(pag, XFS_AG_RESV_RMAPBT) ||
1141 78043801 : xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA))
1142 : error = -ENOSPC;
1143 78045080 : xfs_perag_put(pag);
1144 78045080 : return error;
1145 : }
1146 :
1147 : /*
1148 : * Remap the given extent into the file. The dmap blockcount will be set to
1149 : * the number of blocks that were actually remapped.
1150 : */
1151 : STATIC int
1152 228924381 : xfs_reflink_remap_extent(
1153 : struct xfs_inode *ip,
1154 : struct xfs_bmbt_irec *dmap,
1155 : xfs_off_t new_isize)
1156 : {
1157 228924381 : struct xfs_bmbt_irec smap;
1158 228924381 : struct xfs_mount *mp = ip->i_mount;
1159 228924381 : struct xfs_trans *tp;
1160 228924381 : xfs_off_t newlen;
1161 228924381 : int64_t qdelta = 0;
1162 228924381 : unsigned int resblks;
1163 228924381 : bool quota_reserved = true;
1164 228924381 : bool smap_real;
1165 228924381 : bool dmap_written = xfs_bmap_is_written_extent(dmap);
1166 228924381 : int iext_delta = 0;
1167 228924381 : int nimaps;
1168 228924381 : int error;
1169 :
1170 : /*
1171 : * Start a rolling transaction to switch the mappings.
1172 : *
1173 : * Adding a written extent to the extent map can cause a bmbt split,
1174 : * and removing a mapped extent from the extent can cause a bmbt split.
1175 : * The two operations cannot both cause a split since they operate on
1176 : * the same index in the bmap btree, so we only need a reservation for
1177 : * one bmbt split if either thing is happening. However, we haven't
1178 : * locked the inode yet, so we reserve assuming this is the case.
1179 : *
1180 : * The first allocation call tries to reserve enough space to handle
1181 : * mapping dmap into a sparse part of the file plus the bmbt split. We
1182 : * haven't locked the inode or read the existing mapping yet, so we do
1183 : * not know for sure that we need the space. This should succeed most
1184 : * of the time.
1185 : *
1186 : * If the first attempt fails, try again but reserving only enough
1187 : * space to handle a bmbt split. This is the hard minimum requirement,
1188 : * and we revisit quota reservations later when we know more about what
1189 : * we're remapping.
1190 : */
1191 228924381 : resblks = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
1192 228924381 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
1193 228924381 : resblks + dmap->br_blockcount, 0, false, &tp);
1194 228930023 : if (error == -EDQUOT || error == -ENOSPC) {
1195 2541879 : quota_reserved = false;
1196 2541879 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
1197 : resblks, 0, false, &tp);
1198 : }
1199 228930074 : if (error)
1200 834433 : goto out;
1201 :
1202 : /*
1203 : * Read what's currently mapped in the destination file into smap.
1204 : * If smap isn't a hole, we will have to remove it before we can add
1205 : * dmap to the destination file.
1206 : */
1207 228095641 : nimaps = 1;
1208 228095641 : error = xfs_bmapi_read(ip, dmap->br_startoff, dmap->br_blockcount,
1209 : &smap, &nimaps, 0);
1210 228088635 : if (error)
1211 14 : goto out_cancel;
1212 228088621 : ASSERT(nimaps == 1 && smap.br_startoff == dmap->br_startoff);
1213 228088621 : smap_real = xfs_bmap_is_real_extent(&smap);
1214 :
1215 : /*
1216 : * We can only remap as many blocks as the smaller of the two extent
1217 : * maps, because we can only remap one extent at a time.
1218 : */
1219 228088621 : dmap->br_blockcount = min(dmap->br_blockcount, smap.br_blockcount);
1220 228088621 : ASSERT(dmap->br_blockcount == smap.br_blockcount);
1221 :
1222 228088621 : trace_xfs_reflink_remap_extent_dest(ip, &smap);
1223 :
1224 : /*
1225 : * Two extents mapped to the same physical block must not have
1226 : * different states; that's filesystem corruption. Move on to the next
1227 : * extent if they're both holes or both the same physical extent.
1228 : */
1229 228090094 : if (dmap->br_startblock == smap.br_startblock) {
1230 124564170 : if (dmap->br_state != smap.br_state) {
1231 0 : xfs_bmap_mark_sick(ip, XFS_DATA_FORK);
1232 0 : error = -EFSCORRUPTED;
1233 : }
1234 124564170 : goto out_cancel;
1235 : }
1236 :
1237 : /* If both extents are unwritten, leave them alone. */
1238 103525924 : if (dmap->br_state == XFS_EXT_UNWRITTEN &&
1239 10866046 : smap.br_state == XFS_EXT_UNWRITTEN)
1240 913959 : goto out_cancel;
1241 :
1242 : /* No reflinking if the AG of the dest mapping is low on space. */
1243 102611965 : if (dmap_written) {
1244 156090192 : error = xfs_reflink_ag_has_free_space(mp,
1245 78045096 : XFS_FSB_TO_AGNO(mp, dmap->br_startblock));
1246 78045083 : if (error)
1247 1328 : goto out_cancel;
1248 : }
1249 :
1250 : /*
1251 : * Increase quota reservation if we think the quota block counter for
1252 : * this file could increase.
1253 : *
1254 : * If we are mapping a written extent into the file, we need to have
1255 : * enough quota block count reservation to handle the blocks in that
1256 : * extent. We log only the delta to the quota block counts, so if the
1257 : * extent we're unmapping also has blocks allocated to it, we don't
1258 : * need a quota reservation for the extent itself.
1259 : *
1260 : * Note that if we're replacing a delalloc reservation with a written
1261 : * extent, we have to take the full quota reservation because removing
1262 : * the delalloc reservation gives the block count back to the quota
1263 : * count. This is suboptimal, but the VFS flushed the dest range
1264 : * before we started. That should have removed all the delalloc
1265 : * reservations, but we code defensively.
1266 : *
1267 : * xfs_trans_alloc_inode above already tried to grab an even larger
1268 : * quota reservation, and kicked off a blockgc scan if it couldn't.
1269 : * If we can't get a potentially smaller quota reservation now, we're
1270 : * done.
1271 : */
1272 102610624 : if (!quota_reserved && !smap_real && dmap_written) {
1273 78683 : error = xfs_trans_reserve_quota_nblks(tp, ip,
1274 78683 : dmap->br_blockcount, 0, false);
1275 78683 : if (error)
1276 0 : goto out_cancel;
1277 : }
1278 :
1279 102610624 : if (smap_real)
1280 17244692 : ++iext_delta;
1281 :
1282 102610624 : if (dmap_written)
1283 78043756 : ++iext_delta;
1284 :
1285 102610624 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, iext_delta);
1286 102610708 : if (error == -EFBIG)
1287 18 : error = xfs_iext_count_upgrade(tp, ip, iext_delta);
1288 102610708 : if (error)
1289 18 : goto out_cancel;
1290 :
1291 102610690 : if (smap_real) {
1292 : /*
1293 : * If the extent we're unmapping is backed by storage (written
1294 : * or not), unmap the extent and drop its refcount.
1295 : */
1296 17244790 : xfs_bmap_unmap_extent(tp, ip, XFS_DATA_FORK, &smap);
1297 17244918 : xfs_refcount_decrease_extent(tp, &smap);
1298 17245245 : qdelta -= smap.br_blockcount;
1299 85365900 : } else if (smap.br_startblock == DELAYSTARTBLOCK) {
1300 3245 : int done;
1301 :
1302 : /*
1303 : * If the extent we're unmapping is a delalloc reservation,
1304 : * we can use the regular bunmapi function to release the
1305 : * incore state. Dropping the delalloc reservation takes care
1306 : * of the quota reservation for us.
1307 : */
1308 3245 : error = xfs_bunmapi(NULL, ip, smap.br_startoff,
1309 : smap.br_blockcount, 0, 1, &done);
1310 3245 : if (error)
1311 0 : goto out_cancel;
1312 3245 : ASSERT(done);
1313 : }
1314 :
1315 : /*
1316 : * If the extent we're sharing is backed by written storage, increase
1317 : * its refcount and map it into the file.
1318 : */
1319 102611145 : if (dmap_written) {
1320 78043719 : xfs_refcount_increase_extent(tp, dmap);
1321 78043711 : xfs_bmap_map_extent(tp, ip, XFS_DATA_FORK, dmap);
1322 78043744 : qdelta += dmap->br_blockcount;
1323 : }
1324 :
1325 102611170 : xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, qdelta);
1326 :
1327 : /* Update dest isize if needed. */
1328 102610487 : newlen = XFS_FSB_TO_B(mp, dmap->br_startoff + dmap->br_blockcount);
1329 102610487 : newlen = min_t(xfs_off_t, newlen, new_isize);
1330 102610487 : if (newlen > i_size_read(VFS_I(ip))) {
1331 70763016 : trace_xfs_reflink_update_inode_size(ip, newlen);
1332 70763014 : i_size_write(VFS_I(ip), newlen);
1333 70763014 : ip->i_disk_size = newlen;
1334 70763014 : xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1335 : }
1336 :
1337 : /* Commit everything and unlock. */
1338 102610491 : error = xfs_trans_commit(tp);
1339 102611277 : goto out_unlock;
1340 :
1341 125479489 : out_cancel:
1342 125479489 : xfs_trans_cancel(tp);
1343 228075345 : out_unlock:
1344 228075345 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1345 228898928 : out:
1346 228898928 : if (error)
1347 836734 : trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_);
1348 228898920 : return error;
1349 : }
1350 :
1351 : /* Remap a range of one file to the other. */
1352 : int
1353 116708004 : xfs_reflink_remap_blocks(
1354 : struct xfs_inode *src,
1355 : loff_t pos_in,
1356 : struct xfs_inode *dest,
1357 : loff_t pos_out,
1358 : loff_t remap_len,
1359 : loff_t *remapped)
1360 : {
1361 116708004 : struct xfs_bmbt_irec imap;
1362 116708004 : struct xfs_mount *mp = src->i_mount;
1363 116708004 : xfs_fileoff_t srcoff = XFS_B_TO_FSBT(mp, pos_in);
1364 116708004 : xfs_fileoff_t destoff = XFS_B_TO_FSBT(mp, pos_out);
1365 116708004 : xfs_filblks_t len;
1366 116708004 : xfs_filblks_t remapped_len = 0;
1367 116708004 : xfs_off_t new_isize = pos_out + remap_len;
1368 116708004 : int nimaps;
1369 116708004 : int error = 0;
1370 :
1371 116708004 : len = min_t(xfs_filblks_t, XFS_B_TO_FSB(mp, remap_len),
1372 : XFS_MAX_FILEOFF);
1373 :
1374 116708004 : trace_xfs_reflink_remap_blocks(src, srcoff, len, dest, destoff);
1375 :
1376 344760684 : while (len > 0) {
1377 228915050 : unsigned int lock_mode;
1378 :
1379 : /* Read extent from the source file */
1380 228915050 : nimaps = 1;
1381 228915050 : lock_mode = xfs_ilock_data_map_shared(src);
1382 228923952 : error = xfs_bmapi_read(src, srcoff, len, &imap, &nimaps, 0);
1383 228927116 : xfs_iunlock(src, lock_mode);
1384 228924304 : if (error)
1385 : break;
1386 : /*
1387 : * The caller supposedly flushed all dirty pages in the source
1388 : * file range, which means that writeback should have allocated
1389 : * or deleted all delalloc reservations in that range. If we
1390 : * find one, that's a good sign that something is seriously
1391 : * wrong here.
1392 : */
1393 228924253 : ASSERT(nimaps == 1 && imap.br_startoff == srcoff);
1394 228924253 : if (imap.br_startblock == DELAYSTARTBLOCK) {
1395 0 : ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1396 0 : xfs_bmap_mark_sick(src, XFS_DATA_FORK);
1397 0 : error = -EFSCORRUPTED;
1398 0 : break;
1399 : }
1400 :
1401 228924253 : trace_xfs_reflink_remap_extent_src(src, &imap);
1402 :
1403 : /* Remap into the destination file at the given offset. */
1404 228922922 : imap.br_startoff = destoff;
1405 228922922 : error = xfs_reflink_remap_extent(dest, &imap, new_isize);
1406 228905478 : if (error)
1407 : break;
1408 :
1409 228068749 : if (fatal_signal_pending(current)) {
1410 : error = -EINTR;
1411 : break;
1412 : }
1413 :
1414 : /* Advance drange/srange */
1415 228052680 : srcoff += imap.br_blockcount;
1416 228052680 : destoff += imap.br_blockcount;
1417 228052680 : len -= imap.br_blockcount;
1418 228052680 : remapped_len += imap.br_blockcount;
1419 : }
1420 :
1421 116683903 : if (error)
1422 837021 : trace_xfs_reflink_remap_blocks_error(dest, error, _RET_IP_);
1423 116683914 : *remapped = min_t(loff_t, remap_len,
1424 : XFS_FSB_TO_B(src->i_mount, remapped_len));
1425 116683914 : return error;
1426 : }
1427 :
1428 : /*
1429 : * If we're reflinking to a point past the destination file's EOF, we must
1430 : * zero any speculative post-EOF preallocations that sit between the old EOF
1431 : * and the destination file offset.
1432 : */
1433 : static int
1434 116712147 : xfs_reflink_zero_posteof(
1435 : struct xfs_inode *ip,
1436 : loff_t pos)
1437 : {
1438 116712147 : loff_t isize = i_size_read(VFS_I(ip));
1439 :
1440 116712147 : if (pos <= isize)
1441 : return 0;
1442 :
1443 2605623 : trace_xfs_zero_eof(ip, isize, pos - isize);
1444 2605598 : return xfs_zero_range(ip, isize, pos - isize, NULL);
1445 : }
1446 :
1447 : /*
1448 : * Prepare two files for range cloning. Upon a successful return both inodes
1449 : * will have the iolock and mmaplock held, the page cache of the out file will
1450 : * be truncated, and any leases on the out file will have been broken. This
1451 : * function borrows heavily from xfs_file_aio_write_checks.
1452 : *
1453 : * The VFS allows partial EOF blocks to "match" for dedupe even though it hasn't
1454 : * checked that the bytes beyond EOF physically match. Hence we cannot use the
1455 : * EOF block in the source dedupe range because it's not a complete block match,
1456 : * hence can introduce a corruption into the file that has it's block replaced.
1457 : *
1458 : * In similar fashion, the VFS file cloning also allows partial EOF blocks to be
1459 : * "block aligned" for the purposes of cloning entire files. However, if the
1460 : * source file range includes the EOF block and it lands within the existing EOF
1461 : * of the destination file, then we can expose stale data from beyond the source
1462 : * file EOF in the destination file.
1463 : *
1464 : * XFS doesn't support partial block sharing, so in both cases we have check
1465 : * these cases ourselves. For dedupe, we can simply round the length to dedupe
1466 : * down to the previous whole block and ignore the partial EOF block. While this
1467 : * means we can't dedupe the last block of a file, this is an acceptible
1468 : * tradeoff for simplicity on implementation.
1469 : *
1470 : * For cloning, we want to share the partial EOF block if it is also the new EOF
1471 : * block of the destination file. If the partial EOF block lies inside the
1472 : * existing destination EOF, then we have to abort the clone to avoid exposing
1473 : * stale data in the destination file. Hence we reject these clone attempts with
1474 : * -EINVAL in this case.
1475 : */
1476 : int
1477 190253819 : xfs_reflink_remap_prep(
1478 : struct file *file_in,
1479 : loff_t pos_in,
1480 : struct file *file_out,
1481 : loff_t pos_out,
1482 : loff_t *len,
1483 : unsigned int remap_flags)
1484 : {
1485 190253819 : struct inode *inode_in = file_inode(file_in);
1486 190253819 : struct xfs_inode *src = XFS_I(inode_in);
1487 190253819 : struct inode *inode_out = file_inode(file_out);
1488 190253819 : struct xfs_inode *dest = XFS_I(inode_out);
1489 190253819 : int ret;
1490 :
1491 : /* Lock both files against IO */
1492 190253819 : ret = xfs_ilock2_io_mmap(src, dest);
1493 190254195 : if (ret)
1494 : return ret;
1495 :
1496 : /* Check file eligibility and prepare for block sharing. */
1497 190254195 : ret = -EINVAL;
1498 : /* Don't reflink realtime inodes */
1499 190254195 : if (XFS_IS_REALTIME_INODE(src) || XFS_IS_REALTIME_INODE(dest))
1500 0 : goto out_unlock;
1501 :
1502 : /* Don't share DAX file data with non-DAX file. */
1503 190254195 : if (IS_DAX(inode_in) != IS_DAX(inode_out))
1504 0 : goto out_unlock;
1505 :
1506 190254195 : if (!IS_DAX(inode_in))
1507 190254195 : ret = generic_remap_file_range_prep(file_in, pos_in, file_out,
1508 : pos_out, len, remap_flags);
1509 : else
1510 0 : ret = dax_remap_file_range_prep(file_in, pos_in, file_out,
1511 : pos_out, len, remap_flags, &xfs_read_iomap_ops);
1512 190262138 : if (ret || *len == 0)
1513 73544158 : goto out_unlock;
1514 :
1515 : /* Attach dquots to dest inode before changing block map */
1516 116717980 : ret = xfs_qm_dqattach(dest);
1517 116712121 : if (ret)
1518 0 : goto out_unlock;
1519 :
1520 : /*
1521 : * Zero existing post-eof speculative preallocations in the destination
1522 : * file.
1523 : */
1524 116712121 : ret = xfs_reflink_zero_posteof(dest, pos_out);
1525 116712729 : if (ret)
1526 4285 : goto out_unlock;
1527 :
1528 : /* Set flags and remap blocks. */
1529 116708444 : ret = xfs_reflink_set_inode_flag(src, dest);
1530 116703237 : if (ret)
1531 4 : goto out_unlock;
1532 :
1533 : /*
1534 : * If pos_out > EOF, we may have dirtied blocks between EOF and
1535 : * pos_out. In that case, we need to extend the flush and unmap to cover
1536 : * from EOF to the end of the copy length.
1537 : */
1538 233406466 : if (pos_out > XFS_ISIZE(dest)) {
1539 2595922 : loff_t flen = *len + (pos_out - XFS_ISIZE(dest));
1540 2595922 : ret = xfs_flush_unmap_range(dest, XFS_ISIZE(dest), flen);
1541 : } else {
1542 114107311 : ret = xfs_flush_unmap_range(dest, pos_out, *len);
1543 : }
1544 116713810 : if (ret)
1545 82 : goto out_unlock;
1546 :
1547 : return 0;
1548 73548529 : out_unlock:
1549 73548529 : xfs_iunlock2_io_mmap(src, dest);
1550 73548529 : return ret;
1551 : }
1552 :
1553 : /* Does this inode need the reflink flag? */
1554 : int
1555 41324297 : xfs_reflink_inode_has_shared_extents(
1556 : struct xfs_trans *tp,
1557 : struct xfs_inode *ip,
1558 : bool *has_shared)
1559 : {
1560 41324297 : struct xfs_bmbt_irec got;
1561 41324297 : struct xfs_mount *mp = ip->i_mount;
1562 41324297 : struct xfs_ifork *ifp;
1563 41324297 : struct xfs_iext_cursor icur;
1564 41324297 : bool found;
1565 41324297 : int error;
1566 :
1567 41324297 : ifp = xfs_ifork_ptr(ip, XFS_DATA_FORK);
1568 41324297 : error = xfs_iread_extents(tp, ip, XFS_DATA_FORK);
1569 41328550 : if (error)
1570 : return error;
1571 :
1572 41336380 : *has_shared = false;
1573 41336380 : found = xfs_iext_lookup_extent(ip, ifp, 0, &icur, &got);
1574 286712364 : while (found) {
1575 247593511 : struct xfs_perag *pag;
1576 247593511 : xfs_agblock_t agbno;
1577 247593511 : xfs_extlen_t aglen;
1578 247593511 : xfs_agblock_t rbno;
1579 247593511 : xfs_extlen_t rlen;
1580 :
1581 247593511 : if (isnullstartblock(got.br_startblock) ||
1582 247589774 : got.br_state != XFS_EXT_NORM)
1583 7430311 : goto next;
1584 :
1585 240163200 : pag = xfs_perag_get(mp, XFS_FSB_TO_AGNO(mp, got.br_startblock));
1586 240257192 : agbno = XFS_FSB_TO_AGBNO(mp, got.br_startblock);
1587 240234312 : aglen = got.br_blockcount;
1588 240234312 : error = xfs_reflink_find_shared(pag, tp, agbno, aglen,
1589 : &rbno, &rlen, false);
1590 240276299 : xfs_perag_put(pag);
1591 240285414 : if (error)
1592 2270127 : return error;
1593 :
1594 : /* Is there still a shared block here? */
1595 240285414 : if (rbno != NULLAGBLOCK) {
1596 2270127 : *has_shared = true;
1597 2270127 : return 0;
1598 : }
1599 238015287 : next:
1600 245445598 : found = xfs_iext_next_extent(ifp, &icur, &got);
1601 : }
1602 :
1603 : return 0;
1604 : }
1605 :
1606 : /*
1607 : * Clear the inode reflink flag if there are no shared extents.
1608 : *
1609 : * The caller is responsible for joining the inode to the transaction passed in.
1610 : * The inode will be joined to the transaction that is returned to the caller.
1611 : */
1612 : int
1613 46207 : xfs_reflink_clear_inode_flag(
1614 : struct xfs_inode *ip,
1615 : struct xfs_trans **tpp)
1616 : {
1617 46207 : bool needs_flag;
1618 46207 : int error = 0;
1619 :
1620 46207 : ASSERT(xfs_is_reflink_inode(ip));
1621 :
1622 46207 : error = xfs_reflink_inode_has_shared_extents(*tpp, ip, &needs_flag);
1623 46207 : if (error || needs_flag)
1624 39637 : return error;
1625 :
1626 : /*
1627 : * We didn't find any shared blocks so turn off the reflink flag.
1628 : * First, get rid of any leftover CoW mappings.
1629 : */
1630 6570 : error = xfs_reflink_cancel_cow_blocks(ip, tpp, 0, XFS_MAX_FILEOFF,
1631 : true);
1632 6570 : if (error)
1633 : return error;
1634 :
1635 : /* Clear the inode flag. */
1636 6570 : trace_xfs_reflink_unset_inode_flag(ip);
1637 6570 : ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1638 6570 : xfs_inode_clear_cowblocks_tag(ip);
1639 6570 : xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE);
1640 :
1641 6570 : return error;
1642 : }
1643 :
1644 : /*
1645 : * Clear the inode reflink flag if there are no shared extents and the size
1646 : * hasn't changed.
1647 : */
1648 : STATIC int
1649 110 : xfs_reflink_try_clear_inode_flag(
1650 : struct xfs_inode *ip)
1651 : {
1652 110 : struct xfs_mount *mp = ip->i_mount;
1653 110 : struct xfs_trans *tp;
1654 110 : int error = 0;
1655 :
1656 : /* Start a rolling transaction to remove the mappings */
1657 110 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1658 110 : if (error)
1659 : return error;
1660 :
1661 110 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1662 110 : xfs_trans_ijoin(tp, ip, 0);
1663 :
1664 110 : error = xfs_reflink_clear_inode_flag(ip, &tp);
1665 110 : if (error)
1666 0 : goto cancel;
1667 :
1668 110 : error = xfs_trans_commit(tp);
1669 110 : if (error)
1670 0 : goto out;
1671 :
1672 110 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1673 110 : return 0;
1674 : cancel:
1675 0 : xfs_trans_cancel(tp);
1676 0 : out:
1677 0 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1678 0 : return error;
1679 : }
1680 :
1681 : /*
1682 : * Pre-COW all shared blocks within a given byte range of a file and turn off
1683 : * the reflink flag if we unshare all of the file's blocks.
1684 : */
1685 : int
1686 205 : xfs_reflink_unshare(
1687 : struct xfs_inode *ip,
1688 : xfs_off_t offset,
1689 : xfs_off_t len)
1690 : {
1691 205 : struct inode *inode = VFS_I(ip);
1692 205 : int error;
1693 :
1694 205 : if (!xfs_is_reflink_inode(ip))
1695 : return 0;
1696 :
1697 116 : trace_xfs_reflink_unshare(ip, offset, len);
1698 :
1699 116 : inode_dio_wait(inode);
1700 :
1701 116 : if (IS_DAX(inode))
1702 0 : error = dax_file_unshare(inode, offset, len,
1703 : &xfs_dax_write_iomap_ops);
1704 : else
1705 116 : error = iomap_file_unshare(inode, offset, len,
1706 : &xfs_buffered_write_iomap_ops);
1707 116 : if (error)
1708 0 : goto out;
1709 :
1710 116 : error = filemap_write_and_wait_range(inode->i_mapping, offset,
1711 116 : offset + len - 1);
1712 116 : if (error)
1713 6 : goto out;
1714 :
1715 : /* Turn off the reflink flag if possible. */
1716 110 : error = xfs_reflink_try_clear_inode_flag(ip);
1717 110 : if (error)
1718 0 : goto out;
1719 : return 0;
1720 :
1721 6 : out:
1722 6 : trace_xfs_reflink_unshare_error(ip, error, _RET_IP_);
1723 6 : return error;
1724 : }
|
