blob: 99c5852f9fe785b3bb2522f770f0345ec8d635e6 [file] [log] [blame]
Darrick J. Wong3993bae2016-10-03 09:11:32 -07001/*
2 * Copyright (C) 2016 Oracle. All Rights Reserved.
3 *
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it would be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
19 */
20#include "xfs.h"
21#include "xfs_fs.h"
22#include "xfs_shared.h"
23#include "xfs_format.h"
24#include "xfs_log_format.h"
25#include "xfs_trans_resv.h"
26#include "xfs_mount.h"
27#include "xfs_defer.h"
28#include "xfs_da_format.h"
29#include "xfs_da_btree.h"
30#include "xfs_inode.h"
31#include "xfs_trans.h"
32#include "xfs_inode_item.h"
33#include "xfs_bmap.h"
34#include "xfs_bmap_util.h"
35#include "xfs_error.h"
36#include "xfs_dir2.h"
37#include "xfs_dir2_priv.h"
38#include "xfs_ioctl.h"
39#include "xfs_trace.h"
40#include "xfs_log.h"
41#include "xfs_icache.h"
42#include "xfs_pnfs.h"
Darrick J. Wong174edb02016-10-03 09:11:39 -070043#include "xfs_btree.h"
Darrick J. Wong3993bae2016-10-03 09:11:32 -070044#include "xfs_refcount_btree.h"
45#include "xfs_refcount.h"
46#include "xfs_bmap_btree.h"
47#include "xfs_trans_space.h"
48#include "xfs_bit.h"
49#include "xfs_alloc.h"
50#include "xfs_quota_defs.h"
51#include "xfs_quota.h"
Darrick J. Wong3993bae2016-10-03 09:11:32 -070052#include "xfs_reflink.h"
Darrick J. Wong2a067052016-10-03 09:11:33 -070053#include "xfs_iomap.h"
Darrick J. Wong43caeb12016-10-03 09:11:35 -070054#include "xfs_rmap_btree.h"
Darrick J. Wong6fa164b2016-10-03 09:11:45 -070055#include "xfs_sb.h"
56#include "xfs_ag_resv.h"
Darrick J. Wong3993bae2016-10-03 09:11:32 -070057
58/*
59 * Copy on Write of Shared Blocks
60 *
61 * XFS must preserve "the usual" file semantics even when two files share
62 * the same physical blocks. This means that a write to one file must not
63 * alter the blocks in a different file; the way that we'll do that is
64 * through the use of a copy-on-write mechanism. At a high level, that
65 * means that when we want to write to a shared block, we allocate a new
66 * block, write the data to the new block, and if that succeeds we map the
67 * new block into the file.
68 *
69 * XFS provides a "delayed allocation" mechanism that defers the allocation
70 * of disk blocks to dirty-but-not-yet-mapped file blocks as long as
71 * possible. This reduces fragmentation by enabling the filesystem to ask
72 * for bigger chunks less often, which is exactly what we want for CoW.
73 *
74 * The delalloc mechanism begins when the kernel wants to make a block
75 * writable (write_begin or page_mkwrite). If the offset is not mapped, we
76 * create a delalloc mapping, which is a regular in-core extent, but without
77 * a real startblock. (For delalloc mappings, the startblock encodes both
78 * a flag that this is a delalloc mapping, and a worst-case estimate of how
79 * many blocks might be required to put the mapping into the BMBT.) delalloc
80 * mappings are a reservation against the free space in the filesystem;
81 * adjacent mappings can also be combined into fewer larger mappings.
82 *
Darrick J. Wong5eda4302017-02-02 15:14:02 -080083 * As an optimization, the CoW extent size hint (cowextsz) creates
84 * outsized aligned delalloc reservations in the hope of landing out of
85 * order nearby CoW writes in a single extent on disk, thereby reducing
86 * fragmentation and improving future performance.
87 *
88 * D: --RRRRRRSSSRRRRRRRR--- (data fork)
89 * C: ------DDDDDDD--------- (CoW fork)
90 *
Darrick J. Wong3993bae2016-10-03 09:11:32 -070091 * When dirty pages are being written out (typically in writepage), the
Darrick J. Wong5eda4302017-02-02 15:14:02 -080092 * delalloc reservations are converted into unwritten mappings by
93 * allocating blocks and replacing the delalloc mapping with real ones.
94 * A delalloc mapping can be replaced by several unwritten ones if the
95 * free space is fragmented.
96 *
97 * D: --RRRRRRSSSRRRRRRRR---
98 * C: ------UUUUUUU---------
Darrick J. Wong3993bae2016-10-03 09:11:32 -070099 *
100 * We want to adapt the delalloc mechanism for copy-on-write, since the
101 * write paths are similar. The first two steps (creating the reservation
102 * and allocating the blocks) are exactly the same as delalloc except that
103 * the mappings must be stored in a separate CoW fork because we do not want
104 * to disturb the mapping in the data fork until we're sure that the write
105 * succeeded. IO completion in this case is the process of removing the old
106 * mapping from the data fork and moving the new mapping from the CoW fork to
107 * the data fork. This will be discussed shortly.
108 *
109 * For now, unaligned directio writes will be bounced back to the page cache.
110 * Block-aligned directio writes will use the same mechanism as buffered
111 * writes.
112 *
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800113 * Just prior to submitting the actual disk write requests, we convert
114 * the extents representing the range of the file actually being written
115 * (as opposed to extra pieces created for the cowextsize hint) to real
116 * extents. This will become important in the next step:
117 *
118 * D: --RRRRRRSSSRRRRRRRR---
119 * C: ------UUrrUUU---------
120 *
Darrick J. Wong3993bae2016-10-03 09:11:32 -0700121 * CoW remapping must be done after the data block write completes,
122 * because we don't want to destroy the old data fork map until we're sure
123 * the new block has been written. Since the new mappings are kept in a
124 * separate fork, we can simply iterate these mappings to find the ones
125 * that cover the file blocks that we just CoW'd. For each extent, simply
126 * unmap the corresponding range in the data fork, map the new range into
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800127 * the data fork, and remove the extent from the CoW fork. Because of
128 * the presence of the cowextsize hint, however, we must be careful
129 * only to remap the blocks that we've actually written out -- we must
130 * never remap delalloc reservations nor CoW staging blocks that have
131 * yet to be written. This corresponds exactly to the real extents in
132 * the CoW fork:
133 *
134 * D: --RRRRRRrrSRRRRRRRR---
135 * C: ------UU--UUU---------
Darrick J. Wong3993bae2016-10-03 09:11:32 -0700136 *
137 * Since the remapping operation can be applied to an arbitrary file
138 * range, we record the need for the remap step as a flag in the ioend
139 * instead of declaring a new IO type. This is required for direct io
140 * because we only have ioend for the whole dio, and we have to be able to
141 * remember the presence of unwritten blocks and CoW blocks with a single
142 * ioend structure. Better yet, the more ground we can cover with one
143 * ioend, the better.
144 */
Darrick J. Wong2a067052016-10-03 09:11:33 -0700145
146/*
147 * Given an AG extent, find the lowest-numbered run of shared blocks
148 * within that range and return the range in fbno/flen. If
149 * find_end_of_shared is true, return the longest contiguous extent of
150 * shared blocks. If there are no shared extents, fbno and flen will
151 * be set to NULLAGBLOCK and 0, respectively.
152 */
153int
154xfs_reflink_find_shared(
155 struct xfs_mount *mp,
Darrick J. Wong92ff7282017-06-16 11:00:10 -0700156 struct xfs_trans *tp,
Darrick J. Wong2a067052016-10-03 09:11:33 -0700157 xfs_agnumber_t agno,
158 xfs_agblock_t agbno,
159 xfs_extlen_t aglen,
160 xfs_agblock_t *fbno,
161 xfs_extlen_t *flen,
162 bool find_end_of_shared)
163{
164 struct xfs_buf *agbp;
165 struct xfs_btree_cur *cur;
166 int error;
167
Darrick J. Wong92ff7282017-06-16 11:00:10 -0700168 error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
Darrick J. Wong2a067052016-10-03 09:11:33 -0700169 if (error)
170 return error;
Darrick J. Wong10479e22017-07-17 14:30:57 -0700171 if (!agbp)
172 return -ENOMEM;
Darrick J. Wong2a067052016-10-03 09:11:33 -0700173
Darrick J. Wong92ff7282017-06-16 11:00:10 -0700174 cur = xfs_refcountbt_init_cursor(mp, tp, agbp, agno, NULL);
Darrick J. Wong2a067052016-10-03 09:11:33 -0700175
176 error = xfs_refcount_find_shared(cur, agbno, aglen, fbno, flen,
177 find_end_of_shared);
178
179 xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
180
Darrick J. Wong92ff7282017-06-16 11:00:10 -0700181 xfs_trans_brelse(tp, agbp);
Darrick J. Wong2a067052016-10-03 09:11:33 -0700182 return error;
183}
184
185/*
186 * Trim the mapping to the next block where there's a change in the
187 * shared/unshared status. More specifically, this means that we
188 * find the lowest-numbered extent of shared blocks that coincides with
189 * the given block mapping. If the shared extent overlaps the start of
190 * the mapping, trim the mapping to the end of the shared extent. If
191 * the shared region intersects the mapping, trim the mapping to the
192 * start of the shared extent. If there are no shared regions that
193 * overlap, just return the original extent.
194 */
195int
196xfs_reflink_trim_around_shared(
197 struct xfs_inode *ip,
198 struct xfs_bmbt_irec *irec,
199 bool *shared,
200 bool *trimmed)
201{
202 xfs_agnumber_t agno;
203 xfs_agblock_t agbno;
204 xfs_extlen_t aglen;
205 xfs_agblock_t fbno;
206 xfs_extlen_t flen;
207 int error = 0;
208
209 /* Holes, unwritten, and delalloc extents cannot be shared */
Christoph Hellwig9c4f29d2017-03-28 14:53:35 -0700210 if (!xfs_is_reflink_inode(ip) || !xfs_bmap_is_real_extent(irec)) {
Darrick J. Wong2a067052016-10-03 09:11:33 -0700211 *shared = false;
212 return 0;
213 }
214
215 trace_xfs_reflink_trim_around_shared(ip, irec);
216
217 agno = XFS_FSB_TO_AGNO(ip->i_mount, irec->br_startblock);
218 agbno = XFS_FSB_TO_AGBNO(ip->i_mount, irec->br_startblock);
219 aglen = irec->br_blockcount;
220
Darrick J. Wong92ff7282017-06-16 11:00:10 -0700221 error = xfs_reflink_find_shared(ip->i_mount, NULL, agno, agbno,
Darrick J. Wong2a067052016-10-03 09:11:33 -0700222 aglen, &fbno, &flen, true);
223 if (error)
224 return error;
225
226 *shared = *trimmed = false;
227 if (fbno == NULLAGBLOCK) {
228 /* No shared blocks at all. */
229 return 0;
230 } else if (fbno == agbno) {
231 /*
232 * The start of this extent is shared. Truncate the
233 * mapping at the end of the shared region so that a
234 * subsequent iteration starts at the start of the
235 * unshared region.
236 */
237 irec->br_blockcount = flen;
238 *shared = true;
239 if (flen != aglen)
240 *trimmed = true;
241 return 0;
242 } else {
243 /*
244 * There's a shared extent midway through this extent.
245 * Truncate the mapping at the start of the shared
246 * extent so that a subsequent iteration starts at the
247 * start of the shared region.
248 */
249 irec->br_blockcount = fbno - agbno;
250 *trimmed = true;
251 return 0;
252 }
253}
254
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100255/*
256 * Trim the passed in imap to the next shared/unshared extent boundary, and
257 * if imap->br_startoff points to a shared extent reserve space for it in the
258 * COW fork. In this case *shared is set to true, else to false.
259 *
260 * Note that imap will always contain the block numbers for the existing blocks
261 * in the data fork, as the upper layers need them for read-modify-write
262 * operations.
263 */
264int
265xfs_reflink_reserve_cow(
Darrick J. Wong2a067052016-10-03 09:11:33 -0700266 struct xfs_inode *ip,
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100267 struct xfs_bmbt_irec *imap,
268 bool *shared)
Darrick J. Wong2a067052016-10-03 09:11:33 -0700269{
Christoph Hellwig2755fc442016-11-24 11:39:49 +1100270 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
271 struct xfs_bmbt_irec got;
Christoph Hellwig2755fc442016-11-24 11:39:49 +1100272 int error = 0;
273 bool eof = false, trimmed;
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700274 struct xfs_iext_cursor icur;
Darrick J. Wong2a067052016-10-03 09:11:33 -0700275
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100276 /*
277 * Search the COW fork extent list first. This serves two purposes:
278 * first this implement the speculative preallocation using cowextisze,
279 * so that we also unshared block adjacent to shared blocks instead
280 * of just the shared blocks themselves. Second the lookup in the
281 * extent list is generally faster than going out to the shared extent
282 * tree.
283 */
Christoph Hellwig2755fc442016-11-24 11:39:49 +1100284
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700285 if (!xfs_iext_lookup_extent(ip, ifp, imap->br_startoff, &icur, &got))
Christoph Hellwig2755fc442016-11-24 11:39:49 +1100286 eof = true;
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100287 if (!eof && got.br_startoff <= imap->br_startoff) {
288 trace_xfs_reflink_cow_found(ip, imap);
289 xfs_trim_extent(imap, got.br_startoff, got.br_blockcount);
Darrick J. Wong2a067052016-10-03 09:11:33 -0700290
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100291 *shared = true;
292 return 0;
293 }
Darrick J. Wong2a067052016-10-03 09:11:33 -0700294
295 /* Trim the mapping to the nearest shared extent boundary. */
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100296 error = xfs_reflink_trim_around_shared(ip, imap, shared, &trimmed);
Darrick J. Wong2a067052016-10-03 09:11:33 -0700297 if (error)
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100298 return error;
Darrick J. Wong2a067052016-10-03 09:11:33 -0700299
300 /* Not shared? Just report the (potentially capped) extent. */
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100301 if (!*shared)
302 return 0;
Darrick J. Wong2a067052016-10-03 09:11:33 -0700303
304 /*
305 * Fork all the shared blocks from our write offset until the end of
306 * the extent.
307 */
308 error = xfs_qm_dqattach_locked(ip, 0);
309 if (error)
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100310 return error;
311
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100312 error = xfs_bmapi_reserve_delalloc(ip, XFS_COW_FORK, imap->br_startoff,
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700313 imap->br_blockcount, 0, &got, &icur, eof);
Brian Foster0260d8f2016-11-28 14:57:42 +1100314 if (error == -ENOSPC || error == -EDQUOT)
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100315 trace_xfs_reflink_cow_enospc(ip, imap);
Brian Foster0260d8f2016-11-28 14:57:42 +1100316 if (error)
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100317 return error;
Darrick J. Wong83104d42016-10-03 09:11:46 -0700318
Darrick J. Wong2a067052016-10-03 09:11:33 -0700319 trace_xfs_reflink_cow_alloc(ip, &got);
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100320 return 0;
Darrick J. Wong2a067052016-10-03 09:11:33 -0700321}
Darrick J. Wongef473662016-10-03 09:11:34 -0700322
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800323/* Convert part of an unwritten CoW extent to a real one. */
324STATIC int
325xfs_reflink_convert_cow_extent(
326 struct xfs_inode *ip,
327 struct xfs_bmbt_irec *imap,
328 xfs_fileoff_t offset_fsb,
329 xfs_filblks_t count_fsb,
330 struct xfs_defer_ops *dfops)
331{
Darrick J. Wong4c1a67b2017-07-17 14:30:51 -0700332 xfs_fsblock_t first_block = NULLFSBLOCK;
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800333 int nimaps = 1;
334
335 if (imap->br_state == XFS_EXT_NORM)
336 return 0;
337
Christoph Hellwigdcf95852017-02-06 10:46:01 -0800338 xfs_trim_extent(imap, offset_fsb, count_fsb);
339 trace_xfs_reflink_convert_cow(ip, imap);
340 if (imap->br_blockcount == 0)
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800341 return 0;
Christoph Hellwigdcf95852017-02-06 10:46:01 -0800342 return xfs_bmapi_write(NULL, ip, imap->br_startoff, imap->br_blockcount,
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800343 XFS_BMAPI_COWFORK | XFS_BMAPI_CONVERT, &first_block,
Christoph Hellwigdcf95852017-02-06 10:46:01 -0800344 0, imap, &nimaps, dfops);
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800345}
346
347/* Convert all of the unwritten CoW extents in a file's range to real ones. */
348int
349xfs_reflink_convert_cow(
350 struct xfs_inode *ip,
351 xfs_off_t offset,
352 xfs_off_t count)
353{
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800354 struct xfs_mount *mp = ip->i_mount;
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800355 xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
356 xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, offset + count);
Christoph Hellwigb1214592017-11-03 10:34:44 -0700357 xfs_filblks_t count_fsb = end_fsb - offset_fsb;
358 struct xfs_bmbt_irec imap;
359 struct xfs_defer_ops dfops;
360 xfs_fsblock_t first_block = NULLFSBLOCK;
361 int nimaps = 1, error = 0;
362
363 ASSERT(count != 0);
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800364
365 xfs_ilock(ip, XFS_ILOCK_EXCL);
Christoph Hellwigb1214592017-11-03 10:34:44 -0700366 error = xfs_bmapi_write(NULL, ip, offset_fsb, count_fsb,
367 XFS_BMAPI_COWFORK | XFS_BMAPI_CONVERT |
368 XFS_BMAPI_CONVERT_ONLY, &first_block, 0, &imap, &nimaps,
369 &dfops);
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800370 xfs_iunlock(ip, XFS_ILOCK_EXCL);
371 return error;
372}
373
Darrick J. Wong0613f162016-10-03 09:11:37 -0700374/* Allocate all CoW reservations covering a range of blocks in a file. */
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800375int
376xfs_reflink_allocate_cow(
Darrick J. Wong0613f162016-10-03 09:11:37 -0700377 struct xfs_inode *ip,
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800378 struct xfs_bmbt_irec *imap,
379 bool *shared,
380 uint *lockmode)
Darrick J. Wong0613f162016-10-03 09:11:37 -0700381{
382 struct xfs_mount *mp = ip->i_mount;
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800383 xfs_fileoff_t offset_fsb = imap->br_startoff;
384 xfs_filblks_t count_fsb = imap->br_blockcount;
385 struct xfs_bmbt_irec got;
Darrick J. Wong0613f162016-10-03 09:11:37 -0700386 struct xfs_defer_ops dfops;
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800387 struct xfs_trans *tp = NULL;
Darrick J. Wong0613f162016-10-03 09:11:37 -0700388 xfs_fsblock_t first_block;
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800389 int nimaps, error = 0;
390 bool trimmed;
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800391 xfs_filblks_t resaligned;
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800392 xfs_extlen_t resblks = 0;
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700393 struct xfs_iext_cursor icur;
Darrick J. Wong0613f162016-10-03 09:11:37 -0700394
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800395retry:
396 ASSERT(xfs_is_reflink_inode(ip));
397 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED));
Darrick J. Wong0613f162016-10-03 09:11:37 -0700398
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800399 /*
400 * Even if the extent is not shared we might have a preallocation for
401 * it in the COW fork. If so use it.
402 */
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700403 if (xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got) &&
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800404 got.br_startoff <= offset_fsb) {
405 *shared = true;
406
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800407 /* If we have a real allocation in the COW fork we're done. */
408 if (!isnullstartblock(got.br_startblock)) {
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800409 xfs_trim_extent(&got, offset_fsb, count_fsb);
410 *imap = got;
411 goto convert;
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800412 }
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800413
414 xfs_trim_extent(imap, got.br_startoff, got.br_blockcount);
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800415 } else {
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800416 error = xfs_reflink_trim_around_shared(ip, imap, shared, &trimmed);
417 if (error || !*shared)
418 goto out;
419 }
420
421 if (!tp) {
422 resaligned = xfs_aligned_fsb_count(imap->br_startoff,
423 imap->br_blockcount, xfs_get_cowextsz_hint(ip));
424 resblks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
425
426 xfs_iunlock(ip, *lockmode);
427 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp);
428 *lockmode = XFS_ILOCK_EXCL;
429 xfs_ilock(ip, *lockmode);
430
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800431 if (error)
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800432 return error;
Christoph Hellwig3ba020b2016-10-20 15:53:50 +1100433
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800434 error = xfs_qm_dqattach_locked(ip, 0);
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800435 if (error)
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800436 goto out;
437 goto retry;
Darrick J. Wong0613f162016-10-03 09:11:37 -0700438 }
439
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800440 error = xfs_trans_reserve_quota_nblks(tp, ip, resblks, 0,
441 XFS_QMOPT_RES_REGBLKS);
Darrick J. Wong0613f162016-10-03 09:11:37 -0700442 if (error)
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800443 goto out;
Darrick J. Wong0613f162016-10-03 09:11:37 -0700444
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800445 xfs_trans_ijoin(tp, ip, 0);
446
447 xfs_defer_init(&dfops, &first_block);
448 nimaps = 1;
449
450 /* Allocate the entire reservation as unwritten blocks. */
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800451 error = xfs_bmapi_write(tp, ip, imap->br_startoff, imap->br_blockcount,
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800452 XFS_BMAPI_COWFORK | XFS_BMAPI_PREALLOC, &first_block,
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800453 resblks, imap, &nimaps, &dfops);
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800454 if (error)
455 goto out_bmap_cancel;
456
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800457 /* Finish up. */
Christoph Hellwig8ad7c6292017-08-28 10:21:04 -0700458 error = xfs_defer_finish(&tp, &dfops);
Darrick J. Wong0613f162016-10-03 09:11:37 -0700459 if (error)
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800460 goto out_bmap_cancel;
Darrick J. Wong0613f162016-10-03 09:11:37 -0700461
462 error = xfs_trans_commit(tp);
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800463 if (error)
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800464 return error;
465convert:
466 return xfs_reflink_convert_cow_extent(ip, imap, offset_fsb, count_fsb,
467 &dfops);
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800468out_bmap_cancel:
Darrick J. Wong0613f162016-10-03 09:11:37 -0700469 xfs_defer_cancel(&dfops);
Christoph Hellwiga14234c2017-02-06 10:50:49 -0800470 xfs_trans_unreserve_quota_nblks(tp, ip, (long)resblks, 0,
471 XFS_QMOPT_RES_REGBLKS);
Christoph Hellwig3c68d442017-02-06 10:51:03 -0800472out:
473 if (tp)
474 xfs_trans_cancel(tp);
475 return error;
Darrick J. Wong0613f162016-10-03 09:11:37 -0700476}
477
Darrick J. Wongef473662016-10-03 09:11:34 -0700478/*
Christoph Hellwig092d5d92016-11-24 11:39:49 +1100479 * Find the CoW reservation for a given byte offset of a file.
Darrick J. Wongef473662016-10-03 09:11:34 -0700480 */
481bool
482xfs_reflink_find_cow_mapping(
483 struct xfs_inode *ip,
484 xfs_off_t offset,
Christoph Hellwig092d5d92016-11-24 11:39:49 +1100485 struct xfs_bmbt_irec *imap)
Darrick J. Wongef473662016-10-03 09:11:34 -0700486{
Christoph Hellwig092d5d92016-11-24 11:39:49 +1100487 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
488 xfs_fileoff_t offset_fsb;
489 struct xfs_bmbt_irec got;
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700490 struct xfs_iext_cursor icur;
Darrick J. Wongef473662016-10-03 09:11:34 -0700491
492 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL | XFS_ILOCK_SHARED));
Darrick J. Wongef473662016-10-03 09:11:34 -0700493
Darrick J. Wong73353f42017-12-10 18:03:55 -0800494 if (!xfs_is_reflink_inode(ip))
495 return false;
Christoph Hellwig092d5d92016-11-24 11:39:49 +1100496 offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700497 if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &icur, &got))
Darrick J. Wongef473662016-10-03 09:11:34 -0700498 return false;
Christoph Hellwig092d5d92016-11-24 11:39:49 +1100499 if (got.br_startoff > offset_fsb)
Darrick J. Wongef473662016-10-03 09:11:34 -0700500 return false;
501
502 trace_xfs_reflink_find_cow_mapping(ip, offset, 1, XFS_IO_OVERWRITE,
Christoph Hellwig092d5d92016-11-24 11:39:49 +1100503 &got);
504 *imap = got;
Darrick J. Wongef473662016-10-03 09:11:34 -0700505 return true;
506}
507
508/*
509 * Trim an extent to end at the next CoW reservation past offset_fsb.
510 */
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100511void
Darrick J. Wongef473662016-10-03 09:11:34 -0700512xfs_reflink_trim_irec_to_next_cow(
513 struct xfs_inode *ip,
514 xfs_fileoff_t offset_fsb,
515 struct xfs_bmbt_irec *imap)
516{
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100517 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
518 struct xfs_bmbt_irec got;
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700519 struct xfs_iext_cursor icur;
Darrick J. Wongef473662016-10-03 09:11:34 -0700520
521 if (!xfs_is_reflink_inode(ip))
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100522 return;
Darrick J. Wongef473662016-10-03 09:11:34 -0700523
524 /* Find the extent in the CoW fork. */
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700525 if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &icur, &got))
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100526 return;
Darrick J. Wongef473662016-10-03 09:11:34 -0700527
528 /* This is the extent before; try sliding up one. */
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100529 if (got.br_startoff < offset_fsb) {
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700530 if (!xfs_iext_next_extent(ifp, &icur, &got))
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100531 return;
Darrick J. Wongef473662016-10-03 09:11:34 -0700532 }
533
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100534 if (got.br_startoff >= imap->br_startoff + imap->br_blockcount)
535 return;
Darrick J. Wongef473662016-10-03 09:11:34 -0700536
Christoph Hellwig86f12ab2016-11-24 11:39:50 +1100537 imap->br_blockcount = got.br_startoff - imap->br_startoff;
Darrick J. Wongef473662016-10-03 09:11:34 -0700538 trace_xfs_reflink_trim_irec(ip, imap);
Darrick J. Wongef473662016-10-03 09:11:34 -0700539}
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700540
541/*
Christoph Hellwig3802a342017-03-07 16:45:58 -0800542 * Cancel CoW reservations for some block range of an inode.
543 *
544 * If cancel_real is true this function cancels all COW fork extents for the
545 * inode; if cancel_real is false, real extents are not cleared.
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700546 */
547int
548xfs_reflink_cancel_cow_blocks(
549 struct xfs_inode *ip,
550 struct xfs_trans **tpp,
551 xfs_fileoff_t offset_fsb,
Christoph Hellwig3802a342017-03-07 16:45:58 -0800552 xfs_fileoff_t end_fsb,
553 bool cancel_real)
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700554{
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100555 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
Christoph Hellwigdf5ab1b2016-11-24 11:39:50 +1100556 struct xfs_bmbt_irec got, del;
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700557 struct xfs_iext_cursor icur;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700558 xfs_fsblock_t firstfsb;
559 struct xfs_defer_ops dfops;
Christoph Hellwigdf5ab1b2016-11-24 11:39:50 +1100560 int error = 0;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700561
562 if (!xfs_is_reflink_inode(ip))
563 return 0;
Christoph Hellwig41caabd2017-11-03 10:34:44 -0700564 if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100565 return 0;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700566
Christoph Hellwig41caabd2017-11-03 10:34:44 -0700567 /* Walk backwards until we're out of the I/O range... */
568 while (got.br_startoff + got.br_blockcount > offset_fsb) {
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100569 del = got;
570 xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
Christoph Hellwig41caabd2017-11-03 10:34:44 -0700571
572 /* Extent delete may have bumped ext forward */
573 if (!del.br_blockcount) {
574 xfs_iext_prev(ifp, &icur);
575 goto next_extent;
576 }
577
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100578 trace_xfs_reflink_cancel_cow(ip, &del);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700579
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100580 if (isnullstartblock(del.br_startblock)) {
581 error = xfs_bmap_del_extent_delay(ip, XFS_COW_FORK,
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700582 &icur, &got, &del);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700583 if (error)
584 break;
Christoph Hellwig3802a342017-03-07 16:45:58 -0800585 } else if (del.br_state == XFS_EXT_UNWRITTEN || cancel_real) {
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700586 xfs_trans_ijoin(*tpp, ip, 0);
587 xfs_defer_init(&dfops, &firstfsb);
588
Darrick J. Wong174edb02016-10-03 09:11:39 -0700589 /* Free the CoW orphan record. */
590 error = xfs_refcount_free_cow_extent(ip->i_mount,
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100591 &dfops, del.br_startblock,
592 del.br_blockcount);
Darrick J. Wong174edb02016-10-03 09:11:39 -0700593 if (error)
594 break;
595
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700596 xfs_bmap_add_free(ip->i_mount, &dfops,
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100597 del.br_startblock, del.br_blockcount,
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700598 NULL);
599
600 /* Update quota accounting */
601 xfs_trans_mod_dquot_byino(*tpp, ip, XFS_TRANS_DQ_BCOUNT,
Christoph Hellwig3e0ee782016-10-20 15:54:31 +1100602 -(long)del.br_blockcount);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700603
604 /* Roll the transaction */
Christoph Hellwig8ad7c6292017-08-28 10:21:04 -0700605 xfs_defer_ijoin(&dfops, ip);
606 error = xfs_defer_finish(tpp, &dfops);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700607 if (error) {
608 xfs_defer_cancel(&dfops);
609 break;
610 }
611
612 /* Remove the mapping from the CoW fork. */
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700613 xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700614 }
Christoph Hellwig41caabd2017-11-03 10:34:44 -0700615next_extent:
616 if (!xfs_iext_get_extent(ifp, &icur, &got))
Brian Fosterc17a8ef2016-10-24 14:21:08 +1100617 break;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700618 }
619
Brian Fosterc17a8ef2016-10-24 14:21:08 +1100620 /* clear tag if cow fork is emptied */
621 if (!ifp->if_bytes)
622 xfs_inode_clear_cowblocks_tag(ip);
623
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700624 return error;
625}
626
627/*
Christoph Hellwig3802a342017-03-07 16:45:58 -0800628 * Cancel CoW reservations for some byte range of an inode.
629 *
630 * If cancel_real is true this function cancels all COW fork extents for the
631 * inode; if cancel_real is false, real extents are not cleared.
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700632 */
633int
634xfs_reflink_cancel_cow_range(
635 struct xfs_inode *ip,
636 xfs_off_t offset,
Christoph Hellwig3802a342017-03-07 16:45:58 -0800637 xfs_off_t count,
638 bool cancel_real)
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700639{
640 struct xfs_trans *tp;
641 xfs_fileoff_t offset_fsb;
642 xfs_fileoff_t end_fsb;
643 int error;
644
645 trace_xfs_reflink_cancel_cow_range(ip, offset, count);
Darrick J. Wong63646fc2016-10-10 16:47:32 +1100646 ASSERT(xfs_is_reflink_inode(ip));
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700647
648 offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
649 if (count == NULLFILEOFF)
650 end_fsb = NULLFILEOFF;
651 else
652 end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
653
654 /* Start a rolling transaction to remove the mappings */
655 error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
656 0, 0, 0, &tp);
657 if (error)
658 goto out;
659
660 xfs_ilock(ip, XFS_ILOCK_EXCL);
661 xfs_trans_ijoin(tp, ip, 0);
662
663 /* Scrape out the old CoW reservations */
Christoph Hellwig3802a342017-03-07 16:45:58 -0800664 error = xfs_reflink_cancel_cow_blocks(ip, &tp, offset_fsb, end_fsb,
665 cancel_real);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700666 if (error)
667 goto out_cancel;
668
669 error = xfs_trans_commit(tp);
670
671 xfs_iunlock(ip, XFS_ILOCK_EXCL);
672 return error;
673
674out_cancel:
675 xfs_trans_cancel(tp);
676 xfs_iunlock(ip, XFS_ILOCK_EXCL);
677out:
678 trace_xfs_reflink_cancel_cow_range_error(ip, error, _RET_IP_);
679 return error;
680}
681
682/*
683 * Remap parts of a file's data fork after a successful CoW.
684 */
685int
686xfs_reflink_end_cow(
687 struct xfs_inode *ip,
688 xfs_off_t offset,
689 xfs_off_t count)
690{
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100691 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
Christoph Hellwig4ab86712016-11-24 11:39:50 +1100692 struct xfs_bmbt_irec got, del;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700693 struct xfs_trans *tp;
694 xfs_fileoff_t offset_fsb;
695 xfs_fileoff_t end_fsb;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700696 xfs_fsblock_t firstfsb;
697 struct xfs_defer_ops dfops;
Christoph Hellwig4ab86712016-11-24 11:39:50 +1100698 int error;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700699 unsigned int resblks;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700700 xfs_filblks_t rlen;
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700701 struct xfs_iext_cursor icur;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700702
703 trace_xfs_reflink_end_cow(ip, offset, count);
704
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100705 /* No COW extents? That's easy! */
706 if (ifp->if_bytes == 0)
707 return 0;
708
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700709 offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
710 end_fsb = XFS_B_TO_FSB(ip->i_mount, offset + count);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700711
Darrick J. Wongfe0be232017-04-12 12:26:07 -0700712 /*
713 * Start a rolling transaction to switch the mappings. We're
714 * unlikely ever to have to remap 16T worth of single-block
715 * extents, so just cap the worst case extent count to 2^32-1.
716 * Stick a warning in just in case, and avoid 64-bit division.
717 */
718 BUILD_BUG_ON(MAX_RW_COUNT > UINT_MAX);
719 if (end_fsb - offset_fsb > UINT_MAX) {
720 error = -EFSCORRUPTED;
721 xfs_force_shutdown(ip->i_mount, SHUTDOWN_CORRUPT_INCORE);
722 ASSERT(0);
723 goto out;
724 }
725 resblks = XFS_NEXTENTADD_SPACE_RES(ip->i_mount,
726 (unsigned int)(end_fsb - offset_fsb),
727 XFS_DATA_FORK);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700728 error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
729 resblks, 0, 0, &tp);
730 if (error)
731 goto out;
732
733 xfs_ilock(ip, XFS_ILOCK_EXCL);
734 xfs_trans_ijoin(tp, ip, 0);
735
Christoph Hellwigdc560152017-10-23 16:32:39 -0700736 /*
737 * In case of racing, overlapping AIO writes no COW extents might be
738 * left by the time I/O completes for the loser of the race. In that
739 * case we are done.
740 */
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700741 if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
Christoph Hellwigdc560152017-10-23 16:32:39 -0700742 goto out_cancel;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700743
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100744 /* Walk backwards until we're out of the I/O range... */
745 while (got.br_startoff + got.br_blockcount > offset_fsb) {
746 del = got;
747 xfs_trim_extent(&del, offset_fsb, end_fsb - offset_fsb);
748
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700749 /* Extent delete may have bumped ext forward */
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100750 if (!del.br_blockcount) {
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700751 xfs_iext_prev(ifp, &icur);
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700752 goto next_extent;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700753 }
754
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100755 ASSERT(!isnullstartblock(got.br_startblock));
756
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800757 /*
758 * Don't remap unwritten extents; these are
759 * speculatively preallocated CoW extents that have been
760 * allocated but have not yet been involved in a write.
761 */
762 if (got.br_state == XFS_EXT_UNWRITTEN) {
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700763 xfs_iext_prev(ifp, &icur);
Darrick J. Wong5eda4302017-02-02 15:14:02 -0800764 goto next_extent;
765 }
766
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100767 /* Unmap the old blocks in the data fork. */
768 xfs_defer_init(&dfops, &firstfsb);
769 rlen = del.br_blockcount;
770 error = __xfs_bunmapi(tp, ip, del.br_startoff, &rlen, 0, 1,
771 &firstfsb, &dfops);
772 if (error)
773 goto out_defer;
774
775 /* Trim the extent to whatever got unmapped. */
776 if (rlen) {
777 xfs_trim_extent(&del, del.br_startoff + rlen,
778 del.br_blockcount - rlen);
779 }
780 trace_xfs_reflink_cow_remap(ip, &del);
781
782 /* Free the CoW orphan record. */
783 error = xfs_refcount_free_cow_extent(tp->t_mountp, &dfops,
784 del.br_startblock, del.br_blockcount);
785 if (error)
786 goto out_defer;
787
788 /* Map the new blocks into the data fork. */
789 error = xfs_bmap_map_extent(tp->t_mountp, &dfops, ip, &del);
790 if (error)
791 goto out_defer;
792
793 /* Remove the mapping from the CoW fork. */
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700794 xfs_bmap_del_extent_cow(ip, &icur, &got, &del);
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100795
Christoph Hellwig8ad7c6292017-08-28 10:21:04 -0700796 xfs_defer_ijoin(&dfops, ip);
797 error = xfs_defer_finish(&tp, &dfops);
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100798 if (error)
799 goto out_defer;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700800next_extent:
Christoph Hellwigb2b17122017-11-03 10:34:43 -0700801 if (!xfs_iext_get_extent(ifp, &icur, &got))
Christoph Hellwigc1112b62016-10-20 15:54:45 +1100802 break;
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700803 }
804
805 error = xfs_trans_commit(tp);
806 xfs_iunlock(ip, XFS_ILOCK_EXCL);
807 if (error)
808 goto out;
809 return 0;
810
811out_defer:
812 xfs_defer_cancel(&dfops);
Christoph Hellwige12199f2017-10-03 08:58:33 -0700813out_cancel:
Darrick J. Wong43caeb12016-10-03 09:11:35 -0700814 xfs_trans_cancel(tp);
815 xfs_iunlock(ip, XFS_ILOCK_EXCL);
816out:
817 trace_xfs_reflink_end_cow_error(ip, error, _RET_IP_);
818 return error;
819}
Darrick J. Wong174edb02016-10-03 09:11:39 -0700820
821/*
822 * Free leftover CoW reservations that didn't get cleaned out.
823 */
824int
825xfs_reflink_recover_cow(
826 struct xfs_mount *mp)
827{
828 xfs_agnumber_t agno;
829 int error = 0;
830
831 if (!xfs_sb_version_hasreflink(&mp->m_sb))
832 return 0;
833
834 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
835 error = xfs_refcount_recover_cow_leftovers(mp, agno);
836 if (error)
837 break;
838 }
839
840 return error;
841}
Darrick J. Wong862bb362016-10-03 09:11:40 -0700842
843/*
844 * Reflinking (Block) Ranges of Two Files Together
845 *
846 * First, ensure that the reflink flag is set on both inodes. The flag is an
847 * optimization to avoid unnecessary refcount btree lookups in the write path.
848 *
849 * Now we can iteratively remap the range of extents (and holes) in src to the
850 * corresponding ranges in dest. Let drange and srange denote the ranges of
851 * logical blocks in dest and src touched by the reflink operation.
852 *
853 * While the length of drange is greater than zero,
854 * - Read src's bmbt at the start of srange ("imap")
855 * - If imap doesn't exist, make imap appear to start at the end of srange
856 * with zero length.
857 * - If imap starts before srange, advance imap to start at srange.
858 * - If imap goes beyond srange, truncate imap to end at the end of srange.
859 * - Punch (imap start - srange start + imap len) blocks from dest at
860 * offset (drange start).
861 * - If imap points to a real range of pblks,
862 * > Increase the refcount of the imap's pblks
863 * > Map imap's pblks into dest at the offset
864 * (drange start + imap start - srange start)
865 * - Advance drange and srange by (imap start - srange start + imap len)
866 *
867 * Finally, if the reflink made dest longer, update both the in-core and
868 * on-disk file sizes.
869 *
870 * ASCII Art Demonstration:
871 *
872 * Let's say we want to reflink this source file:
873 *
874 * ----SSSSSSS-SSSSS----SSSSSS (src file)
875 * <-------------------->
876 *
877 * into this destination file:
878 *
879 * --DDDDDDDDDDDDDDDDDDD--DDD (dest file)
880 * <-------------------->
881 * '-' means a hole, and 'S' and 'D' are written blocks in the src and dest.
882 * Observe that the range has different logical offsets in either file.
883 *
884 * Consider that the first extent in the source file doesn't line up with our
885 * reflink range. Unmapping and remapping are separate operations, so we can
886 * unmap more blocks from the destination file than we remap.
887 *
888 * ----SSSSSSS-SSSSS----SSSSSS
889 * <------->
890 * --DDDDD---------DDDDD--DDD
891 * <------->
892 *
893 * Now remap the source extent into the destination file:
894 *
895 * ----SSSSSSS-SSSSS----SSSSSS
896 * <------->
897 * --DDDDD--SSSSSSSDDDDD--DDD
898 * <------->
899 *
900 * Do likewise with the second hole and extent in our range. Holes in the
901 * unmap range don't affect our operation.
902 *
903 * ----SSSSSSS-SSSSS----SSSSSS
904 * <---->
905 * --DDDDD--SSSSSSS-SSSSS-DDD
906 * <---->
907 *
908 * Finally, unmap and remap part of the third extent. This will increase the
909 * size of the destination file.
910 *
911 * ----SSSSSSS-SSSSS----SSSSSS
912 * <----->
913 * --DDDDD--SSSSSSS-SSSSS----SSS
914 * <----->
915 *
916 * Once we update the destination file's i_size, we're done.
917 */
918
919/*
920 * Ensure the reflink bit is set in both inodes.
921 */
922STATIC int
923xfs_reflink_set_inode_flag(
924 struct xfs_inode *src,
925 struct xfs_inode *dest)
926{
927 struct xfs_mount *mp = src->i_mount;
928 int error;
929 struct xfs_trans *tp;
930
931 if (xfs_is_reflink_inode(src) && xfs_is_reflink_inode(dest))
932 return 0;
933
934 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
935 if (error)
936 goto out_error;
937
938 /* Lock both files against IO */
939 if (src->i_ino == dest->i_ino)
940 xfs_ilock(src, XFS_ILOCK_EXCL);
941 else
942 xfs_lock_two_inodes(src, dest, XFS_ILOCK_EXCL);
943
944 if (!xfs_is_reflink_inode(src)) {
945 trace_xfs_reflink_set_inode_flag(src);
946 xfs_trans_ijoin(tp, src, XFS_ILOCK_EXCL);
947 src->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK;
948 xfs_trans_log_inode(tp, src, XFS_ILOG_CORE);
949 xfs_ifork_init_cow(src);
950 } else
951 xfs_iunlock(src, XFS_ILOCK_EXCL);
952
953 if (src->i_ino == dest->i_ino)
954 goto commit_flags;
955
956 if (!xfs_is_reflink_inode(dest)) {
957 trace_xfs_reflink_set_inode_flag(dest);
958 xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
959 dest->i_d.di_flags2 |= XFS_DIFLAG2_REFLINK;
960 xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
961 xfs_ifork_init_cow(dest);
962 } else
963 xfs_iunlock(dest, XFS_ILOCK_EXCL);
964
965commit_flags:
966 error = xfs_trans_commit(tp);
967 if (error)
968 goto out_error;
969 return error;
970
971out_error:
972 trace_xfs_reflink_set_inode_flag_error(dest, error, _RET_IP_);
973 return error;
974}
975
976/*
Darrick J. Wongf7ca3522016-10-03 09:11:43 -0700977 * Update destination inode size & cowextsize hint, if necessary.
Darrick J. Wong862bb362016-10-03 09:11:40 -0700978 */
979STATIC int
980xfs_reflink_update_dest(
981 struct xfs_inode *dest,
Darrick J. Wongf7ca3522016-10-03 09:11:43 -0700982 xfs_off_t newlen,
Christoph Hellwigc5ecb422017-02-06 17:45:51 -0800983 xfs_extlen_t cowextsize,
984 bool is_dedupe)
Darrick J. Wong862bb362016-10-03 09:11:40 -0700985{
986 struct xfs_mount *mp = dest->i_mount;
987 struct xfs_trans *tp;
988 int error;
989
Christoph Hellwigc5ecb422017-02-06 17:45:51 -0800990 if (is_dedupe && newlen <= i_size_read(VFS_I(dest)) && cowextsize == 0)
Darrick J. Wong862bb362016-10-03 09:11:40 -0700991 return 0;
992
993 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
994 if (error)
995 goto out_error;
996
997 xfs_ilock(dest, XFS_ILOCK_EXCL);
998 xfs_trans_ijoin(tp, dest, XFS_ILOCK_EXCL);
999
Darrick J. Wongf7ca3522016-10-03 09:11:43 -07001000 if (newlen > i_size_read(VFS_I(dest))) {
1001 trace_xfs_reflink_update_inode_size(dest, newlen);
1002 i_size_write(VFS_I(dest), newlen);
1003 dest->i_d.di_size = newlen;
1004 }
1005
1006 if (cowextsize) {
1007 dest->i_d.di_cowextsize = cowextsize;
1008 dest->i_d.di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
1009 }
1010
Christoph Hellwigc5ecb422017-02-06 17:45:51 -08001011 if (!is_dedupe) {
1012 xfs_trans_ichgtime(tp, dest,
1013 XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1014 }
Darrick J. Wong862bb362016-10-03 09:11:40 -07001015 xfs_trans_log_inode(tp, dest, XFS_ILOG_CORE);
1016
1017 error = xfs_trans_commit(tp);
1018 if (error)
1019 goto out_error;
1020 return error;
1021
1022out_error:
1023 trace_xfs_reflink_update_inode_size_error(dest, error, _RET_IP_);
1024 return error;
1025}
1026
1027/*
Darrick J. Wong6fa164b2016-10-03 09:11:45 -07001028 * Do we have enough reserve in this AG to handle a reflink? The refcount
1029 * btree already reserved all the space it needs, but the rmap btree can grow
1030 * infinitely, so we won't allow more reflinks when the AG is down to the
1031 * btree reserves.
1032 */
1033static int
1034xfs_reflink_ag_has_free_space(
1035 struct xfs_mount *mp,
1036 xfs_agnumber_t agno)
1037{
1038 struct xfs_perag *pag;
1039 int error = 0;
1040
1041 if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
1042 return 0;
1043
1044 pag = xfs_perag_get(mp, agno);
1045 if (xfs_ag_resv_critical(pag, XFS_AG_RESV_AGFL) ||
1046 xfs_ag_resv_critical(pag, XFS_AG_RESV_METADATA))
1047 error = -ENOSPC;
1048 xfs_perag_put(pag);
1049 return error;
1050}
1051
1052/*
Darrick J. Wong862bb362016-10-03 09:11:40 -07001053 * Unmap a range of blocks from a file, then map other blocks into the hole.
1054 * The range to unmap is (destoff : destoff + srcioff + irec->br_blockcount).
1055 * The extent irec is mapped into dest at irec->br_startoff.
1056 */
1057STATIC int
1058xfs_reflink_remap_extent(
1059 struct xfs_inode *ip,
1060 struct xfs_bmbt_irec *irec,
1061 xfs_fileoff_t destoff,
1062 xfs_off_t new_isize)
1063{
1064 struct xfs_mount *mp = ip->i_mount;
Christoph Hellwig9c4f29d2017-03-28 14:53:35 -07001065 bool real_extent = xfs_bmap_is_real_extent(irec);
Darrick J. Wong862bb362016-10-03 09:11:40 -07001066 struct xfs_trans *tp;
1067 xfs_fsblock_t firstfsb;
1068 unsigned int resblks;
1069 struct xfs_defer_ops dfops;
1070 struct xfs_bmbt_irec uirec;
Darrick J. Wong862bb362016-10-03 09:11:40 -07001071 xfs_filblks_t rlen;
1072 xfs_filblks_t unmap_len;
1073 xfs_off_t newlen;
1074 int error;
1075
1076 unmap_len = irec->br_startoff + irec->br_blockcount - destoff;
1077 trace_xfs_reflink_punch_range(ip, destoff, unmap_len);
1078
Darrick J. Wong6fa164b2016-10-03 09:11:45 -07001079 /* No reflinking if we're low on space */
1080 if (real_extent) {
1081 error = xfs_reflink_ag_has_free_space(mp,
1082 XFS_FSB_TO_AGNO(mp, irec->br_startblock));
1083 if (error)
1084 goto out;
1085 }
1086
Darrick J. Wong862bb362016-10-03 09:11:40 -07001087 /* Start a rolling transaction to switch the mappings */
1088 resblks = XFS_EXTENTADD_SPACE_RES(ip->i_mount, XFS_DATA_FORK);
1089 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, 0, &tp);
1090 if (error)
1091 goto out;
1092
1093 xfs_ilock(ip, XFS_ILOCK_EXCL);
1094 xfs_trans_ijoin(tp, ip, 0);
1095
1096 /* If we're not just clearing space, then do we have enough quota? */
1097 if (real_extent) {
1098 error = xfs_trans_reserve_quota_nblks(tp, ip,
1099 irec->br_blockcount, 0, XFS_QMOPT_RES_REGBLKS);
1100 if (error)
1101 goto out_cancel;
1102 }
1103
1104 trace_xfs_reflink_remap(ip, irec->br_startoff,
1105 irec->br_blockcount, irec->br_startblock);
1106
1107 /* Unmap the old blocks in the data fork. */
1108 rlen = unmap_len;
1109 while (rlen) {
1110 xfs_defer_init(&dfops, &firstfsb);
1111 error = __xfs_bunmapi(tp, ip, destoff, &rlen, 0, 1,
1112 &firstfsb, &dfops);
1113 if (error)
1114 goto out_defer;
1115
1116 /*
1117 * Trim the extent to whatever got unmapped.
1118 * Remember, bunmapi works backwards.
1119 */
1120 uirec.br_startblock = irec->br_startblock + rlen;
1121 uirec.br_startoff = irec->br_startoff + rlen;
1122 uirec.br_blockcount = unmap_len - rlen;
1123 unmap_len = rlen;
1124
1125 /* If this isn't a real mapping, we're done. */
1126 if (!real_extent || uirec.br_blockcount == 0)
1127 goto next_extent;
1128
1129 trace_xfs_reflink_remap(ip, uirec.br_startoff,
1130 uirec.br_blockcount, uirec.br_startblock);
1131
1132 /* Update the refcount tree */
1133 error = xfs_refcount_increase_extent(mp, &dfops, &uirec);
1134 if (error)
1135 goto out_defer;
1136
1137 /* Map the new blocks into the data fork. */
1138 error = xfs_bmap_map_extent(mp, &dfops, ip, &uirec);
1139 if (error)
1140 goto out_defer;
1141
1142 /* Update quota accounting. */
1143 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT,
1144 uirec.br_blockcount);
1145
1146 /* Update dest isize if needed. */
1147 newlen = XFS_FSB_TO_B(mp,
1148 uirec.br_startoff + uirec.br_blockcount);
1149 newlen = min_t(xfs_off_t, newlen, new_isize);
1150 if (newlen > i_size_read(VFS_I(ip))) {
1151 trace_xfs_reflink_update_inode_size(ip, newlen);
1152 i_size_write(VFS_I(ip), newlen);
1153 ip->i_d.di_size = newlen;
1154 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1155 }
1156
1157next_extent:
1158 /* Process all the deferred stuff. */
Christoph Hellwig8ad7c6292017-08-28 10:21:04 -07001159 xfs_defer_ijoin(&dfops, ip);
1160 error = xfs_defer_finish(&tp, &dfops);
Darrick J. Wong862bb362016-10-03 09:11:40 -07001161 if (error)
1162 goto out_defer;
1163 }
1164
1165 error = xfs_trans_commit(tp);
1166 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1167 if (error)
1168 goto out;
1169 return 0;
1170
1171out_defer:
1172 xfs_defer_cancel(&dfops);
1173out_cancel:
1174 xfs_trans_cancel(tp);
1175 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1176out:
1177 trace_xfs_reflink_remap_extent_error(ip, error, _RET_IP_);
1178 return error;
1179}
1180
1181/*
1182 * Iteratively remap one file's extents (and holes) to another's.
1183 */
1184STATIC int
1185xfs_reflink_remap_blocks(
1186 struct xfs_inode *src,
1187 xfs_fileoff_t srcoff,
1188 struct xfs_inode *dest,
1189 xfs_fileoff_t destoff,
1190 xfs_filblks_t len,
1191 xfs_off_t new_isize)
1192{
1193 struct xfs_bmbt_irec imap;
1194 int nimaps;
1195 int error = 0;
1196 xfs_filblks_t range_len;
1197
1198 /* drange = (destoff, destoff + len); srange = (srcoff, srcoff + len) */
1199 while (len) {
1200 trace_xfs_reflink_remap_blocks_loop(src, srcoff, len,
1201 dest, destoff);
1202 /* Read extent from the source file */
1203 nimaps = 1;
1204 xfs_ilock(src, XFS_ILOCK_EXCL);
1205 error = xfs_bmapi_read(src, srcoff, len, &imap, &nimaps, 0);
1206 xfs_iunlock(src, XFS_ILOCK_EXCL);
1207 if (error)
1208 goto err;
1209 ASSERT(nimaps == 1);
1210
1211 trace_xfs_reflink_remap_imap(src, srcoff, len, XFS_IO_OVERWRITE,
1212 &imap);
1213
1214 /* Translate imap into the destination file. */
1215 range_len = imap.br_startoff + imap.br_blockcount - srcoff;
1216 imap.br_startoff += destoff - srcoff;
1217
1218 /* Clear dest from destoff to the end of imap and map it in. */
1219 error = xfs_reflink_remap_extent(dest, &imap, destoff,
1220 new_isize);
1221 if (error)
1222 goto err;
1223
1224 if (fatal_signal_pending(current)) {
1225 error = -EINTR;
1226 goto err;
1227 }
1228
1229 /* Advance drange/srange */
1230 srcoff += range_len;
1231 destoff += range_len;
1232 len -= range_len;
1233 }
1234
1235 return 0;
1236
1237err:
1238 trace_xfs_reflink_remap_blocks_error(dest, error, _RET_IP_);
1239 return error;
1240}
1241
1242/*
1243 * Link a range of blocks from one file to another.
1244 */
1245int
1246xfs_reflink_remap_range(
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001247 struct file *file_in,
1248 loff_t pos_in,
1249 struct file *file_out,
1250 loff_t pos_out,
1251 u64 len,
1252 bool is_dedupe)
Darrick J. Wong862bb362016-10-03 09:11:40 -07001253{
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001254 struct inode *inode_in = file_inode(file_in);
1255 struct xfs_inode *src = XFS_I(inode_in);
1256 struct inode *inode_out = file_inode(file_out);
1257 struct xfs_inode *dest = XFS_I(inode_out);
Darrick J. Wong862bb362016-10-03 09:11:40 -07001258 struct xfs_mount *mp = src->i_mount;
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001259 bool same_inode = (inode_in == inode_out);
Darrick J. Wong862bb362016-10-03 09:11:40 -07001260 xfs_fileoff_t sfsbno, dfsbno;
1261 xfs_filblks_t fsblen;
Darrick J. Wongf7ca3522016-10-03 09:11:43 -07001262 xfs_extlen_t cowextsize;
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001263 ssize_t ret;
Darrick J. Wong862bb362016-10-03 09:11:40 -07001264
1265 if (!xfs_sb_version_hasreflink(&mp->m_sb))
1266 return -EOPNOTSUPP;
1267
1268 if (XFS_FORCED_SHUTDOWN(mp))
1269 return -EIO;
1270
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001271 /* Lock both files against IO */
Christoph Hellwig65523212016-11-30 14:33:25 +11001272 lock_two_nondirectories(inode_in, inode_out);
1273 if (same_inode)
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001274 xfs_ilock(src, XFS_MMAPLOCK_EXCL);
Christoph Hellwig65523212016-11-30 14:33:25 +11001275 else
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001276 xfs_lock_two_inodes(src, dest, XFS_MMAPLOCK_EXCL);
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001277
Darrick J. Wong876bec6f2016-12-09 16:18:30 -08001278 /* Check file eligibility and prepare for block sharing. */
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001279 ret = -EINVAL;
Darrick J. Wong862bb362016-10-03 09:11:40 -07001280 /* Don't reflink realtime inodes */
1281 if (XFS_IS_REALTIME_INODE(src) || XFS_IS_REALTIME_INODE(dest))
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001282 goto out_unlock;
Darrick J. Wong862bb362016-10-03 09:11:40 -07001283
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001284 /* Don't share DAX file data for now. */
1285 if (IS_DAX(inode_in) || IS_DAX(inode_out))
1286 goto out_unlock;
Darrick J. Wongcc714662016-10-03 09:11:41 -07001287
Darrick J. Wong876bec6f2016-12-09 16:18:30 -08001288 ret = vfs_clone_file_prep_inodes(inode_in, pos_in, inode_out, pos_out,
1289 &len, is_dedupe);
Darrick J. Wong22725ce2016-12-19 15:13:26 -08001290 if (ret <= 0)
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001291 goto out_unlock;
1292
1293 trace_xfs_reflink_remap_range(src, pos_in, len, dest, pos_out);
Darrick J. Wong862bb362016-10-03 09:11:40 -07001294
Darrick J. Wong5c989a02017-12-10 18:03:54 -08001295 /*
1296 * Clear out post-eof preallocations because we don't have page cache
1297 * backing the delayed allocations and they'll never get freed on
1298 * their own.
1299 */
1300 if (xfs_can_free_eofblocks(dest, true)) {
1301 ret = xfs_free_eofblocks(dest);
1302 if (ret)
1303 goto out_unlock;
1304 }
1305
Darrick J. Wong876bec6f2016-12-09 16:18:30 -08001306 /* Set flags and remap blocks. */
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001307 ret = xfs_reflink_set_inode_flag(src, dest);
1308 if (ret)
1309 goto out_unlock;
Darrick J. Wong862bb362016-10-03 09:11:40 -07001310
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001311 dfsbno = XFS_B_TO_FSBT(mp, pos_out);
1312 sfsbno = XFS_B_TO_FSBT(mp, pos_in);
Darrick J. Wong862bb362016-10-03 09:11:40 -07001313 fsblen = XFS_B_TO_FSB(mp, len);
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001314 ret = xfs_reflink_remap_blocks(src, sfsbno, dest, dfsbno, fsblen,
1315 pos_out + len);
1316 if (ret)
1317 goto out_unlock;
Darrick J. Wong862bb362016-10-03 09:11:40 -07001318
Darrick J. Wong876bec6f2016-12-09 16:18:30 -08001319 /* Zap any page cache for the destination file's range. */
1320 truncate_inode_pages_range(&inode_out->i_data, pos_out,
1321 PAGE_ALIGN(pos_out + len) - 1);
1322
Darrick J. Wongf7ca3522016-10-03 09:11:43 -07001323 /*
1324 * Carry the cowextsize hint from src to dest if we're sharing the
1325 * entire source file to the entire destination file, the source file
1326 * has a cowextsize hint, and the destination file does not.
1327 */
1328 cowextsize = 0;
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001329 if (pos_in == 0 && len == i_size_read(inode_in) &&
Darrick J. Wongf7ca3522016-10-03 09:11:43 -07001330 (src->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE) &&
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001331 pos_out == 0 && len >= i_size_read(inode_out) &&
Darrick J. Wongf7ca3522016-10-03 09:11:43 -07001332 !(dest->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
1333 cowextsize = src->i_d.di_cowextsize;
1334
Christoph Hellwigc5ecb422017-02-06 17:45:51 -08001335 ret = xfs_reflink_update_dest(dest, pos_out + len, cowextsize,
1336 is_dedupe);
Darrick J. Wong862bb362016-10-03 09:11:40 -07001337
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001338out_unlock:
1339 xfs_iunlock(src, XFS_MMAPLOCK_EXCL);
Christoph Hellwig65523212016-11-30 14:33:25 +11001340 if (!same_inode)
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001341 xfs_iunlock(dest, XFS_MMAPLOCK_EXCL);
Christoph Hellwig65523212016-11-30 14:33:25 +11001342 unlock_two_nondirectories(inode_in, inode_out);
Christoph Hellwig5faaf4f2016-10-20 15:50:07 +11001343 if (ret)
1344 trace_xfs_reflink_remap_range_error(dest, ret, _RET_IP_);
1345 return ret;
Darrick J. Wong862bb362016-10-03 09:11:40 -07001346}
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001347
1348/*
1349 * The user wants to preemptively CoW all shared blocks in this file,
1350 * which enables us to turn off the reflink flag. Iterate all
1351 * extents which are not prealloc/delalloc to see which ranges are
1352 * mentioned in the refcount tree, then read those blocks into the
1353 * pagecache, dirty them, fsync them back out, and then we can update
1354 * the inode flag. What happens if we run out of memory? :)
1355 */
1356STATIC int
1357xfs_reflink_dirty_extents(
1358 struct xfs_inode *ip,
1359 xfs_fileoff_t fbno,
1360 xfs_filblks_t end,
1361 xfs_off_t isize)
1362{
1363 struct xfs_mount *mp = ip->i_mount;
1364 xfs_agnumber_t agno;
1365 xfs_agblock_t agbno;
1366 xfs_extlen_t aglen;
1367 xfs_agblock_t rbno;
1368 xfs_extlen_t rlen;
1369 xfs_off_t fpos;
1370 xfs_off_t flen;
1371 struct xfs_bmbt_irec map[2];
1372 int nmaps;
Darrick J. Wong9780643c2016-10-10 16:49:18 +11001373 int error = 0;
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001374
1375 while (end - fbno > 0) {
1376 nmaps = 1;
1377 /*
1378 * Look for extents in the file. Skip holes, delalloc, or
1379 * unwritten extents; they can't be reflinked.
1380 */
1381 error = xfs_bmapi_read(ip, fbno, end - fbno, map, &nmaps, 0);
1382 if (error)
1383 goto out;
1384 if (nmaps == 0)
1385 break;
Christoph Hellwig9c4f29d2017-03-28 14:53:35 -07001386 if (!xfs_bmap_is_real_extent(&map[0]))
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001387 goto next;
1388
1389 map[1] = map[0];
1390 while (map[1].br_blockcount) {
1391 agno = XFS_FSB_TO_AGNO(mp, map[1].br_startblock);
1392 agbno = XFS_FSB_TO_AGBNO(mp, map[1].br_startblock);
1393 aglen = map[1].br_blockcount;
1394
Darrick J. Wong92ff7282017-06-16 11:00:10 -07001395 error = xfs_reflink_find_shared(mp, NULL, agno, agbno,
1396 aglen, &rbno, &rlen, true);
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001397 if (error)
1398 goto out;
1399 if (rbno == NULLAGBLOCK)
1400 break;
1401
1402 /* Dirty the pages */
1403 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1404 fpos = XFS_FSB_TO_B(mp, map[1].br_startoff +
1405 (rbno - agbno));
1406 flen = XFS_FSB_TO_B(mp, rlen);
1407 if (fpos + flen > isize)
1408 flen = isize - fpos;
1409 error = iomap_file_dirty(VFS_I(ip), fpos, flen,
1410 &xfs_iomap_ops);
1411 xfs_ilock(ip, XFS_ILOCK_EXCL);
1412 if (error)
1413 goto out;
1414
1415 map[1].br_blockcount -= (rbno - agbno + rlen);
1416 map[1].br_startoff += (rbno - agbno + rlen);
1417 map[1].br_startblock += (rbno - agbno + rlen);
1418 }
1419
1420next:
1421 fbno = map[0].br_startoff + map[0].br_blockcount;
1422 }
1423out:
1424 return error;
1425}
1426
Darrick J. Wongea7cdd72017-06-16 11:00:11 -07001427/* Does this inode need the reflink flag? */
1428int
1429xfs_reflink_inode_has_shared_extents(
1430 struct xfs_trans *tp,
1431 struct xfs_inode *ip,
1432 bool *has_shared)
1433{
1434 struct xfs_bmbt_irec got;
1435 struct xfs_mount *mp = ip->i_mount;
1436 struct xfs_ifork *ifp;
1437 xfs_agnumber_t agno;
1438 xfs_agblock_t agbno;
1439 xfs_extlen_t aglen;
1440 xfs_agblock_t rbno;
1441 xfs_extlen_t rlen;
Christoph Hellwigb2b17122017-11-03 10:34:43 -07001442 struct xfs_iext_cursor icur;
Darrick J. Wongea7cdd72017-06-16 11:00:11 -07001443 bool found;
1444 int error;
1445
1446 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1447 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1448 error = xfs_iread_extents(tp, ip, XFS_DATA_FORK);
1449 if (error)
1450 return error;
1451 }
1452
1453 *has_shared = false;
Christoph Hellwigb2b17122017-11-03 10:34:43 -07001454 found = xfs_iext_lookup_extent(ip, ifp, 0, &icur, &got);
Darrick J. Wongea7cdd72017-06-16 11:00:11 -07001455 while (found) {
1456 if (isnullstartblock(got.br_startblock) ||
1457 got.br_state != XFS_EXT_NORM)
1458 goto next;
1459 agno = XFS_FSB_TO_AGNO(mp, got.br_startblock);
1460 agbno = XFS_FSB_TO_AGBNO(mp, got.br_startblock);
1461 aglen = got.br_blockcount;
1462
1463 error = xfs_reflink_find_shared(mp, tp, agno, agbno, aglen,
1464 &rbno, &rlen, false);
1465 if (error)
1466 return error;
1467 /* Is there still a shared block here? */
1468 if (rbno != NULLAGBLOCK) {
1469 *has_shared = true;
1470 return 0;
1471 }
1472next:
Christoph Hellwigb2b17122017-11-03 10:34:43 -07001473 found = xfs_iext_next_extent(ifp, &icur, &got);
Darrick J. Wongea7cdd72017-06-16 11:00:11 -07001474 }
1475
1476 return 0;
1477}
1478
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001479/* Clear the inode reflink flag if there are no shared extents. */
1480int
1481xfs_reflink_clear_inode_flag(
1482 struct xfs_inode *ip,
1483 struct xfs_trans **tpp)
1484{
Darrick J. Wongea7cdd72017-06-16 11:00:11 -07001485 bool needs_flag;
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001486 int error = 0;
1487
Darrick J. Wong63646fc2016-10-10 16:47:32 +11001488 ASSERT(xfs_is_reflink_inode(ip));
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001489
Darrick J. Wongea7cdd72017-06-16 11:00:11 -07001490 error = xfs_reflink_inode_has_shared_extents(*tpp, ip, &needs_flag);
1491 if (error || needs_flag)
1492 return error;
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001493
1494 /*
1495 * We didn't find any shared blocks so turn off the reflink flag.
1496 * First, get rid of any leftover CoW mappings.
1497 */
Christoph Hellwig3802a342017-03-07 16:45:58 -08001498 error = xfs_reflink_cancel_cow_blocks(ip, tpp, 0, NULLFILEOFF, true);
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001499 if (error)
1500 return error;
1501
1502 /* Clear the inode flag. */
1503 trace_xfs_reflink_unset_inode_flag(ip);
1504 ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
Darrick J. Wong83104d42016-10-03 09:11:46 -07001505 xfs_inode_clear_cowblocks_tag(ip);
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001506 xfs_trans_ijoin(*tpp, ip, 0);
1507 xfs_trans_log_inode(*tpp, ip, XFS_ILOG_CORE);
1508
1509 return error;
1510}
1511
1512/*
1513 * Clear the inode reflink flag if there are no shared extents and the size
1514 * hasn't changed.
1515 */
1516STATIC int
1517xfs_reflink_try_clear_inode_flag(
Darrick J. Wong97a1b872016-10-10 16:49:01 +11001518 struct xfs_inode *ip)
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001519{
1520 struct xfs_mount *mp = ip->i_mount;
1521 struct xfs_trans *tp;
1522 int error = 0;
1523
1524 /* Start a rolling transaction to remove the mappings */
1525 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1526 if (error)
1527 return error;
1528
1529 xfs_ilock(ip, XFS_ILOCK_EXCL);
1530 xfs_trans_ijoin(tp, ip, 0);
1531
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001532 error = xfs_reflink_clear_inode_flag(ip, &tp);
1533 if (error)
1534 goto cancel;
1535
1536 error = xfs_trans_commit(tp);
1537 if (error)
1538 goto out;
1539
1540 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1541 return 0;
1542cancel:
1543 xfs_trans_cancel(tp);
1544out:
1545 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1546 return error;
1547}
1548
1549/*
1550 * Pre-COW all shared blocks within a given byte range of a file and turn off
1551 * the reflink flag if we unshare all of the file's blocks.
1552 */
1553int
1554xfs_reflink_unshare(
1555 struct xfs_inode *ip,
1556 xfs_off_t offset,
1557 xfs_off_t len)
1558{
1559 struct xfs_mount *mp = ip->i_mount;
1560 xfs_fileoff_t fbno;
1561 xfs_filblks_t end;
1562 xfs_off_t isize;
1563 int error;
1564
1565 if (!xfs_is_reflink_inode(ip))
1566 return 0;
1567
1568 trace_xfs_reflink_unshare(ip, offset, len);
1569
1570 inode_dio_wait(VFS_I(ip));
1571
1572 /* Try to CoW the selected ranges */
1573 xfs_ilock(ip, XFS_ILOCK_EXCL);
Darrick J. Wong97a1b872016-10-10 16:49:01 +11001574 fbno = XFS_B_TO_FSBT(mp, offset);
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001575 isize = i_size_read(VFS_I(ip));
1576 end = XFS_B_TO_FSB(mp, offset + len);
1577 error = xfs_reflink_dirty_extents(ip, fbno, end, isize);
1578 if (error)
1579 goto out_unlock;
1580 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1581
1582 /* Wait for the IO to finish */
1583 error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1584 if (error)
1585 goto out;
1586
Darrick J. Wong97a1b872016-10-10 16:49:01 +11001587 /* Turn off the reflink flag if possible. */
1588 error = xfs_reflink_try_clear_inode_flag(ip);
1589 if (error)
1590 goto out;
Darrick J. Wong98cc2db2016-10-03 09:11:43 -07001591
1592 return 0;
1593
1594out_unlock:
1595 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1596out:
1597 trace_xfs_reflink_unshare_error(ip, error, _RET_IP_);
1598 return error;
1599}