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 423885914 : xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
41 : {
42 423885914 : if (XFS_IS_REALTIME_INODE(ip))
43 202248418 : return XFS_FSB_TO_BB(ip->i_mount, fsb);
44 221637498 : 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 53260711 : xfs_bmap_rtalloc(
74 : struct xfs_bmalloca *ap)
75 : {
76 53260711 : struct xfs_mount *mp = ap->ip->i_mount;
77 53260711 : xfs_fileoff_t orig_offset = ap->offset;
78 53260711 : xfs_rtblock_t rtb;
79 53260711 : xfs_extlen_t prod = 0; /* product factor for allocators */
80 53260711 : xfs_extlen_t mod = 0; /* product factor for allocators */
81 53260711 : xfs_extlen_t ralen = 0; /* realtime allocation length */
82 53260711 : xfs_extlen_t align; /* minimum allocation alignment */
83 53260711 : xfs_extlen_t orig_length = ap->length;
84 53260711 : xfs_extlen_t minlen = mp->m_sb.sb_rextsize;
85 53260711 : xfs_extlen_t raminlen;
86 53260711 : bool rtlocked = false;
87 53260711 : bool ignore_locality = false;
88 53260711 : int error;
89 :
90 53260711 : align = xfs_get_extsz_hint(ap->ip);
91 : retry:
92 53239446 : prod = align / mp->m_sb.sb_rextsize;
93 159718338 : error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
94 53239446 : align, 1, ap->eof, 0,
95 53239446 : ap->conv, &ap->offset, &ap->length);
96 53253606 : if (error)
97 0 : return error;
98 53253606 : ASSERT(ap->length);
99 53253606 : 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 53253606 : if (ap->offset != orig_offset)
108 3262957 : 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 53253606 : div_u64_rem(ap->offset, align, &mod);
115 53251587 : if (mod || ap->length % align)
116 : prod = 1;
117 : /*
118 : * Set ralen to be the actual requested length in rtextents.
119 : */
120 53251587 : 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 53251587 : if (ralen * mp->m_sb.sb_rextsize >= XFS_MAX_BMBT_EXTLEN)
129 10232 : 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 53251587 : if (!rtlocked) {
135 53251567 : xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
136 53331263 : xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
137 53331263 : xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
138 53331263 : xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL);
139 53331263 : 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 53331283 : if (ap->eof && ap->offset == 0) {
147 6203456 : xfs_rtblock_t rtx; /* realtime extent no */
148 :
149 6203456 : error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
150 6203456 : if (error)
151 0 : return error;
152 6203456 : ap->blkno = rtx * mp->m_sb.sb_rextsize;
153 : } else {
154 47127827 : ap->blkno = 0;
155 : }
156 :
157 53331283 : xfs_bmap_adjacent(ap);
158 :
159 : /*
160 : * Realtime allocation, done through xfs_rtallocate_extent.
161 : */
162 53331283 : if (ignore_locality)
163 10 : ap->blkno = 0;
164 : else
165 53331273 : do_div(ap->blkno, mp->m_sb.sb_rextsize);
166 53331283 : rtb = ap->blkno;
167 53331283 : ap->length = ralen;
168 53331283 : raminlen = max_t(xfs_extlen_t, 1, minlen / mp->m_sb.sb_rextsize);
169 106662566 : error = xfs_rtallocate_extent(ap->tp, ap->blkno, raminlen, ap->length,
170 53331283 : &ralen, ap->wasdel, prod, &rtb);
171 53331283 : if (error)
172 4 : return error;
173 :
174 53331279 : if (rtb != NULLRTBLOCK) {
175 53331259 : ap->blkno = rtb * mp->m_sb.sb_rextsize;
176 53331259 : ap->length = ralen * mp->m_sb.sb_rextsize;
177 53331259 : ap->ip->i_nblocks += ap->length;
178 53331259 : xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
179 53331259 : 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 159993777 : xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
186 53331259 : ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
187 53331259 : XFS_TRANS_DQ_RTBCOUNT, ap->length);
188 53331259 : return 0;
189 : }
190 :
191 20 : 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 10 : ap->offset = orig_offset;
199 10 : ap->length = orig_length;
200 10 : minlen = align = mp->m_sb.sb_rextsize;
201 10 : goto retry;
202 : }
203 :
204 10 : 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 10 : ignore_locality = true;
210 10 : 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 176708777 : xfs_bmap_count_leaves(
229 : struct xfs_ifork *ifp,
230 : xfs_filblks_t *count)
231 : {
232 176708777 : struct xfs_iext_cursor icur;
233 176708777 : struct xfs_bmbt_irec got;
234 176708777 : xfs_extnum_t numrecs = 0;
235 :
236 717795957 : for_each_xfs_iext(ifp, &icur, &got) {
237 541087180 : if (!isnullstartblock(got.br_startblock)) {
238 541049512 : *count += got.br_blockcount;
239 541049512 : numrecs++;
240 : }
241 : }
242 :
243 176640710 : 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 759234146 : 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 759234146 : struct xfs_mount *mp = ip->i_mount;
259 759234146 : struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
260 759859936 : struct xfs_btree_cur *cur;
261 759859936 : xfs_extlen_t btblocks = 0;
262 759859936 : int error;
263 :
264 759859936 : *nextents = 0;
265 759859936 : *count = 0;
266 :
267 759859936 : if (!ifp)
268 : return 0;
269 :
270 398819053 : switch (ifp->if_format) {
271 3986760 : case XFS_DINODE_FMT_BTREE:
272 3986760 : error = xfs_iread_extents(tp, ip, whichfork);
273 3986827 : if (error)
274 : return error;
275 :
276 3986849 : cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
277 3987680 : error = xfs_btree_count_blocks(cur, &btblocks);
278 3987341 : xfs_btree_del_cursor(cur, error);
279 3987149 : 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 3987149 : *count += btblocks - 1;
288 :
289 176596454 : fallthrough;
290 176596454 : case XFS_DINODE_FMT_EXTENTS:
291 176596454 : *nextents = xfs_bmap_count_leaves(ifp, count);
292 176641177 : break;
293 : }
294 :
295 : return 0;
296 : }
297 :
298 : static int
299 2050181 : 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 2050181 : struct kgetbmap *p = out + bmv->bmv_entries;
307 2050181 : bool shared = false;
308 2050181 : int error;
309 :
310 2050181 : error = xfs_reflink_trim_around_shared(ip, got, &shared);
311 2050127 : if (error)
312 : return error;
313 :
314 2050127 : 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 14231 : if (!(bmv->bmv_iflags & BMV_IF_DELALLOC))
323 : return 0;
324 :
325 14231 : p->bmv_oflags |= BMV_OF_DELALLOC;
326 14231 : p->bmv_block = -2;
327 : } else {
328 2035896 : p->bmv_block = xfs_fsb_to_db(ip, got->br_startblock);
329 : }
330 :
331 2050130 : if (got->br_state == XFS_EXT_UNWRITTEN &&
332 1101852 : (bmv->bmv_iflags & BMV_IF_PREALLOC))
333 411261 : p->bmv_oflags |= BMV_OF_PREALLOC;
334 :
335 2050130 : if (shared)
336 203296 : p->bmv_oflags |= BMV_OF_SHARED;
337 :
338 2050130 : p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, got->br_startoff);
339 2050130 : p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, got->br_blockcount);
340 :
341 2050130 : bmv->bmv_offset = p->bmv_offset + p->bmv_length;
342 2050130 : bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
343 2050130 : bmv->bmv_entries++;
344 2050130 : return 0;
345 : }
346 :
347 : static void
348 775841 : 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 775841 : struct kgetbmap *p = out + bmv->bmv_entries;
357 :
358 775841 : if (bmv->bmv_iflags & BMV_IF_NO_HOLES)
359 : return;
360 :
361 128508 : p->bmv_block = -1;
362 128508 : p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, bno);
363 128508 : p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, end - bno);
364 :
365 128508 : bmv->bmv_offset = p->bmv_offset + p->bmv_length;
366 128508 : bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
367 128508 : bmv->bmv_entries++;
368 : }
369 :
370 : static inline bool
371 : xfs_getbmap_full(
372 : struct getbmapx *bmv)
373 : {
374 4845456 : return bmv->bmv_length == 0 || bmv->bmv_entries >= bmv->bmv_count - 1;
375 : }
376 :
377 : static bool
378 1901339 : xfs_getbmap_next_rec(
379 : struct xfs_bmbt_irec *rec,
380 : xfs_fileoff_t total_end)
381 : {
382 1901339 : xfs_fileoff_t end = rec->br_startoff + rec->br_blockcount;
383 :
384 1901339 : if (end == total_end)
385 : return false;
386 :
387 12562 : rec->br_startoff += rec->br_blockcount;
388 12562 : if (!isnullstartblock(rec->br_startblock) &&
389 : rec->br_startblock != DELAYSTARTBLOCK)
390 12562 : rec->br_startblock += rec->br_blockcount;
391 12562 : rec->br_blockcount = total_end - end;
392 12562 : 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 436464 : xfs_getbmap(
404 : struct xfs_inode *ip,
405 : struct getbmapx *bmv, /* user bmap structure */
406 : struct kgetbmap *out)
407 : {
408 436464 : struct xfs_mount *mp = ip->i_mount;
409 436464 : int iflags = bmv->bmv_iflags;
410 436464 : int whichfork, lock, error = 0;
411 436464 : int64_t bmv_end, max_len;
412 436464 : xfs_fileoff_t bno, first_bno;
413 436464 : struct xfs_ifork *ifp;
414 436464 : struct xfs_bmbt_irec got, rec;
415 436464 : xfs_filblks_t len;
416 436464 : struct xfs_iext_cursor icur;
417 :
418 436464 : 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 436464 : if ((iflags & BMV_IF_ATTRFORK) && (iflags & BMV_IF_COWFORK))
426 : return -EINVAL;
427 :
428 436464 : if (bmv->bmv_length < -1)
429 : return -EINVAL;
430 436464 : bmv->bmv_entries = 0;
431 436464 : if (bmv->bmv_length == 0)
432 : return 0;
433 :
434 416190 : if (iflags & BMV_IF_ATTRFORK)
435 : whichfork = XFS_ATTR_FORK;
436 416174 : else if (iflags & BMV_IF_COWFORK)
437 : whichfork = XFS_COW_FORK;
438 : else
439 415981 : whichfork = XFS_DATA_FORK;
440 :
441 416190 : xfs_ilock(ip, XFS_IOLOCK_SHARED);
442 416168 : switch (whichfork) {
443 6 : case XFS_ATTR_FORK:
444 6 : lock = xfs_ilock_attr_map_shared(ip);
445 6 : if (!xfs_inode_has_attr_fork(ip))
446 6 : goto out_unlock_ilock;
447 :
448 : max_len = 1LL << 32;
449 : break;
450 166 : case XFS_COW_FORK:
451 166 : lock = XFS_ILOCK_SHARED;
452 166 : xfs_ilock(ip, lock);
453 :
454 : /* No CoW fork? Just return */
455 166 : if (!xfs_ifork_ptr(ip, whichfork))
456 48 : goto out_unlock_ilock;
457 :
458 118 : if (xfs_get_cowextsz_hint(ip))
459 118 : max_len = mp->m_super->s_maxbytes;
460 : else
461 0 : max_len = XFS_ISIZE(ip);
462 : break;
463 415996 : case XFS_DATA_FORK:
464 415996 : if (!(iflags & BMV_IF_DELALLOC) &&
465 477333 : (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_disk_size)) {
466 23875 : error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
467 23884 : 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 416005 : if (xfs_get_extsz_hint(ip) ||
481 352183 : (ip->i_diflags &
482 : (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))
483 176187 : max_len = mp->m_super->s_maxbytes;
484 : else
485 239732 : max_len = XFS_ISIZE(ip);
486 :
487 415919 : lock = xfs_ilock_data_map_shared(ip);
488 415945 : break;
489 : }
490 :
491 416063 : ifp = xfs_ifork_ptr(ip, whichfork);
492 :
493 416078 : switch (ifp->if_format) {
494 : case XFS_DINODE_FMT_EXTENTS:
495 : case XFS_DINODE_FMT_BTREE:
496 362789 : break;
497 53289 : case XFS_DINODE_FMT_LOCAL:
498 : /* Local format inode forks report no extents. */
499 53289 : goto out_unlock_ilock;
500 0 : default:
501 0 : error = -EINVAL;
502 0 : goto out_unlock_ilock;
503 : }
504 :
505 362789 : if (bmv->bmv_length == -1) {
506 360920 : max_len = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, max_len));
507 360920 : bmv->bmv_length = max(0LL, max_len - bmv->bmv_offset);
508 : }
509 :
510 362789 : bmv_end = bmv->bmv_offset + bmv->bmv_length;
511 :
512 362789 : first_bno = bno = XFS_BB_TO_FSBT(mp, bmv->bmv_offset);
513 362789 : len = XFS_BB_TO_FSB(mp, bmv->bmv_length);
514 :
515 362789 : error = xfs_iread_extents(NULL, ip, whichfork);
516 362761 : if (error)
517 0 : goto out_unlock_ilock;
518 :
519 362761 : 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 39992 : if (iflags & BMV_IF_DELALLOC)
525 55200 : xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
526 36800 : XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));
527 39992 : goto out_unlock_ilock;
528 : }
529 :
530 4075768 : while (!xfs_getbmap_full(bmv)) {
531 2037886 : 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 2037829 : if (got.br_startoff > bno) {
538 732704 : xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
539 : got.br_startoff);
540 1465408 : 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 2037575 : bno = got.br_startoff + got.br_blockcount;
550 2037575 : rec = got;
551 2050137 : do {
552 2050137 : error = xfs_getbmap_report_one(ip, bmv, out, bmv_end,
553 : &rec);
554 4100266 : if (error || xfs_getbmap_full(bmv))
555 148794 : goto out_unlock_ilock;
556 1901339 : } while (xfs_getbmap_next_rec(&rec, bno));
557 :
558 1888777 : if (!xfs_iext_next_extent(ifp, &icur, &got)) {
559 347430 : xfs_fileoff_t end = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
560 :
561 173715 : if (bmv->bmv_entries > 0)
562 173715 : out[bmv->bmv_entries - 1].bmv_oflags |=
563 : BMV_OF_LAST;
564 :
565 198452 : if (whichfork != XFS_ATTR_FORK && bno < end &&
566 : !xfs_getbmap_full(bmv)) {
567 24737 : xfs_getbmap_report_hole(ip, bmv, out, bmv_end,
568 : bno, end);
569 : }
570 : break;
571 : }
572 :
573 1715061 : if (bno >= first_bno + len)
574 : break;
575 : }
576 :
577 254 : out_unlock_ilock:
578 416098 : xfs_iunlock(ip, lock);
579 416152 : out_unlock_iolock:
580 416152 : xfs_iunlock(ip, XFS_IOLOCK_SHARED);
581 416152 : 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 42130 : xfs_bmap_punch_delalloc_range(
592 : struct xfs_inode *ip,
593 : xfs_off_t start_byte,
594 : xfs_off_t end_byte)
595 : {
596 42130 : struct xfs_mount *mp = ip->i_mount;
597 42130 : struct xfs_ifork *ifp = &ip->i_df;
598 42130 : xfs_fileoff_t start_fsb = XFS_B_TO_FSBT(mp, start_byte);
599 42130 : xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, end_byte);
600 42130 : struct xfs_bmbt_irec got, del;
601 42130 : struct xfs_iext_cursor icur;
602 42130 : int error = 0;
603 :
604 42130 : ASSERT(!xfs_need_iread_extents(ifp));
605 :
606 42130 : xfs_ilock(ip, XFS_ILOCK_EXCL);
607 42131 : if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
608 285 : goto out_unlock;
609 :
610 80931 : while (got.br_startoff + got.br_blockcount > start_fsb) {
611 45516 : del = got;
612 45516 : 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 45513 : if (!del.br_blockcount ||
620 42438 : !isnullstartblock(del.br_startblock)) {
621 16274 : if (!xfs_iext_prev_extent(ifp, &icur, &got))
622 : break;
623 12051 : continue;
624 : }
625 :
626 29239 : error = xfs_bmap_del_extent_delay(ip, XFS_DATA_FORK, &icur,
627 : &got, &del);
628 29238 : if (error || !xfs_iext_get_extent(ifp, &icur, &got))
629 : break;
630 : }
631 :
632 41844 : out_unlock:
633 42129 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
634 42130 : 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 1168154562 : xfs_can_free_eofblocks(
644 : struct xfs_inode *ip,
645 : bool force)
646 : {
647 1168154562 : struct xfs_bmbt_irec imap;
648 1168154562 : struct xfs_mount *mp = ip->i_mount;
649 1168154562 : xfs_fileoff_t end_fsb;
650 1168154562 : xfs_fileoff_t last_fsb;
651 1168154562 : int nimaps = 1;
652 1168154562 : 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 1168154562 : 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 1167766991 : 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 736633052 : if (VFS_I(ip)->i_size == 0 &&
670 232806643 : VFS_I(ip)->i_mapping->nrpages == 0 &&
671 232847245 : 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 503789549 : 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 498184581 : if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
683 205576576 : 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 587764836 : end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
692 293882418 : if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1)
693 16523683 : end_fsb = roundup_64(end_fsb, mp->m_sb.sb_rextsize);
694 293882682 : last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
695 293882682 : 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 293903020 : xfs_ilock(ip, XFS_ILOCK_SHARED);
703 293876048 : error = xfs_bmapi_read(ip, end_fsb, last_fsb - end_fsb, &imap, &nimaps,
704 : 0);
705 293887887 : xfs_iunlock(ip, XFS_ILOCK_SHARED);
706 294005873 : 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 535575935 : 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 12372770 : xfs_free_eofblocks(
723 : struct xfs_inode *ip)
724 : {
725 12372770 : struct xfs_trans *tp;
726 12372770 : struct xfs_mount *mp = ip->i_mount;
727 12372770 : int error;
728 :
729 : /* Attach the dquots to the inode up front. */
730 12372770 : error = xfs_qm_dqattach(ip);
731 12353578 : if (error)
732 : return error;
733 :
734 : /* Wait on dio to ensure i_size has settled. */
735 12380247 : inode_dio_wait(VFS_I(ip));
736 :
737 12356675 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
738 12511227 : if (error) {
739 0 : ASSERT(xfs_is_shutdown(mp));
740 0 : return error;
741 : }
742 :
743 12511227 : xfs_ilock(ip, XFS_ILOCK_EXCL);
744 12505511 : 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 24984638 : error = xfs_itruncate_extents_flags(&tp, ip, XFS_DATA_FORK,
753 : XFS_ISIZE(ip), XFS_BMAPI_NODISCARD);
754 12531234 : if (error)
755 50 : goto err_cancel;
756 :
757 12531184 : error = xfs_trans_commit(tp);
758 12517785 : if (error)
759 0 : goto out_unlock;
760 :
761 12517785 : xfs_inode_clear_eofblocks_tag(ip);
762 12508779 : 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 50 : xfs_trans_cancel(tp);
770 12508829 : out_unlock:
771 12508829 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
772 12508829 : return error;
773 : }
774 :
775 : int
776 11357234 : xfs_alloc_file_space(
777 : struct xfs_inode *ip,
778 : xfs_off_t offset,
779 : xfs_off_t len)
780 : {
781 11357234 : xfs_mount_t *mp = ip->i_mount;
782 11357234 : xfs_off_t count;
783 11357234 : xfs_filblks_t allocated_fsb;
784 11357234 : xfs_filblks_t allocatesize_fsb;
785 11357234 : xfs_extlen_t extsz, temp;
786 11357234 : xfs_fileoff_t startoffset_fsb;
787 11357234 : xfs_fileoff_t endoffset_fsb;
788 11357234 : int nimaps;
789 11357234 : int rt;
790 11357234 : xfs_trans_t *tp;
791 11357234 : xfs_bmbt_irec_t imaps[1], *imapp;
792 11357234 : int error;
793 :
794 11357234 : trace_xfs_alloc_file_space(ip);
795 :
796 22714326 : if (xfs_is_shutdown(mp))
797 : return -EIO;
798 :
799 11357155 : error = xfs_qm_dqattach(ip);
800 11357160 : if (error)
801 : return error;
802 :
803 11357160 : if (len <= 0)
804 : return -EINVAL;
805 :
806 11357160 : rt = XFS_IS_REALTIME_INODE(ip);
807 11357160 : extsz = xfs_get_extsz_hint(ip);
808 :
809 11357159 : count = len;
810 11357159 : imapp = &imaps[0];
811 11357159 : nimaps = 1;
812 11357159 : startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
813 11357159 : endoffset_fsb = XFS_B_TO_FSB(mp, offset + count);
814 11357159 : allocatesize_fsb = endoffset_fsb - startoffset_fsb;
815 :
816 : /*
817 : * Allocate file space until done or until there is an error
818 : */
819 31154882 : while (allocatesize_fsb && !error) {
820 20089493 : xfs_fileoff_t s, e;
821 20089493 : unsigned int dblocks, rblocks, resblks;
822 :
823 : /*
824 : * Determine space reservations for data/realtime.
825 : */
826 20089493 : if (unlikely(extsz)) {
827 8990231 : s = startoffset_fsb;
828 8990231 : do_div(s, extsz);
829 8990231 : s *= extsz;
830 8990231 : e = startoffset_fsb + allocatesize_fsb;
831 8990231 : div_u64_rem(startoffset_fsb, extsz, &temp);
832 8990220 : if (temp)
833 1739572 : e += temp;
834 8990220 : div_u64_rem(e, extsz, &temp);
835 8990225 : if (temp)
836 2210086 : 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 20089487 : resblks = min_t(xfs_fileoff_t, (e - s),
851 : (XFS_MAX_BMBT_EXTLEN * nimaps));
852 20089487 : if (unlikely(rt)) {
853 8989072 : dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
854 8989072 : rblocks = resblks;
855 : } else {
856 11100415 : dblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
857 11100415 : rblocks = 0;
858 : }
859 :
860 20089487 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
861 : dblocks, rblocks, false, &tp);
862 20087693 : if (error)
863 : break;
864 :
865 19796345 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
866 : XFS_IEXT_ADD_NOSPLIT_CNT);
867 19795880 : if (error == -EFBIG)
868 15 : error = xfs_iext_count_upgrade(tp, ip,
869 : XFS_IEXT_ADD_NOSPLIT_CNT);
870 19795880 : if (error)
871 15 : goto error;
872 :
873 19795865 : error = xfs_bmapi_write(tp, ip, startoffset_fsb,
874 : allocatesize_fsb, XFS_BMAPI_PREALLOC, 0, imapp,
875 : &nimaps);
876 19798096 : if (error)
877 297 : goto error;
878 :
879 19797799 : ip->i_diflags |= XFS_DIFLAG_PREALLOC;
880 19797799 : xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
881 :
882 19798655 : error = xfs_trans_commit(tp);
883 19798024 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
884 19798048 : if (error)
885 : break;
886 :
887 19797811 : allocated_fsb = imapp->br_blockcount;
888 :
889 19797811 : if (nimaps == 0) {
890 : error = -ENOSPC;
891 : break;
892 : }
893 :
894 19797723 : startoffset_fsb += allocated_fsb;
895 19797723 : allocatesize_fsb -= allocated_fsb;
896 : }
897 :
898 : return error;
899 :
900 312 : error:
901 312 : xfs_trans_cancel(tp);
902 312 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
903 312 : return error;
904 : }
905 :
906 : static int
907 44299536 : 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 44299536 : struct xfs_mount *mp = ip->i_mount;
914 44299536 : struct xfs_trans *tp;
915 44299536 : uint resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
916 44299536 : int error;
917 :
918 44299536 : error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks, 0,
919 : false, &tp);
920 44299785 : if (error)
921 : return error;
922 :
923 44235387 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
924 : XFS_IEXT_PUNCH_HOLE_CNT);
925 44234984 : if (error == -EFBIG)
926 128 : error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
927 44234984 : if (error)
928 128 : goto out_trans_cancel;
929 :
930 44234856 : error = xfs_bunmapi(tp, ip, startoffset_fsb, len_fsb, 0, 2, done);
931 44235281 : if (error)
932 9 : goto out_trans_cancel;
933 :
934 44235272 : error = xfs_trans_commit(tp);
935 44235710 : out_unlock:
936 44235710 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
937 44235710 : return error;
938 :
939 137 : out_trans_cancel:
940 137 : xfs_trans_cancel(tp);
941 137 : goto out_unlock;
942 : }
943 :
944 : /* Caller must first wait for the completion of any pending DIOs if required. */
945 : int
946 133585129 : xfs_flush_unmap_range(
947 : struct xfs_inode *ip,
948 : xfs_off_t offset,
949 : xfs_off_t len)
950 : {
951 133585129 : struct xfs_mount *mp = ip->i_mount;
952 133585129 : struct inode *inode = VFS_I(ip);
953 133585129 : xfs_off_t rounding, start, end;
954 133585129 : int error;
955 :
956 133585129 : rounding = max_t(xfs_off_t, mp->m_sb.sb_blocksize, PAGE_SIZE);
957 133585129 : start = round_down(offset, rounding);
958 133585129 : end = round_up(offset + len, rounding) - 1;
959 :
960 133585129 : error = filemap_write_and_wait_range(inode->i_mapping, start, end);
961 133586897 : if (error)
962 : return error;
963 133586598 : truncate_pagecache_range(inode, start, end);
964 133586598 : return 0;
965 : }
966 :
967 : int
968 43039551 : xfs_free_file_space(
969 : struct xfs_inode *ip,
970 : xfs_off_t offset,
971 : xfs_off_t len)
972 : {
973 43039551 : struct xfs_mount *mp = ip->i_mount;
974 43039551 : xfs_fileoff_t startoffset_fsb;
975 43039551 : xfs_fileoff_t endoffset_fsb;
976 43039551 : int done = 0, error;
977 :
978 43039551 : trace_xfs_free_file_space(ip);
979 :
980 43039273 : error = xfs_qm_dqattach(ip);
981 43039130 : if (error)
982 : return error;
983 :
984 43039130 : if (len <= 0) /* if nothing being freed */
985 : return 0;
986 :
987 43039130 : startoffset_fsb = XFS_B_TO_FSB(mp, offset);
988 43039130 : endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
989 :
990 : /* We can only free complete realtime extents. */
991 43039130 : if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1) {
992 1441045 : startoffset_fsb = roundup_64(startoffset_fsb,
993 : mp->m_sb.sb_rextsize);
994 1441043 : 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 43039130 : if (endoffset_fsb > startoffset_fsb) {
1002 86379578 : while (!done) {
1003 44299460 : error = xfs_unmap_extent(ip, startoffset_fsb,
1004 : endoffset_fsb - startoffset_fsb, &done);
1005 44300065 : if (error)
1006 64580 : 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 85950310 : if (offset >= XFS_ISIZE(ip))
1017 : return 0;
1018 40958385 : if (offset + len > XFS_ISIZE(ip))
1019 569925 : len = XFS_ISIZE(ip) - offset;
1020 40958385 : error = xfs_zero_range(ip, offset, len, NULL);
1021 40958318 : 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 81914488 : if (offset + len >= XFS_ISIZE(ip) && offset_in_page(offset + len) > 0) {
1031 731486 : 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 3981152 : xfs_prepare_shift(
1040 : struct xfs_inode *ip,
1041 : loff_t offset)
1042 : {
1043 3981152 : struct xfs_mount *mp = ip->i_mount;
1044 3981152 : int error;
1045 :
1046 : /*
1047 : * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1048 : * into the accessible region of the file.
1049 : */
1050 3981152 : if (xfs_can_free_eofblocks(ip, true)) {
1051 1605899 : error = xfs_free_eofblocks(ip);
1052 1605913 : 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 3981162 : offset = round_down(offset, mp->m_sb.sb_blocksize);
1064 3981162 : if (offset)
1065 3811303 : 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 7962324 : error = xfs_flush_unmap_range(ip, offset, XFS_ISIZE(ip));
1072 3981163 : 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 7962232 : if (xfs_inode_has_cow_data(ip)) {
1081 1366333 : error = xfs_reflink_cancel_cow_range(ip, offset, NULLFILEOFF,
1082 : true);
1083 1366332 : if (error)
1084 1 : 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 2291047 : xfs_collapse_file_space(
1104 : struct xfs_inode *ip,
1105 : xfs_off_t offset,
1106 : xfs_off_t len)
1107 : {
1108 2291047 : struct xfs_mount *mp = ip->i_mount;
1109 2291047 : struct xfs_trans *tp;
1110 2291047 : int error;
1111 2291047 : xfs_fileoff_t next_fsb = XFS_B_TO_FSB(mp, offset + len);
1112 2291047 : xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
1113 2291047 : bool done = false;
1114 :
1115 2291047 : ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1116 2291040 : ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1117 :
1118 2291041 : trace_xfs_collapse_file_space(ip);
1119 :
1120 2291040 : error = xfs_free_file_space(ip, offset, len);
1121 2291040 : if (error)
1122 : return error;
1123 :
1124 2289017 : error = xfs_prepare_shift(ip, offset);
1125 2289032 : if (error)
1126 : return error;
1127 :
1128 2288999 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1129 2288997 : if (error)
1130 : return error;
1131 :
1132 2288997 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1133 2288999 : xfs_trans_ijoin(tp, ip, 0);
1134 :
1135 104107647 : while (!done) {
1136 104107646 : error = xfs_bmap_collapse_extents(tp, ip, &next_fsb, shift_fsb,
1137 : &done);
1138 104107648 : if (error)
1139 1 : goto out_trans_cancel;
1140 104107647 : if (done)
1141 : break;
1142 :
1143 : /* finish any deferred frees and roll the transaction */
1144 101818653 : error = xfs_defer_finish(&tp);
1145 101818652 : if (error)
1146 4 : goto out_trans_cancel;
1147 : }
1148 :
1149 2288994 : error = xfs_trans_commit(tp);
1150 2288994 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1151 2288994 : return error;
1152 :
1153 5 : out_trans_cancel:
1154 5 : xfs_trans_cancel(tp);
1155 5 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1156 5 : 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 1692132 : xfs_insert_file_space(
1173 : struct xfs_inode *ip,
1174 : loff_t offset,
1175 : loff_t len)
1176 : {
1177 1692132 : struct xfs_mount *mp = ip->i_mount;
1178 1692132 : struct xfs_trans *tp;
1179 1692132 : int error;
1180 1692132 : xfs_fileoff_t stop_fsb = XFS_B_TO_FSB(mp, offset);
1181 1692132 : xfs_fileoff_t next_fsb = NULLFSBLOCK;
1182 1692132 : xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
1183 1692132 : bool done = false;
1184 :
1185 1692132 : ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1186 1692130 : ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1187 :
1188 1692130 : trace_xfs_insert_file_space(ip);
1189 :
1190 1692129 : error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb);
1191 1692136 : if (error)
1192 : return error;
1193 :
1194 1692137 : error = xfs_prepare_shift(ip, offset);
1195 1692134 : if (error)
1196 : return error;
1197 :
1198 1692117 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write,
1199 1692117 : XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp);
1200 1692120 : if (error)
1201 : return error;
1202 :
1203 1689782 : xfs_ilock(ip, XFS_ILOCK_EXCL);
1204 1689781 : xfs_trans_ijoin(tp, ip, 0);
1205 :
1206 1689780 : error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
1207 : XFS_IEXT_PUNCH_HOLE_CNT);
1208 1689779 : if (error == -EFBIG)
1209 11 : error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
1210 1689779 : if (error)
1211 11 : 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 1689768 : error = xfs_bmap_split_extent(tp, ip, stop_fsb);
1219 1689769 : if (error)
1220 0 : goto out_trans_cancel;
1221 :
1222 8439151 : do {
1223 8439151 : error = xfs_defer_finish(&tp);
1224 8439149 : if (error)
1225 1 : goto out_trans_cancel;
1226 :
1227 8439148 : error = xfs_bmap_insert_extents(tp, ip, &next_fsb, shift_fsb,
1228 : &done, stop_fsb);
1229 8439152 : if (error)
1230 0 : goto out_trans_cancel;
1231 8439152 : } while (!done);
1232 :
1233 1689770 : error = xfs_trans_commit(tp);
1234 1689770 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1235 1689770 : return error;
1236 :
1237 12 : out_trans_cancel:
1238 12 : xfs_trans_cancel(tp);
1239 12 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1240 12 : 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 28814 : xfs_swap_extents_check_format(
1265 : struct xfs_inode *ip, /* target inode */
1266 : struct xfs_inode *tip) /* tmp inode */
1267 : {
1268 28814 : struct xfs_ifork *ifp = &ip->i_df;
1269 28814 : struct xfs_ifork *tifp = &tip->i_df;
1270 :
1271 : /* User/group/project quota ids must match if quotas are enforced. */
1272 28814 : if (XFS_IS_QUOTA_ON(ip->i_mount) &&
1273 14234 : (!uid_eq(VFS_I(ip)->i_uid, VFS_I(tip)->i_uid) ||
1274 14234 : !gid_eq(VFS_I(ip)->i_gid, VFS_I(tip)->i_gid) ||
1275 14234 : ip->i_projid != tip->i_projid))
1276 : return -EINVAL;
1277 :
1278 : /* Should never get a local format */
1279 28814 : if (ifp->if_format == XFS_DINODE_FMT_LOCAL ||
1280 28814 : 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 28814 : 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 28794 : 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 11168 : 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 11168 : if (tifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1308 10264 : 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 11168 : if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1313 7903 : 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 11168 : if (tifp->if_format == XFS_DINODE_FMT_BTREE) {
1326 904 : 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 904 : if (tifp->if_nextents <= XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1330 : return -EINVAL;
1331 : }
1332 :
1333 : /* Reciprocal target->temp btree format checks */
1334 11168 : if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
1335 3265 : if (xfs_inode_has_attr_fork(tip) &&
1336 2349 : XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > xfs_inode_fork_boff(tip))
1337 : return -EINVAL;
1338 3265 : 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 57628 : xfs_swap_extent_flush(
1347 : struct xfs_inode *ip)
1348 : {
1349 57628 : int error;
1350 :
1351 57628 : error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1352 57628 : if (error)
1353 : return error;
1354 57628 : truncate_pagecache_range(VFS_I(ip), 0, -1);
1355 :
1356 : /* Verify O_DIRECT for ftmp */
1357 57628 : 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 17626 : xfs_swap_extent_rmap(
1367 : struct xfs_trans **tpp,
1368 : struct xfs_inode *ip,
1369 : struct xfs_inode *tip)
1370 : {
1371 17626 : struct xfs_trans *tp = *tpp;
1372 17626 : struct xfs_bmbt_irec irec;
1373 17626 : struct xfs_bmbt_irec uirec;
1374 17626 : struct xfs_bmbt_irec tirec;
1375 17626 : xfs_fileoff_t offset_fsb;
1376 17626 : xfs_fileoff_t end_fsb;
1377 17626 : xfs_filblks_t count_fsb;
1378 17626 : int error;
1379 17626 : xfs_filblks_t ilen;
1380 17626 : xfs_filblks_t rlen;
1381 17626 : int nimaps;
1382 17626 : 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 17626 : tip_flags2 = tip->i_diflags2;
1391 17626 : if (ip->i_diflags2 & XFS_DIFLAG2_REFLINK)
1392 459 : tip->i_diflags2 |= XFS_DIFLAG2_REFLINK;
1393 :
1394 17626 : offset_fsb = 0;
1395 17626 : end_fsb = XFS_B_TO_FSB(ip->i_mount, i_size_read(VFS_I(ip)));
1396 17626 : count_fsb = (xfs_filblks_t)(end_fsb - offset_fsb);
1397 :
1398 269424 : while (count_fsb) {
1399 : /* Read extent from the donor file */
1400 251819 : nimaps = 1;
1401 251819 : error = xfs_bmapi_read(tip, offset_fsb, count_fsb, &tirec,
1402 : &nimaps, 0);
1403 251819 : if (error)
1404 0 : goto out;
1405 251819 : ASSERT(nimaps == 1);
1406 251819 : ASSERT(tirec.br_startblock != DELAYSTARTBLOCK);
1407 :
1408 251819 : trace_xfs_swap_extent_rmap_remap(tip, &tirec);
1409 251819 : ilen = tirec.br_blockcount;
1410 :
1411 : /* Unmap the old blocks in the source file. */
1412 824155 : while (tirec.br_blockcount) {
1413 572357 : ASSERT(tp->t_highest_agno == NULLAGNUMBER);
1414 572357 : trace_xfs_swap_extent_rmap_remap_piece(tip, &tirec);
1415 :
1416 : /* Read extent from the source file */
1417 572357 : nimaps = 1;
1418 572357 : error = xfs_bmapi_read(ip, tirec.br_startoff,
1419 : tirec.br_blockcount, &irec,
1420 : &nimaps, 0);
1421 572357 : if (error)
1422 0 : goto out;
1423 572357 : ASSERT(nimaps == 1);
1424 572357 : ASSERT(tirec.br_startoff == irec.br_startoff);
1425 572357 : trace_xfs_swap_extent_rmap_remap_piece(ip, &irec);
1426 :
1427 : /* Trim the extent. */
1428 572357 : uirec = tirec;
1429 572357 : uirec.br_blockcount = rlen = min_t(xfs_filblks_t,
1430 : tirec.br_blockcount,
1431 : irec.br_blockcount);
1432 572357 : trace_xfs_swap_extent_rmap_remap_piece(tip, &uirec);
1433 :
1434 1027500 : if (xfs_bmap_is_real_extent(&uirec)) {
1435 455143 : error = xfs_iext_count_may_overflow(ip,
1436 : XFS_DATA_FORK,
1437 : XFS_IEXT_SWAP_RMAP_CNT);
1438 455143 : if (error == -EFBIG)
1439 0 : error = xfs_iext_count_upgrade(tp, ip,
1440 : XFS_IEXT_SWAP_RMAP_CNT);
1441 455143 : if (error)
1442 0 : goto out;
1443 : }
1444 :
1445 1028511 : if (xfs_bmap_is_real_extent(&irec)) {
1446 456154 : error = xfs_iext_count_may_overflow(tip,
1447 : XFS_DATA_FORK,
1448 : XFS_IEXT_SWAP_RMAP_CNT);
1449 456154 : if (error == -EFBIG)
1450 6 : error = xfs_iext_count_upgrade(tp, ip,
1451 : XFS_IEXT_SWAP_RMAP_CNT);
1452 456154 : if (error)
1453 6 : goto out;
1454 : }
1455 :
1456 : /* Remove the mapping from the donor file. */
1457 572351 : xfs_bmap_unmap_extent(tp, tip, &uirec);
1458 :
1459 : /* Remove the mapping from the source file. */
1460 572351 : xfs_bmap_unmap_extent(tp, ip, &irec);
1461 :
1462 : /* Map the donor file's blocks into the source file. */
1463 572351 : xfs_bmap_map_extent(tp, ip, &uirec);
1464 :
1465 : /* Map the source file's blocks into the donor file. */
1466 572351 : xfs_bmap_map_extent(tp, tip, &irec);
1467 :
1468 572351 : error = xfs_defer_finish(tpp);
1469 572351 : tp = *tpp;
1470 572351 : if (error)
1471 15 : goto out;
1472 :
1473 572336 : tirec.br_startoff += rlen;
1474 572336 : if (tirec.br_startblock != HOLESTARTBLOCK &&
1475 : tirec.br_startblock != DELAYSTARTBLOCK)
1476 455122 : tirec.br_startblock += rlen;
1477 572336 : tirec.br_blockcount -= rlen;
1478 : }
1479 :
1480 : /* Roll on... */
1481 251798 : count_fsb -= ilen;
1482 251798 : offset_fsb += ilen;
1483 : }
1484 :
1485 17605 : tip->i_diflags2 = tip_flags2;
1486 17605 : return 0;
1487 :
1488 21 : out:
1489 21 : trace_xfs_swap_extent_rmap_error(ip, error, _RET_IP_);
1490 21 : tip->i_diflags2 = tip_flags2;
1491 21 : return error;
1492 : }
1493 :
1494 : /* Swap the extents of two files by swapping data forks. */
1495 : STATIC int
1496 11168 : 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 11168 : xfs_filblks_t aforkblks = 0;
1504 11168 : xfs_filblks_t taforkblks = 0;
1505 11168 : xfs_extnum_t junk;
1506 11168 : uint64_t tmp;
1507 11168 : int error;
1508 :
1509 : /*
1510 : * Count the number of extended attribute blocks
1511 : */
1512 11168 : if (xfs_inode_has_attr_fork(ip) && ip->i_af.if_nextents > 0 &&
1513 1377 : ip->i_af.if_format != XFS_DINODE_FMT_LOCAL) {
1514 1377 : error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &junk,
1515 : &aforkblks);
1516 1377 : if (error)
1517 : return error;
1518 : }
1519 11168 : 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 11168 : if (xfs_has_v3inodes(ip->i_mount)) {
1535 11168 : if (ip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1536 3265 : (*target_log_flags) |= XFS_ILOG_DOWNER;
1537 11168 : if (tip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1538 904 : (*src_log_flags) |= XFS_ILOG_DOWNER;
1539 : }
1540 :
1541 : /*
1542 : * Swap the data forks of the inodes
1543 : */
1544 11168 : swap(ip->i_df, tip->i_df);
1545 :
1546 : /*
1547 : * Fix the on-disk inode values
1548 : */
1549 11168 : tmp = (uint64_t)ip->i_nblocks;
1550 11168 : ip->i_nblocks = tip->i_nblocks - taforkblks + aforkblks;
1551 11168 : 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 11168 : ASSERT(tip->i_delayed_blks == 0);
1563 11168 : tip->i_delayed_blks = ip->i_delayed_blks;
1564 11168 : ip->i_delayed_blks = 0;
1565 :
1566 11168 : switch (ip->i_df.if_format) {
1567 10264 : case XFS_DINODE_FMT_EXTENTS:
1568 10264 : (*src_log_flags) |= XFS_ILOG_DEXT;
1569 10264 : break;
1570 904 : case XFS_DINODE_FMT_BTREE:
1571 904 : ASSERT(!xfs_has_v3inodes(ip->i_mount) ||
1572 : (*src_log_flags & XFS_ILOG_DOWNER));
1573 904 : (*src_log_flags) |= XFS_ILOG_DBROOT;
1574 904 : break;
1575 : }
1576 :
1577 11168 : switch (tip->i_df.if_format) {
1578 7903 : case XFS_DINODE_FMT_EXTENTS:
1579 7903 : (*target_log_flags) |= XFS_ILOG_DEXT;
1580 7903 : break;
1581 3265 : case XFS_DINODE_FMT_BTREE:
1582 3265 : (*target_log_flags) |= XFS_ILOG_DBROOT;
1583 3265 : 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 4169 : xfs_swap_change_owner(
1601 : struct xfs_trans **tpp,
1602 : struct xfs_inode *ip,
1603 : struct xfs_inode *tmpip)
1604 : {
1605 4169 : int error;
1606 4169 : struct xfs_trans *tp = *tpp;
1607 :
1608 12623 : do {
1609 8396 : error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK, ip->i_ino,
1610 : NULL);
1611 : /* success or fatal error */
1612 8396 : if (error != -EAGAIN)
1613 : break;
1614 :
1615 4227 : error = xfs_trans_roll(tpp);
1616 4227 : if (error)
1617 : break;
1618 4227 : tp = *tpp;
1619 :
1620 : /*
1621 : * Redirty both inodes so they can relog and keep the log tail
1622 : * moving forward.
1623 : */
1624 4227 : xfs_trans_ijoin(tp, ip, 0);
1625 4227 : xfs_trans_ijoin(tp, tmpip, 0);
1626 4227 : xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1627 4227 : xfs_trans_log_inode(tp, tmpip, XFS_ILOG_CORE);
1628 : } while (true);
1629 :
1630 4169 : return error;
1631 : }
1632 :
1633 : int
1634 28814 : xfs_swap_extents(
1635 : struct xfs_inode *ip, /* target inode */
1636 : struct xfs_inode *tip, /* tmp inode */
1637 : struct xfs_swapext *sxp)
1638 : {
1639 28814 : struct xfs_mount *mp = ip->i_mount;
1640 28814 : struct xfs_trans *tp;
1641 28814 : struct xfs_bstat *sbp = &sxp->sx_stat;
1642 28814 : int src_log_flags, target_log_flags;
1643 28814 : int error = 0;
1644 28814 : uint64_t f;
1645 28814 : int resblks = 0;
1646 28814 : 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 28814 : lock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1655 28814 : 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 28814 : 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 64066 : if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
1666 0 : error = -EINVAL;
1667 0 : goto out_unlock;
1668 : }
1669 :
1670 28814 : error = xfs_qm_dqattach(ip);
1671 28814 : if (error)
1672 0 : goto out_unlock;
1673 :
1674 28814 : error = xfs_qm_dqattach(tip);
1675 28814 : if (error)
1676 0 : goto out_unlock;
1677 :
1678 28814 : error = xfs_swap_extent_flush(ip);
1679 28814 : if (error)
1680 0 : goto out_unlock;
1681 28814 : error = xfs_swap_extent_flush(tip);
1682 28814 : if (error)
1683 0 : goto out_unlock;
1684 :
1685 57628 : 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 28814 : if (xfs_has_rmapbt(mp)) {
1697 17626 : int w = XFS_DATA_FORK;
1698 17626 : uint32_t ipnext = ip->i_df.if_nextents;
1699 17626 : 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 17626 : resblks = XFS_SWAP_RMAP_SPACE_RES(mp, ipnext, w);
1707 17626 : 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 17626 : flags |= XFS_TRANS_RES_FDBLKS;
1717 : }
1718 28814 : error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, flags,
1719 : &tp);
1720 28814 : 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 28814 : xfs_lock_two_inodes(ip, XFS_ILOCK_EXCL, tip, XFS_ILOCK_EXCL);
1728 28814 : xfs_trans_ijoin(tp, ip, 0);
1729 28814 : xfs_trans_ijoin(tp, tip, 0);
1730 :
1731 :
1732 : /* Verify all data are being swapped */
1733 28814 : if (sxp->sx_offset != 0 ||
1734 28814 : sxp->sx_length != ip->i_disk_size ||
1735 28814 : sxp->sx_length != tip->i_disk_size) {
1736 0 : error = -EFAULT;
1737 0 : goto out_trans_cancel;
1738 : }
1739 :
1740 28814 : trace_xfs_swap_extent_before(ip, 0);
1741 28814 : trace_xfs_swap_extent_before(tip, 1);
1742 :
1743 : /* check inode formats now that data is flushed */
1744 28814 : error = xfs_swap_extents_check_format(ip, tip);
1745 28814 : if (error) {
1746 20 : xfs_notice(mp,
1747 : "%s: inode 0x%llx format is incompatible for exchanging.",
1748 : __func__, ip->i_ino);
1749 20 : 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 28794 : if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
1760 28794 : (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
1761 28794 : (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
1762 28794 : (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 28794 : src_log_flags = XFS_ILOG_CORE;
1775 28794 : target_log_flags = XFS_ILOG_CORE;
1776 :
1777 28794 : if (xfs_has_rmapbt(mp))
1778 17626 : error = xfs_swap_extent_rmap(&tp, ip, tip);
1779 : else
1780 11168 : error = xfs_swap_extent_forks(tp, ip, tip, &src_log_flags,
1781 : &target_log_flags);
1782 28794 : if (error)
1783 21 : goto out_trans_cancel;
1784 :
1785 : /* Do we have to swap reflink flags? */
1786 28773 : if ((ip->i_diflags2 & XFS_DIFLAG2_REFLINK) ^
1787 28773 : (tip->i_diflags2 & XFS_DIFLAG2_REFLINK)) {
1788 444 : f = ip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1789 444 : ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1790 444 : ip->i_diflags2 |= tip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1791 444 : tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1792 444 : tip->i_diflags2 |= f & XFS_DIFLAG2_REFLINK;
1793 : }
1794 :
1795 : /* Swap the cow forks. */
1796 28773 : if (xfs_has_reflink(mp)) {
1797 17605 : ASSERT(!ip->i_cowfp ||
1798 : ip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1799 17605 : ASSERT(!tip->i_cowfp ||
1800 : tip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1801 :
1802 17605 : swap(ip->i_cowfp, tip->i_cowfp);
1803 :
1804 17605 : if (ip->i_cowfp && ip->i_cowfp->if_bytes)
1805 0 : xfs_inode_set_cowblocks_tag(ip);
1806 : else
1807 17605 : xfs_inode_clear_cowblocks_tag(ip);
1808 17605 : if (tip->i_cowfp && tip->i_cowfp->if_bytes)
1809 0 : xfs_inode_set_cowblocks_tag(tip);
1810 : else
1811 17605 : xfs_inode_clear_cowblocks_tag(tip);
1812 : }
1813 :
1814 28773 : xfs_trans_log_inode(tp, ip, src_log_flags);
1815 28773 : 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 28773 : if (src_log_flags & XFS_ILOG_DOWNER) {
1824 904 : error = xfs_swap_change_owner(&tp, ip, tip);
1825 904 : if (error)
1826 0 : goto out_trans_cancel;
1827 : }
1828 28773 : if (target_log_flags & XFS_ILOG_DOWNER) {
1829 3265 : error = xfs_swap_change_owner(&tp, tip, ip);
1830 3265 : 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 28773 : if (xfs_has_wsync(mp))
1839 0 : xfs_trans_set_sync(tp);
1840 :
1841 28773 : error = xfs_trans_commit(tp);
1842 :
1843 28773 : trace_xfs_swap_extent_after(ip, 0);
1844 28773 : trace_xfs_swap_extent_after(tip, 1);
1845 :
1846 28814 : out_unlock_ilock:
1847 28814 : xfs_iunlock(ip, XFS_ILOCK_EXCL);
1848 28814 : xfs_iunlock(tip, XFS_ILOCK_EXCL);
1849 28814 : out_unlock:
1850 28814 : filemap_invalidate_unlock_two(VFS_I(ip)->i_mapping,
1851 : VFS_I(tip)->i_mapping);
1852 28814 : unlock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1853 28814 : return error;
1854 :
1855 41 : out_trans_cancel:
1856 41 : xfs_trans_cancel(tp);
1857 41 : goto out_unlock_ilock;
1858 : }
|
