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.
225 xfs_bmap_count_leaves(
233 for (b
= 0; b
< numrecs
; b
++) {
234 xfs_bmbt_rec_host_t
*frp
= xfs_iext_get_ext(ifp
, idx
+ b
);
235 *count
+= xfs_bmbt_get_blockcount(frp
);
240 * Count leaf blocks given a range of extent records originally
244 xfs_bmap_disk_count_leaves(
245 struct xfs_mount
*mp
,
246 struct xfs_btree_block
*block
,
253 for (b
= 1; b
<= numrecs
; b
++) {
254 frp
= XFS_BMBT_REC_ADDR(mp
, block
, b
);
255 *count
+= xfs_bmbt_disk_get_blockcount(frp
);
260 * Recursively walks each level of a btree
261 * to count total fsblocks in use.
263 STATIC
int /* error */
265 xfs_mount_t
*mp
, /* file system mount point */
266 xfs_trans_t
*tp
, /* transaction pointer */
267 xfs_ifork_t
*ifp
, /* inode fork pointer */
268 xfs_fsblock_t blockno
, /* file system block number */
269 int levelin
, /* level in btree */
270 int *count
) /* Count of blocks */
276 xfs_fsblock_t bno
= blockno
;
277 xfs_fsblock_t nextbno
;
278 struct xfs_btree_block
*block
, *nextblock
;
281 error
= xfs_btree_read_bufl(mp
, tp
, bno
, 0, &bp
, XFS_BMAP_BTREE_REF
,
286 block
= XFS_BUF_TO_BLOCK(bp
);
289 /* Not at node above leaves, count this level of nodes */
290 nextbno
= be64_to_cpu(block
->bb_u
.l
.bb_rightsib
);
291 while (nextbno
!= NULLFSBLOCK
) {
292 error
= xfs_btree_read_bufl(mp
, tp
, nextbno
, 0, &nbp
,
298 nextblock
= XFS_BUF_TO_BLOCK(nbp
);
299 nextbno
= be64_to_cpu(nextblock
->bb_u
.l
.bb_rightsib
);
300 xfs_trans_brelse(tp
, nbp
);
303 /* Dive to the next level */
304 pp
= XFS_BMBT_PTR_ADDR(mp
, block
, 1, mp
->m_bmap_dmxr
[1]);
305 bno
= be64_to_cpu(*pp
);
306 if (unlikely((error
=
307 xfs_bmap_count_tree(mp
, tp
, ifp
, bno
, level
, count
)) < 0)) {
308 xfs_trans_brelse(tp
, bp
);
309 XFS_ERROR_REPORT("xfs_bmap_count_tree(1)",
310 XFS_ERRLEVEL_LOW
, mp
);
311 return -EFSCORRUPTED
;
313 xfs_trans_brelse(tp
, bp
);
315 /* count all level 1 nodes and their leaves */
317 nextbno
= be64_to_cpu(block
->bb_u
.l
.bb_rightsib
);
318 numrecs
= be16_to_cpu(block
->bb_numrecs
);
319 xfs_bmap_disk_count_leaves(mp
, block
, numrecs
, count
);
320 xfs_trans_brelse(tp
, bp
);
321 if (nextbno
== NULLFSBLOCK
)
324 error
= xfs_btree_read_bufl(mp
, tp
, bno
, 0, &bp
,
330 block
= XFS_BUF_TO_BLOCK(bp
);
337 * Count fsblocks of the given fork.
339 static int /* error */
340 xfs_bmap_count_blocks(
341 xfs_trans_t
*tp
, /* transaction pointer */
342 xfs_inode_t
*ip
, /* incore inode */
343 int whichfork
, /* data or attr fork */
344 int *count
) /* out: count of blocks */
346 struct xfs_btree_block
*block
; /* current btree block */
347 xfs_fsblock_t bno
; /* block # of "block" */
348 xfs_ifork_t
*ifp
; /* fork structure */
349 int level
; /* btree level, for checking */
350 xfs_mount_t
*mp
; /* file system mount structure */
351 __be64
*pp
; /* pointer to block address */
355 ifp
= XFS_IFORK_PTR(ip
, whichfork
);
356 if ( XFS_IFORK_FORMAT(ip
, whichfork
) == XFS_DINODE_FMT_EXTENTS
) {
357 xfs_bmap_count_leaves(ifp
, 0, xfs_iext_count(ifp
), count
);
362 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
364 block
= ifp
->if_broot
;
365 level
= be16_to_cpu(block
->bb_level
);
367 pp
= XFS_BMAP_BROOT_PTR_ADDR(mp
, block
, 1, ifp
->if_broot_bytes
);
368 bno
= be64_to_cpu(*pp
);
369 ASSERT(bno
!= NULLFSBLOCK
);
370 ASSERT(XFS_FSB_TO_AGNO(mp
, bno
) < mp
->m_sb
.sb_agcount
);
371 ASSERT(XFS_FSB_TO_AGBNO(mp
, bno
) < mp
->m_sb
.sb_agblocks
);
373 if (unlikely(xfs_bmap_count_tree(mp
, tp
, ifp
, bno
, level
, count
) < 0)) {
374 XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)", XFS_ERRLEVEL_LOW
,
376 return -EFSCORRUPTED
;
383 * returns 1 for success, 0 if we failed to map the extent.
386 xfs_getbmapx_fix_eof_hole(
387 xfs_inode_t
*ip
, /* xfs incore inode pointer */
389 struct getbmapx
*out
, /* output structure */
390 int prealloced
, /* this is a file with
391 * preallocated data space */
392 __int64_t end
, /* last block requested */
393 xfs_fsblock_t startblock
,
397 xfs_mount_t
*mp
; /* file system mount point */
398 xfs_ifork_t
*ifp
; /* inode fork pointer */
399 xfs_extnum_t lastx
; /* last extent pointer */
400 xfs_fileoff_t fileblock
;
402 if (startblock
== HOLESTARTBLOCK
) {
405 fixlen
= XFS_FSB_TO_BB(mp
, XFS_B_TO_FSB(mp
, XFS_ISIZE(ip
)));
406 fixlen
-= out
->bmv_offset
;
407 if (prealloced
&& out
->bmv_offset
+ out
->bmv_length
== end
) {
408 /* Came to hole at EOF. Trim it. */
411 out
->bmv_length
= fixlen
;
414 if (startblock
== DELAYSTARTBLOCK
)
417 out
->bmv_block
= xfs_fsb_to_db(ip
, startblock
);
418 fileblock
= XFS_BB_TO_FSB(ip
->i_mount
, out
->bmv_offset
);
419 ifp
= XFS_IFORK_PTR(ip
, whichfork
);
421 xfs_iext_bno_to_ext(ifp
, fileblock
, &lastx
) &&
422 (lastx
== xfs_iext_count(ifp
) - 1))
423 out
->bmv_oflags
|= BMV_OF_LAST
;
429 /* Adjust the reported bmap around shared/unshared extent transitions. */
431 xfs_getbmap_adjust_shared(
432 struct xfs_inode
*ip
,
434 struct xfs_bmbt_irec
*map
,
435 struct getbmapx
*out
,
436 struct xfs_bmbt_irec
*next_map
)
438 struct xfs_mount
*mp
= ip
->i_mount
;
446 next_map
->br_startblock
= NULLFSBLOCK
;
447 next_map
->br_startoff
= NULLFILEOFF
;
448 next_map
->br_blockcount
= 0;
450 /* Only written data blocks can be shared. */
451 if (!xfs_is_reflink_inode(ip
) || whichfork
!= XFS_DATA_FORK
||
452 map
->br_startblock
== DELAYSTARTBLOCK
||
453 map
->br_startblock
== HOLESTARTBLOCK
||
457 agno
= XFS_FSB_TO_AGNO(mp
, map
->br_startblock
);
458 agbno
= XFS_FSB_TO_AGBNO(mp
, map
->br_startblock
);
459 error
= xfs_reflink_find_shared(mp
, agno
, agbno
, map
->br_blockcount
,
464 if (ebno
== NULLAGBLOCK
) {
465 /* No shared blocks at all. */
467 } else if (agbno
== ebno
) {
469 * Shared extent at (agbno, elen). Shrink the reported
470 * extent length and prepare to move the start of map[i]
471 * to agbno+elen, with the aim of (re)formatting the new
472 * map[i] the next time through the inner loop.
474 out
->bmv_length
= XFS_FSB_TO_BB(mp
, elen
);
475 out
->bmv_oflags
|= BMV_OF_SHARED
;
476 if (elen
!= map
->br_blockcount
) {
478 next_map
->br_startblock
+= elen
;
479 next_map
->br_startoff
+= elen
;
480 next_map
->br_blockcount
-= elen
;
482 map
->br_blockcount
-= elen
;
485 * There's an unshared extent (agbno, ebno - agbno)
486 * followed by shared extent at (ebno, elen). Shrink
487 * the reported extent length to cover only the unshared
488 * extent and prepare to move up the start of map[i] to
489 * ebno, with the aim of (re)formatting the new map[i]
490 * the next time through the inner loop.
494 out
->bmv_length
= XFS_FSB_TO_BB(mp
, nlen
);
495 next_map
->br_startblock
+= nlen
;
496 next_map
->br_startoff
+= nlen
;
497 next_map
->br_blockcount
-= nlen
;
498 map
->br_blockcount
-= nlen
;
505 * Get inode's extents as described in bmv, and format for output.
506 * Calls formatter to fill the user's buffer until all extents
507 * are mapped, until the passed-in bmv->bmv_count slots have
508 * been filled, or until the formatter short-circuits the loop,
509 * if it is tracking filled-in extents on its own.
514 struct getbmapx
*bmv
, /* user bmap structure */
515 xfs_bmap_format_t formatter
, /* format to user */
516 void *arg
) /* formatter arg */
518 __int64_t bmvend
; /* last block requested */
519 int error
= 0; /* return value */
520 __int64_t fixlen
; /* length for -1 case */
521 int i
; /* extent number */
522 int lock
; /* lock state */
523 xfs_bmbt_irec_t
*map
; /* buffer for user's data */
524 xfs_mount_t
*mp
; /* file system mount point */
525 int nex
; /* # of user extents can do */
526 int subnex
; /* # of bmapi's can do */
527 int nmap
; /* number of map entries */
528 struct getbmapx
*out
; /* output structure */
529 int whichfork
; /* data or attr fork */
530 int prealloced
; /* this is a file with
531 * preallocated data space */
532 int iflags
; /* interface flags */
533 int bmapi_flags
; /* flags for xfs_bmapi */
535 struct xfs_bmbt_irec inject_map
;
538 iflags
= bmv
->bmv_iflags
;
541 /* Only allow CoW fork queries if we're debugging. */
542 if (iflags
& BMV_IF_COWFORK
)
545 if ((iflags
& BMV_IF_ATTRFORK
) && (iflags
& BMV_IF_COWFORK
))
548 if (iflags
& BMV_IF_ATTRFORK
)
549 whichfork
= XFS_ATTR_FORK
;
550 else if (iflags
& BMV_IF_COWFORK
)
551 whichfork
= XFS_COW_FORK
;
553 whichfork
= XFS_DATA_FORK
;
557 if (XFS_IFORK_Q(ip
)) {
558 if (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_EXTENTS
&&
559 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_BTREE
&&
560 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)
563 ip
->i_d
.di_aformat
!= 0 &&
564 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_EXTENTS
)) {
565 XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW
,
567 return -EFSCORRUPTED
;
574 if (ip
->i_cformat
!= XFS_DINODE_FMT_EXTENTS
)
577 if (xfs_get_cowextsz_hint(ip
)) {
579 fixlen
= mp
->m_super
->s_maxbytes
;
582 fixlen
= XFS_ISIZE(ip
);
586 if (ip
->i_d
.di_format
!= XFS_DINODE_FMT_EXTENTS
&&
587 ip
->i_d
.di_format
!= XFS_DINODE_FMT_BTREE
&&
588 ip
->i_d
.di_format
!= XFS_DINODE_FMT_LOCAL
)
591 if (xfs_get_extsz_hint(ip
) ||
592 ip
->i_d
.di_flags
& (XFS_DIFLAG_PREALLOC
|XFS_DIFLAG_APPEND
)){
594 fixlen
= mp
->m_super
->s_maxbytes
;
597 fixlen
= XFS_ISIZE(ip
);
602 if (bmv
->bmv_length
== -1) {
603 fixlen
= XFS_FSB_TO_BB(mp
, XFS_B_TO_FSB(mp
, fixlen
));
605 max_t(__int64_t
, fixlen
- bmv
->bmv_offset
, 0);
606 } else if (bmv
->bmv_length
== 0) {
607 bmv
->bmv_entries
= 0;
609 } else if (bmv
->bmv_length
< 0) {
613 nex
= bmv
->bmv_count
- 1;
616 bmvend
= bmv
->bmv_offset
+ bmv
->bmv_length
;
619 if (bmv
->bmv_count
> ULONG_MAX
/ sizeof(struct getbmapx
))
621 out
= kmem_zalloc_large(bmv
->bmv_count
* sizeof(struct getbmapx
), 0);
625 xfs_ilock(ip
, XFS_IOLOCK_SHARED
);
628 if (!(iflags
& BMV_IF_DELALLOC
) &&
629 (ip
->i_delayed_blks
|| XFS_ISIZE(ip
) > ip
->i_d
.di_size
)) {
630 error
= filemap_write_and_wait(VFS_I(ip
)->i_mapping
);
632 goto out_unlock_iolock
;
635 * Even after flushing the inode, there can still be
636 * delalloc blocks on the inode beyond EOF due to
637 * speculative preallocation. These are not removed
638 * until the release function is called or the inode
639 * is inactivated. Hence we cannot assert here that
640 * ip->i_delayed_blks == 0.
644 lock
= xfs_ilock_data_map_shared(ip
);
647 lock
= XFS_ILOCK_SHARED
;
651 lock
= xfs_ilock_attr_map_shared(ip
);
656 * Don't let nex be bigger than the number of extents
657 * we can have assuming alternating holes and real extents.
659 if (nex
> XFS_IFORK_NEXTENTS(ip
, whichfork
) * 2 + 1)
660 nex
= XFS_IFORK_NEXTENTS(ip
, whichfork
) * 2 + 1;
662 bmapi_flags
= xfs_bmapi_aflag(whichfork
);
663 if (!(iflags
& BMV_IF_PREALLOC
))
664 bmapi_flags
|= XFS_BMAPI_IGSTATE
;
667 * Allocate enough space to handle "subnex" maps at a time.
671 map
= kmem_alloc(subnex
* sizeof(*map
), KM_MAYFAIL
| KM_NOFS
);
673 goto out_unlock_ilock
;
675 bmv
->bmv_entries
= 0;
677 if (XFS_IFORK_NEXTENTS(ip
, whichfork
) == 0 &&
678 (whichfork
== XFS_ATTR_FORK
|| !(iflags
& BMV_IF_DELALLOC
))) {
684 nmap
= (nex
> subnex
) ? subnex
: nex
;
685 error
= xfs_bmapi_read(ip
, XFS_BB_TO_FSBT(mp
, bmv
->bmv_offset
),
686 XFS_BB_TO_FSB(mp
, bmv
->bmv_length
),
687 map
, &nmap
, bmapi_flags
);
690 ASSERT(nmap
<= subnex
);
692 for (i
= 0; i
< nmap
&& bmv
->bmv_length
&&
693 cur_ext
< bmv
->bmv_count
- 1; i
++) {
694 out
[cur_ext
].bmv_oflags
= 0;
695 if (map
[i
].br_state
== XFS_EXT_UNWRITTEN
)
696 out
[cur_ext
].bmv_oflags
|= BMV_OF_PREALLOC
;
697 else if (map
[i
].br_startblock
== DELAYSTARTBLOCK
)
698 out
[cur_ext
].bmv_oflags
|= BMV_OF_DELALLOC
;
699 out
[cur_ext
].bmv_offset
=
700 XFS_FSB_TO_BB(mp
, map
[i
].br_startoff
);
701 out
[cur_ext
].bmv_length
=
702 XFS_FSB_TO_BB(mp
, map
[i
].br_blockcount
);
703 out
[cur_ext
].bmv_unused1
= 0;
704 out
[cur_ext
].bmv_unused2
= 0;
707 * delayed allocation extents that start beyond EOF can
708 * occur due to speculative EOF allocation when the
709 * delalloc extent is larger than the largest freespace
710 * extent at conversion time. These extents cannot be
711 * converted by data writeback, so can exist here even
712 * if we are not supposed to be finding delalloc
715 if (map
[i
].br_startblock
== DELAYSTARTBLOCK
&&
716 map
[i
].br_startoff
<= XFS_B_TO_FSB(mp
, XFS_ISIZE(ip
)))
717 ASSERT((iflags
& BMV_IF_DELALLOC
) != 0);
719 if (map
[i
].br_startblock
== HOLESTARTBLOCK
&&
720 whichfork
== XFS_ATTR_FORK
) {
721 /* came to the end of attribute fork */
722 out
[cur_ext
].bmv_oflags
|= BMV_OF_LAST
;
726 /* Is this a shared block? */
727 error
= xfs_getbmap_adjust_shared(ip
, whichfork
,
728 &map
[i
], &out
[cur_ext
], &inject_map
);
732 if (!xfs_getbmapx_fix_eof_hole(ip
, whichfork
,
733 &out
[cur_ext
], prealloced
, bmvend
,
734 map
[i
].br_startblock
,
735 inject_map
.br_startblock
!= NULLFSBLOCK
))
739 out
[cur_ext
].bmv_offset
+
740 out
[cur_ext
].bmv_length
;
742 max_t(__int64_t
, 0, bmvend
- bmv
->bmv_offset
);
745 * In case we don't want to return the hole,
746 * don't increase cur_ext so that we can reuse
747 * it in the next loop.
749 if ((iflags
& BMV_IF_NO_HOLES
) &&
750 map
[i
].br_startblock
== HOLESTARTBLOCK
) {
751 memset(&out
[cur_ext
], 0, sizeof(out
[cur_ext
]));
756 * In order to report shared extents accurately,
757 * we report each distinct shared/unshared part
758 * of a single bmbt record using multiple bmap
759 * extents. To make that happen, we iterate the
760 * same map array item multiple times, each
761 * time trimming out the subextent that we just
764 * Because of this, we must check the out array
765 * index (cur_ext) directly against bmv_count-1
766 * to avoid overflows.
768 if (inject_map
.br_startblock
!= NULLFSBLOCK
) {
775 } while (nmap
&& bmv
->bmv_length
&& cur_ext
< bmv
->bmv_count
- 1);
780 xfs_iunlock(ip
, lock
);
782 xfs_iunlock(ip
, XFS_IOLOCK_SHARED
);
784 for (i
= 0; i
< cur_ext
; i
++) {
785 /* format results & advance arg */
786 error
= formatter(&arg
, &out
[i
]);
796 * dead simple method of punching delalyed allocation blocks from a range in
797 * the inode. Walks a block at a time so will be slow, but is only executed in
798 * rare error cases so the overhead is not critical. This will always punch out
799 * both the start and end blocks, even if the ranges only partially overlap
800 * them, so it is up to the caller to ensure that partial blocks are not
804 xfs_bmap_punch_delalloc_range(
805 struct xfs_inode
*ip
,
806 xfs_fileoff_t start_fsb
,
807 xfs_fileoff_t length
)
809 xfs_fileoff_t remaining
= length
;
812 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
816 xfs_bmbt_irec_t imap
;
818 xfs_fsblock_t firstblock
;
819 struct xfs_defer_ops dfops
;
822 * Map the range first and check that it is a delalloc extent
823 * before trying to unmap the range. Otherwise we will be
824 * trying to remove a real extent (which requires a
825 * transaction) or a hole, which is probably a bad idea...
827 error
= xfs_bmapi_read(ip
, start_fsb
, 1, &imap
, &nimaps
,
831 /* something screwed, just bail */
832 if (!XFS_FORCED_SHUTDOWN(ip
->i_mount
)) {
833 xfs_alert(ip
->i_mount
,
834 "Failed delalloc mapping lookup ino %lld fsb %lld.",
835 ip
->i_ino
, start_fsb
);
843 if (imap
.br_startblock
!= DELAYSTARTBLOCK
) {
844 /* been converted, ignore */
847 WARN_ON(imap
.br_blockcount
== 0);
850 * Note: while we initialise the firstblock/dfops pair, they
851 * should never be used because blocks should never be
852 * allocated or freed for a delalloc extent and hence we need
853 * don't cancel or finish them after the xfs_bunmapi() call.
855 xfs_defer_init(&dfops
, &firstblock
);
856 error
= xfs_bunmapi(NULL
, ip
, start_fsb
, 1, 0, 1, &firstblock
,
861 ASSERT(!xfs_defer_has_unfinished_work(&dfops
));
865 } while(remaining
> 0);
871 * Test whether it is appropriate to check an inode for and free post EOF
872 * blocks. The 'force' parameter determines whether we should also consider
873 * regular files that are marked preallocated or append-only.
876 xfs_can_free_eofblocks(struct xfs_inode
*ip
, bool force
)
878 /* prealloc/delalloc exists only on regular files */
879 if (!S_ISREG(VFS_I(ip
)->i_mode
))
883 * Zero sized files with no cached pages and delalloc blocks will not
884 * have speculative prealloc/delalloc blocks to remove.
886 if (VFS_I(ip
)->i_size
== 0 &&
887 VFS_I(ip
)->i_mapping
->nrpages
== 0 &&
888 ip
->i_delayed_blks
== 0)
891 /* If we haven't read in the extent list, then don't do it now. */
892 if (!(ip
->i_df
.if_flags
& XFS_IFEXTENTS
))
896 * Do not free real preallocated or append-only files unless the file
897 * has delalloc blocks and we are forced to remove them.
899 if (ip
->i_d
.di_flags
& (XFS_DIFLAG_PREALLOC
| XFS_DIFLAG_APPEND
))
900 if (!force
|| ip
->i_delayed_blks
== 0)
907 * This is called by xfs_inactive to free any blocks beyond eof
908 * when the link count isn't zero and by xfs_dm_punch_hole() when
909 * punching a hole to EOF.
913 struct xfs_inode
*ip
)
915 struct xfs_trans
*tp
;
917 xfs_fileoff_t end_fsb
;
918 xfs_fileoff_t last_fsb
;
919 xfs_filblks_t map_len
;
921 struct xfs_bmbt_irec imap
;
922 struct xfs_mount
*mp
= ip
->i_mount
;
924 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_EXCL
));
927 * Figure out if there are any blocks beyond the end
928 * of the file. If not, then there is nothing to do.
930 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)XFS_ISIZE(ip
));
931 last_fsb
= XFS_B_TO_FSB(mp
, mp
->m_super
->s_maxbytes
);
932 if (last_fsb
<= end_fsb
)
934 map_len
= last_fsb
- end_fsb
;
937 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
938 error
= xfs_bmapi_read(ip
, end_fsb
, map_len
, &imap
, &nimaps
, 0);
939 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
942 * If there are blocks after the end of file, truncate the file to its
943 * current size to free them up.
945 if (!error
&& (nimaps
!= 0) &&
946 (imap
.br_startblock
!= HOLESTARTBLOCK
||
947 ip
->i_delayed_blks
)) {
949 * Attach the dquots to the inode up front.
951 error
= xfs_qm_dqattach(ip
, 0);
955 /* wait on dio to ensure i_size has settled */
956 inode_dio_wait(VFS_I(ip
));
958 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_itruncate
, 0, 0, 0,
961 ASSERT(XFS_FORCED_SHUTDOWN(mp
));
965 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
966 xfs_trans_ijoin(tp
, ip
, 0);
969 * Do not update the on-disk file size. If we update the
970 * on-disk file size and then the system crashes before the
971 * contents of the file are flushed to disk then the files
972 * may be full of holes (ie NULL files bug).
974 error
= xfs_itruncate_extents(&tp
, ip
, XFS_DATA_FORK
,
978 * If we get an error at this point we simply don't
979 * bother truncating the file.
981 xfs_trans_cancel(tp
);
983 error
= xfs_trans_commit(tp
);
985 xfs_inode_clear_eofblocks_tag(ip
);
988 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
994 xfs_alloc_file_space(
995 struct xfs_inode
*ip
,
1000 xfs_mount_t
*mp
= ip
->i_mount
;
1002 xfs_filblks_t allocated_fsb
;
1003 xfs_filblks_t allocatesize_fsb
;
1004 xfs_extlen_t extsz
, temp
;
1005 xfs_fileoff_t startoffset_fsb
;
1006 xfs_fsblock_t firstfsb
;
1011 xfs_bmbt_irec_t imaps
[1], *imapp
;
1012 struct xfs_defer_ops dfops
;
1013 uint qblocks
, resblks
, resrtextents
;
1016 trace_xfs_alloc_file_space(ip
);
1018 if (XFS_FORCED_SHUTDOWN(mp
))
1021 error
= xfs_qm_dqattach(ip
, 0);
1028 rt
= XFS_IS_REALTIME_INODE(ip
);
1029 extsz
= xfs_get_extsz_hint(ip
);
1034 startoffset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
1035 allocatesize_fsb
= XFS_B_TO_FSB(mp
, count
);
1038 * Allocate file space until done or until there is an error
1040 while (allocatesize_fsb
&& !error
) {
1044 * Determine space reservations for data/realtime.
1046 if (unlikely(extsz
)) {
1047 s
= startoffset_fsb
;
1050 e
= startoffset_fsb
+ allocatesize_fsb
;
1051 if ((temp
= do_mod(startoffset_fsb
, extsz
)))
1053 if ((temp
= do_mod(e
, extsz
)))
1057 e
= allocatesize_fsb
;
1061 * The transaction reservation is limited to a 32-bit block
1062 * count, hence we need to limit the number of blocks we are
1063 * trying to reserve to avoid an overflow. We can't allocate
1064 * more than @nimaps extents, and an extent is limited on disk
1065 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
1067 resblks
= min_t(xfs_fileoff_t
, (e
- s
), (MAXEXTLEN
* nimaps
));
1069 resrtextents
= qblocks
= resblks
;
1070 resrtextents
/= mp
->m_sb
.sb_rextsize
;
1071 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
1072 quota_flag
= XFS_QMOPT_RES_RTBLKS
;
1075 resblks
= qblocks
= XFS_DIOSTRAT_SPACE_RES(mp
, resblks
);
1076 quota_flag
= XFS_QMOPT_RES_REGBLKS
;
1080 * Allocate and setup the transaction.
1082 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
,
1083 resrtextents
, 0, &tp
);
1086 * Check for running out of space
1090 * Free the transaction structure.
1092 ASSERT(error
== -ENOSPC
|| XFS_FORCED_SHUTDOWN(mp
));
1095 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1096 error
= xfs_trans_reserve_quota_nblks(tp
, ip
, qblocks
,
1101 xfs_trans_ijoin(tp
, ip
, 0);
1103 xfs_defer_init(&dfops
, &firstfsb
);
1104 error
= xfs_bmapi_write(tp
, ip
, startoffset_fsb
,
1105 allocatesize_fsb
, alloc_type
, &firstfsb
,
1106 resblks
, imapp
, &nimaps
, &dfops
);
1111 * Complete the transaction
1113 error
= xfs_defer_finish(&tp
, &dfops
, NULL
);
1117 error
= xfs_trans_commit(tp
);
1118 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1122 allocated_fsb
= imapp
->br_blockcount
;
1129 startoffset_fsb
+= allocated_fsb
;
1130 allocatesize_fsb
-= allocated_fsb
;
1135 error0
: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
1136 xfs_defer_cancel(&dfops
);
1137 xfs_trans_unreserve_quota_nblks(tp
, ip
, (long)qblocks
, 0, quota_flag
);
1139 error1
: /* Just cancel transaction */
1140 xfs_trans_cancel(tp
);
1141 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1147 struct xfs_inode
*ip
,
1148 xfs_fileoff_t startoffset_fsb
,
1149 xfs_filblks_t len_fsb
,
1152 struct xfs_mount
*mp
= ip
->i_mount
;
1153 struct xfs_trans
*tp
;
1154 struct xfs_defer_ops dfops
;
1155 xfs_fsblock_t firstfsb
;
1156 uint resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
1159 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, 0, 0, &tp
);
1161 ASSERT(error
== -ENOSPC
|| XFS_FORCED_SHUTDOWN(mp
));
1165 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1166 error
= xfs_trans_reserve_quota(tp
, mp
, ip
->i_udquot
, ip
->i_gdquot
,
1167 ip
->i_pdquot
, resblks
, 0, XFS_QMOPT_RES_REGBLKS
);
1169 goto out_trans_cancel
;
1171 xfs_trans_ijoin(tp
, ip
, 0);
1173 xfs_defer_init(&dfops
, &firstfsb
);
1174 error
= xfs_bunmapi(tp
, ip
, startoffset_fsb
, len_fsb
, 0, 2, &firstfsb
,
1177 goto out_bmap_cancel
;
1179 error
= xfs_defer_finish(&tp
, &dfops
, ip
);
1181 goto out_bmap_cancel
;
1183 error
= xfs_trans_commit(tp
);
1185 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1189 xfs_defer_cancel(&dfops
);
1191 xfs_trans_cancel(tp
);
1196 xfs_adjust_extent_unmap_boundaries(
1197 struct xfs_inode
*ip
,
1198 xfs_fileoff_t
*startoffset_fsb
,
1199 xfs_fileoff_t
*endoffset_fsb
)
1201 struct xfs_mount
*mp
= ip
->i_mount
;
1202 struct xfs_bmbt_irec imap
;
1204 xfs_extlen_t mod
= 0;
1207 error
= xfs_bmapi_read(ip
, *startoffset_fsb
, 1, &imap
, &nimap
, 0);
1211 if (nimap
&& imap
.br_startblock
!= HOLESTARTBLOCK
) {
1214 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
1215 block
= imap
.br_startblock
;
1216 mod
= do_div(block
, mp
->m_sb
.sb_rextsize
);
1218 *startoffset_fsb
+= mp
->m_sb
.sb_rextsize
- mod
;
1222 error
= xfs_bmapi_read(ip
, *endoffset_fsb
- 1, 1, &imap
, &nimap
, 0);
1226 if (nimap
&& imap
.br_startblock
!= HOLESTARTBLOCK
) {
1227 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
1229 if (mod
&& mod
!= mp
->m_sb
.sb_rextsize
)
1230 *endoffset_fsb
-= mod
;
1237 xfs_flush_unmap_range(
1238 struct xfs_inode
*ip
,
1242 struct xfs_mount
*mp
= ip
->i_mount
;
1243 struct inode
*inode
= VFS_I(ip
);
1244 xfs_off_t rounding
, start
, end
;
1247 /* wait for the completion of any pending DIOs */
1248 inode_dio_wait(inode
);
1250 rounding
= max_t(xfs_off_t
, 1 << mp
->m_sb
.sb_blocklog
, PAGE_SIZE
);
1251 start
= round_down(offset
, rounding
);
1252 end
= round_up(offset
+ len
, rounding
) - 1;
1254 error
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
1257 truncate_pagecache_range(inode
, start
, end
);
1262 xfs_free_file_space(
1263 struct xfs_inode
*ip
,
1267 struct xfs_mount
*mp
= ip
->i_mount
;
1268 xfs_fileoff_t startoffset_fsb
;
1269 xfs_fileoff_t endoffset_fsb
;
1270 int done
= 0, error
;
1272 trace_xfs_free_file_space(ip
);
1274 error
= xfs_qm_dqattach(ip
, 0);
1278 if (len
<= 0) /* if nothing being freed */
1281 error
= xfs_flush_unmap_range(ip
, offset
, len
);
1285 startoffset_fsb
= XFS_B_TO_FSB(mp
, offset
);
1286 endoffset_fsb
= XFS_B_TO_FSBT(mp
, offset
+ len
);
1289 * Need to zero the stuff we're not freeing, on disk. If it's a RT file
1290 * and we can't use unwritten extents then we actually need to ensure
1291 * to zero the whole extent, otherwise we just need to take of block
1292 * boundaries, and xfs_bunmapi will handle the rest.
1294 if (XFS_IS_REALTIME_INODE(ip
) &&
1295 !xfs_sb_version_hasextflgbit(&mp
->m_sb
)) {
1296 error
= xfs_adjust_extent_unmap_boundaries(ip
, &startoffset_fsb
,
1302 if (endoffset_fsb
> startoffset_fsb
) {
1304 error
= xfs_unmap_extent(ip
, startoffset_fsb
,
1305 endoffset_fsb
- startoffset_fsb
, &done
);
1312 * Now that we've unmap all full blocks we'll have to zero out any
1313 * partial block at the beginning and/or end. xfs_zero_range is
1314 * smart enough to skip any holes, including those we just created.
1316 return xfs_zero_range(ip
, offset
, len
, NULL
);
1320 * Preallocate and zero a range of a file. This mechanism has the allocation
1321 * semantics of fallocate and in addition converts data in the range to zeroes.
1324 xfs_zero_file_space(
1325 struct xfs_inode
*ip
,
1329 struct xfs_mount
*mp
= ip
->i_mount
;
1333 trace_xfs_zero_file_space(ip
);
1335 blksize
= 1 << mp
->m_sb
.sb_blocklog
;
1338 * Punch a hole and prealloc the range. We use hole punch rather than
1339 * unwritten extent conversion for two reasons:
1341 * 1.) Hole punch handles partial block zeroing for us.
1343 * 2.) If prealloc returns ENOSPC, the file range is still zero-valued
1344 * by virtue of the hole punch.
1346 error
= xfs_free_file_space(ip
, offset
, len
);
1350 error
= xfs_alloc_file_space(ip
, round_down(offset
, blksize
),
1351 round_up(offset
+ len
, blksize
) -
1352 round_down(offset
, blksize
),
1353 XFS_BMAPI_PREALLOC
);
1360 * @next_fsb will keep track of the extent currently undergoing shift.
1361 * @stop_fsb will keep track of the extent at which we have to stop.
1362 * If we are shifting left, we will start with block (offset + len) and
1363 * shift each extent till last extent.
1364 * If we are shifting right, we will start with last extent inside file space
1365 * and continue until we reach the block corresponding to offset.
1368 xfs_shift_file_space(
1369 struct xfs_inode
*ip
,
1372 enum shift_direction direction
)
1375 struct xfs_mount
*mp
= ip
->i_mount
;
1376 struct xfs_trans
*tp
;
1378 struct xfs_defer_ops dfops
;
1379 xfs_fsblock_t first_block
;
1380 xfs_fileoff_t stop_fsb
;
1381 xfs_fileoff_t next_fsb
;
1382 xfs_fileoff_t shift_fsb
;
1385 ASSERT(direction
== SHIFT_LEFT
|| direction
== SHIFT_RIGHT
);
1387 if (direction
== SHIFT_LEFT
) {
1389 * Reserve blocks to cover potential extent merges after left
1392 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
1393 next_fsb
= XFS_B_TO_FSB(mp
, offset
+ len
);
1394 stop_fsb
= XFS_B_TO_FSB(mp
, VFS_I(ip
)->i_size
);
1397 * If right shift, delegate the work of initialization of
1398 * next_fsb to xfs_bmap_shift_extent as it has ilock held.
1401 next_fsb
= NULLFSBLOCK
;
1402 stop_fsb
= XFS_B_TO_FSB(mp
, offset
);
1405 shift_fsb
= XFS_B_TO_FSB(mp
, len
);
1408 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1409 * into the accessible region of the file.
1411 if (xfs_can_free_eofblocks(ip
, true)) {
1412 error
= xfs_free_eofblocks(ip
);
1418 * Writeback and invalidate cache for the remainder of the file as we're
1419 * about to shift down every extent from offset to EOF.
1421 error
= filemap_write_and_wait_range(VFS_I(ip
)->i_mapping
,
1425 error
= invalidate_inode_pages2_range(VFS_I(ip
)->i_mapping
,
1426 offset
>> PAGE_SHIFT
, -1);
1431 * The extent shiting code works on extent granularity. So, if
1432 * stop_fsb is not the starting block of extent, we need to split
1433 * the extent at stop_fsb.
1435 if (direction
== SHIFT_RIGHT
) {
1436 error
= xfs_bmap_split_extent(ip
, stop_fsb
);
1441 while (!error
&& !done
) {
1442 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, 0, 0,
1447 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1448 error
= xfs_trans_reserve_quota(tp
, mp
, ip
->i_udquot
,
1449 ip
->i_gdquot
, ip
->i_pdquot
, resblks
, 0,
1450 XFS_QMOPT_RES_REGBLKS
);
1452 goto out_trans_cancel
;
1454 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
1456 xfs_defer_init(&dfops
, &first_block
);
1459 * We are using the write transaction in which max 2 bmbt
1460 * updates are allowed
1462 error
= xfs_bmap_shift_extents(tp
, ip
, &next_fsb
, shift_fsb
,
1463 &done
, stop_fsb
, &first_block
, &dfops
,
1464 direction
, XFS_BMAP_MAX_SHIFT_EXTENTS
);
1466 goto out_bmap_cancel
;
1468 error
= xfs_defer_finish(&tp
, &dfops
, NULL
);
1470 goto out_bmap_cancel
;
1472 error
= xfs_trans_commit(tp
);
1478 xfs_defer_cancel(&dfops
);
1480 xfs_trans_cancel(tp
);
1485 * xfs_collapse_file_space()
1486 * This routine frees disk space and shift extent for the given file.
1487 * The first thing we do is to free data blocks in the specified range
1488 * by calling xfs_free_file_space(). It would also sync dirty data
1489 * and invalidate page cache over the region on which collapse range
1490 * is working. And Shift extent records to the left to cover a hole.
1497 xfs_collapse_file_space(
1498 struct xfs_inode
*ip
,
1504 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_EXCL
));
1505 trace_xfs_collapse_file_space(ip
);
1507 error
= xfs_free_file_space(ip
, offset
, len
);
1511 return xfs_shift_file_space(ip
, offset
, len
, SHIFT_LEFT
);
1515 * xfs_insert_file_space()
1516 * This routine create hole space by shifting extents for the given file.
1517 * The first thing we do is to sync dirty data and invalidate page cache
1518 * over the region on which insert range is working. And split an extent
1519 * to two extents at given offset by calling xfs_bmap_split_extent.
1520 * And shift all extent records which are laying between [offset,
1521 * last allocated extent] to the right to reserve hole range.
1527 xfs_insert_file_space(
1528 struct xfs_inode
*ip
,
1532 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_EXCL
));
1533 trace_xfs_insert_file_space(ip
);
1535 return xfs_shift_file_space(ip
, offset
, len
, SHIFT_RIGHT
);
1539 * We need to check that the format of the data fork in the temporary inode is
1540 * valid for the target inode before doing the swap. This is not a problem with
1541 * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
1542 * data fork depending on the space the attribute fork is taking so we can get
1543 * invalid formats on the target inode.
1545 * E.g. target has space for 7 extents in extent format, temp inode only has
1546 * space for 6. If we defragment down to 7 extents, then the tmp format is a
1547 * btree, but when swapped it needs to be in extent format. Hence we can't just
1548 * blindly swap data forks on attr2 filesystems.
1550 * Note that we check the swap in both directions so that we don't end up with
1551 * a corrupt temporary inode, either.
1553 * Note that fixing the way xfs_fsr sets up the attribute fork in the source
1554 * inode will prevent this situation from occurring, so all we do here is
1555 * reject and log the attempt. basically we are putting the responsibility on
1556 * userspace to get this right.
1559 xfs_swap_extents_check_format(
1560 struct xfs_inode
*ip
, /* target inode */
1561 struct xfs_inode
*tip
) /* tmp inode */
1564 /* Should never get a local format */
1565 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
||
1566 tip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
)
1570 * if the target inode has less extents that then temporary inode then
1571 * why did userspace call us?
1573 if (ip
->i_d
.di_nextents
< tip
->i_d
.di_nextents
)
1577 * If we have to use the (expensive) rmap swap method, we can
1578 * handle any number of extents and any format.
1580 if (xfs_sb_version_hasrmapbt(&ip
->i_mount
->m_sb
))
1584 * if the target inode is in extent form and the temp inode is in btree
1585 * form then we will end up with the target inode in the wrong format
1586 * as we already know there are less extents in the temp inode.
1588 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1589 tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
)
1592 /* Check temp in extent form to max in target */
1593 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1594 XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) >
1595 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
1598 /* Check target in extent form to max in temp */
1599 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1600 XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) >
1601 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
1605 * If we are in a btree format, check that the temp root block will fit
1606 * in the target and that it has enough extents to be in btree format
1609 * Note that we have to be careful to allow btree->extent conversions
1610 * (a common defrag case) which will occur when the temp inode is in
1613 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1614 if (XFS_IFORK_BOFF(ip
) &&
1615 XFS_BMAP_BMDR_SPACE(tip
->i_df
.if_broot
) > XFS_IFORK_BOFF(ip
))
1617 if (XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) <=
1618 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
1622 /* Reciprocal target->temp btree format checks */
1623 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1624 if (XFS_IFORK_BOFF(tip
) &&
1625 XFS_BMAP_BMDR_SPACE(ip
->i_df
.if_broot
) > XFS_IFORK_BOFF(tip
))
1627 if (XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) <=
1628 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
1636 xfs_swap_extent_flush(
1637 struct xfs_inode
*ip
)
1641 error
= filemap_write_and_wait(VFS_I(ip
)->i_mapping
);
1644 truncate_pagecache_range(VFS_I(ip
), 0, -1);
1646 /* Verify O_DIRECT for ftmp */
1647 if (VFS_I(ip
)->i_mapping
->nrpages
)
1653 * Move extents from one file to another, when rmap is enabled.
1656 xfs_swap_extent_rmap(
1657 struct xfs_trans
**tpp
,
1658 struct xfs_inode
*ip
,
1659 struct xfs_inode
*tip
)
1661 struct xfs_bmbt_irec irec
;
1662 struct xfs_bmbt_irec uirec
;
1663 struct xfs_bmbt_irec tirec
;
1664 xfs_fileoff_t offset_fsb
;
1665 xfs_fileoff_t end_fsb
;
1666 xfs_filblks_t count_fsb
;
1667 xfs_fsblock_t firstfsb
;
1668 struct xfs_defer_ops dfops
;
1673 __uint64_t tip_flags2
;
1676 * If the source file has shared blocks, we must flag the donor
1677 * file as having shared blocks so that we get the shared-block
1678 * rmap functions when we go to fix up the rmaps. The flags
1679 * will be switch for reals later.
1681 tip_flags2
= tip
->i_d
.di_flags2
;
1682 if (ip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
)
1683 tip
->i_d
.di_flags2
|= XFS_DIFLAG2_REFLINK
;
1686 end_fsb
= XFS_B_TO_FSB(ip
->i_mount
, i_size_read(VFS_I(ip
)));
1687 count_fsb
= (xfs_filblks_t
)(end_fsb
- offset_fsb
);
1690 /* Read extent from the donor file */
1692 error
= xfs_bmapi_read(tip
, offset_fsb
, count_fsb
, &tirec
,
1696 ASSERT(nimaps
== 1);
1697 ASSERT(tirec
.br_startblock
!= DELAYSTARTBLOCK
);
1699 trace_xfs_swap_extent_rmap_remap(tip
, &tirec
);
1700 ilen
= tirec
.br_blockcount
;
1702 /* Unmap the old blocks in the source file. */
1703 while (tirec
.br_blockcount
) {
1704 xfs_defer_init(&dfops
, &firstfsb
);
1705 trace_xfs_swap_extent_rmap_remap_piece(tip
, &tirec
);
1707 /* Read extent from the source file */
1709 error
= xfs_bmapi_read(ip
, tirec
.br_startoff
,
1710 tirec
.br_blockcount
, &irec
,
1714 ASSERT(nimaps
== 1);
1715 ASSERT(tirec
.br_startoff
== irec
.br_startoff
);
1716 trace_xfs_swap_extent_rmap_remap_piece(ip
, &irec
);
1718 /* Trim the extent. */
1720 uirec
.br_blockcount
= rlen
= min_t(xfs_filblks_t
,
1721 tirec
.br_blockcount
,
1722 irec
.br_blockcount
);
1723 trace_xfs_swap_extent_rmap_remap_piece(tip
, &uirec
);
1725 /* Remove the mapping from the donor file. */
1726 error
= xfs_bmap_unmap_extent((*tpp
)->t_mountp
, &dfops
,
1731 /* Remove the mapping from the source file. */
1732 error
= xfs_bmap_unmap_extent((*tpp
)->t_mountp
, &dfops
,
1737 /* Map the donor file's blocks into the source file. */
1738 error
= xfs_bmap_map_extent((*tpp
)->t_mountp
, &dfops
,
1743 /* Map the source file's blocks into the donor file. */
1744 error
= xfs_bmap_map_extent((*tpp
)->t_mountp
, &dfops
,
1749 error
= xfs_defer_finish(tpp
, &dfops
, ip
);
1753 tirec
.br_startoff
+= rlen
;
1754 if (tirec
.br_startblock
!= HOLESTARTBLOCK
&&
1755 tirec
.br_startblock
!= DELAYSTARTBLOCK
)
1756 tirec
.br_startblock
+= rlen
;
1757 tirec
.br_blockcount
-= rlen
;
1765 tip
->i_d
.di_flags2
= tip_flags2
;
1769 xfs_defer_cancel(&dfops
);
1771 trace_xfs_swap_extent_rmap_error(ip
, error
, _RET_IP_
);
1772 tip
->i_d
.di_flags2
= tip_flags2
;
1776 /* Swap the extents of two files by swapping data forks. */
1778 xfs_swap_extent_forks(
1779 struct xfs_trans
*tp
,
1780 struct xfs_inode
*ip
,
1781 struct xfs_inode
*tip
,
1783 int *target_log_flags
)
1785 struct xfs_ifork tempifp
, *ifp
, *tifp
;
1788 xfs_extnum_t nextents
;
1793 * Count the number of extended attribute blocks
1795 if ( ((XFS_IFORK_Q(ip
) != 0) && (ip
->i_d
.di_anextents
> 0)) &&
1796 (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
1797 error
= xfs_bmap_count_blocks(tp
, ip
, XFS_ATTR_FORK
,
1802 if ( ((XFS_IFORK_Q(tip
) != 0) && (tip
->i_d
.di_anextents
> 0)) &&
1803 (tip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
1804 error
= xfs_bmap_count_blocks(tp
, tip
, XFS_ATTR_FORK
,
1811 * Before we've swapped the forks, lets set the owners of the forks
1812 * appropriately. We have to do this as we are demand paging the btree
1813 * buffers, and so the validation done on read will expect the owner
1814 * field to be correctly set. Once we change the owners, we can swap the
1817 if (ip
->i_d
.di_version
== 3 &&
1818 ip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1819 (*target_log_flags
) |= XFS_ILOG_DOWNER
;
1820 error
= xfs_bmbt_change_owner(tp
, ip
, XFS_DATA_FORK
,
1826 if (tip
->i_d
.di_version
== 3 &&
1827 tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1828 (*src_log_flags
) |= XFS_ILOG_DOWNER
;
1829 error
= xfs_bmbt_change_owner(tp
, tip
, XFS_DATA_FORK
,
1836 * Swap the data forks of the inodes
1840 tempifp
= *ifp
; /* struct copy */
1841 *ifp
= *tifp
; /* struct copy */
1842 *tifp
= tempifp
; /* struct copy */
1845 * Fix the on-disk inode values
1847 tmp
= (__uint64_t
)ip
->i_d
.di_nblocks
;
1848 ip
->i_d
.di_nblocks
= tip
->i_d
.di_nblocks
- taforkblks
+ aforkblks
;
1849 tip
->i_d
.di_nblocks
= tmp
+ taforkblks
- aforkblks
;
1851 tmp
= (__uint64_t
) ip
->i_d
.di_nextents
;
1852 ip
->i_d
.di_nextents
= tip
->i_d
.di_nextents
;
1853 tip
->i_d
.di_nextents
= tmp
;
1855 tmp
= (__uint64_t
) ip
->i_d
.di_format
;
1856 ip
->i_d
.di_format
= tip
->i_d
.di_format
;
1857 tip
->i_d
.di_format
= tmp
;
1860 * The extents in the source inode could still contain speculative
1861 * preallocation beyond EOF (e.g. the file is open but not modified
1862 * while defrag is in progress). In that case, we need to copy over the
1863 * number of delalloc blocks the data fork in the source inode is
1864 * tracking beyond EOF so that when the fork is truncated away when the
1865 * temporary inode is unlinked we don't underrun the i_delayed_blks
1866 * counter on that inode.
1868 ASSERT(tip
->i_delayed_blks
== 0);
1869 tip
->i_delayed_blks
= ip
->i_delayed_blks
;
1870 ip
->i_delayed_blks
= 0;
1872 switch (ip
->i_d
.di_format
) {
1873 case XFS_DINODE_FMT_EXTENTS
:
1875 * If the extents fit in the inode, fix the pointer. Otherwise
1876 * it's already NULL or pointing to the extent.
1878 nextents
= xfs_iext_count(&ip
->i_df
);
1879 if (nextents
<= XFS_INLINE_EXTS
)
1880 ifp
->if_u1
.if_extents
= ifp
->if_u2
.if_inline_ext
;
1881 (*src_log_flags
) |= XFS_ILOG_DEXT
;
1883 case XFS_DINODE_FMT_BTREE
:
1884 ASSERT(ip
->i_d
.di_version
< 3 ||
1885 (*src_log_flags
& XFS_ILOG_DOWNER
));
1886 (*src_log_flags
) |= XFS_ILOG_DBROOT
;
1890 switch (tip
->i_d
.di_format
) {
1891 case XFS_DINODE_FMT_EXTENTS
:
1893 * If the extents fit in the inode, fix the pointer. Otherwise
1894 * it's already NULL or pointing to the extent.
1896 nextents
= xfs_iext_count(&tip
->i_df
);
1897 if (nextents
<= XFS_INLINE_EXTS
)
1898 tifp
->if_u1
.if_extents
= tifp
->if_u2
.if_inline_ext
;
1899 (*target_log_flags
) |= XFS_ILOG_DEXT
;
1901 case XFS_DINODE_FMT_BTREE
:
1902 (*target_log_flags
) |= XFS_ILOG_DBROOT
;
1903 ASSERT(tip
->i_d
.di_version
< 3 ||
1904 (*target_log_flags
& XFS_ILOG_DOWNER
));
1913 struct xfs_inode
*ip
, /* target inode */
1914 struct xfs_inode
*tip
, /* tmp inode */
1915 struct xfs_swapext
*sxp
)
1917 struct xfs_mount
*mp
= ip
->i_mount
;
1918 struct xfs_trans
*tp
;
1919 struct xfs_bstat
*sbp
= &sxp
->sx_stat
;
1920 int src_log_flags
, target_log_flags
;
1923 struct xfs_ifork
*cowfp
;
1928 * Lock the inodes against other IO, page faults and truncate to
1929 * begin with. Then we can ensure the inodes are flushed and have no
1930 * page cache safely. Once we have done this we can take the ilocks and
1931 * do the rest of the checks.
1933 lock_two_nondirectories(VFS_I(ip
), VFS_I(tip
));
1934 lock_flags
= XFS_MMAPLOCK_EXCL
;
1935 xfs_lock_two_inodes(ip
, tip
, XFS_MMAPLOCK_EXCL
);
1937 /* Verify that both files have the same format */
1938 if ((VFS_I(ip
)->i_mode
& S_IFMT
) != (VFS_I(tip
)->i_mode
& S_IFMT
)) {
1943 /* Verify both files are either real-time or non-realtime */
1944 if (XFS_IS_REALTIME_INODE(ip
) != XFS_IS_REALTIME_INODE(tip
)) {
1949 error
= xfs_swap_extent_flush(ip
);
1952 error
= xfs_swap_extent_flush(tip
);
1957 * Extent "swapping" with rmap requires a permanent reservation and
1958 * a block reservation because it's really just a remap operation
1959 * performed with log redo items!
1961 if (xfs_sb_version_hasrmapbt(&mp
->m_sb
)) {
1963 * Conceptually this shouldn't affect the shape of either
1964 * bmbt, but since we atomically move extents one by one,
1965 * we reserve enough space to rebuild both trees.
1967 resblks
= XFS_SWAP_RMAP_SPACE_RES(mp
,
1968 XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
),
1970 XFS_SWAP_RMAP_SPACE_RES(mp
,
1971 XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
),
1973 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
,
1976 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_ichange
, 0,
1982 * Lock and join the inodes to the tansaction so that transaction commit
1983 * or cancel will unlock the inodes from this point onwards.
1985 xfs_lock_two_inodes(ip
, tip
, XFS_ILOCK_EXCL
);
1986 lock_flags
|= XFS_ILOCK_EXCL
;
1987 xfs_trans_ijoin(tp
, ip
, 0);
1988 xfs_trans_ijoin(tp
, tip
, 0);
1991 /* Verify all data are being swapped */
1992 if (sxp
->sx_offset
!= 0 ||
1993 sxp
->sx_length
!= ip
->i_d
.di_size
||
1994 sxp
->sx_length
!= tip
->i_d
.di_size
) {
1996 goto out_trans_cancel
;
1999 trace_xfs_swap_extent_before(ip
, 0);
2000 trace_xfs_swap_extent_before(tip
, 1);
2002 /* check inode formats now that data is flushed */
2003 error
= xfs_swap_extents_check_format(ip
, tip
);
2006 "%s: inode 0x%llx format is incompatible for exchanging.",
2007 __func__
, ip
->i_ino
);
2008 goto out_trans_cancel
;
2012 * Compare the current change & modify times with that
2013 * passed in. If they differ, we abort this swap.
2014 * This is the mechanism used to ensure the calling
2015 * process that the file was not changed out from
2018 if ((sbp
->bs_ctime
.tv_sec
!= VFS_I(ip
)->i_ctime
.tv_sec
) ||
2019 (sbp
->bs_ctime
.tv_nsec
!= VFS_I(ip
)->i_ctime
.tv_nsec
) ||
2020 (sbp
->bs_mtime
.tv_sec
!= VFS_I(ip
)->i_mtime
.tv_sec
) ||
2021 (sbp
->bs_mtime
.tv_nsec
!= VFS_I(ip
)->i_mtime
.tv_nsec
)) {
2023 goto out_trans_cancel
;
2027 * Note the trickiness in setting the log flags - we set the owner log
2028 * flag on the opposite inode (i.e. the inode we are setting the new
2029 * owner to be) because once we swap the forks and log that, log
2030 * recovery is going to see the fork as owned by the swapped inode,
2031 * not the pre-swapped inodes.
2033 src_log_flags
= XFS_ILOG_CORE
;
2034 target_log_flags
= XFS_ILOG_CORE
;
2036 if (xfs_sb_version_hasrmapbt(&mp
->m_sb
))
2037 error
= xfs_swap_extent_rmap(&tp
, ip
, tip
);
2039 error
= xfs_swap_extent_forks(tp
, ip
, tip
, &src_log_flags
,
2042 goto out_trans_cancel
;
2044 /* Do we have to swap reflink flags? */
2045 if ((ip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
) ^
2046 (tip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
)) {
2047 f
= ip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
;
2048 ip
->i_d
.di_flags2
&= ~XFS_DIFLAG2_REFLINK
;
2049 ip
->i_d
.di_flags2
|= tip
->i_d
.di_flags2
& XFS_DIFLAG2_REFLINK
;
2050 tip
->i_d
.di_flags2
&= ~XFS_DIFLAG2_REFLINK
;
2051 tip
->i_d
.di_flags2
|= f
& XFS_DIFLAG2_REFLINK
;
2052 cowfp
= ip
->i_cowfp
;
2053 ip
->i_cowfp
= tip
->i_cowfp
;
2054 tip
->i_cowfp
= cowfp
;
2055 xfs_inode_set_cowblocks_tag(ip
);
2056 xfs_inode_set_cowblocks_tag(tip
);
2059 xfs_trans_log_inode(tp
, ip
, src_log_flags
);
2060 xfs_trans_log_inode(tp
, tip
, target_log_flags
);
2063 * If this is a synchronous mount, make sure that the
2064 * transaction goes to disk before returning to the user.
2066 if (mp
->m_flags
& XFS_MOUNT_WSYNC
)
2067 xfs_trans_set_sync(tp
);
2069 error
= xfs_trans_commit(tp
);
2071 trace_xfs_swap_extent_after(ip
, 0);
2072 trace_xfs_swap_extent_after(tip
, 1);
2075 xfs_iunlock(ip
, lock_flags
);
2076 xfs_iunlock(tip
, lock_flags
);
2077 unlock_two_nondirectories(VFS_I(ip
), VFS_I(tip
));
2081 xfs_trans_cancel(tp
);