Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4 : * Copyright (c) 2012 Red Hat, Inc.
5 : * All Rights Reserved.
6 : */
7 : #include "xfs.h"
8 : #include "xfs_fs.h"
9 : #include "xfs_shared.h"
10 : #include "xfs_format.h"
11 : #include "xfs_log_format.h"
12 : #include "xfs_trans_resv.h"
13 : #include "xfs_bit.h"
14 : #include "xfs_mount.h"
15 : #include "xfs_defer.h"
16 : #include "xfs_inode.h"
17 : #include "xfs_btree.h"
18 : #include "xfs_trans.h"
19 : #include "xfs_alloc.h"
20 : #include "xfs_bmap.h"
21 : #include "xfs_bmap_util.h"
22 : #include "xfs_bmap_btree.h"
23 : #include "xfs_rtalloc.h"
24 : #include "xfs_error.h"
25 : #include "xfs_quota.h"
26 : #include "xfs_trans_space.h"
27 : #include "xfs_trace.h"
28 : #include "xfs_icache.h"
29 : #include "xfs_iomap.h"
30 : #include "xfs_reflink.h"
31 :
32 : /* Kernel only BMAP related definitions and functions */
33 :
34 : /*
35 : * Convert the given file system block to a disk block. We have to treat it
36 : * differently based on whether the file is a real time file or not, because the
37 : * bmap code does.
38 : */
39 : xfs_daddr_t
40 81844166 : xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
41 : {
42 81844166 : if (XFS_IS_REALTIME_INODE(ip))
43 19452860 : return XFS_FSB_TO_BB(ip->i_mount, fsb);
44 62391573 : return XFS_FSB_TO_DADDR(ip->i_mount, fsb);
45 : }
46 :
47 : /*
48 : * Routine to zero an extent on disk allocated to the specific inode.
49 : *
50 : * The VFS functions take a linearised filesystem block offset, so we have to
51 : * convert the sparse xfs fsb to the right format first.
52 : * VFS types are real funky, too.
53 : */
54 : int
55 0 : xfs_zero_extent(
56 : struct xfs_inode *ip,
57 : xfs_fsblock_t start_fsb,
58 : xfs_off_t count_fsb)
59 : {
60 0 : struct xfs_mount *mp = ip->i_mount;
61 0 : struct xfs_buftarg *target = xfs_inode_buftarg(ip);
62 0 : xfs_daddr_t sector = xfs_fsb_to_db(ip, start_fsb);
63 0 : sector_t block = XFS_BB_TO_FSBT(mp, sector);
64 :
65 0 : return blkdev_issue_zeroout(target->bt_bdev,
66 0 : block << (mp->m_super->s_blocksize_bits - 9),
67 0 : count_fsb << (mp->m_super->s_blocksize_bits - 9),
68 : GFP_NOFS, 0);
69 : }
70 :
71 : #ifdef CONFIG_XFS_RT
72 : int
73 6825143 : xfs_bmap_rtalloc(
74 : struct xfs_bmalloca *ap)
75 : {
76 6825143 : struct xfs_mount *mp = ap->ip->i_mount;
77 6825143 : xfs_fileoff_t orig_offset = ap->offset;
78 6825143 : xfs_rtblock_t rtb;
79 6825143 : xfs_extlen_t prod = 0; /* product factor for allocators */
80 6825143 : xfs_extlen_t mod = 0; /* product factor for allocators */
81 6825143 : xfs_extlen_t ralen = 0; /* realtime allocation length */
82 6825143 : xfs_extlen_t align; /* minimum allocation alignment */
83 6825143 : xfs_extlen_t orig_length = ap->length;
84 6825143 : xfs_extlen_t minlen = mp->m_sb.sb_rextsize;
85 6825143 : xfs_extlen_t raminlen;
86 6825143 : bool rtlocked = false;
87 6825143 : bool ignore_locality = false;
88 6825143 : int error;
89 :
90 6825143 : align = xfs_get_extsz_hint(ap->ip);
91 : retry:
92 6825187 : prod = align / mp->m_sb.sb_rextsize;
93 20475561 : error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
94 6825187 : align, 1, ap->eof, 0,
95 6825187 : ap->conv, &ap->offset, &ap->length);
96 6825145 : if (error)
97 0 : return error;
98 6825145 : ASSERT(ap->length);
99 6825145 : ASSERT(ap->length % mp->m_sb.sb_rextsize == 0);
100 :
101 : /*
102 : * If we shifted the file offset downward to satisfy an extent size
103 : * hint, increase minlen by that amount so that the allocator won't
104 : * give us an allocation that's too short to cover at least one of the
105 : * blocks that the caller asked for.
106 : */
107 6825145 : if (ap->offset != orig_offset)
108 4 : minlen += orig_offset - ap->offset;
109 :
110 : /*
111 : * If the offset & length are not perfectly aligned
112 : * then kill prod, it will just get us in trouble.
113 : */
114 6825145 : div_u64_rem(ap->offset, align, &mod);
115 6825186 : if (mod || ap->length % align)
116 : prod = 1;
117 : /*
118 : * Set ralen to be the actual requested length in rtextents.
119 : */
120 6825186 : ralen = ap->length / mp->m_sb.sb_rextsize;
121 : /*
122 : * If the old value was close enough to XFS_BMBT_MAX_EXTLEN that
123 : * we rounded up to it, cut it back so it's valid again.
124 : * Note that if it's a really large request (bigger than
125 : * XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't
126 : * adjust the starting point to match it.
127 : */
128 6825186 : if (ralen * mp->m_sb.sb_rextsize >= XFS_MAX_BMBT_EXTLEN)
129 0 : ralen = XFS_MAX_BMBT_EXTLEN / mp->m_sb.sb_rextsize;
130 :
131 : /*
132 : * Lock out modifications to both the RT bitmap and summary inodes
133 : */
134 6825186 : if (!rtlocked) {
135 6825186 : xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
136 6825236 : xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
137 6825236 : xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
138 6825236 : xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL);
139 6825236 : rtlocked = true;
140 : }
141 :
142 : /*
143 : * If it's an allocation to an empty file at offset 0,
144 : * pick an extent that will space things out in the rt area.
145 : */
146 6825236 : if (ap->eof && ap->offset == 0) {
147 7173 : xfs_rtblock_t rtx; /* realtime extent no */
148 :
149 7173 : error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
150 7173 : if (error)
151 0 : return error;
152 7173 : ap->blkno = rtx * mp->m_sb.sb_rextsize;
153 : } else {
154 6818063 : ap->blkno = 0;
155 : }
156 :
157 6825236 : xfs_bmap_adjacent(ap);
158 :
159 : /*
160 : * Realtime allocation, done through xfs_rtallocate_extent.
161 : */
162 6825236 : if (ignore_locality)
163 0 : ap->blkno = 0;
164 : else
165 6825236 : do_div(ap->blkno, mp->m_sb.sb_rextsize);
166 6825236 : rtb = ap->blkno;
167 6825236 : ap->length = ralen;
168 6825236 : raminlen = max_t(xfs_extlen_t, 1, minlen / mp->m_sb.sb_rextsize);
169 13650472 : error = xfs_rtallocate_extent(ap->tp, ap->blkno, raminlen, ap->length,
170 6825236 : &ralen, ap->wasdel, prod, &rtb);
171 6825236 : if (error)
172 0 : return error;
173 :
174 6825236 : if (rtb != NULLRTBLOCK) {
175 6825236 : ap->blkno = rtb * mp->m_sb.sb_rextsize;
176 6825236 : ap->length = ralen * mp->m_sb.sb_rextsize;
177 6825236 : ap->ip->i_nblocks += ap->length;
178 6825236 : xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
179 6825236 : if (ap->wasdel)
180 0 : ap->ip->i_delayed_blks -= ap->length;
181 : /*
182 : * Adjust the disk quota also. This was reserved
183 : * earlier.
184 : */
185 20475708 : xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
186 6825236 : ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
187 6825236 : XFS_TRANS_DQ_RTBCOUNT, ap->length);
188 6825236 : return 0;
189 : }
190 :
191 0 : if (align > mp->m_sb.sb_rextsize) {
192 : /*
193 : * We previously enlarged the request length to try to satisfy
194 : * an extent size hint. The allocator didn't return anything,
195 : * so reset the parameters to the original values and try again
196 : * without alignment criteria.
197 : */
198 0 : ap->offset = orig_offset;
199 0 : ap->length = orig_length;
200 0 : minlen = align = mp->m_sb.sb_rextsize;
201 0 : goto retry;
202 : }
203 :
204 0 : if (!ignore_locality && ap->blkno != 0) {
205 : /*
206 : * If we can't allocate near a specific rt extent, try again
207 : * without locality criteria.
208 : */
209 0 : ignore_locality = true;
210 0 : goto retry;
211 : }
212 :
213 0 : ap->blkno = NULLFSBLOCK;
214 0 : ap->length = 0;
215 0 : return 0;
216 : }
217 : #endif /* CONFIG_XFS_RT */
218 :
219 : /*
220 : * Extent tree block counting routines.
221 : */
222 :
223 : /*
224 : * Count leaf blocks given a range of extent records. Delayed allocation
225 : * extents are not counted towards the totals.
226 : */
227 : xfs_extnum_t
228 122983831 : xfs_bmap_count_leaves(
229 : struct xfs_ifork *ifp,
230 : xfs_filblks_t *count)
231 : {
232 122983831 : struct xfs_iext_cursor icur;
233 122983831 : struct xfs_bmbt_irec got;
234 122983831 : xfs_extnum_t numrecs = 0;
235 :
236 477654807 : for_each_xfs_iext(ifp, &icur, &got) {
237 354670976 : if (!isnullstartblock(got.br_startblock)) {
238 354637640 : *count += got.br_blockcount;
239 354637640 : numrecs++;
240 : }
241 : }
242 :
243 122985253 : return numrecs;
244 : }
245 :
246 : /*
247 : * Count fsblocks of the given fork. Delayed allocation extents are
248 : * not counted towards the totals.
249 : */
250 : int
251 649955476 : xfs_bmap_count_blocks(
252 : struct xfs_trans *tp,
253 : struct xfs_inode *ip,
254 : int whichfork,
255 : xfs_extnum_t *nextents,
256 : xfs_filblks_t *count)
257 : {
258 649955476 : struct xfs_mount *mp = ip->i_mount;
259 649955476 : struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
260 649977163 : struct xfs_btree_cur *cur;
261 649977163 : xfs_extlen_t btblocks = 0;
262 649977163 : int error;
263 :
264 649977163 : *nextents = 0;
265 649977163 : *count = 0;
266 :
267 649977163 : if (!ifp)
268 : return 0;
269 :
270 338528227 : switch (ifp->if_format) {
271 2435912 : case XFS_DINODE_FMT_BTREE:
272 2435912 : error = xfs_iread_extents(tp, ip, whichfork);
273 2435910 : if (error)
274 : return error;
275 :
276 2435912 : cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
277 2435911 : error = xfs_btree_count_blocks(cur, &btblocks);
278 2435911 : xfs_btree_del_cursor(cur, error);
279 2435911 : if (error)
280 : return error;
281 :
282 : /*
283 : * xfs_btree_count_blocks includes the root block contained in
284 : * the inode fork in @btblocks, so subtract one because we're
285 : * only interested in allocated disk blocks.
286 : */
287 2435911 : *count += btblocks - 1;
288 :
289 122984485 : fallthrough;
290 122984485 : case XFS_DINODE_FMT_EXTENTS:
291 122984485 : *nextents = xfs_bmap_count_leaves(ifp, count);
292 122986212 : break;
293 : }
294 :
295 : return 0;
296 : }
297 :
298 : static int
299 1991374 : xfs_getbmap_report_one(
300 : struct xfs_inode *ip,
301 : struct getbmapx *bmv,
302 : struct kgetbmap *out,
303 : int64_t bmv_end,
304 : struct xfs_bmbt_irec *got)
305 : {
306 1991374 : struct kgetbmap *p = out + bmv->bmv_entries;
307 1991374 : bool shared = false;
308 1991374 : int error;
309 :
310 1991374 : error = xfs_reflink_trim_around_shared(ip, got, &shared);
311 1991371 : if (error)
312 : return error;
313 :
314 1991371 : if (isnullstartblock(got->br_startblock) ||
315 : got->br_startblock == DELAYSTARTBLOCK) {
316 : /*
317 : * Take the flush completion as being a point-in-time snapshot
318 : * where there are no delalloc extents, and if any new ones
319 : * have been created racily, just skip them as being 'after'
320 : * the flush and so don't get reported.
321 : */
322 5300 : if (!(bmv->bmv_iflags & BMV_IF_DELALLOC))
323 : return 0;
324 :
325 5300 : p->bmv_oflags |= BMV_OF_DELALLOC;
326 5300 : p->bmv_block = -2;
327 : } else {
328 1986071 : p->bmv_block = xfs_fsb_to_db(ip, got->br_startblock);
329 : }
330 :
331 1991369 : if (got->br_state == XFS_EXT_UNWRITTEN &&
332 646853 : (bmv->bmv_iflags & BMV_IF_PREALLOC))
333 71178 : p->bmv_oflags |= BMV_OF_PREALLOC;
334 :
335 1991369 : if (shared)
336 93855 : p->bmv_oflags |= BMV_OF_SHARED;
337 :
338 1991369 : p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, got->br_startoff);
339 1991369 : p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, got->br_blockcount);
340 :
341 1991369 : bmv->bmv_offset = p->bmv_offset + p->bmv_length;
342 1991369 : bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
343 1991369 : bmv->bmv_entries++;
344 1991369 : return 0;
345 : }
346 :
347 : static void
348 1630309 : xfs_getbmap_report_hole(
349 : struct xfs_inode *ip,
350 : struct getbmapx *bmv,
351 : struct kgetbmap *out,
352 : int64_t bmv_end,
353 : xfs_fileoff_t bno,
354 : xfs_fileoff_t end)
355 : {
356 1630309 : struct kgetbmap *p = out + bmv->bmv_entries;
357 :
358 1630309 : if (bmv->bmv_iflags & BMV_IF_NO_HOLES)
359 : return;
360 :
361 16827 : p->bmv_block = -1;
362 16827 : p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, bno);
363 16827 : p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, end - bno);
364 :
365 16827 : bmv->bmv_offset = p->bmv_offset + p->bmv_length;
366 16827 : bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
367 16827 : bmv->bmv_entries++;
368 : }
369 :
370 : static inline bool
371 : xfs_getbmap_full(
372 : struct getbmapx *bmv)
373 : {
374 5556073 : return bmv->bmv_length == 0 || bmv->bmv_entries >= bmv->bmv_count - 1;
375 : }
376 :
377 : static bool
378 1892935 : xfs_getbmap_next_rec(
379 : struct xfs_bmbt_irec *rec,
380 : xfs_fileoff_t total_end)
381 : {
382 1892935 : xfs_fileoff_t end = rec->br_startoff + rec->br_blockcount;
383 :
384 1892935 : if (end == total_end)
385 : return false;
386 :
387 9851 : rec->br_startoff += rec->br_blockcount;
388 9851 : if (!isnullstartblock(rec->br_startblock) &&
389 : rec->br_startblock != DELAYSTARTBLOCK)
390 9851 : rec->br_startblock += rec->br_blockcount;
391 9851 : rec->br_blockcount = total_end - end;
392 9851 : return true;
393 : }
394 :
395 : /*
396 : * Get inode's extents as described in bmv, and format for output.
397 : * Calls formatter to fill the user's buffer until all extents
398 : * are mapped, until the passed-in bmv->bmv_count slots have
399 : * been filled, or until the formatter short-circuits the loop,
400 : * if it is tracking filled-in extents on its own.
401 : */
402 : int /* error code */
403 522423 : xfs_getbmap(
404 : struct xfs_inode *ip,
405 : struct getbmapx *bmv, /* user bmap structure */
406 : struct kgetbmap *out)
407 : {
408 522423 : struct xfs_mount *mp = ip->i_mount;
409 522423 : int iflags = bmv->bmv_iflags;
410 522423 : int whichfork, lock, error = 0;
411 522423 : int64_t bmv_end, max_len;
412 522423 : xfs_fileoff_t bno, first_bno;
413 522423 : struct xfs_ifork *ifp;
414 522423 : struct xfs_bmbt_irec got, rec;
415 522423 : xfs_filblks_t len;
416 522423 : struct xfs_iext_cursor icur;
417 :
418 522423 : if (bmv->bmv_iflags & ~BMV_IF_VALID)
419 : return -EINVAL;
420 : #ifndef DEBUG
421 : /* Only allow CoW fork queries if we're debugging. */
422 : if (iflags & BMV_IF_COWFORK)
423 : return -EINVAL;
424 : #endif
425 522423 : if ((iflags & BMV_IF_ATTRFORK) && (iflags & BMV_IF_COWFORK))
426 : return -EINVAL;
427 :
428 522423 : if (bmv->bmv_length < -1)
429 : return -EINVAL;
430 522423 : bmv->bmv_entries = 0;
431 522423 : if (bmv->bmv_length == 0)
432 : return 0;
433 :
434 457660 : if (iflags & BMV_IF_ATTRFORK)
435 : whichfork = XFS_ATTR_FORK;
436 457657 : else if (iflags & BMV_IF_COWFORK)
437 : whichfork = XFS_COW_FORK;
438 : else
439 457606 : whichfork = XFS_DATA_FORK;
440 :
441 457660 : xfs_ilock(ip, XFS_IOLOCK_SHARED);
442 457655 : switch (whichfork) {
443 2 : case XFS_ATTR_FORK:
444 2 : lock = xfs_ilock_attr_map_shared(ip);
445 2 : if (!xfs_inode_has_attr_fork(ip))
446 2 : goto out_unlock_ilock;
447 :
448 : max_len = 1LL << 32;
449 : break;
450 54 : case XFS_COW_FORK:
451 54 : lock = XFS_ILOCK_SHARED;
452 54 : xfs_ilock(ip, lock);
453 :
454 : /* No CoW fork? Just return */
455 54 : if (!xfs_ifork_ptr(ip, whichfork))
456 14 : goto out_unlock_ilock;
457 :
458 40 : if (xfs_get_cowextsz_hint(ip))
459 40 : max_len = mp->m_super->s_maxbytes;
460 : else
461 0 : max_len = XFS_ISIZE(ip);
462 : break;
463 457599 : case XFS_DATA_FORK:
464 457599 : if (!(iflags & BMV_IF_DELALLOC) &&
465 88376 : (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_disk_size)) {
466 4815 : error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
467 4815 : if (error)
468 0 : goto out_unlock_iolock;
469 :
470 : /*
471 : * Even after flushing the inode, there can still be
472 : * delalloc blocks on the inode beyond EOF due to
473 : * speculative preallocation. These are not removed
474 : * until the release function is called or the inode
475 : * is inactivated. Hence we cannot assert here that
476 : * ip->i_delayed_blks == 0.
477 : */
478 : }
479 :
480 457599 : if (xfs_get_extsz_hint(ip) ||
481 457588 : (ip->i_diflags &
482 : (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))
483 151238 : max_len = mp->m_super->s_maxbytes;
484 : else
485 306352 : max_len = XFS_ISIZE(ip);
486 :
487 457590 : lock = xfs_ilock_data_map_shared(ip);
488 457594 : break;
489 : }
490 :
491 457634 : ifp = xfs_ifork_ptr(ip, whichfork);
492 :
493 457634 : switch (ifp->if_format) {
494 : case XFS_DINODE_FMT_EXTENTS:
495 : case XFS_DINODE_FMT_BTREE:
496 327229 : break;
497 130405 : case XFS_DINODE_FMT_LOCAL:
498 : /* Local format inode forks report no extents. */
499 130405 : goto out_unlock_ilock;
500 0 : default:
501 0 : error = -EINVAL;
502 0 : goto out_unlock_ilock;
503 : }
504 :
505 327229 : if (bmv->bmv_length == -1) {
506 325149 : max_len = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, max_len));
507 325149 : bmv->bmv_length = max(0LL, max_len - bmv->bmv_offset);
508 : }
509 :
510 327229 : bmv_end = bmv->bmv_offset + bmv->bmv_length;
511 :
512 327229 : first_bno = bno = XFS_BB_TO_FSBT(mp, bmv->bmv_offset);
513 327229 : len = XFS_BB_TO_FSB(mp, bmv->bmv_length);
514 :
515 327229 : error = xfs_iread_extents(NULL, ip, whichfork);
516 327223 : if (error)
517 0 : goto out_unlock_ilock;
518 :
519 327223 : if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
520 : /*
521 : * Report a whole-file hole if the delalloc flag is set to
522 : * stay compatible with the old implementation.
523 : */
524 47685 : if (iflags & BMV_IF_DELALLOC)
525 141483 : xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
526 94322 : XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));
527 47685 : goto out_unlock_ilock;
528 : }
529 :
530 3963115 : while (!xfs_getbmap_full(bmv)) {
531 1981554 : xfs_trim_extent(&got, first_bno, len);
532 :
533 : /*
534 : * Report an entry for a hole if this extent doesn't directly
535 : * follow the previous one.
536 : */
537 1981565 : if (got.br_startoff > bno) {
538 1495670 : xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
539 : got.br_startoff);
540 2991340 : if (xfs_getbmap_full(bmv))
541 : break;
542 : }
543 :
544 : /*
545 : * In order to report shared extents accurately, we report each
546 : * distinct shared / unshared part of a single bmbt record with
547 : * an individual getbmapx record.
548 : */
549 1981532 : bno = got.br_startoff + got.br_blockcount;
550 1981532 : rec = got;
551 1991383 : do {
552 1991383 : error = xfs_getbmap_report_one(ip, bmv, out, bmv_end,
553 : &rec);
554 3982747 : if (error || xfs_getbmap_full(bmv))
555 98448 : goto out_unlock_ilock;
556 1892935 : } while (xfs_getbmap_next_rec(&rec, bno));
557 :
558 1883084 : if (!xfs_iext_next_extent(ifp, &icur, &got)) {
559 362144 : xfs_fileoff_t end = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
560 :
561 181072 : if (bmv->bmv_entries > 0)
562 181072 : out[bmv->bmv_entries - 1].bmv_oflags |=
563 : BMV_OF_LAST;
564 :
565 268550 : if (whichfork != XFS_ATTR_FORK && bno < end &&
566 : !xfs_getbmap_full(bmv)) {
567 87478 : xfs_getbmap_report_hole(ip, bmv, out, bmv_end,
568 : bno, end);
569 : }
570 : break;
571 : }
572 :
573 1702012 : if (bno >= first_bno + len)
574 : break;
575 : }
576 :
577 33 : out_unlock_ilock:
578 457659 : xfs_iunlock(ip, lock);
579 457661 : out_unlock_iolock:
580 457661 : xfs_iunlock(ip, XFS_IOLOCK_SHARED);
581 457661 : return error;
582 : }
583 :
584 : /*
585 : * Dead simple method of punching delalyed allocation blocks from a range in
586 : * the inode. This will always punch out both the start and end blocks, even
587 : * if the ranges only partially overlap them, so it is up to the caller to
588 : * ensure that partial blocks are not passed in.
589 : */
590 : int
591 3889 : xfs_bmap_punch_delalloc_range(
592 : struct xfs_inode *ip,
593 : xfs_off_t start_byte,
594 : xfs_off_t end_byte)
595 : {
596 3889 : struct xfs_mount *mp = ip->i_mount;
597 3889 : struct xfs_ifork *ifp = &ip->i_df;
598 3889 : xfs_fileoff_t start_fsb = XFS_B_TO_FSBT(mp, start_byte);
599 3889 : xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, end_byte);
600 3889 : struct xfs_bmbt_irec got, del;
601 3889 : struct xfs_iext_cursor icur;
602 3889 : int error = 0;
603 :
604 3889 : ASSERT(!xfs_need_iread_extents(ifp));
605 :
606 3889 : xfs_ilock(ip, XFS_ILOCK_EXCL);
607 3889 : if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
608 0 : goto out_unlock;
609 :
610 7353 : while (got.br_startoff + got.br_blockcount > start_fsb) {
611 4312 : del = got;
612 4312 : xfs_trim_extent(&del, start_fsb, end_fsb - start_fsb);
613 :
614 : /*
615 : * A delete can push the cursor forward. Step back to the
616 : * previous extent on non-delalloc or extents outside the
617 : * target range.
618 : */
619 4312 : if (!del.br_blockcount ||
620 3981 : !isnullstartblock(del.br_startblock)) {
621 1936 : if (!xfs_iext_prev_extent(ifp, &icur, &got))
622 : break;
623 1598 : continue;
624 : }
625 :
626 2376 : error = xfs_bmap_del_extent_delay(ip, XFS_DATA_FORK, &icur,
627 : &got, &del);
628 2376 : if (error || !xfs_iext_get_extent(ifp, &icur, &got))
629 : break;
630 : }
631 :
632 3889 : out_unlock:
633 3889 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
634 3889 : return error;
635 : }
636 :
637 : /*
638 : * Test whether it is appropriate to check an inode for and free post EOF
639 : * blocks. The 'force' parameter determines whether we should also consider
640 : * regular files that are marked preallocated or append-only.
641 : */
642 : bool
643 990180149 : xfs_can_free_eofblocks(
644 : struct xfs_inode *ip,
645 : bool force)
646 : {
647 990180149 : struct xfs_bmbt_irec imap;
648 990180149 : struct xfs_mount *mp = ip->i_mount;
649 990180149 : xfs_fileoff_t end_fsb;
650 990180149 : xfs_fileoff_t last_fsb;
651 990180149 : int nimaps = 1;
652 990180149 : int error;
653 :
654 : /*
655 : * Caller must either hold the exclusive io lock; or be inactivating
656 : * the inode, which guarantees there are no other users of the inode.
657 : */
658 990180149 : ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL) ||
659 : (VFS_I(ip)->i_state & I_FREEING));
660 :
661 : /* prealloc/delalloc exists only on regular files */
662 990215565 : if (!S_ISREG(VFS_I(ip)->i_mode))
663 : return false;
664 :
665 : /*
666 : * Zero sized files with no cached pages and delalloc blocks will not
667 : * have speculative prealloc/delalloc blocks to remove.
668 : */
669 490308419 : if (VFS_I(ip)->i_size == 0 &&
670 151554339 : VFS_I(ip)->i_mapping->nrpages == 0 &&
671 151564891 : ip->i_delayed_blks == 0)
672 : return false;
673 :
674 : /* If we haven't read in the extent list, then don't do it now. */
675 338743313 : if (xfs_need_iread_extents(&ip->i_df))
676 : return false;
677 :
678 : /*
679 : * Do not free real preallocated or append-only files unless the file
680 : * has delalloc blocks and we are forced to remove them.
681 : */
682 334712535 : if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
683 162298269 : if (!force || ip->i_delayed_blks == 0)
684 : return false;
685 :
686 : /*
687 : * Do not try to free post-EOF blocks if EOF is beyond the end of the
688 : * range supported by the page cache, because the truncation will loop
689 : * forever.
690 : */
691 345100524 : end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
692 172550262 : if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1)
693 368 : end_fsb = roundup_64(end_fsb, mp->m_sb.sb_rextsize);
694 172550262 : last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
695 172550262 : if (last_fsb <= end_fsb)
696 : return false;
697 :
698 : /*
699 : * Look up the mapping for the first block past EOF. If we can't find
700 : * it, there's nothing to free.
701 : */
702 172549879 : xfs_ilock(ip, XFS_ILOCK_SHARED);
703 172550884 : error = xfs_bmapi_read(ip, end_fsb, last_fsb - end_fsb, &imap, &nimaps,
704 : 0);
705 172549471 : xfs_iunlock(ip, XFS_ILOCK_SHARED);
706 172551408 : if (error || nimaps == 0)
707 : return false;
708 :
709 : /*
710 : * If there's a real mapping there or there are delayed allocation
711 : * reservations, then we have post-EOF blocks to try to free.
712 : */
713 324935570 : return imap.br_startblock != HOLESTARTBLOCK || ip->i_delayed_blks;
714 : }
715 :
716 : /*
717 : * This is called to free any blocks beyond eof. The caller must hold
718 : * IOLOCK_EXCL unless we are in the inode reclaim path and have the only
719 : * reference to the inode.
720 : */
721 : int
722 5059608 : xfs_free_eofblocks(
723 : struct xfs_inode *ip)
724 : {
725 5059608 : struct xfs_trans *tp;
726 5059608 : struct xfs_mount *mp = ip->i_mount;
727 5059608 : int error;
728 :
729 : /* Attach the dquots to the inode up front. */
730 5059608 : error = xfs_qm_dqattach(ip);
731 5059595 : if (error)
732 : return error;
733 :
734 : /* Wait on dio to ensure i_size has settled. */
735 5059562 : inode_dio_wait(VFS_I(ip));
736 :
737 5059584 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
738 5059604 : if (error) {
739 0 : ASSERT(xfs_is_shutdown(mp));
740 0 : return error;
741 : }
742 :
743 5059604 : xfs_ilock(ip, XFS_ILOCK_EXCL);
744 5059621 : xfs_trans_ijoin(tp, ip, 0);
745 :
746 : /*
747 : * Do not update the on-disk file size. If we update the on-disk file
748 : * size and then the system crashes before the contents of the file are
749 : * flushed to disk then the files may be full of holes (ie NULL files
750 : * bug).
751 : */
752 10119188 : error = xfs_itruncate_extents_flags(&tp, ip, XFS_DATA_FORK,
753 : XFS_ISIZE(ip), XFS_BMAPI_NODISCARD);
754 5059620 : if (error)
755 37 : goto err_cancel;
756 :
757 5059583 : error = xfs_trans_commit(tp);
758 5059582 : if (error)
759 0 : goto out_unlock;
760 :
761 5059582 : xfs_inode_clear_eofblocks_tag(ip);
762 5059577 : goto out_unlock;
763 :
764 : err_cancel:
765 : /*
766 : * If we get an error at this point we simply don't
767 : * bother truncating the file.
768 : */
769 37 : xfs_trans_cancel(tp);
770 5059614 : out_unlock:
771 5059614 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
772 5059614 : return error;
773 : }
774 :
775 : int
776 4555004 : xfs_alloc_file_space(
777 : struct xfs_inode *ip,
778 : xfs_off_t offset,
779 : xfs_off_t len)
780 : {
781 4555004 : xfs_mount_t *mp = ip->i_mount;
782 4555004 : xfs_off_t count;
783 4555004 : xfs_filblks_t allocated_fsb;
784 4555004 : xfs_filblks_t allocatesize_fsb;
785 4555004 : xfs_extlen_t extsz, temp;
786 4555004 : xfs_fileoff_t startoffset_fsb;
787 4555004 : xfs_fileoff_t endoffset_fsb;
788 4555004 : int nimaps;
789 4555004 : int rt;
790 4555004 : xfs_trans_t *tp;
791 4555004 : xfs_bmbt_irec_t imaps[1], *imapp;
792 4555004 : int error;
793 :
794 4555004 : trace_xfs_alloc_file_space(ip);
795 :
796 9110022 : if (xfs_is_shutdown(mp))
797 : return -EIO;
798 :
799 4555008 : error = xfs_qm_dqattach(ip);
800 4555006 : if (error)
801 : return error;
802 :
803 4555006 : if (len <= 0)
804 : return -EINVAL;
805 :
806 4555006 : rt = XFS_IS_REALTIME_INODE(ip);
807 4555006 : extsz = xfs_get_extsz_hint(ip);
808 :
809 4555006 : count = len;
810 4555006 : imapp = &imaps[0];
811 4555006 : nimaps = 1;
812 4555006 : startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
813 4555006 : endoffset_fsb = XFS_B_TO_FSB(mp, offset + count);
814 4555006 : allocatesize_fsb = endoffset_fsb - startoffset_fsb;
815 :
816 : /*
817 : * Allocate file space until done or until there is an error
818 : */
819 11972384 : while (allocatesize_fsb && !error) {
820 7506079 : xfs_fileoff_t s, e;
821 7506079 : unsigned int dblocks, rblocks, resblks;
822 :
823 : /*
824 : * Determine space reservations for data/realtime.
825 : */
826 7506079 : if (unlikely(extsz)) {
827 2308114 : s = startoffset_fsb;
828 2308114 : do_div(s, extsz);
829 2308114 : s *= extsz;
830 2308114 : e = startoffset_fsb + allocatesize_fsb;
831 2308114 : div_u64_rem(startoffset_fsb, extsz, &temp);
832 2308118 : if (temp)
833 14 : e += temp;
834 2308118 : div_u64_rem(e, extsz, &temp);
835 2308118 : if (temp)
836 22 : e += extsz - temp;
837 : } else {
838 : s = 0;
839 : e = allocatesize_fsb;
840 : }
841 :
842 : /*
843 : * The transaction reservation is limited to a 32-bit block
844 : * count, hence we need to limit the number of blocks we are
845 : * trying to reserve to avoid an overflow. We can't allocate
846 : * more than @nimaps extents, and an extent is limited on disk
847 : * to XFS_BMBT_MAX_EXTLEN (21 bits), so use that to enforce the
848 : * limit.
849 : */
850 7506083 : resblks = min_t(xfs_fileoff_t, (e - s),
851 : (XFS_MAX_BMBT_EXTLEN * nimaps));
852 7506083 : if (unlikely(rt)) {
853 2307710 : dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
854 2307710 : rblocks = resblks;
855 : } else {
856 5198373 : dblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
857 5198373 : rblocks = 0;
858 : }
859 :
860 7506083 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
861 : dblocks, rblocks, false, &tp);
862 7506092 : if (error)
863 : break;
864 :
865 7417658 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
866 : XFS_IEXT_ADD_NOSPLIT_CNT);
867 7417657 : if (error == -EFBIG)
868 4 : error = xfs_iext_count_upgrade(tp, ip,
869 : XFS_IEXT_ADD_NOSPLIT_CNT);
870 7417657 : if (error)
871 4 : goto error;
872 :
873 7417653 : error = xfs_bmapi_write(tp, ip, startoffset_fsb,
874 : allocatesize_fsb, XFS_BMAPI_PREALLOC, 0, imapp,
875 : &nimaps);
876 7417638 : if (error)
877 154 : goto error;
878 :
879 7417484 : ip->i_diflags |= XFS_DIFLAG_PREALLOC;
880 7417484 : xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
881 :
882 7417497 : error = xfs_trans_commit(tp);
883 7417501 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
884 7417489 : if (error)
885 : break;
886 :
887 7417385 : allocated_fsb = imapp->br_blockcount;
888 :
889 7417385 : if (nimaps == 0) {
890 : error = -ENOSPC;
891 : break;
892 : }
893 :
894 7417378 : startoffset_fsb += allocated_fsb;
895 7417378 : allocatesize_fsb -= allocated_fsb;
896 : }
897 :
898 : return error;
899 :
900 158 : error:
901 158 : xfs_trans_cancel(tp);
902 158 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
903 158 : return error;
904 : }
905 :
906 : static int
907 9688174 : xfs_unmap_extent(
908 : struct xfs_inode *ip,
909 : xfs_fileoff_t startoffset_fsb,
910 : xfs_filblks_t len_fsb,
911 : int *done)
912 : {
913 9688174 : struct xfs_mount *mp = ip->i_mount;
914 9688174 : struct xfs_trans *tp;
915 9688174 : uint resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
916 9688174 : int error;
917 :
918 9688174 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks, 0,
919 : false, &tp);
920 9688177 : if (error)
921 : return error;
922 :
923 9663050 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
924 : XFS_IEXT_PUNCH_HOLE_CNT);
925 9663048 : if (error == -EFBIG)
926 24 : error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
927 9663048 : if (error)
928 24 : goto out_trans_cancel;
929 :
930 9663024 : error = xfs_bunmapi(tp, ip, startoffset_fsb, len_fsb, 0, 2, done);
931 9663027 : if (error)
932 4 : goto out_trans_cancel;
933 :
934 9663023 : error = xfs_trans_commit(tp);
935 9663055 : out_unlock:
936 9663055 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
937 9663055 : return error;
938 :
939 28 : out_trans_cancel:
940 28 : xfs_trans_cancel(tp);
941 28 : goto out_unlock;
942 : }
943 :
944 : /* Caller must first wait for the completion of any pending DIOs if required. */
945 : int
946 90397528 : xfs_flush_unmap_range(
947 : struct xfs_inode *ip,
948 : xfs_off_t offset,
949 : xfs_off_t len)
950 : {
951 90397528 : struct xfs_mount *mp = ip->i_mount;
952 90397528 : struct inode *inode = VFS_I(ip);
953 90397528 : xfs_off_t rounding, start, end;
954 90397528 : int error;
955 :
956 90397528 : rounding = max_t(xfs_off_t, mp->m_sb.sb_blocksize, PAGE_SIZE);
957 90397528 : start = round_down(offset, rounding);
958 90397528 : end = round_up(offset + len, rounding) - 1;
959 :
960 90397528 : error = filemap_write_and_wait_range(inode->i_mapping, start, end);
961 90399537 : if (error)
962 : return error;
963 90398285 : truncate_pagecache_range(inode, start, end);
964 90398285 : return 0;
965 : }
966 :
967 : int
968 9408713 : xfs_free_file_space(
969 : struct xfs_inode *ip,
970 : xfs_off_t offset,
971 : xfs_off_t len)
972 : {
973 9408713 : struct xfs_mount *mp = ip->i_mount;
974 9408713 : xfs_fileoff_t startoffset_fsb;
975 9408713 : xfs_fileoff_t endoffset_fsb;
976 9408713 : int done = 0, error;
977 :
978 9408713 : trace_xfs_free_file_space(ip);
979 :
980 9408717 : error = xfs_qm_dqattach(ip);
981 9408714 : if (error)
982 : return error;
983 :
984 9408714 : if (len <= 0) /* if nothing being freed */
985 : return 0;
986 :
987 9408714 : startoffset_fsb = XFS_B_TO_FSB(mp, offset);
988 9408714 : endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
989 :
990 : /* We can only free complete realtime extents. */
991 9408714 : if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1) {
992 28 : startoffset_fsb = roundup_64(startoffset_fsb,
993 : mp->m_sb.sb_rextsize);
994 28 : endoffset_fsb = rounddown_64(endoffset_fsb,
995 : mp->m_sb.sb_rextsize);
996 : }
997 :
998 : /*
999 : * Need to zero the stuff we're not freeing, on disk.
1000 : */
1001 9408714 : if (endoffset_fsb > startoffset_fsb) {
1002 18909488 : while (!done) {
1003 9688173 : error = xfs_unmap_extent(ip, startoffset_fsb,
1004 : endoffset_fsb - startoffset_fsb, &done);
1005 9688180 : if (error)
1006 25164 : return error;
1007 : }
1008 : }
1009 :
1010 : /*
1011 : * Now that we've unmap all full blocks we'll have to zero out any
1012 : * partial block at the beginning and/or end. xfs_zero_range is smart
1013 : * enough to skip any holes, including those we just created, but we
1014 : * must take care not to zero beyond EOF and enlarge i_size.
1015 : */
1016 18767114 : if (offset >= XFS_ISIZE(ip))
1017 : return 0;
1018 8485087 : if (offset + len > XFS_ISIZE(ip))
1019 213618 : len = XFS_ISIZE(ip) - offset;
1020 8485087 : error = xfs_zero_range(ip, offset, len, NULL);
1021 8485086 : if (error)
1022 : return error;
1023 :
1024 : /*
1025 : * If we zeroed right up to EOF and EOF straddles a page boundary we
1026 : * must make sure that the post-EOF area is also zeroed because the
1027 : * page could be mmap'd and xfs_zero_range doesn't do that for us.
1028 : * Writeback of the eof page will do this, albeit clumsily.
1029 : */
1030 16969984 : if (offset + len >= XFS_ISIZE(ip) && offset_in_page(offset + len) > 0) {
1031 304335 : error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
1032 : round_down(offset + len, PAGE_SIZE), LLONG_MAX);
1033 : }
1034 :
1035 : return error;
1036 : }
1037 :
1038 : static int
1039 790110 : xfs_prepare_shift(
1040 : struct xfs_inode *ip,
1041 : loff_t offset)
1042 : {
1043 790110 : struct xfs_mount *mp = ip->i_mount;
1044 790110 : int error;
1045 :
1046 : /*
1047 : * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1048 : * into the accessible region of the file.
1049 : */
1050 790110 : if (xfs_can_free_eofblocks(ip, true)) {
1051 147170 : error = xfs_free_eofblocks(ip);
1052 147170 : if (error)
1053 : return error;
1054 : }
1055 :
1056 : /*
1057 : * Shift operations must stabilize the start block offset boundary along
1058 : * with the full range of the operation. If we don't, a COW writeback
1059 : * completion could race with an insert, front merge with the start
1060 : * extent (after split) during the shift and corrupt the file. Start
1061 : * with the block just prior to the start to stabilize the boundary.
1062 : */
1063 790110 : offset = round_down(offset, mp->m_sb.sb_blocksize);
1064 790110 : if (offset)
1065 713058 : offset -= mp->m_sb.sb_blocksize;
1066 :
1067 : /*
1068 : * Writeback and invalidate cache for the remainder of the file as we're
1069 : * about to shift down every extent from offset to EOF.
1070 : */
1071 1580220 : error = xfs_flush_unmap_range(ip, offset, XFS_ISIZE(ip));
1072 790110 : if (error)
1073 : return error;
1074 :
1075 : /*
1076 : * Clean out anything hanging around in the cow fork now that
1077 : * we've flushed all the dirty data out to disk to avoid having
1078 : * CoW extents at the wrong offsets.
1079 : */
1080 1580060 : if (xfs_inode_has_cow_data(ip)) {
1081 77543 : error = xfs_reflink_cancel_cow_range(ip, offset, NULLFILEOFF,
1082 : true);
1083 77543 : if (error)
1084 0 : return error;
1085 : }
1086 :
1087 : return 0;
1088 : }
1089 :
1090 : /*
1091 : * xfs_collapse_file_space()
1092 : * This routine frees disk space and shift extent for the given file.
1093 : * The first thing we do is to free data blocks in the specified range
1094 : * by calling xfs_free_file_space(). It would also sync dirty data
1095 : * and invalidate page cache over the region on which collapse range
1096 : * is working. And Shift extent records to the left to cover a hole.
1097 : * RETURNS:
1098 : * 0 on success
1099 : * errno on error
1100 : *
1101 : */
1102 : int
1103 439871 : xfs_collapse_file_space(
1104 : struct xfs_inode *ip,
1105 : xfs_off_t offset,
1106 : xfs_off_t len)
1107 : {
1108 439871 : struct xfs_mount *mp = ip->i_mount;
1109 439871 : struct xfs_trans *tp;
1110 439871 : int error;
1111 439871 : xfs_fileoff_t next_fsb = XFS_B_TO_FSB(mp, offset + len);
1112 439871 : xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
1113 439871 : bool done = false;
1114 :
1115 439871 : ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1116 439871 : ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1117 :
1118 439871 : trace_xfs_collapse_file_space(ip);
1119 :
1120 439871 : error = xfs_free_file_space(ip, offset, len);
1121 439871 : if (error)
1122 : return error;
1123 :
1124 438084 : error = xfs_prepare_shift(ip, offset);
1125 438084 : if (error)
1126 : return error;
1127 :
1128 438026 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1129 438026 : if (error)
1130 : return error;
1131 :
1132 438025 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1133 438025 : xfs_trans_ijoin(tp, ip, 0);
1134 :
1135 18944237 : while (!done) {
1136 18944237 : error = xfs_bmap_collapse_extents(tp, ip, &next_fsb, shift_fsb,
1137 : &done);
1138 18944237 : if (error)
1139 1 : goto out_trans_cancel;
1140 18944236 : if (done)
1141 : break;
1142 :
1143 : /* finish any deferred frees and roll the transaction */
1144 18506213 : error = xfs_defer_finish(&tp);
1145 18506213 : if (error)
1146 1 : goto out_trans_cancel;
1147 : }
1148 :
1149 438023 : error = xfs_trans_commit(tp);
1150 438023 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1151 438023 : return error;
1152 :
1153 2 : out_trans_cancel:
1154 2 : xfs_trans_cancel(tp);
1155 2 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1156 2 : return error;
1157 : }
1158 :
1159 : /*
1160 : * xfs_insert_file_space()
1161 : * This routine create hole space by shifting extents for the given file.
1162 : * The first thing we do is to sync dirty data and invalidate page cache
1163 : * over the region on which insert range is working. And split an extent
1164 : * to two extents at given offset by calling xfs_bmap_split_extent.
1165 : * And shift all extent records which are laying between [offset,
1166 : * last allocated extent] to the right to reserve hole range.
1167 : * RETURNS:
1168 : * 0 on success
1169 : * errno on error
1170 : */
1171 : int
1172 352028 : xfs_insert_file_space(
1173 : struct xfs_inode *ip,
1174 : loff_t offset,
1175 : loff_t len)
1176 : {
1177 352028 : struct xfs_mount *mp = ip->i_mount;
1178 352028 : struct xfs_trans *tp;
1179 352028 : int error;
1180 352028 : xfs_fileoff_t stop_fsb = XFS_B_TO_FSB(mp, offset);
1181 352028 : xfs_fileoff_t next_fsb = NULLFSBLOCK;
1182 352028 : xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
1183 352028 : bool done = false;
1184 :
1185 352028 : ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1186 352028 : ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1187 :
1188 352028 : trace_xfs_insert_file_space(ip);
1189 :
1190 352028 : error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb);
1191 352028 : if (error)
1192 : return error;
1193 :
1194 352026 : error = xfs_prepare_shift(ip, offset);
1195 352026 : if (error)
1196 : return error;
1197 :
1198 352004 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write,
1199 352004 : XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp);
1200 352004 : if (error)
1201 : return error;
1202 :
1203 350252 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1204 350252 : xfs_trans_ijoin(tp, ip, 0);
1205 :
1206 350252 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
1207 : XFS_IEXT_PUNCH_HOLE_CNT);
1208 350252 : if (error == -EFBIG)
1209 2 : error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
1210 350252 : if (error)
1211 2 : goto out_trans_cancel;
1212 :
1213 : /*
1214 : * The extent shifting code works on extent granularity. So, if stop_fsb
1215 : * is not the starting block of extent, we need to split the extent at
1216 : * stop_fsb.
1217 : */
1218 350250 : error = xfs_bmap_split_extent(tp, ip, stop_fsb);
1219 350250 : if (error)
1220 0 : goto out_trans_cancel;
1221 :
1222 1497521 : do {
1223 1497521 : error = xfs_defer_finish(&tp);
1224 1497521 : if (error)
1225 3 : goto out_trans_cancel;
1226 :
1227 1497518 : error = xfs_bmap_insert_extents(tp, ip, &next_fsb, shift_fsb,
1228 : &done, stop_fsb);
1229 1497518 : if (error)
1230 0 : goto out_trans_cancel;
1231 1497518 : } while (!done);
1232 :
1233 350247 : error = xfs_trans_commit(tp);
1234 350247 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1235 350247 : return error;
1236 :
1237 5 : out_trans_cancel:
1238 5 : xfs_trans_cancel(tp);
1239 5 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1240 5 : return error;
1241 : }
1242 :
1243 : /*
1244 : * We need to check that the format of the data fork in the temporary inode is
1245 : * valid for the target inode before doing the swap. This is not a problem with
1246 : * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
1247 : * data fork depending on the space the attribute fork is taking so we can get
1248 : * invalid formats on the target inode.
1249 : *
1250 : * E.g. target has space for 7 extents in extent format, temp inode only has
1251 : * space for 6. If we defragment down to 7 extents, then the tmp format is a
1252 : * btree, but when swapped it needs to be in extent format. Hence we can't just
1253 : * blindly swap data forks on attr2 filesystems.
1254 : *
1255 : * Note that we check the swap in both directions so that we don't end up with
1256 : * a corrupt temporary inode, either.
1257 : *
1258 : * Note that fixing the way xfs_fsr sets up the attribute fork in the source
1259 : * inode will prevent this situation from occurring, so all we do here is
1260 : * reject and log the attempt. basically we are putting the responsibility on
1261 : * userspace to get this right.
1262 : */
1263 : static int
1264 6776 : xfs_swap_extents_check_format(
1265 : struct xfs_inode *ip, /* target inode */
1266 : struct xfs_inode *tip) /* tmp inode */
1267 : {
1268 6776 : struct xfs_ifork *ifp = &ip->i_df;
1269 6776 : struct xfs_ifork *tifp = &tip->i_df;
1270 :
1271 : /* User/group/project quota ids must match if quotas are enforced. */
1272 6776 : if (XFS_IS_QUOTA_ON(ip->i_mount) &&
1273 6772 : (!uid_eq(VFS_I(ip)->i_uid, VFS_I(tip)->i_uid) ||
1274 6772 : !gid_eq(VFS_I(ip)->i_gid, VFS_I(tip)->i_gid) ||
1275 6772 : ip->i_projid != tip->i_projid))
1276 : return -EINVAL;
1277 :
1278 : /* Should never get a local format */
1279 6776 : if (ifp->if_format == XFS_DINODE_FMT_LOCAL ||
1280 6776 : tifp->if_format == XFS_DINODE_FMT_LOCAL)
1281 : return -EINVAL;
1282 :
1283 : /*
1284 : * if the target inode has less extents that then temporary inode then
1285 : * why did userspace call us?
1286 : */
1287 6776 : if (ifp->if_nextents < tifp->if_nextents)
1288 : return -EINVAL;
1289 :
1290 : /*
1291 : * If we have to use the (expensive) rmap swap method, we can
1292 : * handle any number of extents and any format.
1293 : */
1294 6776 : if (xfs_has_rmapbt(ip->i_mount))
1295 : return 0;
1296 :
1297 : /*
1298 : * if the target inode is in extent form and the temp inode is in btree
1299 : * form then we will end up with the target inode in the wrong format
1300 : * as we already know there are less extents in the temp inode.
1301 : */
1302 0 : if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1303 : tifp->if_format == XFS_DINODE_FMT_BTREE)
1304 : return -EINVAL;
1305 :
1306 : /* Check temp in extent form to max in target */
1307 0 : if (tifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1308 0 : tifp->if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1309 : return -EINVAL;
1310 :
1311 : /* Check target in extent form to max in temp */
1312 0 : if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1313 0 : ifp->if_nextents > XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
1314 : return -EINVAL;
1315 :
1316 : /*
1317 : * If we are in a btree format, check that the temp root block will fit
1318 : * in the target and that it has enough extents to be in btree format
1319 : * in the target.
1320 : *
1321 : * Note that we have to be careful to allow btree->extent conversions
1322 : * (a common defrag case) which will occur when the temp inode is in
1323 : * extent format...
1324 : */
1325 0 : if (tifp->if_format == XFS_DINODE_FMT_BTREE) {
1326 0 : if (xfs_inode_has_attr_fork(ip) &&
1327 0 : XFS_BMAP_BMDR_SPACE(tifp->if_broot) > xfs_inode_fork_boff(ip))
1328 : return -EINVAL;
1329 0 : if (tifp->if_nextents <= XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1330 : return -EINVAL;
1331 : }
1332 :
1333 : /* Reciprocal target->temp btree format checks */
1334 0 : if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
1335 0 : if (xfs_inode_has_attr_fork(tip) &&
1336 0 : XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > xfs_inode_fork_boff(tip))
1337 : return -EINVAL;
1338 0 : if (ifp->if_nextents <= XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
1339 0 : return -EINVAL;
1340 : }
1341 :
1342 : return 0;
1343 : }
1344 :
1345 : static int
1346 13552 : xfs_swap_extent_flush(
1347 : struct xfs_inode *ip)
1348 : {
1349 13552 : int error;
1350 :
1351 13552 : error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1352 13552 : if (error)
1353 : return error;
1354 13552 : truncate_pagecache_range(VFS_I(ip), 0, -1);
1355 :
1356 : /* Verify O_DIRECT for ftmp */
1357 13552 : if (VFS_I(ip)->i_mapping->nrpages)
1358 0 : return -EINVAL;
1359 : return 0;
1360 : }
1361 :
1362 : /*
1363 : * Move extents from one file to another, when rmap is enabled.
1364 : */
1365 : STATIC int
1366 6776 : xfs_swap_extent_rmap(
1367 : struct xfs_trans **tpp,
1368 : struct xfs_inode *ip,
1369 : struct xfs_inode *tip)
1370 : {
1371 6776 : struct xfs_trans *tp = *tpp;
1372 6776 : struct xfs_bmbt_irec irec;
1373 6776 : struct xfs_bmbt_irec uirec;
1374 6776 : struct xfs_bmbt_irec tirec;
1375 6776 : xfs_fileoff_t offset_fsb;
1376 6776 : xfs_fileoff_t end_fsb;
1377 6776 : xfs_filblks_t count_fsb;
1378 6776 : int error;
1379 6776 : xfs_filblks_t ilen;
1380 6776 : xfs_filblks_t rlen;
1381 6776 : int nimaps;
1382 6776 : uint64_t tip_flags2;
1383 :
1384 : /*
1385 : * If the source file has shared blocks, we must flag the donor
1386 : * file as having shared blocks so that we get the shared-block
1387 : * rmap functions when we go to fix up the rmaps. The flags
1388 : * will be switch for reals later.
1389 : */
1390 6776 : tip_flags2 = tip->i_diflags2;
1391 6776 : if (ip->i_diflags2 & XFS_DIFLAG2_REFLINK)
1392 15 : tip->i_diflags2 |= XFS_DIFLAG2_REFLINK;
1393 :
1394 6776 : offset_fsb = 0;
1395 6776 : end_fsb = XFS_B_TO_FSB(ip->i_mount, i_size_read(VFS_I(ip)));
1396 6776 : count_fsb = (xfs_filblks_t)(end_fsb - offset_fsb);
1397 :
1398 95763 : while (count_fsb) {
1399 : /* Read extent from the donor file */
1400 88995 : nimaps = 1;
1401 88995 : error = xfs_bmapi_read(tip, offset_fsb, count_fsb, &tirec,
1402 : &nimaps, 0);
1403 88995 : if (error)
1404 0 : goto out;
1405 88995 : ASSERT(nimaps == 1);
1406 88995 : ASSERT(tirec.br_startblock != DELAYSTARTBLOCK);
1407 :
1408 88995 : trace_xfs_swap_extent_rmap_remap(tip, &tirec);
1409 88995 : ilen = tirec.br_blockcount;
1410 :
1411 : /* Unmap the old blocks in the source file. */
1412 281401 : while (tirec.br_blockcount) {
1413 192414 : ASSERT(tp->t_highest_agno == NULLAGNUMBER);
1414 192414 : trace_xfs_swap_extent_rmap_remap_piece(tip, &tirec);
1415 :
1416 : /* Read extent from the source file */
1417 192414 : nimaps = 1;
1418 192414 : error = xfs_bmapi_read(ip, tirec.br_startoff,
1419 : tirec.br_blockcount, &irec,
1420 : &nimaps, 0);
1421 192414 : if (error)
1422 0 : goto out;
1423 192414 : ASSERT(nimaps == 1);
1424 192414 : ASSERT(tirec.br_startoff == irec.br_startoff);
1425 192414 : trace_xfs_swap_extent_rmap_remap_piece(ip, &irec);
1426 :
1427 : /* Trim the extent. */
1428 192414 : uirec = tirec;
1429 192414 : uirec.br_blockcount = rlen = min_t(xfs_filblks_t,
1430 : tirec.br_blockcount,
1431 : irec.br_blockcount);
1432 192414 : trace_xfs_swap_extent_rmap_remap_piece(tip, &uirec);
1433 :
1434 342955 : if (xfs_bmap_is_real_extent(&uirec)) {
1435 150541 : error = xfs_iext_count_may_overflow(ip,
1436 : XFS_DATA_FORK,
1437 : XFS_IEXT_SWAP_RMAP_CNT);
1438 150541 : if (error == -EFBIG)
1439 0 : error = xfs_iext_count_upgrade(tp, ip,
1440 : XFS_IEXT_SWAP_RMAP_CNT);
1441 150541 : if (error)
1442 0 : goto out;
1443 : }
1444 :
1445 343359 : if (xfs_bmap_is_real_extent(&irec)) {
1446 150945 : error = xfs_iext_count_may_overflow(tip,
1447 : XFS_DATA_FORK,
1448 : XFS_IEXT_SWAP_RMAP_CNT);
1449 150945 : if (error == -EFBIG)
1450 2 : error = xfs_iext_count_upgrade(tp, ip,
1451 : XFS_IEXT_SWAP_RMAP_CNT);
1452 150945 : if (error)
1453 2 : goto out;
1454 : }
1455 :
1456 : /* Remove the mapping from the donor file. */
1457 192412 : xfs_bmap_unmap_extent(tp, tip, &uirec);
1458 :
1459 : /* Remove the mapping from the source file. */
1460 192412 : xfs_bmap_unmap_extent(tp, ip, &irec);
1461 :
1462 : /* Map the donor file's blocks into the source file. */
1463 192412 : xfs_bmap_map_extent(tp, ip, &uirec);
1464 :
1465 : /* Map the source file's blocks into the donor file. */
1466 192412 : xfs_bmap_map_extent(tp, tip, &irec);
1467 :
1468 192412 : error = xfs_defer_finish(tpp);
1469 192412 : tp = *tpp;
1470 192412 : if (error)
1471 6 : goto out;
1472 :
1473 192406 : tirec.br_startoff += rlen;
1474 192406 : if (tirec.br_startblock != HOLESTARTBLOCK &&
1475 : tirec.br_startblock != DELAYSTARTBLOCK)
1476 150533 : tirec.br_startblock += rlen;
1477 192406 : tirec.br_blockcount -= rlen;
1478 : }
1479 :
1480 : /* Roll on... */
1481 88987 : count_fsb -= ilen;
1482 88987 : offset_fsb += ilen;
1483 : }
1484 :
1485 6768 : tip->i_diflags2 = tip_flags2;
1486 6768 : return 0;
1487 :
1488 8 : out:
1489 8 : trace_xfs_swap_extent_rmap_error(ip, error, _RET_IP_);
1490 8 : tip->i_diflags2 = tip_flags2;
1491 8 : return error;
1492 : }
1493 :
1494 : /* Swap the extents of two files by swapping data forks. */
1495 : STATIC int
1496 0 : xfs_swap_extent_forks(
1497 : struct xfs_trans *tp,
1498 : struct xfs_inode *ip,
1499 : struct xfs_inode *tip,
1500 : int *src_log_flags,
1501 : int *target_log_flags)
1502 : {
1503 0 : xfs_filblks_t aforkblks = 0;
1504 0 : xfs_filblks_t taforkblks = 0;
1505 0 : xfs_extnum_t junk;
1506 0 : uint64_t tmp;
1507 0 : int error;
1508 :
1509 : /*
1510 : * Count the number of extended attribute blocks
1511 : */
1512 0 : if (xfs_inode_has_attr_fork(ip) && ip->i_af.if_nextents > 0 &&
1513 0 : ip->i_af.if_format != XFS_DINODE_FMT_LOCAL) {
1514 0 : error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &junk,
1515 : &aforkblks);
1516 0 : if (error)
1517 : return error;
1518 : }
1519 0 : if (xfs_inode_has_attr_fork(tip) && tip->i_af.if_nextents > 0 &&
1520 0 : tip->i_af.if_format != XFS_DINODE_FMT_LOCAL) {
1521 0 : error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK, &junk,
1522 : &taforkblks);
1523 0 : if (error)
1524 : return error;
1525 : }
1526 :
1527 : /*
1528 : * Btree format (v3) inodes have the inode number stamped in the bmbt
1529 : * block headers. We can't start changing the bmbt blocks until the
1530 : * inode owner change is logged so recovery does the right thing in the
1531 : * event of a crash. Set the owner change log flags now and leave the
1532 : * bmbt scan as the last step.
1533 : */
1534 0 : if (xfs_has_v3inodes(ip->i_mount)) {
1535 0 : if (ip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1536 0 : (*target_log_flags) |= XFS_ILOG_DOWNER;
1537 0 : if (tip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1538 0 : (*src_log_flags) |= XFS_ILOG_DOWNER;
1539 : }
1540 :
1541 : /*
1542 : * Swap the data forks of the inodes
1543 : */
1544 0 : swap(ip->i_df, tip->i_df);
1545 :
1546 : /*
1547 : * Fix the on-disk inode values
1548 : */
1549 0 : tmp = (uint64_t)ip->i_nblocks;
1550 0 : ip->i_nblocks = tip->i_nblocks - taforkblks + aforkblks;
1551 0 : tip->i_nblocks = tmp + taforkblks - aforkblks;
1552 :
1553 : /*
1554 : * The extents in the source inode could still contain speculative
1555 : * preallocation beyond EOF (e.g. the file is open but not modified
1556 : * while defrag is in progress). In that case, we need to copy over the
1557 : * number of delalloc blocks the data fork in the source inode is
1558 : * tracking beyond EOF so that when the fork is truncated away when the
1559 : * temporary inode is unlinked we don't underrun the i_delayed_blks
1560 : * counter on that inode.
1561 : */
1562 0 : ASSERT(tip->i_delayed_blks == 0);
1563 0 : tip->i_delayed_blks = ip->i_delayed_blks;
1564 0 : ip->i_delayed_blks = 0;
1565 :
1566 0 : switch (ip->i_df.if_format) {
1567 0 : case XFS_DINODE_FMT_EXTENTS:
1568 0 : (*src_log_flags) |= XFS_ILOG_DEXT;
1569 0 : break;
1570 0 : case XFS_DINODE_FMT_BTREE:
1571 0 : ASSERT(!xfs_has_v3inodes(ip->i_mount) ||
1572 : (*src_log_flags & XFS_ILOG_DOWNER));
1573 0 : (*src_log_flags) |= XFS_ILOG_DBROOT;
1574 0 : break;
1575 : }
1576 :
1577 0 : switch (tip->i_df.if_format) {
1578 0 : case XFS_DINODE_FMT_EXTENTS:
1579 0 : (*target_log_flags) |= XFS_ILOG_DEXT;
1580 0 : break;
1581 0 : case XFS_DINODE_FMT_BTREE:
1582 0 : (*target_log_flags) |= XFS_ILOG_DBROOT;
1583 0 : ASSERT(!xfs_has_v3inodes(ip->i_mount) ||
1584 : (*target_log_flags & XFS_ILOG_DOWNER));
1585 : break;
1586 : }
1587 :
1588 : return 0;
1589 : }
1590 :
1591 : /*
1592 : * Fix up the owners of the bmbt blocks to refer to the current inode. The
1593 : * change owner scan attempts to order all modified buffers in the current
1594 : * transaction. In the event of ordered buffer failure, the offending buffer is
1595 : * physically logged as a fallback and the scan returns -EAGAIN. We must roll
1596 : * the transaction in this case to replenish the fallback log reservation and
1597 : * restart the scan. This process repeats until the scan completes.
1598 : */
1599 : static int
1600 0 : xfs_swap_change_owner(
1601 : struct xfs_trans **tpp,
1602 : struct xfs_inode *ip,
1603 : struct xfs_inode *tmpip)
1604 : {
1605 0 : int error;
1606 0 : struct xfs_trans *tp = *tpp;
1607 :
1608 0 : do {
1609 0 : error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK, ip->i_ino,
1610 : NULL);
1611 : /* success or fatal error */
1612 0 : if (error != -EAGAIN)
1613 : break;
1614 :
1615 0 : error = xfs_trans_roll(tpp);
1616 0 : if (error)
1617 : break;
1618 0 : tp = *tpp;
1619 :
1620 : /*
1621 : * Redirty both inodes so they can relog and keep the log tail
1622 : * moving forward.
1623 : */
1624 0 : xfs_trans_ijoin(tp, ip, 0);
1625 0 : xfs_trans_ijoin(tp, tmpip, 0);
1626 0 : xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1627 0 : xfs_trans_log_inode(tp, tmpip, XFS_ILOG_CORE);
1628 : } while (true);
1629 :
1630 0 : return error;
1631 : }
1632 :
1633 : int
1634 6776 : xfs_swap_extents(
1635 : struct xfs_inode *ip, /* target inode */
1636 : struct xfs_inode *tip, /* tmp inode */
1637 : struct xfs_swapext *sxp)
1638 : {
1639 6776 : struct xfs_mount *mp = ip->i_mount;
1640 6776 : struct xfs_trans *tp;
1641 6776 : struct xfs_bstat *sbp = &sxp->sx_stat;
1642 6776 : int src_log_flags, target_log_flags;
1643 6776 : int error = 0;
1644 6776 : uint64_t f;
1645 6776 : int resblks = 0;
1646 6776 : unsigned int flags = 0;
1647 :
1648 : /*
1649 : * Lock the inodes against other IO, page faults and truncate to
1650 : * begin with. Then we can ensure the inodes are flushed and have no
1651 : * page cache safely. Once we have done this we can take the ilocks and
1652 : * do the rest of the checks.
1653 : */
1654 6776 : lock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1655 6776 : filemap_invalidate_lock_two(VFS_I(ip)->i_mapping,
1656 : VFS_I(tip)->i_mapping);
1657 :
1658 : /* Verify that both files have the same format */
1659 6776 : if ((VFS_I(ip)->i_mode & S_IFMT) != (VFS_I(tip)->i_mode & S_IFMT)) {
1660 0 : error = -EINVAL;
1661 0 : goto out_unlock;
1662 : }
1663 :
1664 : /* Verify both files are either real-time or non-realtime */
1665 20328 : if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
1666 0 : error = -EINVAL;
1667 0 : goto out_unlock;
1668 : }
1669 :
1670 6776 : error = xfs_qm_dqattach(ip);
1671 6776 : if (error)
1672 0 : goto out_unlock;
1673 :
1674 6776 : error = xfs_qm_dqattach(tip);
1675 6776 : if (error)
1676 0 : goto out_unlock;
1677 :
1678 6776 : error = xfs_swap_extent_flush(ip);
1679 6776 : if (error)
1680 0 : goto out_unlock;
1681 6776 : error = xfs_swap_extent_flush(tip);
1682 6776 : if (error)
1683 0 : goto out_unlock;
1684 :
1685 13552 : if (xfs_inode_has_cow_data(tip)) {
1686 0 : error = xfs_reflink_cancel_cow_range(tip, 0, NULLFILEOFF, true);
1687 0 : if (error)
1688 0 : goto out_unlock;
1689 : }
1690 :
1691 : /*
1692 : * Extent "swapping" with rmap requires a permanent reservation and
1693 : * a block reservation because it's really just a remap operation
1694 : * performed with log redo items!
1695 : */
1696 6776 : if (xfs_has_rmapbt(mp)) {
1697 6776 : int w = XFS_DATA_FORK;
1698 6776 : uint32_t ipnext = ip->i_df.if_nextents;
1699 6776 : uint32_t tipnext = tip->i_df.if_nextents;
1700 :
1701 : /*
1702 : * Conceptually this shouldn't affect the shape of either bmbt,
1703 : * but since we atomically move extents one by one, we reserve
1704 : * enough space to rebuild both trees.
1705 : */
1706 6776 : resblks = XFS_SWAP_RMAP_SPACE_RES(mp, ipnext, w);
1707 6776 : resblks += XFS_SWAP_RMAP_SPACE_RES(mp, tipnext, w);
1708 :
1709 : /*
1710 : * If either inode straddles a bmapbt block allocation boundary,
1711 : * the rmapbt algorithm triggers repeated allocs and frees as
1712 : * extents are remapped. This can exhaust the block reservation
1713 : * prematurely and cause shutdown. Return freed blocks to the
1714 : * transaction reservation to counter this behavior.
1715 : */
1716 6776 : flags |= XFS_TRANS_RES_FDBLKS;
1717 : }
1718 6776 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, flags,
1719 : &tp);
1720 6776 : if (error)
1721 0 : goto out_unlock;
1722 :
1723 : /*
1724 : * Lock and join the inodes to the tansaction so that transaction commit
1725 : * or cancel will unlock the inodes from this point onwards.
1726 : */
1727 6776 : xfs_lock_two_inodes(ip, XFS_ILOCK_EXCL, tip, XFS_ILOCK_EXCL);
1728 6776 : xfs_trans_ijoin(tp, ip, 0);
1729 6776 : xfs_trans_ijoin(tp, tip, 0);
1730 :
1731 :
1732 : /* Verify all data are being swapped */
1733 6776 : if (sxp->sx_offset != 0 ||
1734 6776 : sxp->sx_length != ip->i_disk_size ||
1735 6776 : sxp->sx_length != tip->i_disk_size) {
1736 0 : error = -EFAULT;
1737 0 : goto out_trans_cancel;
1738 : }
1739 :
1740 6776 : trace_xfs_swap_extent_before(ip, 0);
1741 6776 : trace_xfs_swap_extent_before(tip, 1);
1742 :
1743 : /* check inode formats now that data is flushed */
1744 6776 : error = xfs_swap_extents_check_format(ip, tip);
1745 6776 : if (error) {
1746 0 : xfs_notice(mp,
1747 : "%s: inode 0x%llx format is incompatible for exchanging.",
1748 : __func__, ip->i_ino);
1749 0 : goto out_trans_cancel;
1750 : }
1751 :
1752 : /*
1753 : * Compare the current change & modify times with that
1754 : * passed in. If they differ, we abort this swap.
1755 : * This is the mechanism used to ensure the calling
1756 : * process that the file was not changed out from
1757 : * under it.
1758 : */
1759 6776 : if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
1760 6776 : (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
1761 6776 : (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
1762 6776 : (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
1763 0 : error = -EBUSY;
1764 0 : goto out_trans_cancel;
1765 : }
1766 :
1767 : /*
1768 : * Note the trickiness in setting the log flags - we set the owner log
1769 : * flag on the opposite inode (i.e. the inode we are setting the new
1770 : * owner to be) because once we swap the forks and log that, log
1771 : * recovery is going to see the fork as owned by the swapped inode,
1772 : * not the pre-swapped inodes.
1773 : */
1774 6776 : src_log_flags = XFS_ILOG_CORE;
1775 6776 : target_log_flags = XFS_ILOG_CORE;
1776 :
1777 6776 : if (xfs_has_rmapbt(mp))
1778 6776 : error = xfs_swap_extent_rmap(&tp, ip, tip);
1779 : else
1780 0 : error = xfs_swap_extent_forks(tp, ip, tip, &src_log_flags,
1781 : &target_log_flags);
1782 6776 : if (error)
1783 8 : goto out_trans_cancel;
1784 :
1785 : /* Do we have to swap reflink flags? */
1786 6768 : if ((ip->i_diflags2 & XFS_DIFLAG2_REFLINK) ^
1787 6768 : (tip->i_diflags2 & XFS_DIFLAG2_REFLINK)) {
1788 9 : f = ip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1789 9 : ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1790 9 : ip->i_diflags2 |= tip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1791 9 : tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1792 9 : tip->i_diflags2 |= f & XFS_DIFLAG2_REFLINK;
1793 : }
1794 :
1795 : /* Swap the cow forks. */
1796 6768 : if (xfs_has_reflink(mp)) {
1797 6768 : ASSERT(!ip->i_cowfp ||
1798 : ip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1799 6768 : ASSERT(!tip->i_cowfp ||
1800 : tip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1801 :
1802 6768 : swap(ip->i_cowfp, tip->i_cowfp);
1803 :
1804 6768 : if (ip->i_cowfp && ip->i_cowfp->if_bytes)
1805 0 : xfs_inode_set_cowblocks_tag(ip);
1806 : else
1807 6768 : xfs_inode_clear_cowblocks_tag(ip);
1808 6768 : if (tip->i_cowfp && tip->i_cowfp->if_bytes)
1809 0 : xfs_inode_set_cowblocks_tag(tip);
1810 : else
1811 6768 : xfs_inode_clear_cowblocks_tag(tip);
1812 : }
1813 :
1814 6768 : xfs_trans_log_inode(tp, ip, src_log_flags);
1815 6768 : xfs_trans_log_inode(tp, tip, target_log_flags);
1816 :
1817 : /*
1818 : * The extent forks have been swapped, but crc=1,rmapbt=0 filesystems
1819 : * have inode number owner values in the bmbt blocks that still refer to
1820 : * the old inode. Scan each bmbt to fix up the owner values with the
1821 : * inode number of the current inode.
1822 : */
1823 6768 : if (src_log_flags & XFS_ILOG_DOWNER) {
1824 0 : error = xfs_swap_change_owner(&tp, ip, tip);
1825 0 : if (error)
1826 0 : goto out_trans_cancel;
1827 : }
1828 6768 : if (target_log_flags & XFS_ILOG_DOWNER) {
1829 0 : error = xfs_swap_change_owner(&tp, tip, ip);
1830 0 : if (error)
1831 0 : goto out_trans_cancel;
1832 : }
1833 :
1834 : /*
1835 : * If this is a synchronous mount, make sure that the
1836 : * transaction goes to disk before returning to the user.
1837 : */
1838 6768 : if (xfs_has_wsync(mp))
1839 0 : xfs_trans_set_sync(tp);
1840 :
1841 6768 : error = xfs_trans_commit(tp);
1842 :
1843 6768 : trace_xfs_swap_extent_after(ip, 0);
1844 6768 : trace_xfs_swap_extent_after(tip, 1);
1845 :
1846 6776 : out_unlock_ilock:
1847 6776 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1848 6776 : xfs_iunlock(tip, XFS_ILOCK_EXCL);
1849 6776 : out_unlock:
1850 6776 : filemap_invalidate_unlock_two(VFS_I(ip)->i_mapping,
1851 : VFS_I(tip)->i_mapping);
1852 6776 : unlock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1853 6776 : return error;
1854 :
1855 8 : out_trans_cancel:
1856 8 : xfs_trans_cancel(tp);
1857 8 : goto out_unlock_ilock;
1858 : }
|
