2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3 * Copyright (c) 2012 Red Hat, Inc.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it would be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 #include "xfs_shared.h"
22 #include "xfs_format.h"
23 #include "xfs_log_format.h"
24 #include "xfs_trans_resv.h"
26 #include "xfs_mount.h"
27 #include "xfs_da_format.h"
28 #include "xfs_defer.h"
29 #include "xfs_inode.h"
30 #include "xfs_btree.h"
31 #include "xfs_trans.h"
32 #include "xfs_extfree_item.h"
33 #include "xfs_alloc.h"
35 #include "xfs_bmap_util.h"
36 #include "xfs_bmap_btree.h"
37 #include "xfs_rtalloc.h"
38 #include "xfs_error.h"
39 #include "xfs_quota.h"
40 #include "xfs_trans_space.h"
41 #include "xfs_trace.h"
42 #include "xfs_icache.h"
44 #include "xfs_rmap_btree.h"
45 #include "xfs_iomap.h"
46 #include "xfs_reflink.h"
47 #include "xfs_refcount.h"
49 /* Kernel only BMAP related definitions and functions */
52 * Convert the given file system block to a disk block. We have to treat it
53 * differently based on whether the file is a real time file or not, because the
57 xfs_fsb_to_db(struct xfs_inode
*ip
, xfs_fsblock_t fsb
)
59 return (XFS_IS_REALTIME_INODE(ip
) ? \
60 (xfs_daddr_t
)XFS_FSB_TO_BB((ip
)->i_mount
, (fsb
)) : \
61 XFS_FSB_TO_DADDR((ip
)->i_mount
, (fsb
)));
65 * Routine to zero an extent on disk allocated to the specific inode.
67 * The VFS functions take a linearised filesystem block offset, so we have to
68 * convert the sparse xfs fsb to the right format first.
69 * VFS types are real funky, too.
74 xfs_fsblock_t start_fsb
,
77 struct xfs_mount
*mp
= ip
->i_mount
;
78 xfs_daddr_t sector
= xfs_fsb_to_db(ip
, start_fsb
);
79 sector_t block
= XFS_BB_TO_FSBT(mp
, sector
);
81 return blkdev_issue_zeroout(xfs_find_bdev_for_inode(VFS_I(ip
)),
82 block
<< (mp
->m_super
->s_blocksize_bits
- 9),
83 count_fsb
<< (mp
->m_super
->s_blocksize_bits
- 9),
89 struct xfs_bmalloca
*ap
) /* bmap alloc argument struct */
91 int error
; /* error return value */
92 xfs_mount_t
*mp
; /* mount point structure */
93 xfs_extlen_t prod
= 0; /* product factor for allocators */
94 xfs_extlen_t ralen
= 0; /* realtime allocation length */
95 xfs_extlen_t align
; /* minimum allocation alignment */
99 align
= xfs_get_extsz_hint(ap
->ip
);
100 prod
= align
/ mp
->m_sb
.sb_rextsize
;
101 error
= xfs_bmap_extsize_align(mp
, &ap
->got
, &ap
->prev
,
102 align
, 1, ap
->eof
, 0,
103 ap
->conv
, &ap
->offset
, &ap
->length
);
107 ASSERT(ap
->length
% mp
->m_sb
.sb_rextsize
== 0);
110 * If the offset & length are not perfectly aligned
111 * then kill prod, it will just get us in trouble.
113 if (do_mod(ap
->offset
, align
) || ap
->length
% align
)
116 * Set ralen to be the actual requested length in rtextents.
118 ralen
= ap
->length
/ mp
->m_sb
.sb_rextsize
;
120 * If the old value was close enough to MAXEXTLEN that
121 * we rounded up to it, cut it back so it's valid again.
122 * Note that if it's a really large request (bigger than
123 * MAXEXTLEN), we don't hear about that number, and can't
124 * adjust the starting point to match it.
126 if (ralen
* mp
->m_sb
.sb_rextsize
>= MAXEXTLEN
)
127 ralen
= MAXEXTLEN
/ mp
->m_sb
.sb_rextsize
;
130 * Lock out modifications to both the RT bitmap and summary inodes
132 xfs_ilock(mp
->m_rbmip
, XFS_ILOCK_EXCL
|XFS_ILOCK_RTBITMAP
);
133 xfs_trans_ijoin(ap
->tp
, mp
->m_rbmip
, XFS_ILOCK_EXCL
);
134 xfs_ilock(mp
->m_rsumip
, XFS_ILOCK_EXCL
|XFS_ILOCK_RTSUM
);
135 xfs_trans_ijoin(ap
->tp
, mp
->m_rsumip
, XFS_ILOCK_EXCL
);
138 * If it's an allocation to an empty file at offset 0,
139 * pick an extent that will space things out in the rt area.
141 if (ap
->eof
&& ap
->offset
== 0) {
142 xfs_rtblock_t
uninitialized_var(rtx
); /* realtime extent no */
144 error
= xfs_rtpick_extent(mp
, ap
->tp
, ralen
, &rtx
);
147 ap
->blkno
= rtx
* mp
->m_sb
.sb_rextsize
;
152 xfs_bmap_adjacent(ap
);
155 * Realtime allocation, done through xfs_rtallocate_extent.
157 do_div(ap
->blkno
, mp
->m_sb
.sb_rextsize
);
160 error
= xfs_rtallocate_extent(ap
->tp
, ap
->blkno
, 1, ap
->length
,
161 &ralen
, ap
->wasdel
, prod
, &rtb
);
166 if (ap
->blkno
!= NULLFSBLOCK
) {
167 ap
->blkno
*= mp
->m_sb
.sb_rextsize
;
168 ralen
*= mp
->m_sb
.sb_rextsize
;
170 ap
->ip
->i_d
.di_nblocks
+= ralen
;
171 xfs_trans_log_inode(ap
->tp
, ap
->ip
, XFS_ILOG_CORE
);
173 ap
->ip
->i_delayed_blks
-= ralen
;
175 * Adjust the disk quota also. This was reserved
178 xfs_trans_mod_dquot_byino(ap
->tp
, ap
->ip
,
179 ap
->wasdel
? XFS_TRANS_DQ_DELRTBCOUNT
:
180 XFS_TRANS_DQ_RTBCOUNT
, (long) ralen
);
182 /* Zero the extent if we were asked to do so */
183 if (ap
->datatype
& XFS_ALLOC_USERDATA_ZERO
) {
184 error
= xfs_zero_extent(ap
->ip
, ap
->blkno
, ap
->length
);
195 * Check if the endoff is outside the last extent. If so the caller will grow
196 * the allocation to a stripe unit boundary. All offsets are considered outside
197 * the end of file for an empty fork, so 1 is returned in *eof in that case.
201 struct xfs_inode
*ip
,
202 xfs_fileoff_t endoff
,
206 struct xfs_bmbt_irec rec
;
209 error
= xfs_bmap_last_extent(NULL
, ip
, whichfork
, &rec
, eof
);
213 *eof
= endoff
>= rec
.br_startoff
+ rec
.br_blockcount
;
218 * Extent tree block counting routines.
222 * Count leaf blocks given a range of extent records. Delayed allocation
223 * extents are not counted towards the totals.
226 xfs_bmap_count_leaves(
227 struct xfs_ifork
*ifp
,
228 xfs_filblks_t
*count
)
230 struct xfs_bmbt_irec got
;
231 xfs_extnum_t numrecs
= 0, i
= 0;
233 while (xfs_iext_get_extent(ifp
, i
++, &got
)) {
234 if (!isnullstartblock(got
.br_startblock
)) {
235 *count
+= got
.br_blockcount
;
243 * Count leaf blocks given a range of extent records originally
247 xfs_bmap_disk_count_leaves(
248 struct xfs_mount
*mp
,
249 struct xfs_btree_block
*block
,
251 xfs_filblks_t
*count
)
256 for (b
= 1; b
<= numrecs
; b
++) {
257 frp
= XFS_BMBT_REC_ADDR(mp
, block
, b
);
258 *count
+= xfs_bmbt_disk_get_blockcount(frp
);
263 * Recursively walks each level of a btree
264 * to count total fsblocks in use.
268 struct xfs_mount
*mp
,
269 struct xfs_trans
*tp
,
270 struct xfs_ifork
*ifp
,
271 xfs_fsblock_t blockno
,
273 xfs_extnum_t
*nextents
,
274 xfs_filblks_t
*count
)
277 struct xfs_buf
*bp
, *nbp
;
280 xfs_fsblock_t bno
= blockno
;
281 xfs_fsblock_t nextbno
;
282 struct xfs_btree_block
*block
, *nextblock
;
285 error
= xfs_btree_read_bufl(mp
, tp
, bno
, 0, &bp
, XFS_BMAP_BTREE_REF
,
290 block
= XFS_BUF_TO_BLOCK(bp
);
293 /* Not at node above leaves, count this level of nodes */
294 nextbno
= be64_to_cpu(block
->bb_u
.l
.bb_rightsib
);
295 while (nextbno
!= NULLFSBLOCK
) {
296 error
= xfs_btree_read_bufl(mp
, tp
, nextbno
, 0, &nbp
,
302 nextblock
= XFS_BUF_TO_BLOCK(nbp
);
303 nextbno
= be64_to_cpu(nextblock
->bb_u
.l
.bb_rightsib
);
304 xfs_trans_brelse(tp
, nbp
);
307 /* Dive to the next level */
308 pp
= XFS_BMBT_PTR_ADDR(mp
, block
, 1, mp
->m_bmap_dmxr
[1]);
309 bno
= be64_to_cpu(*pp
);
310 error
= xfs_bmap_count_tree(mp
, tp
, ifp
, bno
, level
, nextents
,
313 xfs_trans_brelse(tp
, bp
);
314 XFS_ERROR_REPORT("xfs_bmap_count_tree(1)",
315 XFS_ERRLEVEL_LOW
, mp
);
316 return -EFSCORRUPTED
;
318 xfs_trans_brelse(tp
, bp
);
320 /* count all level 1 nodes and their leaves */
322 nextbno
= be64_to_cpu(block
->bb_u
.l
.bb_rightsib
);
323 numrecs
= be16_to_cpu(block
->bb_numrecs
);
324 (*nextents
) += numrecs
;
325 xfs_bmap_disk_count_leaves(mp
, block
, numrecs
, count
);
326 xfs_trans_brelse(tp
, bp
);
327 if (nextbno
== NULLFSBLOCK
)
330 error
= xfs_btree_read_bufl(mp
, tp
, bno
, 0, &bp
,
336 block
= XFS_BUF_TO_BLOCK(bp
);
343 * Count fsblocks of the given fork. Delayed allocation extents are
344 * not counted towards the totals.
347 xfs_bmap_count_blocks(
348 struct xfs_trans
*tp
,
349 struct xfs_inode
*ip
,
351 xfs_extnum_t
*nextents
,
352 xfs_filblks_t
*count
)
354 struct xfs_mount
*mp
; /* file system mount structure */
355 __be64
*pp
; /* pointer to block address */
356 struct xfs_btree_block
*block
; /* current btree block */
357 struct xfs_ifork
*ifp
; /* fork structure */
358 xfs_fsblock_t bno
; /* block # of "block" */
359 int level
; /* btree level, for checking */
366 ifp
= XFS_IFORK_PTR(ip
, whichfork
);
370 switch (XFS_IFORK_FORMAT(ip
, whichfork
)) {
371 case XFS_DINODE_FMT_EXTENTS
:
372 *nextents
= xfs_bmap_count_leaves(ifp
, count
);
374 case XFS_DINODE_FMT_BTREE
:
375 if (!(ifp
->if_flags
& XFS_IFEXTENTS
)) {
376 error
= xfs_iread_extents(tp
, ip
, whichfork
);
382 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
384 block
= ifp
->if_broot
;
385 level
= be16_to_cpu(block
->bb_level
);
387 pp
= XFS_BMAP_BROOT_PTR_ADDR(mp
, block
, 1, ifp
->if_broot_bytes
);
388 bno
= be64_to_cpu(*pp
);
389 ASSERT(bno
!= NULLFSBLOCK
);
390 ASSERT(XFS_FSB_TO_AGNO(mp
, bno
) < mp
->m_sb
.sb_agcount
);
391 ASSERT(XFS_FSB_TO_AGBNO(mp
, bno
) < mp
->m_sb
.sb_agblocks
);
393 error
= xfs_bmap_count_tree(mp
, tp
, ifp
, bno
, level
,
396 XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)",
397 XFS_ERRLEVEL_LOW
, mp
);
398 return -EFSCORRUPTED
;
407 * returns 1 for success, 0 if we failed to map the extent.
410 xfs_getbmapx_fix_eof_hole(
411 xfs_inode_t
*ip
, /* xfs incore inode pointer */
413 struct getbmapx
*out
, /* output structure */
414 int prealloced
, /* this is a file with
415 * preallocated data space */
416 int64_t end
, /* last block requested */
417 xfs_fsblock_t startblock
,
421 xfs_mount_t
*mp
; /* file system mount point */
422 xfs_ifork_t
*ifp
; /* inode fork pointer */
423 xfs_extnum_t lastx
; /* last extent pointer */
424 xfs_fileoff_t fileblock
;
426 if (startblock
== HOLESTARTBLOCK
) {
429 fixlen
= XFS_FSB_TO_BB(mp
, XFS_B_TO_FSB(mp
, XFS_ISIZE(ip
)));
430 fixlen
-= out
->bmv_offset
;
431 if (prealloced
&& out
->bmv_offset
+ out
->bmv_length
== end
) {
432 /* Came to hole at EOF. Trim it. */
435 out
->bmv_length
= fixlen
;
438 if (startblock
== DELAYSTARTBLOCK
)
441 out
->bmv_block
= xfs_fsb_to_db(ip
, startblock
);
442 fileblock
= XFS_BB_TO_FSB(ip
->i_mount
, out
->bmv_offset
);
443 ifp
= XFS_IFORK_PTR(ip
, whichfork
);
445 xfs_iext_bno_to_ext(ifp
, fileblock
, &lastx
) &&
446 (lastx
== xfs_iext_count(ifp
) - 1))
447 out
->bmv_oflags
|= BMV_OF_LAST
;
453 /* Adjust the reported bmap around shared/unshared extent transitions. */
455 xfs_getbmap_adjust_shared(
456 struct xfs_inode
*ip
,
458 struct xfs_bmbt_irec
*map
,
459 struct getbmapx
*out
,
460 struct xfs_bmbt_irec
*next_map
)
462 struct xfs_mount
*mp
= ip
->i_mount
;
470 next_map
->br_startblock
= NULLFSBLOCK
;
471 next_map
->br_startoff
= NULLFILEOFF
;
472 next_map
->br_blockcount
= 0;
474 /* Only written data blocks can be shared. */
475 if (!xfs_is_reflink_inode(ip
) ||
476 whichfork
!= XFS_DATA_FORK
||
477 !xfs_bmap_is_real_extent(map
))
480 agno
= XFS_FSB_TO_AGNO(mp
, map
->br_startblock
);
481 agbno
= XFS_FSB_TO_AGBNO(mp
, map
->br_startblock
);
482 error
= xfs_reflink_find_shared(mp
, NULL
, agno
, agbno
,
483 map
->br_blockcount
, &ebno
, &elen
, true);
487 if (ebno
== NULLAGBLOCK
) {
488 /* No shared blocks at all. */
490 } else if (agbno
== ebno
) {
492 * Shared extent at (agbno, elen). Shrink the reported
493 * extent length and prepare to move the start of map[i]
494 * to agbno+elen, with the aim of (re)formatting the new
495 * map[i] the next time through the inner loop.
497 out
->bmv_length
= XFS_FSB_TO_BB(mp
, elen
);
498 out
->bmv_oflags
|= BMV_OF_SHARED
;
499 if (elen
!= map
->br_blockcount
) {
501 next_map
->br_startblock
+= elen
;
502 next_map
->br_startoff
+= elen
;
503 next_map
->br_blockcount
-= elen
;
505 map
->br_blockcount
-= elen
;
508 * There's an unshared extent (agbno, ebno - agbno)
509 * followed by shared extent at (ebno, elen). Shrink
510 * the reported extent length to cover only the unshared
511 * extent and prepare to move up the start of map[i] to
512 * ebno, with the aim of (re)formatting the new map[i]
513 * the next time through the inner loop.
517 out
->bmv_length
= XFS_FSB_TO_BB(mp
, nlen
);
518 next_map
->br_startblock
+= nlen
;
519 next_map
->br_startoff
+= nlen
;
520 next_map
->br_blockcount
-= nlen
;
521 map
->br_blockcount
-= nlen
;
528 * Get inode's extents as described in bmv, and format for output.
529 * Calls formatter to fill the user's buffer until all extents
530 * are mapped, until the passed-in bmv->bmv_count slots have
531 * been filled, or until the formatter short-circuits the loop,
532 * if it is tracking filled-in extents on its own.
537 struct getbmapx
*bmv
, /* user bmap structure */
538 xfs_bmap_format_t formatter
, /* format to user */
539 void *arg
) /* formatter arg */
541 int64_t bmvend
; /* last block requested */
542 int error
= 0; /* return value */
543 int64_t fixlen
; /* length for -1 case */
544 int i
; /* extent number */
545 int lock
; /* lock state */
546 xfs_bmbt_irec_t
*map
; /* buffer for user's data */
547 xfs_mount_t
*mp
; /* file system mount point */
548 int nex
; /* # of user extents can do */
549 int subnex
; /* # of bmapi's can do */
550 int nmap
; /* number of map entries */
551 struct getbmapx
*out
; /* output structure */
552 int whichfork
; /* data or attr fork */
553 int prealloced
; /* this is a file with
554 * preallocated data space */
555 int iflags
; /* interface flags */
556 int bmapi_flags
; /* flags for xfs_bmapi */
558 struct xfs_bmbt_irec inject_map
;
561 iflags
= bmv
->bmv_iflags
;
564 /* Only allow CoW fork queries if we're debugging. */
565 if (iflags
& BMV_IF_COWFORK
)
568 if ((iflags
& BMV_IF_ATTRFORK
) && (iflags
& BMV_IF_COWFORK
))
571 if (iflags
& BMV_IF_ATTRFORK
)
572 whichfork
= XFS_ATTR_FORK
;
573 else if (iflags
& BMV_IF_COWFORK
)
574 whichfork
= XFS_COW_FORK
;
576 whichfork
= XFS_DATA_FORK
;
580 if (XFS_IFORK_Q(ip
)) {
581 if (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_EXTENTS
&&
582 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_BTREE
&&
583 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)
586 ip
->i_d
.di_aformat
!= 0 &&
587 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_EXTENTS
)) {
588 XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW
,
590 return -EFSCORRUPTED
;
597 if (ip
->i_cformat
!= XFS_DINODE_FMT_EXTENTS
)
600 if (xfs_get_cowextsz_hint(ip
)) {
602 fixlen
= mp
->m_super
->s_maxbytes
;
605 fixlen
= XFS_ISIZE(ip
);
609 /* Local format data forks report no extents. */
610 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
) {
611 bmv
->bmv_entries
= 0;
614 if (ip
->i_d
.di_format
!= XFS_DINODE_FMT_EXTENTS
&&
615 ip
->i_d
.di_format
!= XFS_DINODE_FMT_BTREE
)
618 if (xfs_get_extsz_hint(ip
) ||
619 ip
->i_d
.di_flags
& (XFS_DIFLAG_PREALLOC
|XFS_DIFLAG_APPEND
)){
621 fixlen
= mp
->m_super
->s_maxbytes
;
624 fixlen
= XFS_ISIZE(ip
);
629 if (bmv
->bmv_length
== -1) {
630 fixlen
= XFS_FSB_TO_BB(mp
, XFS_B_TO_FSB(mp
, fixlen
));
632 max_t(int64_t, fixlen
- bmv
->bmv_offset
, 0);
633 } else if (bmv
->bmv_length
== 0) {
634 bmv
->bmv_entries
= 0;
636 } else if (bmv
->bmv_length
< 0) {
640 nex
= bmv
->bmv_count
- 1;
643 bmvend
= bmv
->bmv_offset
+ bmv
->bmv_length
;
646 if (bmv
->bmv_count
> ULONG_MAX
/ sizeof(struct getbmapx
))
648 out
= kmem_zalloc_large(bmv
->bmv_count
* sizeof(struct getbmapx
), 0);
652 xfs_ilock(ip
, XFS_IOLOCK_SHARED
);
655 if (!(iflags
& BMV_IF_DELALLOC
) &&
656 (ip
->i_delayed_blks
|| XFS_ISIZE(ip
) > ip
->i_d
.di_size
)) {
657 error
= filemap_write_and_wait(VFS_I(ip
)->i_mapping
);
659 goto out_unlock_iolock
;
662 * Even after flushing the inode, there can still be
663 * delalloc blocks on the inode beyond EOF due to
664 * speculative preallocation. These are not removed
665 * until the release function is called or the inode
666 * is inactivated. Hence we cannot assert here that
667 * ip->i_delayed_blks == 0.
671 lock
= xfs_ilock_data_map_shared(ip
);
674 lock
= XFS_ILOCK_SHARED
;
678 lock
= xfs_ilock_attr_map_shared(ip
);
683 * Don't let nex be bigger than the number of extents
684 * we can have assuming alternating holes and real extents.
686 if (nex
> XFS_IFORK_NEXTENTS(ip
, whichfork
) * 2 + 1)
687 nex
= XFS_IFORK_NEXTENTS(ip
, whichfork
) * 2 + 1;
689 bmapi_flags
= xfs_bmapi_aflag(whichfork
);
690 if (!(iflags
& BMV_IF_PREALLOC
))
691 bmapi_flags
|= XFS_BMAPI_IGSTATE
;
694 * Allocate enough space to handle "subnex" maps at a time.
698 map
= kmem_alloc(subnex
* sizeof(*map
), KM_MAYFAIL
| KM_NOFS
);
700 goto out_unlock_ilock
;
702 bmv
->bmv_entries
= 0;
704 if (XFS_IFORK_NEXTENTS(ip
, whichfork
) == 0 &&
705 (whichfork
== XFS_ATTR_FORK
|| !(iflags
& BMV_IF_DELALLOC
))) {
711 nmap
= (nex
> subnex
) ? subnex
: nex
;
712 error
= xfs_bmapi_read(ip
, XFS_BB_TO_FSBT(mp
, bmv
->bmv_offset
),
713 XFS_BB_TO_FSB(mp
, bmv
->bmv_length
),
714 map
, &nmap
, bmapi_flags
);
717 ASSERT(nmap
<= subnex
);
719 for (i
= 0; i
< nmap
&& bmv
->bmv_length
&&
720 cur_ext
< bmv
->bmv_count
- 1; i
++) {
721 out
[cur_ext
].bmv_oflags
= 0;
722 if (map
[i
].br_state
== XFS_EXT_UNWRITTEN
)
723 out
[cur_ext
].bmv_oflags
|= BMV_OF_PREALLOC
;
724 else if (map
[i
].br_startblock
== DELAYSTARTBLOCK
)
725 out
[cur_ext
].bmv_oflags
|= BMV_OF_DELALLOC
;
726 out
[cur_ext
].bmv_offset
=
727 XFS_FSB_TO_BB(mp
, map
[i
].br_startoff
);
728 out
[cur_ext
].bmv_length
=
729 XFS_FSB_TO_BB(mp
, map
[i
].br_blockcount
);
730 out
[cur_ext
].bmv_unused1
= 0;
731 out
[cur_ext
].bmv_unused2
= 0;
734 * delayed allocation extents that start beyond EOF can
735 * occur due to speculative EOF allocation when the
736 * delalloc extent is larger than the largest freespace
737 * extent at conversion time. These extents cannot be
738 * converted by data writeback, so can exist here even
739 * if we are not supposed to be finding delalloc
742 if (map
[i
].br_startblock
== DELAYSTARTBLOCK
&&
743 map
[i
].br_startoff
< XFS_B_TO_FSB(mp
, XFS_ISIZE(ip
)))
744 ASSERT((iflags
& BMV_IF_DELALLOC
) != 0);
746 if (map
[i
].br_startblock
== HOLESTARTBLOCK
&&
747 whichfork
== XFS_ATTR_FORK
) {
748 /* came to the end of attribute fork */
749 out
[cur_ext
].bmv_oflags
|= BMV_OF_LAST
;
753 /* Is this a shared block? */
754 error
= xfs_getbmap_adjust_shared(ip
, whichfork
,
755 &map
[i
], &out
[cur_ext
], &inject_map
);
759 if (!xfs_getbmapx_fix_eof_hole(ip
, whichfork
,
760 &out
[cur_ext
], prealloced
, bmvend
,
761 map
[i
].br_startblock
,
762 inject_map
.br_startblock
!= NULLFSBLOCK
))
766 out
[cur_ext
].bmv_offset
+
767 out
[cur_ext
].bmv_length
;
769 max_t(int64_t, 0, bmvend
- bmv
->bmv_offset
);
772 * In case we don't want to return the hole,
773 * don't increase cur_ext so that we can reuse
774 * it in the next loop.
776 if ((iflags
& BMV_IF_NO_HOLES
) &&
777 map
[i
].br_startblock
== HOLESTARTBLOCK
) {
778 memset(&out
[cur_ext
], 0, sizeof(out
[cur_ext
]));
783 * In order to report shared extents accurately,
784 * we report each distinct shared/unshared part
785 * of a single bmbt record using multiple bmap
786 * extents. To make that happen, we iterate the
787 * same map array item multiple times, each
788 * time trimming out the subextent that we just
791 * Because of this, we must check the out array
792 * index (cur_ext) directly against bmv_count-1
793 * to avoid overflows.
795 if (inject_map
.br_startblock
!= NULLFSBLOCK
) {
802 } while (nmap
&& bmv
->bmv_length
&& cur_ext
< bmv
->bmv_count
- 1);
807 xfs_iunlock(ip
, lock
);
809 xfs_iunlock(ip
, XFS_IOLOCK_SHARED
);
811 for (i
= 0; i
< cur_ext
; i
++) {
812 /* format results & advance arg */
813 error
= formatter(&arg
, &out
[i
]);
823 * dead simple method of punching delalyed allocation blocks from a range in
824 * the inode. Walks a block at a time so will be slow, but is only executed in
825 * rare error cases so the overhead is not critical. This will always punch out
826 * both the start and end blocks, even if the ranges only partially overlap
827 * them, so it is up to the caller to ensure that partial blocks are not
831 xfs_bmap_punch_delalloc_range(
832 struct xfs_inode
*ip
,
833 xfs_fileoff_t start_fsb
,
834 xfs_fileoff_t length
)
836 xfs_fileoff_t remaining
= length
;
839 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
843 xfs_bmbt_irec_t imap
;
845 xfs_fsblock_t firstblock
;
846 struct xfs_defer_ops dfops
;
849 * Map the range first and check that it is a delalloc extent
850 * before trying to unmap the range. Otherwise we will be
851 * trying to remove a real extent (which requires a
852 * transaction) or a hole, which is probably a bad idea...
854 error
= xfs_bmapi_read(ip
, start_fsb
, 1, &imap
, &nimaps
,
858 /* something screwed, just bail */
859 if (!XFS_FORCED_SHUTDOWN(ip
->i_mount
)) {
860 xfs_alert(ip
->i_mount
,
861 "Failed delalloc mapping lookup ino %lld fsb %lld.",
862 ip
->i_ino
, start_fsb
);
870 if (imap
.br_startblock
!= DELAYSTARTBLOCK
) {
871 /* been converted, ignore */
874 WARN_ON(imap
.br_blockcount
== 0);
877 * Note: while we initialise the firstblock/dfops pair, they
878 * should never be used because blocks should never be
879 * allocated or freed for a delalloc extent and hence we need
880 * don't cancel or finish them after the xfs_bunmapi() call.
882 xfs_defer_init(&dfops
, &firstblock
);
883 error
= xfs_bunmapi(NULL
, ip
, start_fsb
, 1, 0, 1, &firstblock
,
888 ASSERT(!xfs_defer_has_unfinished_work(&dfops
));
892 } while(remaining
> 0);
898 * Test whether it is appropriate to check an inode for and free post EOF
899 * blocks. The 'force' parameter determines whether we should also consider
900 * regular files that are marked preallocated or append-only.
903 xfs_can_free_eofblocks(struct xfs_inode
*ip
, bool force
)
905 /* prealloc/delalloc exists only on regular files */
906 if (!S_ISREG(VFS_I(ip
)->i_mode
))
910 * Zero sized files with no cached pages and delalloc blocks will not
911 * have speculative prealloc/delalloc blocks to remove.
913 if (VFS_I(ip
)->i_size
== 0 &&
914 VFS_I(ip
)->i_mapping
->nrpages
== 0 &&
915 ip
->i_delayed_blks
== 0)
918 /* If we haven't read in the extent list, then don't do it now. */
919 if (!(ip
->i_df
.if_flags
& XFS_IFEXTENTS
))
923 * Do not free real preallocated or append-only files unless the file
924 * has delalloc blocks and we are forced to remove them.
926 if (ip
->i_d
.di_flags
& (XFS_DIFLAG_PREALLOC
| XFS_DIFLAG_APPEND
))
927 if (!force
|| ip
->i_delayed_blks
== 0)
934 * This is called to free any blocks beyond eof. The caller must hold
935 * IOLOCK_EXCL unless we are in the inode reclaim path and have the only
936 * reference to the inode.
940 struct xfs_inode
*ip
)
942 struct xfs_trans
*tp
;
944 xfs_fileoff_t end_fsb
;
945 xfs_fileoff_t last_fsb
;
946 xfs_filblks_t map_len
;
948 struct xfs_bmbt_irec imap
;
949 struct xfs_mount
*mp
= ip
->i_mount
;
952 * Figure out if there are any blocks beyond the end
953 * of the file. If not, then there is nothing to do.
955 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)XFS_ISIZE(ip
));
956 last_fsb
= XFS_B_TO_FSB(mp
, mp
->m_super
->s_maxbytes
);
957 if (last_fsb
<= end_fsb
)
959 map_len
= last_fsb
- end_fsb
;
962 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
963 error
= xfs_bmapi_read(ip
, end_fsb
, map_len
, &imap
, &nimaps
, 0);
964 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
967 * If there are blocks after the end of file, truncate the file to its
968 * current size to free them up.
970 if (!error
&& (nimaps
!= 0) &&
971 (imap
.br_startblock
!= HOLESTARTBLOCK
||
972 ip
->i_delayed_blks
)) {
974 * Attach the dquots to the inode up front.
976 error
= xfs_qm_dqattach(ip
, 0);
980 /* wait on dio to ensure i_size has settled */
981 inode_dio_wait(VFS_I(ip
));
983 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_itruncate
, 0, 0, 0,
986 ASSERT(XFS_FORCED_SHUTDOWN(mp
));
990 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
991 xfs_trans_ijoin(tp
, ip
, 0);
994 * Do not update the on-disk file size. If we update the
995 * on-disk file size and then the system crashes before the
996 * contents of the file are flushed to disk then the files
997 * may be full of holes (ie NULL files bug).
999 error
= xfs_itruncate_extents(&tp
, ip
, XFS_DATA_FORK
,
1003 * If we get an error at this point we simply don't
1004 * bother truncating the file.
1006 xfs_trans_cancel(tp
);
1008 error
= xfs_trans_commit(tp
);
1010 xfs_inode_clear_eofblocks_tag(ip
);
1013 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1019 xfs_alloc_file_space(
1020 struct xfs_inode
*ip
,
1025 xfs_mount_t
*mp
= ip
->i_mount
;
1027 xfs_filblks_t allocated_fsb
;
1028 xfs_filblks_t allocatesize_fsb
;
1029 xfs_extlen_t extsz
, temp
;
1030 xfs_fileoff_t startoffset_fsb
;
1031 xfs_fsblock_t firstfsb
;
1036 xfs_bmbt_irec_t imaps
[1], *imapp
;
1037 struct xfs_defer_ops dfops
;
1038 uint qblocks
, resblks
, resrtextents
;
1041 trace_xfs_alloc_file_space(ip
);
1043 if (XFS_FORCED_SHUTDOWN(mp
))
1046 error
= xfs_qm_dqattach(ip
, 0);
1053 rt
= XFS_IS_REALTIME_INODE(ip
);
1054 extsz
= xfs_get_extsz_hint(ip
);
1059 startoffset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
1060 allocatesize_fsb
= XFS_B_TO_FSB(mp
, count
);
1063 * Allocate file space until done or until there is an error
1065 while (allocatesize_fsb
&& !error
) {
1069 * Determine space reservations for data/realtime.
1071 if (unlikely(extsz
)) {
1072 s
= startoffset_fsb
;
1075 e
= startoffset_fsb
+ allocatesize_fsb
;
1076 if ((temp
= do_mod(startoffset_fsb
, extsz
)))
1078 if ((temp
= do_mod(e
, extsz
)))
1082 e
= allocatesize_fsb
;
1086 * The transaction reservation is limited to a 32-bit block
1087 * count, hence we need to limit the number of blocks we are
1088 * trying to reserve to avoid an overflow. We can't allocate
1089 * more than @nimaps extents, and an extent is limited on disk
1090 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
1092 resblks
= min_t(xfs_fileoff_t
, (e
- s
), (MAXEXTLEN
* nimaps
));
1094 resrtextents
= qblocks
= resblks
;
1095 resrtextents
/= mp
->m_sb
.sb_rextsize
;
1096 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
1097 quota_flag
= XFS_QMOPT_RES_RTBLKS
;
1100 resblks
= qblocks
= XFS_DIOSTRAT_SPACE_RES(mp
, resblks
);
1101 quota_flag
= XFS_QMOPT_RES_REGBLKS
;
1105 * Allocate and setup the transaction.
1107 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
,
1108 resrtextents
, 0, &tp
);
1111 * Check for running out of space
1115 * Free the transaction structure.
1117 ASSERT(error
== -ENOSPC
|| XFS_FORCED_SHUTDOWN(mp
));
1120 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1121 error
= xfs_trans_reserve_quota_nblks(tp
, ip
, qblocks
,
1126 xfs_trans_ijoin(tp
, ip
, 0);
1128 xfs_defer_init(&dfops
, &firstfsb
);
1129 error
= xfs_bmapi_write(tp
, ip
, startoffset_fsb
,
1130 allocatesize_fsb
, alloc_type
, &firstfsb
,
1131 resblks
, imapp
, &nimaps
, &dfops
);
1136 * Complete the transaction
1138 error
= xfs_defer_finish(&tp
, &dfops
);
1142 error
= xfs_trans_commit(tp
);
1143 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1147 allocated_fsb
= imapp
->br_blockcount
;
1154 startoffset_fsb
+= allocated_fsb
;
1155 allocatesize_fsb
-= allocated_fsb
;
1160 error0
: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
1161 xfs_defer_cancel(&dfops
);
1162 xfs_trans_unreserve_quota_nblks(tp
, ip
, (long)qblocks
, 0, quota_flag
);
1164 error1
: /* Just cancel transaction */
1165 xfs_trans_cancel(tp
);
1166 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1172 struct xfs_inode
*ip
,
1173 xfs_fileoff_t startoffset_fsb
,
1174 xfs_filblks_t len_fsb
,
1177 struct xfs_mount
*mp
= ip
->i_mount
;
1178 struct xfs_trans
*tp
;
1179 struct xfs_defer_ops dfops
;
1180 xfs_fsblock_t firstfsb
;
1181 uint resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
1184 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, 0, 0, &tp
);
1186 ASSERT(error
== -ENOSPC
|| XFS_FORCED_SHUTDOWN(mp
));
1190 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1191 error
= xfs_trans_reserve_quota(tp
, mp
, ip
->i_udquot
, ip
->i_gdquot
,
1192 ip
->i_pdquot
, resblks
, 0, XFS_QMOPT_RES_REGBLKS
);
1194 goto out_trans_cancel
;
1196 xfs_trans_ijoin(tp
, ip
, 0);
1198 xfs_defer_init(&dfops
, &firstfsb
);
1199 error
= xfs_bunmapi(tp
, ip
, startoffset_fsb
, len_fsb
, 0, 2, &firstfsb
,
1202 goto out_bmap_cancel
;
1204 xfs_defer_ijoin(&dfops
, ip
);
1205 error
= xfs_defer_finish(&tp
, &dfops
);
1207 goto out_bmap_cancel
;
1209 error
= xfs_trans_commit(tp
);
1211 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1215 xfs_defer_cancel(&dfops
);
1217 xfs_trans_cancel(tp
);
1222 xfs_adjust_extent_unmap_boundaries(
1223 struct xfs_inode
*ip
,
1224 xfs_fileoff_t
*startoffset_fsb
,
1225 xfs_fileoff_t
*endoffset_fsb
)
1227 struct xfs_mount
*mp
= ip
->i_mount
;
1228 struct xfs_bmbt_irec imap
;
1230 xfs_extlen_t mod
= 0;
1233 error
= xfs_bmapi_read(ip
, *startoffset_fsb
, 1, &imap
, &nimap
, 0);
1237 if (nimap
&& imap
.br_startblock
!= HOLESTARTBLOCK
) {
1238 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
1239 mod
= do_mod(imap
.br_startblock
, mp
->m_sb
.sb_rextsize
);
1241 *startoffset_fsb
+= mp
->m_sb
.sb_rextsize
- mod
;
1245 error
= xfs_bmapi_read(ip
, *endoffset_fsb
- 1, 1, &imap
, &nimap
, 0);
1249 if (nimap
&& imap
.br_startblock
!= HOLESTARTBLOCK
) {
1250 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
1252 if (mod
&& mod
!= mp
->m_sb
.sb_rextsize
)
1253 *endoffset_fsb
-= mod
;
1260 xfs_flush_unmap_range(
1261 struct xfs_inode
*ip
,
1265 struct xfs_mount
*mp
= ip
->i_mount
;
1266 struct inode
*inode
= VFS_I(ip
);
1267 xfs_off_t rounding
, start
, end
;
1270 /* wait for the completion of any pending DIOs */
1271 inode_dio_wait(inode
);
1273 rounding
= max_t(xfs_off_t
, 1 << mp
->m_sb
.sb_blocklog
, PAGE_SIZE
);
1274 start
= round_down(offset
, rounding
);
1275 end
= round_up(offset
+ len
, rounding
) - 1;
1277 error
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
1280 truncate_pagecache_range(inode
, start
, end
);
1285 xfs_free_file_space(
1286 struct xfs_inode
*ip
,
1290 struct xfs_mount
*mp
= ip
->i_mount
;
1291 xfs_fileoff_t startoffset_fsb
;
1292 xfs_fileoff_t endoffset_fsb
;
1293 int done
= 0, error
;
1295 trace_xfs_free_file_space(ip
);
1297 error
= xfs_qm_dqattach(ip
, 0);
1301 if (len
<= 0) /* if nothing being freed */
1304 error
= xfs_flush_unmap_range(ip
, offset
, len
);
1308 startoffset_fsb
= XFS_B_TO_FSB(mp
, offset
);
1309 endoffset_fsb
= XFS_B_TO_FSBT(mp
, offset
+ len
);
1312 * Need to zero the stuff we're not freeing, on disk. If it's a RT file
1313 * and we can't use unwritten extents then we actually need to ensure
1314 * to zero the whole extent, otherwise we just need to take of block
1315 * boundaries, and xfs_bunmapi will handle the rest.
1317 if (XFS_IS_REALTIME_INODE(ip
) &&
1318 !xfs_sb_version_hasextflgbit(&mp
->m_sb
)) {
1319 error
= xfs_adjust_extent_unmap_boundaries(ip
, &startoffset_fsb
,
1325 if (endoffset_fsb
> startoffset_fsb
) {
1327 error
= xfs_unmap_extent(ip
, startoffset_fsb
,
1328 endoffset_fsb
- startoffset_fsb
, &done
);
1335 * Now that we've unmap all full blocks we'll have to zero out any
1336 * partial block at the beginning and/or end. xfs_zero_range is
1337 * smart enough to skip any holes, including those we just created,
1338 * but we must take care not to zero beyond EOF and enlarge i_size.
1341 if (offset
>= XFS_ISIZE(ip
))
1344 if (offset
+ len
> XFS_ISIZE(ip
))
1345 len
= XFS_ISIZE(ip
) - offset
;
1347 return xfs_zero_range(ip
, offset
, len
, NULL
);
1351 * Preallocate and zero a range of a file. This mechanism has the allocation
1352 * semantics of fallocate and in addition converts data in the range to zeroes.
1355 xfs_zero_file_space(
1356 struct xfs_inode
*ip
,
1360 struct xfs_mount
*mp
= ip
->i_mount
;
1364 trace_xfs_zero_file_space(ip
);
1366 blksize
= 1 << mp
->m_sb
.sb_blocklog
;
1369 * Punch a hole and prealloc the range. We use hole punch rather than
1370 * unwritten extent conversion for two reasons:
1372 * 1.) Hole punch handles partial block zeroing for us.
1374 * 2.) If prealloc returns ENOSPC, the file range is still zero-valued
1375 * by virtue of the hole punch.
1377 error
= xfs_free_file_space(ip
, offset
, len
);
1381 error
= xfs_alloc_file_space(ip
, round_down(offset
, blksize
),
1382 round_up(offset
+ len
, blksize
) -
1383 round_down(offset
, blksize
),
1384 XFS_BMAPI_PREALLOC
);
1391 * @next_fsb will keep track of the extent currently undergoing shift.
1392 * @stop_fsb will keep track of the extent at which we have to stop.
1393 * If we are shifting left, we will start with block (offset + len) and
1394 * shift each extent till last extent.
1395 * If we are shifting right, we will start with last extent inside file space
1396 * and continue until we reach the block corresponding to offset.
1399 xfs_shift_file_space(
1400 struct xfs_inode
*ip
,
1403 enum shift_direction direction
)
1406 struct xfs_mount
*mp
= ip
->i_mount
;
1407 struct xfs_trans
*tp
;
1409 struct xfs_defer_ops dfops
;
1410 xfs_fsblock_t first_block
;
1411 xfs_fileoff_t stop_fsb
;
1412 xfs_fileoff_t next_fsb
;
1413 xfs_fileoff_t shift_fsb
;
1416 ASSERT(direction
== SHIFT_LEFT
|| direction
== SHIFT_RIGHT
);
1418 if (direction
== SHIFT_LEFT
) {
1420 * Reserve blocks to cover potential extent merges after left
1423 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
1424 next_fsb
= XFS_B_TO_FSB(mp
, offset
+ len
);
1425 stop_fsb
= XFS_B_TO_FSB(mp
, VFS_I(ip
)->i_size
);
1428 * If right shift, delegate the work of initialization of
1429 * next_fsb to xfs_bmap_shift_extent as it has ilock held.
1432 next_fsb
= NULLFSBLOCK
;
1433 stop_fsb
= XFS_B_TO_FSB(mp
, offset
);
1436 shift_fsb
= XFS_B_TO_FSB(mp
, len
);
1439 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1440 * into the accessible region of the file.
1442 if (xfs_can_free_eofblocks(ip
, true)) {
1443 error
= xfs_free_eofblocks(ip
);
1449 * Writeback and invalidate cache for the remainder of the file as we're
1450 * about to shift down every extent from offset to EOF.
1452 error
= filemap_write_and_wait_range(VFS_I(ip
)->i_mapping
,
1456 error
= invalidate_inode_pages2_range(VFS_I(ip
)->i_mapping
,
1457 offset
>> PAGE_SHIFT
, -1);
1462 * Clean out anything hanging around in the cow fork now that
1463 * we've flushed all the dirty data out to disk to avoid having
1464 * CoW extents at the wrong offsets.
1466 if (xfs_is_reflink_inode(ip
)) {
1467 error
= xfs_reflink_cancel_cow_range(ip
, offset
, NULLFILEOFF
,
1474 * The extent shifting code works on extent granularity. So, if
1475 * stop_fsb is not the starting block of extent, we need to split
1476 * the extent at stop_fsb.
1478 if (direction
== SHIFT_RIGHT
) {
1479 error
= xfs_bmap_split_extent(ip
, stop_fsb
);
1484 while (!error
&& !done
) {
1485 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, 0, 0,
1490 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1491 error
= xfs_trans_reserve_quota(tp
, mp
, ip
->i_udquot
,
1492 ip
->i_gdquot
, ip
->i_pdquot
, resblks
, 0,
1493 XFS_QMOPT_RES_REGBLKS
);
1495 goto out_trans_cancel
;
1497 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
1499 xfs_defer_init(&dfops
, &first_block
);
1502 * We are using the write transaction in which max 2 bmbt
1503 * updates are allowed
1505 error
= xfs_bmap_shift_extents(tp
, ip
, &next_fsb
, shift_fsb
,
1506 &done
, stop_fsb
, &first_block
, &dfops
,
1507 direction
, XFS_BMAP_MAX_SHIFT_EXTENTS
);
1509 goto out_bmap_cancel
;
1511 error
= xfs_defer_finish(&tp
, &dfops
);
1513 goto out_bmap_cancel
;
1515 error
= xfs_trans_commit(tp
);
1521 xfs_defer_cancel(&dfops
);
1523 xfs_trans_cancel(tp
);
1528 * xfs_collapse_file_space()
1529 * This routine frees disk space and shift extent for the given file.
1530 * The first thing we do is to free data blocks in the specified range
1531 * by calling xfs_free_file_space(). It would also sync dirty data
1532 * and invalidate page cache over the region on which collapse range
1533 * is working. And Shift extent records to the left to cover a hole.
1540 xfs_collapse_file_space(
1541 struct xfs_inode
*ip
,
1547 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_EXCL
));
1548 trace_xfs_collapse_file_space(ip
);
1550 error
= xfs_free_file_space(ip
, offset
, len
);
1554 return xfs_shift_file_space(ip
, offset
, len
, SHIFT_LEFT
);
1558 * xfs_insert_file_space()
1559 * This routine create hole space by shifting extents for the given file.
1560 * The first thing we do is to sync dirty data and invalidate page cache
1561 * over the region on which insert range is working. And split an extent
1562 * to two extents at given offset by calling xfs_bmap_split_extent.
1563 * And shift all extent records which are laying between [offset,
1564 * last allocated extent] to the right to reserve hole range.
1570 xfs_insert_file_space(
1571 struct xfs_inode
*ip
,
1575 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_EXCL
));
1576 trace_xfs_insert_file_space(ip
);
1578 return xfs_shift_file_space(ip
, offset
, len
, SHIFT_RIGHT
);
1582 * We need to check that the format of the data fork in the temporary inode is
1583 * valid for the target inode before doing the swap. This is not a problem with
1584 * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
1585 * data fork depending on the space the attribute fork is taking so we can get
1586 * invalid formats on the target inode.
1588 * E.g. target has space for 7 extents in extent format, temp inode only has
1589 * space for 6. If we defragment down to 7 extents, then the tmp format is a
1590 * btree, but when swapped it needs to be in extent format. Hence we can't just
1591 * blindly swap data forks on attr2 filesystems.
1593 * Note that we check the swap in both directions so that we don't end up with
1594 * a corrupt temporary inode, either.
1596 * Note that fixing the way xfs_fsr sets up the attribute fork in the source
1597 * inode will prevent this situation from occurring, so all we do here is
1598 * reject and log the attempt. basically we are putting the responsibility on
1599 * userspace to get this right.
1602 xfs_swap_extents_check_format(
1603 struct xfs_inode
*ip
, /* target inode */
1604 struct xfs_inode
*tip
) /* tmp inode */
1607 /* Should never get a local format */
1608 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
||
1609 tip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
)
1613 * if the target inode has less extents that then temporary inode then
1614 * why did userspace call us?
1616 if (ip
->i_d
.di_nextents
< tip
->i_d
.di_nextents
)
1620 * If we have to use the (expensive) rmap swap method, we can
1621 * handle any number of extents and any format.
1623 if (xfs_sb_version_hasrmapbt(&ip
->i_mount
->m_sb
))
1627 * if the target inode is in extent form and the temp inode is in btree
1628 * form then we will end up with the target inode in the wrong format
1629 * as we already know there are less extents in the temp inode.
1631 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1632 tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
)
1635 /* Check temp in extent form to max in target */
1636 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1637 XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) >
1638 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
1641 /* Check target in extent form to max in temp */
1642 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1643 XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) >
1644 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
1648 * If we are in a btree format, check that the temp root block will fit
1649 * in the target and that it has enough extents to be in btree format
1652 * Note that we have to be careful to allow btree->extent conversions
1653 * (a common defrag case) which will occur when the temp inode is in
1656 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1657 if (XFS_IFORK_Q(ip
) &&
1658 XFS_BMAP_BMDR_SPACE(tip
->i_df
.if_broot
) > XFS_IFORK_BOFF(ip
))
1660 if (XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) <=
1661 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
1665 /* Reciprocal target->temp btree format checks */
1666 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1667 if (XFS_IFORK_Q(tip
) &&
1668 XFS_BMAP_BMDR_SPACE(ip
->i_df
.if_broot
) > XFS_IFORK_BOFF(tip
))
1670 if (XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) <=
1671 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
1679 xfs_swap_extent_flush(
1680 struct xfs_inode
*ip
)
1684 error
= filemap_write_and_wait(VFS_I(ip
)->i_mapping
);
1687 truncate_pagecache_range(VFS_I(ip
), 0, -1);
1689 /* Verify O_DIRECT for ftmp */
1690 if (VFS_I(ip
)->i_mapping
->nrpages
)
1696 * Move extents from one file to another, when rmap is enabled.
1699 xfs_swap_extent_rmap(
1700 struct xfs_trans
**tpp
,
1701 struct xfs_inode
*ip
,
1702 struct xfs_inode
*tip
)
1704 struct xfs_bmbt_irec irec
;
1705 struct xfs_bmbt_irec uirec
;
1706 struct xfs_bmbt_irec tirec
;
1707 xfs_fileoff_t offset_fsb
;
1708 xfs_fileoff_t end_fsb
;
1709 xfs_filblks_t count_fsb
;
1710 xfs_fsblock_t firstfsb
;
1711 struct xfs_defer_ops dfops
;
1716 uint64_t tip_flags2
;
1719 * If the source file has shared blocks, we must flag the donor
1720 * file as having shared blocks so that we get the shared-block
1721 * rmap functions when we go to fix up the rmaps. The flags
1722 * will be switch for reals later.
1724 tip_flags2
= tip
->i_d
.di_flags2
;
1725 if (ip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
)
1726 tip
->i_d
.di_flags2
|= XFS_DIFLAG2_REFLINK
;
1729 end_fsb
= XFS_B_TO_FSB(ip
->i_mount
, i_size_read(VFS_I(ip
)));
1730 count_fsb
= (xfs_filblks_t
)(end_fsb
- offset_fsb
);
1733 /* Read extent from the donor file */
1735 error
= xfs_bmapi_read(tip
, offset_fsb
, count_fsb
, &tirec
,
1739 ASSERT(nimaps
== 1);
1740 ASSERT(tirec
.br_startblock
!= DELAYSTARTBLOCK
);
1742 trace_xfs_swap_extent_rmap_remap(tip
, &tirec
);
1743 ilen
= tirec
.br_blockcount
;
1745 /* Unmap the old blocks in the source file. */
1746 while (tirec
.br_blockcount
) {
1747 xfs_defer_init(&dfops
, &firstfsb
);
1748 trace_xfs_swap_extent_rmap_remap_piece(tip
, &tirec
);
1750 /* Read extent from the source file */
1752 error
= xfs_bmapi_read(ip
, tirec
.br_startoff
,
1753 tirec
.br_blockcount
, &irec
,
1757 ASSERT(nimaps
== 1);
1758 ASSERT(tirec
.br_startoff
== irec
.br_startoff
);
1759 trace_xfs_swap_extent_rmap_remap_piece(ip
, &irec
);
1761 /* Trim the extent. */
1763 uirec
.br_blockcount
= rlen
= min_t(xfs_filblks_t
,
1764 tirec
.br_blockcount
,
1765 irec
.br_blockcount
);
1766 trace_xfs_swap_extent_rmap_remap_piece(tip
, &uirec
);
1768 /* Remove the mapping from the donor file. */
1769 error
= xfs_bmap_unmap_extent((*tpp
)->t_mountp
, &dfops
,
1774 /* Remove the mapping from the source file. */
1775 error
= xfs_bmap_unmap_extent((*tpp
)->t_mountp
, &dfops
,
1780 /* Map the donor file's blocks into the source file. */
1781 error
= xfs_bmap_map_extent((*tpp
)->t_mountp
, &dfops
,
1786 /* Map the source file's blocks into the donor file. */
1787 error
= xfs_bmap_map_extent((*tpp
)->t_mountp
, &dfops
,
1792 xfs_defer_ijoin(&dfops
, ip
);
1793 error
= xfs_defer_finish(tpp
, &dfops
);
1797 tirec
.br_startoff
+= rlen
;
1798 if (tirec
.br_startblock
!= HOLESTARTBLOCK
&&
1799 tirec
.br_startblock
!= DELAYSTARTBLOCK
)
1800 tirec
.br_startblock
+= rlen
;
1801 tirec
.br_blockcount
-= rlen
;
1809 tip
->i_d
.di_flags2
= tip_flags2
;
1813 xfs_defer_cancel(&dfops
);
1815 trace_xfs_swap_extent_rmap_error(ip
, error
, _RET_IP_
);
1816 tip
->i_d
.di_flags2
= tip_flags2
;
1820 /* Swap the extents of two files by swapping data forks. */
1822 xfs_swap_extent_forks(
1823 struct xfs_trans
*tp
,
1824 struct xfs_inode
*ip
,
1825 struct xfs_inode
*tip
,
1827 int *target_log_flags
)
1829 struct xfs_ifork tempifp
, *ifp
, *tifp
;
1830 xfs_filblks_t aforkblks
= 0;
1831 xfs_filblks_t taforkblks
= 0;
1833 xfs_extnum_t nextents
;
1838 * Count the number of extended attribute blocks
1840 if ( ((XFS_IFORK_Q(ip
) != 0) && (ip
->i_d
.di_anextents
> 0)) &&
1841 (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
1842 error
= xfs_bmap_count_blocks(tp
, ip
, XFS_ATTR_FORK
, &junk
,
1847 if ( ((XFS_IFORK_Q(tip
) != 0) && (tip
->i_d
.di_anextents
> 0)) &&
1848 (tip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
1849 error
= xfs_bmap_count_blocks(tp
, tip
, XFS_ATTR_FORK
, &junk
,
1856 * Btree format (v3) inodes have the inode number stamped in the bmbt
1857 * block headers. We can't start changing the bmbt blocks until the
1858 * inode owner change is logged so recovery does the right thing in the
1859 * event of a crash. Set the owner change log flags now and leave the
1860 * bmbt scan as the last step.
1862 if (ip
->i_d
.di_version
== 3 &&
1863 ip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
)
1864 (*target_log_flags
) |= XFS_ILOG_DOWNER
;
1865 if (tip
->i_d
.di_version
== 3 &&
1866 tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
)
1867 (*src_log_flags
) |= XFS_ILOG_DOWNER
;
1870 * Swap the data forks of the inodes
1874 tempifp
= *ifp
; /* struct copy */
1875 *ifp
= *tifp
; /* struct copy */
1876 *tifp
= tempifp
; /* struct copy */
1879 * Fix the on-disk inode values
1881 tmp
= (uint64_t)ip
->i_d
.di_nblocks
;
1882 ip
->i_d
.di_nblocks
= tip
->i_d
.di_nblocks
- taforkblks
+ aforkblks
;
1883 tip
->i_d
.di_nblocks
= tmp
+ taforkblks
- aforkblks
;
1885 tmp
= (uint64_t) ip
->i_d
.di_nextents
;
1886 ip
->i_d
.di_nextents
= tip
->i_d
.di_nextents
;
1887 tip
->i_d
.di_nextents
= tmp
;
1889 tmp
= (uint64_t) ip
->i_d
.di_format
;
1890 ip
->i_d
.di_format
= tip
->i_d
.di_format
;
1891 tip
->i_d
.di_format
= tmp
;
1894 * The extents in the source inode could still contain speculative
1895 * preallocation beyond EOF (e.g. the file is open but not modified
1896 * while defrag is in progress). In that case, we need to copy over the
1897 * number of delalloc blocks the data fork in the source inode is
1898 * tracking beyond EOF so that when the fork is truncated away when the
1899 * temporary inode is unlinked we don't underrun the i_delayed_blks
1900 * counter on that inode.
1902 ASSERT(tip
->i_delayed_blks
== 0);
1903 tip
->i_delayed_blks
= ip
->i_delayed_blks
;
1904 ip
->i_delayed_blks
= 0;
1906 switch (ip
->i_d
.di_format
) {
1907 case XFS_DINODE_FMT_EXTENTS
:
1909 * If the extents fit in the inode, fix the pointer. Otherwise
1910 * it's already NULL or pointing to the extent.
1912 nextents
= xfs_iext_count(&ip
->i_df
);
1913 if (nextents
<= XFS_INLINE_EXTS
)
1914 ifp
->if_u1
.if_extents
= ifp
->if_u2
.if_inline_ext
;
1915 (*src_log_flags
) |= XFS_ILOG_DEXT
;
1917 case XFS_DINODE_FMT_BTREE
:
1918 ASSERT(ip
->i_d
.di_version
< 3 ||
1919 (*src_log_flags
& XFS_ILOG_DOWNER
));
1920 (*src_log_flags
) |= XFS_ILOG_DBROOT
;
1924 switch (tip
->i_d
.di_format
) {
1925 case XFS_DINODE_FMT_EXTENTS
:
1927 * If the extents fit in the inode, fix the pointer. Otherwise
1928 * it's already NULL or pointing to the extent.
1930 nextents
= xfs_iext_count(&tip
->i_df
);
1931 if (nextents
<= XFS_INLINE_EXTS
)
1932 tifp
->if_u1
.if_extents
= tifp
->if_u2
.if_inline_ext
;
1933 (*target_log_flags
) |= XFS_ILOG_DEXT
;
1935 case XFS_DINODE_FMT_BTREE
:
1936 (*target_log_flags
) |= XFS_ILOG_DBROOT
;
1937 ASSERT(tip
->i_d
.di_version
< 3 ||
1938 (*target_log_flags
& XFS_ILOG_DOWNER
));
1946 * Fix up the owners of the bmbt blocks to refer to the current inode. The
1947 * change owner scan attempts to order all modified buffers in the current
1948 * transaction. In the event of ordered buffer failure, the offending buffer is
1949 * physically logged as a fallback and the scan returns -EAGAIN. We must roll
1950 * the transaction in this case to replenish the fallback log reservation and
1951 * restart the scan. This process repeats until the scan completes.
1954 xfs_swap_change_owner(
1955 struct xfs_trans
**tpp
,
1956 struct xfs_inode
*ip
,
1957 struct xfs_inode
*tmpip
)
1960 struct xfs_trans
*tp
= *tpp
;
1963 error
= xfs_bmbt_change_owner(tp
, ip
, XFS_DATA_FORK
, ip
->i_ino
,
1965 /* success or fatal error */
1966 if (error
!= -EAGAIN
)
1969 error
= xfs_trans_roll(tpp
);
1975 * Redirty both inodes so they can relog and keep the log tail
1978 xfs_trans_ijoin(tp
, ip
, 0);
1979 xfs_trans_ijoin(tp
, tmpip
, 0);
1980 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
1981 xfs_trans_log_inode(tp
, tmpip
, XFS_ILOG_CORE
);
1989 struct xfs_inode
*ip
, /* target inode */
1990 struct xfs_inode
*tip
, /* tmp inode */
1991 struct xfs_swapext
*sxp
)
1993 struct xfs_mount
*mp
= ip
->i_mount
;
1994 struct xfs_trans
*tp
;
1995 struct xfs_bstat
*sbp
= &sxp
->sx_stat
;
1996 int src_log_flags
, target_log_flags
;
1999 struct xfs_ifork
*cowfp
;
2004 * Lock the inodes against other IO, page faults and truncate to
2005 * begin with. Then we can ensure the inodes are flushed and have no
2006 * page cache safely. Once we have done this we can take the ilocks and
2007 * do the rest of the checks.
2009 lock_two_nondirectories(VFS_I(ip
), VFS_I(tip
));
2010 lock_flags
= XFS_MMAPLOCK_EXCL
;
2011 xfs_lock_two_inodes(ip
, tip
, XFS_MMAPLOCK_EXCL
);
2013 /* Verify that both files have the same format */
2014 if ((VFS_I(ip
)->i_mode
& S_IFMT
) != (VFS_I(tip
)->i_mode
& S_IFMT
)) {
2019 /* Verify both files are either real-time or non-realtime */
2020 if (XFS_IS_REALTIME_INODE(ip
) != XFS_IS_REALTIME_INODE(tip
)) {
2025 error
= xfs_swap_extent_flush(ip
);
2028 error
= xfs_swap_extent_flush(tip
);
2033 * Extent "swapping" with rmap requires a permanent reservation and
2034 * a block reservation because it's really just a remap operation
2035 * performed with log redo items!
2037 if (xfs_sb_version_hasrmapbt(&mp
->m_sb
)) {
2039 * Conceptually this shouldn't affect the shape of either
2040 * bmbt, but since we atomically move extents one by one,
2041 * we reserve enough space to rebuild both trees.
2043 resblks
= XFS_SWAP_RMAP_SPACE_RES(mp
,
2044 XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
),
2046 XFS_SWAP_RMAP_SPACE_RES(mp
,
2047 XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
),
2050 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, 0, 0, &tp
);
2055 * Lock and join the inodes to the tansaction so that transaction commit
2056 * or cancel will unlock the inodes from this point onwards.
2058 xfs_lock_two_inodes(ip
, tip
, XFS_ILOCK_EXCL
);
2059 lock_flags
|= XFS_ILOCK_EXCL
;
2060 xfs_trans_ijoin(tp
, ip
, 0);
2061 xfs_trans_ijoin(tp
, tip
, 0);
2064 /* Verify all data are being swapped */
2065 if (sxp
->sx_offset
!= 0 ||
2066 sxp
->sx_length
!= ip
->i_d
.di_size
||
2067 sxp
->sx_length
!= tip
->i_d
.di_size
) {
2069 goto out_trans_cancel
;
2072 trace_xfs_swap_extent_before(ip
, 0);
2073 trace_xfs_swap_extent_before(tip
, 1);
2075 /* check inode formats now that data is flushed */
2076 error
= xfs_swap_extents_check_format(ip
, tip
);
2079 "%s: inode 0x%llx format is incompatible for exchanging.",
2080 __func__
, ip
->i_ino
);
2081 goto out_trans_cancel
;
2085 * Compare the current change & modify times with that
2086 * passed in. If they differ, we abort this swap.
2087 * This is the mechanism used to ensure the calling
2088 * process that the file was not changed out from
2091 if ((sbp
->bs_ctime
.tv_sec
!= VFS_I(ip
)->i_ctime
.tv_sec
) ||
2092 (sbp
->bs_ctime
.tv_nsec
!= VFS_I(ip
)->i_ctime
.tv_nsec
) ||
2093 (sbp
->bs_mtime
.tv_sec
!= VFS_I(ip
)->i_mtime
.tv_sec
) ||
2094 (sbp
->bs_mtime
.tv_nsec
!= VFS_I(ip
)->i_mtime
.tv_nsec
)) {
2096 goto out_trans_cancel
;
2100 * Note the trickiness in setting the log flags - we set the owner log
2101 * flag on the opposite inode (i.e. the inode we are setting the new
2102 * owner to be) because once we swap the forks and log that, log
2103 * recovery is going to see the fork as owned by the swapped inode,
2104 * not the pre-swapped inodes.
2106 src_log_flags
= XFS_ILOG_CORE
;
2107 target_log_flags
= XFS_ILOG_CORE
;
2109 if (xfs_sb_version_hasrmapbt(&mp
->m_sb
))
2110 error
= xfs_swap_extent_rmap(&tp
, ip
, tip
);
2112 error
= xfs_swap_extent_forks(tp
, ip
, tip
, &src_log_flags
,
2115 goto out_trans_cancel
;
2117 /* Do we have to swap reflink flags? */
2118 if ((ip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
) ^
2119 (tip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
)) {
2120 f
= ip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
;
2121 ip
->i_d
.di_flags2
&= ~XFS_DIFLAG2_REFLINK
;
2122 ip
->i_d
.di_flags2
|= tip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
;
2123 tip
->i_d
.di_flags2
&= ~XFS_DIFLAG2_REFLINK
;
2124 tip
->i_d
.di_flags2
|= f
& XFS_DIFLAG2_REFLINK
;
2127 /* Swap the cow forks. */
2128 if (xfs_sb_version_hasreflink(&mp
->m_sb
)) {
2129 xfs_extnum_t extnum
;
2131 ASSERT(ip
->i_cformat
== XFS_DINODE_FMT_EXTENTS
);
2132 ASSERT(tip
->i_cformat
== XFS_DINODE_FMT_EXTENTS
);
2134 extnum
= ip
->i_cnextents
;
2135 ip
->i_cnextents
= tip
->i_cnextents
;
2136 tip
->i_cnextents
= extnum
;
2138 cowfp
= ip
->i_cowfp
;
2139 ip
->i_cowfp
= tip
->i_cowfp
;
2140 tip
->i_cowfp
= cowfp
;
2142 if (ip
->i_cowfp
&& ip
->i_cnextents
)
2143 xfs_inode_set_cowblocks_tag(ip
);
2145 xfs_inode_clear_cowblocks_tag(ip
);
2146 if (tip
->i_cowfp
&& tip
->i_cnextents
)
2147 xfs_inode_set_cowblocks_tag(tip
);
2149 xfs_inode_clear_cowblocks_tag(tip
);
2152 xfs_trans_log_inode(tp
, ip
, src_log_flags
);
2153 xfs_trans_log_inode(tp
, tip
, target_log_flags
);
2156 * The extent forks have been swapped, but crc=1,rmapbt=0 filesystems
2157 * have inode number owner values in the bmbt blocks that still refer to
2158 * the old inode. Scan each bmbt to fix up the owner values with the
2159 * inode number of the current inode.
2161 if (src_log_flags
& XFS_ILOG_DOWNER
) {
2162 error
= xfs_swap_change_owner(&tp
, ip
, tip
);
2164 goto out_trans_cancel
;
2166 if (target_log_flags
& XFS_ILOG_DOWNER
) {
2167 error
= xfs_swap_change_owner(&tp
, tip
, ip
);
2169 goto out_trans_cancel
;
2173 * If this is a synchronous mount, make sure that the
2174 * transaction goes to disk before returning to the user.
2176 if (mp
->m_flags
& XFS_MOUNT_WSYNC
)
2177 xfs_trans_set_sync(tp
);
2179 error
= xfs_trans_commit(tp
);
2181 trace_xfs_swap_extent_after(ip
, 0);
2182 trace_xfs_swap_extent_after(tip
, 1);
2185 xfs_iunlock(ip
, lock_flags
);
2186 xfs_iunlock(tip
, lock_flags
);
2187 unlock_two_nondirectories(VFS_I(ip
), VFS_I(tip
));
2191 xfs_trans_cancel(tp
);