Loading...
Note: File does not exist in v3.1.
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 */
39xfs_daddr_t
40xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
41{
42 if (XFS_IS_REALTIME_INODE(ip))
43 return XFS_FSB_TO_BB(ip->i_mount, fsb);
44 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 */
54int
55xfs_zero_extent(
56 struct xfs_inode *ip,
57 xfs_fsblock_t start_fsb,
58 xfs_off_t count_fsb)
59{
60 struct xfs_mount *mp = ip->i_mount;
61 struct xfs_buftarg *target = xfs_inode_buftarg(ip);
62 xfs_daddr_t sector = xfs_fsb_to_db(ip, start_fsb);
63 sector_t block = XFS_BB_TO_FSBT(mp, sector);
64
65 return blkdev_issue_zeroout(target->bt_bdev,
66 block << (mp->m_super->s_blocksize_bits - 9),
67 count_fsb << (mp->m_super->s_blocksize_bits - 9),
68 GFP_NOFS, 0);
69}
70
71#ifdef CONFIG_XFS_RT
72int
73xfs_bmap_rtalloc(
74 struct xfs_bmalloca *ap)
75{
76 struct xfs_mount *mp = ap->ip->i_mount;
77 xfs_fileoff_t orig_offset = ap->offset;
78 xfs_rtblock_t rtb;
79 xfs_extlen_t prod = 0; /* product factor for allocators */
80 xfs_extlen_t mod = 0; /* product factor for allocators */
81 xfs_extlen_t ralen = 0; /* realtime allocation length */
82 xfs_extlen_t align; /* minimum allocation alignment */
83 xfs_extlen_t orig_length = ap->length;
84 xfs_extlen_t minlen = mp->m_sb.sb_rextsize;
85 xfs_extlen_t raminlen;
86 bool rtlocked = false;
87 bool ignore_locality = false;
88 int error;
89
90 align = xfs_get_extsz_hint(ap->ip);
91retry:
92 prod = align / mp->m_sb.sb_rextsize;
93 error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
94 align, 1, ap->eof, 0,
95 ap->conv, &ap->offset, &ap->length);
96 if (error)
97 return error;
98 ASSERT(ap->length);
99 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 if (ap->offset != orig_offset)
108 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 div_u64_rem(ap->offset, align, &mod);
115 if (mod || ap->length % align)
116 prod = 1;
117 /*
118 * Set ralen to be the actual requested length in rtextents.
119 */
120 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 if (ralen * mp->m_sb.sb_rextsize >= XFS_MAX_BMBT_EXTLEN)
129 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 if (!rtlocked) {
135 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
136 xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
137 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
138 xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL);
139 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 if (ap->eof && ap->offset == 0) {
147 xfs_rtblock_t rtx; /* realtime extent no */
148
149 error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
150 if (error)
151 return error;
152 ap->blkno = rtx * mp->m_sb.sb_rextsize;
153 } else {
154 ap->blkno = 0;
155 }
156
157 xfs_bmap_adjacent(ap);
158
159 /*
160 * Realtime allocation, done through xfs_rtallocate_extent.
161 */
162 if (ignore_locality)
163 ap->blkno = 0;
164 else
165 do_div(ap->blkno, mp->m_sb.sb_rextsize);
166 rtb = ap->blkno;
167 ap->length = ralen;
168 raminlen = max_t(xfs_extlen_t, 1, minlen / mp->m_sb.sb_rextsize);
169 error = xfs_rtallocate_extent(ap->tp, ap->blkno, raminlen, ap->length,
170 &ralen, ap->wasdel, prod, &rtb);
171 if (error)
172 return error;
173
174 if (rtb != NULLRTBLOCK) {
175 ap->blkno = rtb * mp->m_sb.sb_rextsize;
176 ap->length = ralen * mp->m_sb.sb_rextsize;
177 ap->ip->i_nblocks += ap->length;
178 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
179 if (ap->wasdel)
180 ap->ip->i_delayed_blks -= ap->length;
181 /*
182 * Adjust the disk quota also. This was reserved
183 * earlier.
184 */
185 xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
186 ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
187 XFS_TRANS_DQ_RTBCOUNT, ap->length);
188 return 0;
189 }
190
191 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 ap->offset = orig_offset;
199 ap->length = orig_length;
200 minlen = align = mp->m_sb.sb_rextsize;
201 goto retry;
202 }
203
204 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 ignore_locality = true;
210 goto retry;
211 }
212
213 ap->blkno = NULLFSBLOCK;
214 ap->length = 0;
215 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 */
227xfs_extnum_t
228xfs_bmap_count_leaves(
229 struct xfs_ifork *ifp,
230 xfs_filblks_t *count)
231{
232 struct xfs_iext_cursor icur;
233 struct xfs_bmbt_irec got;
234 xfs_extnum_t numrecs = 0;
235
236 for_each_xfs_iext(ifp, &icur, &got) {
237 if (!isnullstartblock(got.br_startblock)) {
238 *count += got.br_blockcount;
239 numrecs++;
240 }
241 }
242
243 return numrecs;
244}
245
246/*
247 * Count fsblocks of the given fork. Delayed allocation extents are
248 * not counted towards the totals.
249 */
250int
251xfs_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 struct xfs_mount *mp = ip->i_mount;
259 struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
260 struct xfs_btree_cur *cur;
261 xfs_extlen_t btblocks = 0;
262 int error;
263
264 *nextents = 0;
265 *count = 0;
266
267 if (!ifp)
268 return 0;
269
270 switch (ifp->if_format) {
271 case XFS_DINODE_FMT_BTREE:
272 error = xfs_iread_extents(tp, ip, whichfork);
273 if (error)
274 return error;
275
276 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
277 error = xfs_btree_count_blocks(cur, &btblocks);
278 xfs_btree_del_cursor(cur, error);
279 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 *count += btblocks - 1;
288
289 fallthrough;
290 case XFS_DINODE_FMT_EXTENTS:
291 *nextents = xfs_bmap_count_leaves(ifp, count);
292 break;
293 }
294
295 return 0;
296}
297
298static int
299xfs_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 struct kgetbmap *p = out + bmv->bmv_entries;
307 bool shared = false;
308 int error;
309
310 error = xfs_reflink_trim_around_shared(ip, got, &shared);
311 if (error)
312 return error;
313
314 if (isnullstartblock(got->br_startblock) ||
315 got->br_startblock == DELAYSTARTBLOCK) {
316 /*
317 * Delalloc extents that start beyond EOF can occur due to
318 * speculative EOF allocation when the delalloc extent is larger
319 * than the largest freespace extent at conversion time. These
320 * extents cannot be converted by data writeback, so can exist
321 * here even if we are not supposed to be finding delalloc
322 * extents.
323 */
324 if (got->br_startoff < XFS_B_TO_FSB(ip->i_mount, XFS_ISIZE(ip)))
325 ASSERT((bmv->bmv_iflags & BMV_IF_DELALLOC) != 0);
326
327 p->bmv_oflags |= BMV_OF_DELALLOC;
328 p->bmv_block = -2;
329 } else {
330 p->bmv_block = xfs_fsb_to_db(ip, got->br_startblock);
331 }
332
333 if (got->br_state == XFS_EXT_UNWRITTEN &&
334 (bmv->bmv_iflags & BMV_IF_PREALLOC))
335 p->bmv_oflags |= BMV_OF_PREALLOC;
336
337 if (shared)
338 p->bmv_oflags |= BMV_OF_SHARED;
339
340 p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, got->br_startoff);
341 p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, got->br_blockcount);
342
343 bmv->bmv_offset = p->bmv_offset + p->bmv_length;
344 bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
345 bmv->bmv_entries++;
346 return 0;
347}
348
349static void
350xfs_getbmap_report_hole(
351 struct xfs_inode *ip,
352 struct getbmapx *bmv,
353 struct kgetbmap *out,
354 int64_t bmv_end,
355 xfs_fileoff_t bno,
356 xfs_fileoff_t end)
357{
358 struct kgetbmap *p = out + bmv->bmv_entries;
359
360 if (bmv->bmv_iflags & BMV_IF_NO_HOLES)
361 return;
362
363 p->bmv_block = -1;
364 p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, bno);
365 p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, end - bno);
366
367 bmv->bmv_offset = p->bmv_offset + p->bmv_length;
368 bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
369 bmv->bmv_entries++;
370}
371
372static inline bool
373xfs_getbmap_full(
374 struct getbmapx *bmv)
375{
376 return bmv->bmv_length == 0 || bmv->bmv_entries >= bmv->bmv_count - 1;
377}
378
379static bool
380xfs_getbmap_next_rec(
381 struct xfs_bmbt_irec *rec,
382 xfs_fileoff_t total_end)
383{
384 xfs_fileoff_t end = rec->br_startoff + rec->br_blockcount;
385
386 if (end == total_end)
387 return false;
388
389 rec->br_startoff += rec->br_blockcount;
390 if (!isnullstartblock(rec->br_startblock) &&
391 rec->br_startblock != DELAYSTARTBLOCK)
392 rec->br_startblock += rec->br_blockcount;
393 rec->br_blockcount = total_end - end;
394 return true;
395}
396
397/*
398 * Get inode's extents as described in bmv, and format for output.
399 * Calls formatter to fill the user's buffer until all extents
400 * are mapped, until the passed-in bmv->bmv_count slots have
401 * been filled, or until the formatter short-circuits the loop,
402 * if it is tracking filled-in extents on its own.
403 */
404int /* error code */
405xfs_getbmap(
406 struct xfs_inode *ip,
407 struct getbmapx *bmv, /* user bmap structure */
408 struct kgetbmap *out)
409{
410 struct xfs_mount *mp = ip->i_mount;
411 int iflags = bmv->bmv_iflags;
412 int whichfork, lock, error = 0;
413 int64_t bmv_end, max_len;
414 xfs_fileoff_t bno, first_bno;
415 struct xfs_ifork *ifp;
416 struct xfs_bmbt_irec got, rec;
417 xfs_filblks_t len;
418 struct xfs_iext_cursor icur;
419
420 if (bmv->bmv_iflags & ~BMV_IF_VALID)
421 return -EINVAL;
422#ifndef DEBUG
423 /* Only allow CoW fork queries if we're debugging. */
424 if (iflags & BMV_IF_COWFORK)
425 return -EINVAL;
426#endif
427 if ((iflags & BMV_IF_ATTRFORK) && (iflags & BMV_IF_COWFORK))
428 return -EINVAL;
429
430 if (bmv->bmv_length < -1)
431 return -EINVAL;
432 bmv->bmv_entries = 0;
433 if (bmv->bmv_length == 0)
434 return 0;
435
436 if (iflags & BMV_IF_ATTRFORK)
437 whichfork = XFS_ATTR_FORK;
438 else if (iflags & BMV_IF_COWFORK)
439 whichfork = XFS_COW_FORK;
440 else
441 whichfork = XFS_DATA_FORK;
442
443 xfs_ilock(ip, XFS_IOLOCK_SHARED);
444 switch (whichfork) {
445 case XFS_ATTR_FORK:
446 lock = xfs_ilock_attr_map_shared(ip);
447 if (!xfs_inode_has_attr_fork(ip))
448 goto out_unlock_ilock;
449
450 max_len = 1LL << 32;
451 break;
452 case XFS_COW_FORK:
453 lock = XFS_ILOCK_SHARED;
454 xfs_ilock(ip, lock);
455
456 /* No CoW fork? Just return */
457 if (!xfs_ifork_ptr(ip, whichfork))
458 goto out_unlock_ilock;
459
460 if (xfs_get_cowextsz_hint(ip))
461 max_len = mp->m_super->s_maxbytes;
462 else
463 max_len = XFS_ISIZE(ip);
464 break;
465 case XFS_DATA_FORK:
466 if (!(iflags & BMV_IF_DELALLOC) &&
467 (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_disk_size)) {
468 error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
469 if (error)
470 goto out_unlock_iolock;
471
472 /*
473 * Even after flushing the inode, there can still be
474 * delalloc blocks on the inode beyond EOF due to
475 * speculative preallocation. These are not removed
476 * until the release function is called or the inode
477 * is inactivated. Hence we cannot assert here that
478 * ip->i_delayed_blks == 0.
479 */
480 }
481
482 if (xfs_get_extsz_hint(ip) ||
483 (ip->i_diflags &
484 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))
485 max_len = mp->m_super->s_maxbytes;
486 else
487 max_len = XFS_ISIZE(ip);
488
489 lock = xfs_ilock_data_map_shared(ip);
490 break;
491 }
492
493 ifp = xfs_ifork_ptr(ip, whichfork);
494
495 switch (ifp->if_format) {
496 case XFS_DINODE_FMT_EXTENTS:
497 case XFS_DINODE_FMT_BTREE:
498 break;
499 case XFS_DINODE_FMT_LOCAL:
500 /* Local format inode forks report no extents. */
501 goto out_unlock_ilock;
502 default:
503 error = -EINVAL;
504 goto out_unlock_ilock;
505 }
506
507 if (bmv->bmv_length == -1) {
508 max_len = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, max_len));
509 bmv->bmv_length = max(0LL, max_len - bmv->bmv_offset);
510 }
511
512 bmv_end = bmv->bmv_offset + bmv->bmv_length;
513
514 first_bno = bno = XFS_BB_TO_FSBT(mp, bmv->bmv_offset);
515 len = XFS_BB_TO_FSB(mp, bmv->bmv_length);
516
517 error = xfs_iread_extents(NULL, ip, whichfork);
518 if (error)
519 goto out_unlock_ilock;
520
521 if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
522 /*
523 * Report a whole-file hole if the delalloc flag is set to
524 * stay compatible with the old implementation.
525 */
526 if (iflags & BMV_IF_DELALLOC)
527 xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
528 XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));
529 goto out_unlock_ilock;
530 }
531
532 while (!xfs_getbmap_full(bmv)) {
533 xfs_trim_extent(&got, first_bno, len);
534
535 /*
536 * Report an entry for a hole if this extent doesn't directly
537 * follow the previous one.
538 */
539 if (got.br_startoff > bno) {
540 xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
541 got.br_startoff);
542 if (xfs_getbmap_full(bmv))
543 break;
544 }
545
546 /*
547 * In order to report shared extents accurately, we report each
548 * distinct shared / unshared part of a single bmbt record with
549 * an individual getbmapx record.
550 */
551 bno = got.br_startoff + got.br_blockcount;
552 rec = got;
553 do {
554 error = xfs_getbmap_report_one(ip, bmv, out, bmv_end,
555 &rec);
556 if (error || xfs_getbmap_full(bmv))
557 goto out_unlock_ilock;
558 } while (xfs_getbmap_next_rec(&rec, bno));
559
560 if (!xfs_iext_next_extent(ifp, &icur, &got)) {
561 xfs_fileoff_t end = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
562
563 out[bmv->bmv_entries - 1].bmv_oflags |= BMV_OF_LAST;
564
565 if (whichfork != XFS_ATTR_FORK && bno < end &&
566 !xfs_getbmap_full(bmv)) {
567 xfs_getbmap_report_hole(ip, bmv, out, bmv_end,
568 bno, end);
569 }
570 break;
571 }
572
573 if (bno >= first_bno + len)
574 break;
575 }
576
577out_unlock_ilock:
578 xfs_iunlock(ip, lock);
579out_unlock_iolock:
580 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
581 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 */
590int
591xfs_bmap_punch_delalloc_range(
592 struct xfs_inode *ip,
593 xfs_off_t start_byte,
594 xfs_off_t end_byte)
595{
596 struct xfs_mount *mp = ip->i_mount;
597 struct xfs_ifork *ifp = &ip->i_df;
598 xfs_fileoff_t start_fsb = XFS_B_TO_FSBT(mp, start_byte);
599 xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, end_byte);
600 struct xfs_bmbt_irec got, del;
601 struct xfs_iext_cursor icur;
602 int error = 0;
603
604 ASSERT(!xfs_need_iread_extents(ifp));
605
606 xfs_ilock(ip, XFS_ILOCK_EXCL);
607 if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
608 goto out_unlock;
609
610 while (got.br_startoff + got.br_blockcount > start_fsb) {
611 del = got;
612 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 if (!del.br_blockcount ||
620 !isnullstartblock(del.br_startblock)) {
621 if (!xfs_iext_prev_extent(ifp, &icur, &got))
622 break;
623 continue;
624 }
625
626 error = xfs_bmap_del_extent_delay(ip, XFS_DATA_FORK, &icur,
627 &got, &del);
628 if (error || !xfs_iext_get_extent(ifp, &icur, &got))
629 break;
630 }
631
632out_unlock:
633 xfs_iunlock(ip, XFS_ILOCK_EXCL);
634 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 */
642bool
643xfs_can_free_eofblocks(
644 struct xfs_inode *ip,
645 bool force)
646{
647 struct xfs_bmbt_irec imap;
648 struct xfs_mount *mp = ip->i_mount;
649 xfs_fileoff_t end_fsb;
650 xfs_fileoff_t last_fsb;
651 int nimaps = 1;
652 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 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 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 if (VFS_I(ip)->i_size == 0 &&
670 VFS_I(ip)->i_mapping->nrpages == 0 &&
671 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 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 if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
683 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 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
692 if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1)
693 end_fsb = roundup_64(end_fsb, mp->m_sb.sb_rextsize);
694 last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
695 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 xfs_ilock(ip, XFS_ILOCK_SHARED);
703 error = xfs_bmapi_read(ip, end_fsb, last_fsb - end_fsb, &imap, &nimaps,
704 0);
705 xfs_iunlock(ip, XFS_ILOCK_SHARED);
706 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 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 */
721int
722xfs_free_eofblocks(
723 struct xfs_inode *ip)
724{
725 struct xfs_trans *tp;
726 struct xfs_mount *mp = ip->i_mount;
727 int error;
728
729 /* Attach the dquots to the inode up front. */
730 error = xfs_qm_dqattach(ip);
731 if (error)
732 return error;
733
734 /* Wait on dio to ensure i_size has settled. */
735 inode_dio_wait(VFS_I(ip));
736
737 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
738 if (error) {
739 ASSERT(xfs_is_shutdown(mp));
740 return error;
741 }
742
743 xfs_ilock(ip, XFS_ILOCK_EXCL);
744 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 error = xfs_itruncate_extents_flags(&tp, ip, XFS_DATA_FORK,
753 XFS_ISIZE(ip), XFS_BMAPI_NODISCARD);
754 if (error)
755 goto err_cancel;
756
757 error = xfs_trans_commit(tp);
758 if (error)
759 goto out_unlock;
760
761 xfs_inode_clear_eofblocks_tag(ip);
762 goto out_unlock;
763
764err_cancel:
765 /*
766 * If we get an error at this point we simply don't
767 * bother truncating the file.
768 */
769 xfs_trans_cancel(tp);
770out_unlock:
771 xfs_iunlock(ip, XFS_ILOCK_EXCL);
772 return error;
773}
774
775int
776xfs_alloc_file_space(
777 struct xfs_inode *ip,
778 xfs_off_t offset,
779 xfs_off_t len)
780{
781 xfs_mount_t *mp = ip->i_mount;
782 xfs_off_t count;
783 xfs_filblks_t allocated_fsb;
784 xfs_filblks_t allocatesize_fsb;
785 xfs_extlen_t extsz, temp;
786 xfs_fileoff_t startoffset_fsb;
787 xfs_fileoff_t endoffset_fsb;
788 int nimaps;
789 int rt;
790 xfs_trans_t *tp;
791 xfs_bmbt_irec_t imaps[1], *imapp;
792 int error;
793
794 trace_xfs_alloc_file_space(ip);
795
796 if (xfs_is_shutdown(mp))
797 return -EIO;
798
799 error = xfs_qm_dqattach(ip);
800 if (error)
801 return error;
802
803 if (len <= 0)
804 return -EINVAL;
805
806 rt = XFS_IS_REALTIME_INODE(ip);
807 extsz = xfs_get_extsz_hint(ip);
808
809 count = len;
810 imapp = &imaps[0];
811 nimaps = 1;
812 startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
813 endoffset_fsb = XFS_B_TO_FSB(mp, offset + count);
814 allocatesize_fsb = endoffset_fsb - startoffset_fsb;
815
816 /*
817 * Allocate file space until done or until there is an error
818 */
819 while (allocatesize_fsb && !error) {
820 xfs_fileoff_t s, e;
821 unsigned int dblocks, rblocks, resblks;
822
823 /*
824 * Determine space reservations for data/realtime.
825 */
826 if (unlikely(extsz)) {
827 s = startoffset_fsb;
828 do_div(s, extsz);
829 s *= extsz;
830 e = startoffset_fsb + allocatesize_fsb;
831 div_u64_rem(startoffset_fsb, extsz, &temp);
832 if (temp)
833 e += temp;
834 div_u64_rem(e, extsz, &temp);
835 if (temp)
836 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 resblks = min_t(xfs_fileoff_t, (e - s),
851 (XFS_MAX_BMBT_EXTLEN * nimaps));
852 if (unlikely(rt)) {
853 dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
854 rblocks = resblks;
855 } else {
856 dblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
857 rblocks = 0;
858 }
859
860 error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
861 dblocks, rblocks, false, &tp);
862 if (error)
863 break;
864
865 error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
866 XFS_IEXT_ADD_NOSPLIT_CNT);
867 if (error == -EFBIG)
868 error = xfs_iext_count_upgrade(tp, ip,
869 XFS_IEXT_ADD_NOSPLIT_CNT);
870 if (error)
871 goto error;
872
873 error = xfs_bmapi_write(tp, ip, startoffset_fsb,
874 allocatesize_fsb, XFS_BMAPI_PREALLOC, 0, imapp,
875 &nimaps);
876 if (error)
877 goto error;
878
879 ip->i_diflags |= XFS_DIFLAG_PREALLOC;
880 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
881
882 error = xfs_trans_commit(tp);
883 xfs_iunlock(ip, XFS_ILOCK_EXCL);
884 if (error)
885 break;
886
887 allocated_fsb = imapp->br_blockcount;
888
889 if (nimaps == 0) {
890 error = -ENOSPC;
891 break;
892 }
893
894 startoffset_fsb += allocated_fsb;
895 allocatesize_fsb -= allocated_fsb;
896 }
897
898 return error;
899
900error:
901 xfs_trans_cancel(tp);
902 xfs_iunlock(ip, XFS_ILOCK_EXCL);
903 return error;
904}
905
906static int
907xfs_unmap_extent(
908 struct xfs_inode *ip,
909 xfs_fileoff_t startoffset_fsb,
910 xfs_filblks_t len_fsb,
911 int *done)
912{
913 struct xfs_mount *mp = ip->i_mount;
914 struct xfs_trans *tp;
915 uint resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
916 int error;
917
918 error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks, 0,
919 false, &tp);
920 if (error)
921 return error;
922
923 error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
924 XFS_IEXT_PUNCH_HOLE_CNT);
925 if (error == -EFBIG)
926 error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
927 if (error)
928 goto out_trans_cancel;
929
930 error = xfs_bunmapi(tp, ip, startoffset_fsb, len_fsb, 0, 2, done);
931 if (error)
932 goto out_trans_cancel;
933
934 error = xfs_trans_commit(tp);
935out_unlock:
936 xfs_iunlock(ip, XFS_ILOCK_EXCL);
937 return error;
938
939out_trans_cancel:
940 xfs_trans_cancel(tp);
941 goto out_unlock;
942}
943
944/* Caller must first wait for the completion of any pending DIOs if required. */
945int
946xfs_flush_unmap_range(
947 struct xfs_inode *ip,
948 xfs_off_t offset,
949 xfs_off_t len)
950{
951 struct xfs_mount *mp = ip->i_mount;
952 struct inode *inode = VFS_I(ip);
953 xfs_off_t rounding, start, end;
954 int error;
955
956 rounding = max_t(xfs_off_t, mp->m_sb.sb_blocksize, PAGE_SIZE);
957 start = round_down(offset, rounding);
958 end = round_up(offset + len, rounding) - 1;
959
960 error = filemap_write_and_wait_range(inode->i_mapping, start, end);
961 if (error)
962 return error;
963 truncate_pagecache_range(inode, start, end);
964 return 0;
965}
966
967int
968xfs_free_file_space(
969 struct xfs_inode *ip,
970 xfs_off_t offset,
971 xfs_off_t len)
972{
973 struct xfs_mount *mp = ip->i_mount;
974 xfs_fileoff_t startoffset_fsb;
975 xfs_fileoff_t endoffset_fsb;
976 int done = 0, error;
977
978 trace_xfs_free_file_space(ip);
979
980 error = xfs_qm_dqattach(ip);
981 if (error)
982 return error;
983
984 if (len <= 0) /* if nothing being freed */
985 return 0;
986
987 startoffset_fsb = XFS_B_TO_FSB(mp, offset);
988 endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
989
990 /* We can only free complete realtime extents. */
991 if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1) {
992 startoffset_fsb = roundup_64(startoffset_fsb,
993 mp->m_sb.sb_rextsize);
994 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 if (endoffset_fsb > startoffset_fsb) {
1002 while (!done) {
1003 error = xfs_unmap_extent(ip, startoffset_fsb,
1004 endoffset_fsb - startoffset_fsb, &done);
1005 if (error)
1006 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 if (offset >= XFS_ISIZE(ip))
1017 return 0;
1018 if (offset + len > XFS_ISIZE(ip))
1019 len = XFS_ISIZE(ip) - offset;
1020 error = xfs_zero_range(ip, offset, len, NULL);
1021 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 if (offset + len >= XFS_ISIZE(ip) && offset_in_page(offset + len) > 0) {
1031 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
1038static int
1039xfs_prepare_shift(
1040 struct xfs_inode *ip,
1041 loff_t offset)
1042{
1043 struct xfs_mount *mp = ip->i_mount;
1044 int error;
1045
1046 /*
1047 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1048 * into the accessible region of the file.
1049 */
1050 if (xfs_can_free_eofblocks(ip, true)) {
1051 error = xfs_free_eofblocks(ip);
1052 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 offset = round_down(offset, mp->m_sb.sb_blocksize);
1064 if (offset)
1065 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 error = xfs_flush_unmap_range(ip, offset, XFS_ISIZE(ip));
1072 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 if (xfs_inode_has_cow_data(ip)) {
1081 error = xfs_reflink_cancel_cow_range(ip, offset, NULLFILEOFF,
1082 true);
1083 if (error)
1084 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 */
1102int
1103xfs_collapse_file_space(
1104 struct xfs_inode *ip,
1105 xfs_off_t offset,
1106 xfs_off_t len)
1107{
1108 struct xfs_mount *mp = ip->i_mount;
1109 struct xfs_trans *tp;
1110 int error;
1111 xfs_fileoff_t next_fsb = XFS_B_TO_FSB(mp, offset + len);
1112 xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
1113 bool done = false;
1114
1115 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1116 ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1117
1118 trace_xfs_collapse_file_space(ip);
1119
1120 error = xfs_free_file_space(ip, offset, len);
1121 if (error)
1122 return error;
1123
1124 error = xfs_prepare_shift(ip, offset);
1125 if (error)
1126 return error;
1127
1128 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
1129 if (error)
1130 return error;
1131
1132 xfs_ilock(ip, XFS_ILOCK_EXCL);
1133 xfs_trans_ijoin(tp, ip, 0);
1134
1135 while (!done) {
1136 error = xfs_bmap_collapse_extents(tp, ip, &next_fsb, shift_fsb,
1137 &done);
1138 if (error)
1139 goto out_trans_cancel;
1140 if (done)
1141 break;
1142
1143 /* finish any deferred frees and roll the transaction */
1144 error = xfs_defer_finish(&tp);
1145 if (error)
1146 goto out_trans_cancel;
1147 }
1148
1149 error = xfs_trans_commit(tp);
1150 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1151 return error;
1152
1153out_trans_cancel:
1154 xfs_trans_cancel(tp);
1155 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1156 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 */
1171int
1172xfs_insert_file_space(
1173 struct xfs_inode *ip,
1174 loff_t offset,
1175 loff_t len)
1176{
1177 struct xfs_mount *mp = ip->i_mount;
1178 struct xfs_trans *tp;
1179 int error;
1180 xfs_fileoff_t stop_fsb = XFS_B_TO_FSB(mp, offset);
1181 xfs_fileoff_t next_fsb = NULLFSBLOCK;
1182 xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
1183 bool done = false;
1184
1185 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1186 ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
1187
1188 trace_xfs_insert_file_space(ip);
1189
1190 error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb);
1191 if (error)
1192 return error;
1193
1194 error = xfs_prepare_shift(ip, offset);
1195 if (error)
1196 return error;
1197
1198 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write,
1199 XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp);
1200 if (error)
1201 return error;
1202
1203 xfs_ilock(ip, XFS_ILOCK_EXCL);
1204 xfs_trans_ijoin(tp, ip, 0);
1205
1206 error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
1207 XFS_IEXT_PUNCH_HOLE_CNT);
1208 if (error == -EFBIG)
1209 error = xfs_iext_count_upgrade(tp, ip, XFS_IEXT_PUNCH_HOLE_CNT);
1210 if (error)
1211 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 error = xfs_bmap_split_extent(tp, ip, stop_fsb);
1219 if (error)
1220 goto out_trans_cancel;
1221
1222 do {
1223 error = xfs_defer_finish(&tp);
1224 if (error)
1225 goto out_trans_cancel;
1226
1227 error = xfs_bmap_insert_extents(tp, ip, &next_fsb, shift_fsb,
1228 &done, stop_fsb);
1229 if (error)
1230 goto out_trans_cancel;
1231 } while (!done);
1232
1233 error = xfs_trans_commit(tp);
1234 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1235 return error;
1236
1237out_trans_cancel:
1238 xfs_trans_cancel(tp);
1239 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1240 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 */
1263static int
1264xfs_swap_extents_check_format(
1265 struct xfs_inode *ip, /* target inode */
1266 struct xfs_inode *tip) /* tmp inode */
1267{
1268 struct xfs_ifork *ifp = &ip->i_df;
1269 struct xfs_ifork *tifp = &tip->i_df;
1270
1271 /* User/group/project quota ids must match if quotas are enforced. */
1272 if (XFS_IS_QUOTA_ON(ip->i_mount) &&
1273 (!uid_eq(VFS_I(ip)->i_uid, VFS_I(tip)->i_uid) ||
1274 !gid_eq(VFS_I(ip)->i_gid, VFS_I(tip)->i_gid) ||
1275 ip->i_projid != tip->i_projid))
1276 return -EINVAL;
1277
1278 /* Should never get a local format */
1279 if (ifp->if_format == XFS_DINODE_FMT_LOCAL ||
1280 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 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 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 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 if (tifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1308 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 if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
1313 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 if (tifp->if_format == XFS_DINODE_FMT_BTREE) {
1326 if (xfs_inode_has_attr_fork(ip) &&
1327 XFS_BMAP_BMDR_SPACE(tifp->if_broot) > xfs_inode_fork_boff(ip))
1328 return -EINVAL;
1329 if (tifp->if_nextents <= XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1330 return -EINVAL;
1331 }
1332
1333 /* Reciprocal target->temp btree format checks */
1334 if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
1335 if (xfs_inode_has_attr_fork(tip) &&
1336 XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > xfs_inode_fork_boff(tip))
1337 return -EINVAL;
1338 if (ifp->if_nextents <= XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
1339 return -EINVAL;
1340 }
1341
1342 return 0;
1343}
1344
1345static int
1346xfs_swap_extent_flush(
1347 struct xfs_inode *ip)
1348{
1349 int error;
1350
1351 error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1352 if (error)
1353 return error;
1354 truncate_pagecache_range(VFS_I(ip), 0, -1);
1355
1356 /* Verify O_DIRECT for ftmp */
1357 if (VFS_I(ip)->i_mapping->nrpages)
1358 return -EINVAL;
1359 return 0;
1360}
1361
1362/*
1363 * Move extents from one file to another, when rmap is enabled.
1364 */
1365STATIC int
1366xfs_swap_extent_rmap(
1367 struct xfs_trans **tpp,
1368 struct xfs_inode *ip,
1369 struct xfs_inode *tip)
1370{
1371 struct xfs_trans *tp = *tpp;
1372 struct xfs_bmbt_irec irec;
1373 struct xfs_bmbt_irec uirec;
1374 struct xfs_bmbt_irec tirec;
1375 xfs_fileoff_t offset_fsb;
1376 xfs_fileoff_t end_fsb;
1377 xfs_filblks_t count_fsb;
1378 int error;
1379 xfs_filblks_t ilen;
1380 xfs_filblks_t rlen;
1381 int nimaps;
1382 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 tip_flags2 = tip->i_diflags2;
1391 if (ip->i_diflags2 & XFS_DIFLAG2_REFLINK)
1392 tip->i_diflags2 |= XFS_DIFLAG2_REFLINK;
1393
1394 offset_fsb = 0;
1395 end_fsb = XFS_B_TO_FSB(ip->i_mount, i_size_read(VFS_I(ip)));
1396 count_fsb = (xfs_filblks_t)(end_fsb - offset_fsb);
1397
1398 while (count_fsb) {
1399 /* Read extent from the donor file */
1400 nimaps = 1;
1401 error = xfs_bmapi_read(tip, offset_fsb, count_fsb, &tirec,
1402 &nimaps, 0);
1403 if (error)
1404 goto out;
1405 ASSERT(nimaps == 1);
1406 ASSERT(tirec.br_startblock != DELAYSTARTBLOCK);
1407
1408 trace_xfs_swap_extent_rmap_remap(tip, &tirec);
1409 ilen = tirec.br_blockcount;
1410
1411 /* Unmap the old blocks in the source file. */
1412 while (tirec.br_blockcount) {
1413 ASSERT(tp->t_firstblock == NULLFSBLOCK);
1414 trace_xfs_swap_extent_rmap_remap_piece(tip, &tirec);
1415
1416 /* Read extent from the source file */
1417 nimaps = 1;
1418 error = xfs_bmapi_read(ip, tirec.br_startoff,
1419 tirec.br_blockcount, &irec,
1420 &nimaps, 0);
1421 if (error)
1422 goto out;
1423 ASSERT(nimaps == 1);
1424 ASSERT(tirec.br_startoff == irec.br_startoff);
1425 trace_xfs_swap_extent_rmap_remap_piece(ip, &irec);
1426
1427 /* Trim the extent. */
1428 uirec = tirec;
1429 uirec.br_blockcount = rlen = min_t(xfs_filblks_t,
1430 tirec.br_blockcount,
1431 irec.br_blockcount);
1432 trace_xfs_swap_extent_rmap_remap_piece(tip, &uirec);
1433
1434 if (xfs_bmap_is_real_extent(&uirec)) {
1435 error = xfs_iext_count_may_overflow(ip,
1436 XFS_DATA_FORK,
1437 XFS_IEXT_SWAP_RMAP_CNT);
1438 if (error == -EFBIG)
1439 error = xfs_iext_count_upgrade(tp, ip,
1440 XFS_IEXT_SWAP_RMAP_CNT);
1441 if (error)
1442 goto out;
1443 }
1444
1445 if (xfs_bmap_is_real_extent(&irec)) {
1446 error = xfs_iext_count_may_overflow(tip,
1447 XFS_DATA_FORK,
1448 XFS_IEXT_SWAP_RMAP_CNT);
1449 if (error == -EFBIG)
1450 error = xfs_iext_count_upgrade(tp, ip,
1451 XFS_IEXT_SWAP_RMAP_CNT);
1452 if (error)
1453 goto out;
1454 }
1455
1456 /* Remove the mapping from the donor file. */
1457 xfs_bmap_unmap_extent(tp, tip, &uirec);
1458
1459 /* Remove the mapping from the source file. */
1460 xfs_bmap_unmap_extent(tp, ip, &irec);
1461
1462 /* Map the donor file's blocks into the source file. */
1463 xfs_bmap_map_extent(tp, ip, &uirec);
1464
1465 /* Map the source file's blocks into the donor file. */
1466 xfs_bmap_map_extent(tp, tip, &irec);
1467
1468 error = xfs_defer_finish(tpp);
1469 tp = *tpp;
1470 if (error)
1471 goto out;
1472
1473 tirec.br_startoff += rlen;
1474 if (tirec.br_startblock != HOLESTARTBLOCK &&
1475 tirec.br_startblock != DELAYSTARTBLOCK)
1476 tirec.br_startblock += rlen;
1477 tirec.br_blockcount -= rlen;
1478 }
1479
1480 /* Roll on... */
1481 count_fsb -= ilen;
1482 offset_fsb += ilen;
1483 }
1484
1485 tip->i_diflags2 = tip_flags2;
1486 return 0;
1487
1488out:
1489 trace_xfs_swap_extent_rmap_error(ip, error, _RET_IP_);
1490 tip->i_diflags2 = tip_flags2;
1491 return error;
1492}
1493
1494/* Swap the extents of two files by swapping data forks. */
1495STATIC int
1496xfs_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 xfs_filblks_t aforkblks = 0;
1504 xfs_filblks_t taforkblks = 0;
1505 xfs_extnum_t junk;
1506 uint64_t tmp;
1507 int error;
1508
1509 /*
1510 * Count the number of extended attribute blocks
1511 */
1512 if (xfs_inode_has_attr_fork(ip) && ip->i_af.if_nextents > 0 &&
1513 ip->i_af.if_format != XFS_DINODE_FMT_LOCAL) {
1514 error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &junk,
1515 &aforkblks);
1516 if (error)
1517 return error;
1518 }
1519 if (xfs_inode_has_attr_fork(tip) && tip->i_af.if_nextents > 0 &&
1520 tip->i_af.if_format != XFS_DINODE_FMT_LOCAL) {
1521 error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK, &junk,
1522 &taforkblks);
1523 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 if (xfs_has_v3inodes(ip->i_mount)) {
1535 if (ip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1536 (*target_log_flags) |= XFS_ILOG_DOWNER;
1537 if (tip->i_df.if_format == XFS_DINODE_FMT_BTREE)
1538 (*src_log_flags) |= XFS_ILOG_DOWNER;
1539 }
1540
1541 /*
1542 * Swap the data forks of the inodes
1543 */
1544 swap(ip->i_df, tip->i_df);
1545
1546 /*
1547 * Fix the on-disk inode values
1548 */
1549 tmp = (uint64_t)ip->i_nblocks;
1550 ip->i_nblocks = tip->i_nblocks - taforkblks + aforkblks;
1551 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 ASSERT(tip->i_delayed_blks == 0);
1563 tip->i_delayed_blks = ip->i_delayed_blks;
1564 ip->i_delayed_blks = 0;
1565
1566 switch (ip->i_df.if_format) {
1567 case XFS_DINODE_FMT_EXTENTS:
1568 (*src_log_flags) |= XFS_ILOG_DEXT;
1569 break;
1570 case XFS_DINODE_FMT_BTREE:
1571 ASSERT(!xfs_has_v3inodes(ip->i_mount) ||
1572 (*src_log_flags & XFS_ILOG_DOWNER));
1573 (*src_log_flags) |= XFS_ILOG_DBROOT;
1574 break;
1575 }
1576
1577 switch (tip->i_df.if_format) {
1578 case XFS_DINODE_FMT_EXTENTS:
1579 (*target_log_flags) |= XFS_ILOG_DEXT;
1580 break;
1581 case XFS_DINODE_FMT_BTREE:
1582 (*target_log_flags) |= XFS_ILOG_DBROOT;
1583 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 */
1599static int
1600xfs_swap_change_owner(
1601 struct xfs_trans **tpp,
1602 struct xfs_inode *ip,
1603 struct xfs_inode *tmpip)
1604{
1605 int error;
1606 struct xfs_trans *tp = *tpp;
1607
1608 do {
1609 error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK, ip->i_ino,
1610 NULL);
1611 /* success or fatal error */
1612 if (error != -EAGAIN)
1613 break;
1614
1615 error = xfs_trans_roll(tpp);
1616 if (error)
1617 break;
1618 tp = *tpp;
1619
1620 /*
1621 * Redirty both inodes so they can relog and keep the log tail
1622 * moving forward.
1623 */
1624 xfs_trans_ijoin(tp, ip, 0);
1625 xfs_trans_ijoin(tp, tmpip, 0);
1626 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1627 xfs_trans_log_inode(tp, tmpip, XFS_ILOG_CORE);
1628 } while (true);
1629
1630 return error;
1631}
1632
1633int
1634xfs_swap_extents(
1635 struct xfs_inode *ip, /* target inode */
1636 struct xfs_inode *tip, /* tmp inode */
1637 struct xfs_swapext *sxp)
1638{
1639 struct xfs_mount *mp = ip->i_mount;
1640 struct xfs_trans *tp;
1641 struct xfs_bstat *sbp = &sxp->sx_stat;
1642 int src_log_flags, target_log_flags;
1643 int error = 0;
1644 uint64_t f;
1645 int resblks = 0;
1646 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 lock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1655 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 if ((VFS_I(ip)->i_mode & S_IFMT) != (VFS_I(tip)->i_mode & S_IFMT)) {
1660 error = -EINVAL;
1661 goto out_unlock;
1662 }
1663
1664 /* Verify both files are either real-time or non-realtime */
1665 if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
1666 error = -EINVAL;
1667 goto out_unlock;
1668 }
1669
1670 error = xfs_qm_dqattach(ip);
1671 if (error)
1672 goto out_unlock;
1673
1674 error = xfs_qm_dqattach(tip);
1675 if (error)
1676 goto out_unlock;
1677
1678 error = xfs_swap_extent_flush(ip);
1679 if (error)
1680 goto out_unlock;
1681 error = xfs_swap_extent_flush(tip);
1682 if (error)
1683 goto out_unlock;
1684
1685 if (xfs_inode_has_cow_data(tip)) {
1686 error = xfs_reflink_cancel_cow_range(tip, 0, NULLFILEOFF, true);
1687 if (error)
1688 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 if (xfs_has_rmapbt(mp)) {
1697 int w = XFS_DATA_FORK;
1698 uint32_t ipnext = ip->i_df.if_nextents;
1699 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 resblks = XFS_SWAP_RMAP_SPACE_RES(mp, ipnext, w);
1707 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 flags |= XFS_TRANS_RES_FDBLKS;
1717 }
1718 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, flags,
1719 &tp);
1720 if (error)
1721 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 xfs_lock_two_inodes(ip, XFS_ILOCK_EXCL, tip, XFS_ILOCK_EXCL);
1728 xfs_trans_ijoin(tp, ip, 0);
1729 xfs_trans_ijoin(tp, tip, 0);
1730
1731
1732 /* Verify all data are being swapped */
1733 if (sxp->sx_offset != 0 ||
1734 sxp->sx_length != ip->i_disk_size ||
1735 sxp->sx_length != tip->i_disk_size) {
1736 error = -EFAULT;
1737 goto out_trans_cancel;
1738 }
1739
1740 trace_xfs_swap_extent_before(ip, 0);
1741 trace_xfs_swap_extent_before(tip, 1);
1742
1743 /* check inode formats now that data is flushed */
1744 error = xfs_swap_extents_check_format(ip, tip);
1745 if (error) {
1746 xfs_notice(mp,
1747 "%s: inode 0x%llx format is incompatible for exchanging.",
1748 __func__, ip->i_ino);
1749 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 if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
1760 (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
1761 (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
1762 (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
1763 error = -EBUSY;
1764 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 src_log_flags = XFS_ILOG_CORE;
1775 target_log_flags = XFS_ILOG_CORE;
1776
1777 if (xfs_has_rmapbt(mp))
1778 error = xfs_swap_extent_rmap(&tp, ip, tip);
1779 else
1780 error = xfs_swap_extent_forks(tp, ip, tip, &src_log_flags,
1781 &target_log_flags);
1782 if (error)
1783 goto out_trans_cancel;
1784
1785 /* Do we have to swap reflink flags? */
1786 if ((ip->i_diflags2 & XFS_DIFLAG2_REFLINK) ^
1787 (tip->i_diflags2 & XFS_DIFLAG2_REFLINK)) {
1788 f = ip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1789 ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1790 ip->i_diflags2 |= tip->i_diflags2 & XFS_DIFLAG2_REFLINK;
1791 tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
1792 tip->i_diflags2 |= f & XFS_DIFLAG2_REFLINK;
1793 }
1794
1795 /* Swap the cow forks. */
1796 if (xfs_has_reflink(mp)) {
1797 ASSERT(!ip->i_cowfp ||
1798 ip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1799 ASSERT(!tip->i_cowfp ||
1800 tip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
1801
1802 swap(ip->i_cowfp, tip->i_cowfp);
1803
1804 if (ip->i_cowfp && ip->i_cowfp->if_bytes)
1805 xfs_inode_set_cowblocks_tag(ip);
1806 else
1807 xfs_inode_clear_cowblocks_tag(ip);
1808 if (tip->i_cowfp && tip->i_cowfp->if_bytes)
1809 xfs_inode_set_cowblocks_tag(tip);
1810 else
1811 xfs_inode_clear_cowblocks_tag(tip);
1812 }
1813
1814 xfs_trans_log_inode(tp, ip, src_log_flags);
1815 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 if (src_log_flags & XFS_ILOG_DOWNER) {
1824 error = xfs_swap_change_owner(&tp, ip, tip);
1825 if (error)
1826 goto out_trans_cancel;
1827 }
1828 if (target_log_flags & XFS_ILOG_DOWNER) {
1829 error = xfs_swap_change_owner(&tp, tip, ip);
1830 if (error)
1831 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 if (xfs_has_wsync(mp))
1839 xfs_trans_set_sync(tp);
1840
1841 error = xfs_trans_commit(tp);
1842
1843 trace_xfs_swap_extent_after(ip, 0);
1844 trace_xfs_swap_extent_after(tip, 1);
1845
1846out_unlock_ilock:
1847 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1848 xfs_iunlock(tip, XFS_ILOCK_EXCL);
1849out_unlock:
1850 filemap_invalidate_unlock_two(VFS_I(ip)->i_mapping,
1851 VFS_I(tip)->i_mapping);
1852 unlock_two_nondirectories(VFS_I(ip), VFS_I(tip));
1853 return error;
1854
1855out_trans_cancel:
1856 xfs_trans_cancel(tp);
1857 goto out_unlock_ilock;
1858}