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"
45 /* Kernel only BMAP related definitions and functions */
48 * Convert the given file system block to a disk block. We have to treat it
49 * differently based on whether the file is a real time file or not, because the
53 xfs_fsb_to_db(struct xfs_inode
*ip
, xfs_fsblock_t fsb
)
55 return (XFS_IS_REALTIME_INODE(ip
) ? \
56 (xfs_daddr_t
)XFS_FSB_TO_BB((ip
)->i_mount
, (fsb
)) : \
57 XFS_FSB_TO_DADDR((ip
)->i_mount
, (fsb
)));
61 * Routine to zero an extent on disk allocated to the specific inode.
63 * The VFS functions take a linearised filesystem block offset, so we have to
64 * convert the sparse xfs fsb to the right format first.
65 * VFS types are real funky, too.
70 xfs_fsblock_t start_fsb
,
73 struct xfs_mount
*mp
= ip
->i_mount
;
74 xfs_daddr_t sector
= xfs_fsb_to_db(ip
, start_fsb
);
75 sector_t block
= XFS_BB_TO_FSBT(mp
, sector
);
77 return blkdev_issue_zeroout(xfs_find_bdev_for_inode(VFS_I(ip
)),
78 block
<< (mp
->m_super
->s_blocksize_bits
- 9),
79 count_fsb
<< (mp
->m_super
->s_blocksize_bits
- 9),
85 struct xfs_bmalloca
*ap
) /* bmap alloc argument struct */
87 xfs_alloctype_t atype
= 0; /* type for allocation routines */
88 int error
; /* error return value */
89 xfs_mount_t
*mp
; /* mount point structure */
90 xfs_extlen_t prod
= 0; /* product factor for allocators */
91 xfs_extlen_t ralen
= 0; /* realtime allocation length */
92 xfs_extlen_t align
; /* minimum allocation alignment */
96 align
= xfs_get_extsz_hint(ap
->ip
);
97 prod
= align
/ mp
->m_sb
.sb_rextsize
;
98 error
= xfs_bmap_extsize_align(mp
, &ap
->got
, &ap
->prev
,
100 ap
->conv
, &ap
->offset
, &ap
->length
);
104 ASSERT(ap
->length
% mp
->m_sb
.sb_rextsize
== 0);
107 * If the offset & length are not perfectly aligned
108 * then kill prod, it will just get us in trouble.
110 if (do_mod(ap
->offset
, align
) || ap
->length
% align
)
113 * Set ralen to be the actual requested length in rtextents.
115 ralen
= ap
->length
/ mp
->m_sb
.sb_rextsize
;
117 * If the old value was close enough to MAXEXTLEN that
118 * we rounded up to it, cut it back so it's valid again.
119 * Note that if it's a really large request (bigger than
120 * MAXEXTLEN), we don't hear about that number, and can't
121 * adjust the starting point to match it.
123 if (ralen
* mp
->m_sb
.sb_rextsize
>= MAXEXTLEN
)
124 ralen
= MAXEXTLEN
/ mp
->m_sb
.sb_rextsize
;
127 * Lock out modifications to both the RT bitmap and summary inodes
129 xfs_ilock(mp
->m_rbmip
, XFS_ILOCK_EXCL
|XFS_ILOCK_RTBITMAP
);
130 xfs_trans_ijoin(ap
->tp
, mp
->m_rbmip
, XFS_ILOCK_EXCL
);
131 xfs_ilock(mp
->m_rsumip
, XFS_ILOCK_EXCL
|XFS_ILOCK_RTSUM
);
132 xfs_trans_ijoin(ap
->tp
, mp
->m_rsumip
, XFS_ILOCK_EXCL
);
135 * If it's an allocation to an empty file at offset 0,
136 * pick an extent that will space things out in the rt area.
138 if (ap
->eof
&& ap
->offset
== 0) {
139 xfs_rtblock_t
uninitialized_var(rtx
); /* realtime extent no */
141 error
= xfs_rtpick_extent(mp
, ap
->tp
, ralen
, &rtx
);
144 ap
->blkno
= rtx
* mp
->m_sb
.sb_rextsize
;
149 xfs_bmap_adjacent(ap
);
152 * Realtime allocation, done through xfs_rtallocate_extent.
154 atype
= ap
->blkno
== 0 ? XFS_ALLOCTYPE_ANY_AG
: XFS_ALLOCTYPE_NEAR_BNO
;
155 do_div(ap
->blkno
, mp
->m_sb
.sb_rextsize
);
158 if ((error
= xfs_rtallocate_extent(ap
->tp
, ap
->blkno
, 1, ap
->length
,
159 &ralen
, atype
, ap
->wasdel
, prod
, &rtb
)))
161 if (rtb
== NULLFSBLOCK
&& prod
> 1 &&
162 (error
= xfs_rtallocate_extent(ap
->tp
, ap
->blkno
, 1,
163 ap
->length
, &ralen
, atype
,
164 ap
->wasdel
, 1, &rtb
)))
167 if (ap
->blkno
!= NULLFSBLOCK
) {
168 ap
->blkno
*= mp
->m_sb
.sb_rextsize
;
169 ralen
*= mp
->m_sb
.sb_rextsize
;
171 ap
->ip
->i_d
.di_nblocks
+= ralen
;
172 xfs_trans_log_inode(ap
->tp
, ap
->ip
, XFS_ILOG_CORE
);
174 ap
->ip
->i_delayed_blks
-= ralen
;
176 * Adjust the disk quota also. This was reserved
179 xfs_trans_mod_dquot_byino(ap
->tp
, ap
->ip
,
180 ap
->wasdel
? XFS_TRANS_DQ_DELRTBCOUNT
:
181 XFS_TRANS_DQ_RTBCOUNT
, (long) ralen
);
183 /* Zero the extent if we were asked to do so */
184 if (ap
->userdata
& XFS_ALLOC_USERDATA_ZERO
) {
185 error
= xfs_zero_extent(ap
->ip
, ap
->blkno
, ap
->length
);
196 * Check if the endoff is outside the last extent. If so the caller will grow
197 * the allocation to a stripe unit boundary. All offsets are considered outside
198 * the end of file for an empty fork, so 1 is returned in *eof in that case.
202 struct xfs_inode
*ip
,
203 xfs_fileoff_t endoff
,
207 struct xfs_bmbt_irec rec
;
210 error
= xfs_bmap_last_extent(NULL
, ip
, whichfork
, &rec
, eof
);
214 *eof
= endoff
>= rec
.br_startoff
+ rec
.br_blockcount
;
219 * Extent tree block counting routines.
223 * Count leaf blocks given a range of extent records.
226 xfs_bmap_count_leaves(
234 for (b
= 0; b
< numrecs
; b
++) {
235 xfs_bmbt_rec_host_t
*frp
= xfs_iext_get_ext(ifp
, idx
+ b
);
236 *count
+= xfs_bmbt_get_blockcount(frp
);
241 * Count leaf blocks given a range of extent records originally
245 xfs_bmap_disk_count_leaves(
246 struct xfs_mount
*mp
,
247 struct xfs_btree_block
*block
,
254 for (b
= 1; b
<= numrecs
; b
++) {
255 frp
= XFS_BMBT_REC_ADDR(mp
, block
, b
);
256 *count
+= xfs_bmbt_disk_get_blockcount(frp
);
261 * Recursively walks each level of a btree
262 * to count total fsblocks in use.
264 STATIC
int /* error */
266 xfs_mount_t
*mp
, /* file system mount point */
267 xfs_trans_t
*tp
, /* transaction pointer */
268 xfs_ifork_t
*ifp
, /* inode fork pointer */
269 xfs_fsblock_t blockno
, /* file system block number */
270 int levelin
, /* level in btree */
271 int *count
) /* Count of blocks */
277 xfs_fsblock_t bno
= blockno
;
278 xfs_fsblock_t nextbno
;
279 struct xfs_btree_block
*block
, *nextblock
;
282 error
= xfs_btree_read_bufl(mp
, tp
, bno
, 0, &bp
, XFS_BMAP_BTREE_REF
,
287 block
= XFS_BUF_TO_BLOCK(bp
);
290 /* Not at node above leaves, count this level of nodes */
291 nextbno
= be64_to_cpu(block
->bb_u
.l
.bb_rightsib
);
292 while (nextbno
!= NULLFSBLOCK
) {
293 error
= xfs_btree_read_bufl(mp
, tp
, nextbno
, 0, &nbp
,
299 nextblock
= XFS_BUF_TO_BLOCK(nbp
);
300 nextbno
= be64_to_cpu(nextblock
->bb_u
.l
.bb_rightsib
);
301 xfs_trans_brelse(tp
, nbp
);
304 /* Dive to the next level */
305 pp
= XFS_BMBT_PTR_ADDR(mp
, block
, 1, mp
->m_bmap_dmxr
[1]);
306 bno
= be64_to_cpu(*pp
);
307 if (unlikely((error
=
308 xfs_bmap_count_tree(mp
, tp
, ifp
, bno
, level
, count
)) < 0)) {
309 xfs_trans_brelse(tp
, bp
);
310 XFS_ERROR_REPORT("xfs_bmap_count_tree(1)",
311 XFS_ERRLEVEL_LOW
, mp
);
312 return -EFSCORRUPTED
;
314 xfs_trans_brelse(tp
, bp
);
316 /* count all level 1 nodes and their leaves */
318 nextbno
= be64_to_cpu(block
->bb_u
.l
.bb_rightsib
);
319 numrecs
= be16_to_cpu(block
->bb_numrecs
);
320 xfs_bmap_disk_count_leaves(mp
, block
, numrecs
, count
);
321 xfs_trans_brelse(tp
, bp
);
322 if (nextbno
== NULLFSBLOCK
)
325 error
= xfs_btree_read_bufl(mp
, tp
, bno
, 0, &bp
,
331 block
= XFS_BUF_TO_BLOCK(bp
);
338 * Count fsblocks of the given fork.
340 static int /* error */
341 xfs_bmap_count_blocks(
342 xfs_trans_t
*tp
, /* transaction pointer */
343 xfs_inode_t
*ip
, /* incore inode */
344 int whichfork
, /* data or attr fork */
345 int *count
) /* out: count of blocks */
347 struct xfs_btree_block
*block
; /* current btree block */
348 xfs_fsblock_t bno
; /* block # of "block" */
349 xfs_ifork_t
*ifp
; /* fork structure */
350 int level
; /* btree level, for checking */
351 xfs_mount_t
*mp
; /* file system mount structure */
352 __be64
*pp
; /* pointer to block address */
356 ifp
= XFS_IFORK_PTR(ip
, whichfork
);
357 if ( XFS_IFORK_FORMAT(ip
, whichfork
) == XFS_DINODE_FMT_EXTENTS
) {
358 xfs_bmap_count_leaves(ifp
, 0,
359 ifp
->if_bytes
/ (uint
)sizeof(xfs_bmbt_rec_t
),
365 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
367 block
= ifp
->if_broot
;
368 level
= be16_to_cpu(block
->bb_level
);
370 pp
= XFS_BMAP_BROOT_PTR_ADDR(mp
, block
, 1, ifp
->if_broot_bytes
);
371 bno
= be64_to_cpu(*pp
);
372 ASSERT(bno
!= NULLFSBLOCK
);
373 ASSERT(XFS_FSB_TO_AGNO(mp
, bno
) < mp
->m_sb
.sb_agcount
);
374 ASSERT(XFS_FSB_TO_AGBNO(mp
, bno
) < mp
->m_sb
.sb_agblocks
);
376 if (unlikely(xfs_bmap_count_tree(mp
, tp
, ifp
, bno
, level
, count
) < 0)) {
377 XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)", XFS_ERRLEVEL_LOW
,
379 return -EFSCORRUPTED
;
386 * returns 1 for success, 0 if we failed to map the extent.
389 xfs_getbmapx_fix_eof_hole(
390 xfs_inode_t
*ip
, /* xfs incore inode pointer */
391 struct getbmapx
*out
, /* output structure */
392 int prealloced
, /* this is a file with
393 * preallocated data space */
394 __int64_t end
, /* last block requested */
395 xfs_fsblock_t startblock
)
398 xfs_mount_t
*mp
; /* file system mount point */
399 xfs_ifork_t
*ifp
; /* inode fork pointer */
400 xfs_extnum_t lastx
; /* last extent pointer */
401 xfs_fileoff_t fileblock
;
403 if (startblock
== HOLESTARTBLOCK
) {
406 fixlen
= XFS_FSB_TO_BB(mp
, XFS_B_TO_FSB(mp
, XFS_ISIZE(ip
)));
407 fixlen
-= out
->bmv_offset
;
408 if (prealloced
&& out
->bmv_offset
+ out
->bmv_length
== end
) {
409 /* Came to hole at EOF. Trim it. */
412 out
->bmv_length
= fixlen
;
415 if (startblock
== DELAYSTARTBLOCK
)
418 out
->bmv_block
= xfs_fsb_to_db(ip
, startblock
);
419 fileblock
= XFS_BB_TO_FSB(ip
->i_mount
, out
->bmv_offset
);
420 ifp
= XFS_IFORK_PTR(ip
, XFS_DATA_FORK
);
421 if (xfs_iext_bno_to_ext(ifp
, fileblock
, &lastx
) &&
422 (lastx
== (ifp
->if_bytes
/ (uint
)sizeof(xfs_bmbt_rec_t
))-1))
423 out
->bmv_oflags
|= BMV_OF_LAST
;
430 * Get inode's extents as described in bmv, and format for output.
431 * Calls formatter to fill the user's buffer until all extents
432 * are mapped, until the passed-in bmv->bmv_count slots have
433 * been filled, or until the formatter short-circuits the loop,
434 * if it is tracking filled-in extents on its own.
439 struct getbmapx
*bmv
, /* user bmap structure */
440 xfs_bmap_format_t formatter
, /* format to user */
441 void *arg
) /* formatter arg */
443 __int64_t bmvend
; /* last block requested */
444 int error
= 0; /* return value */
445 __int64_t fixlen
; /* length for -1 case */
446 int i
; /* extent number */
447 int lock
; /* lock state */
448 xfs_bmbt_irec_t
*map
; /* buffer for user's data */
449 xfs_mount_t
*mp
; /* file system mount point */
450 int nex
; /* # of user extents can do */
451 int nexleft
; /* # of user extents left */
452 int subnex
; /* # of bmapi's can do */
453 int nmap
; /* number of map entries */
454 struct getbmapx
*out
; /* output structure */
455 int whichfork
; /* data or attr fork */
456 int prealloced
; /* this is a file with
457 * preallocated data space */
458 int iflags
; /* interface flags */
459 int bmapi_flags
; /* flags for xfs_bmapi */
463 iflags
= bmv
->bmv_iflags
;
464 whichfork
= iflags
& BMV_IF_ATTRFORK
? XFS_ATTR_FORK
: XFS_DATA_FORK
;
466 if (whichfork
== XFS_ATTR_FORK
) {
467 if (XFS_IFORK_Q(ip
)) {
468 if (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_EXTENTS
&&
469 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_BTREE
&&
470 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)
473 ip
->i_d
.di_aformat
!= 0 &&
474 ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_EXTENTS
)) {
475 XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW
,
477 return -EFSCORRUPTED
;
483 if (ip
->i_d
.di_format
!= XFS_DINODE_FMT_EXTENTS
&&
484 ip
->i_d
.di_format
!= XFS_DINODE_FMT_BTREE
&&
485 ip
->i_d
.di_format
!= XFS_DINODE_FMT_LOCAL
)
488 if (xfs_get_extsz_hint(ip
) ||
489 ip
->i_d
.di_flags
& (XFS_DIFLAG_PREALLOC
|XFS_DIFLAG_APPEND
)){
491 fixlen
= mp
->m_super
->s_maxbytes
;
494 fixlen
= XFS_ISIZE(ip
);
498 if (bmv
->bmv_length
== -1) {
499 fixlen
= XFS_FSB_TO_BB(mp
, XFS_B_TO_FSB(mp
, fixlen
));
501 max_t(__int64_t
, fixlen
- bmv
->bmv_offset
, 0);
502 } else if (bmv
->bmv_length
== 0) {
503 bmv
->bmv_entries
= 0;
505 } else if (bmv
->bmv_length
< 0) {
509 nex
= bmv
->bmv_count
- 1;
512 bmvend
= bmv
->bmv_offset
+ bmv
->bmv_length
;
515 if (bmv
->bmv_count
> ULONG_MAX
/ sizeof(struct getbmapx
))
517 out
= kmem_zalloc_large(bmv
->bmv_count
* sizeof(struct getbmapx
), 0);
521 xfs_ilock(ip
, XFS_IOLOCK_SHARED
);
522 if (whichfork
== XFS_DATA_FORK
) {
523 if (!(iflags
& BMV_IF_DELALLOC
) &&
524 (ip
->i_delayed_blks
|| XFS_ISIZE(ip
) > ip
->i_d
.di_size
)) {
525 error
= filemap_write_and_wait(VFS_I(ip
)->i_mapping
);
527 goto out_unlock_iolock
;
530 * Even after flushing the inode, there can still be
531 * delalloc blocks on the inode beyond EOF due to
532 * speculative preallocation. These are not removed
533 * until the release function is called or the inode
534 * is inactivated. Hence we cannot assert here that
535 * ip->i_delayed_blks == 0.
539 lock
= xfs_ilock_data_map_shared(ip
);
541 lock
= xfs_ilock_attr_map_shared(ip
);
545 * Don't let nex be bigger than the number of extents
546 * we can have assuming alternating holes and real extents.
548 if (nex
> XFS_IFORK_NEXTENTS(ip
, whichfork
) * 2 + 1)
549 nex
= XFS_IFORK_NEXTENTS(ip
, whichfork
) * 2 + 1;
551 bmapi_flags
= xfs_bmapi_aflag(whichfork
);
552 if (!(iflags
& BMV_IF_PREALLOC
))
553 bmapi_flags
|= XFS_BMAPI_IGSTATE
;
556 * Allocate enough space to handle "subnex" maps at a time.
560 map
= kmem_alloc(subnex
* sizeof(*map
), KM_MAYFAIL
| KM_NOFS
);
562 goto out_unlock_ilock
;
564 bmv
->bmv_entries
= 0;
566 if (XFS_IFORK_NEXTENTS(ip
, whichfork
) == 0 &&
567 (whichfork
== XFS_ATTR_FORK
|| !(iflags
& BMV_IF_DELALLOC
))) {
575 nmap
= (nexleft
> subnex
) ? subnex
: nexleft
;
576 error
= xfs_bmapi_read(ip
, XFS_BB_TO_FSBT(mp
, bmv
->bmv_offset
),
577 XFS_BB_TO_FSB(mp
, bmv
->bmv_length
),
578 map
, &nmap
, bmapi_flags
);
581 ASSERT(nmap
<= subnex
);
583 for (i
= 0; i
< nmap
&& nexleft
&& bmv
->bmv_length
; i
++) {
584 out
[cur_ext
].bmv_oflags
= 0;
585 if (map
[i
].br_state
== XFS_EXT_UNWRITTEN
)
586 out
[cur_ext
].bmv_oflags
|= BMV_OF_PREALLOC
;
587 else if (map
[i
].br_startblock
== DELAYSTARTBLOCK
)
588 out
[cur_ext
].bmv_oflags
|= BMV_OF_DELALLOC
;
589 out
[cur_ext
].bmv_offset
=
590 XFS_FSB_TO_BB(mp
, map
[i
].br_startoff
);
591 out
[cur_ext
].bmv_length
=
592 XFS_FSB_TO_BB(mp
, map
[i
].br_blockcount
);
593 out
[cur_ext
].bmv_unused1
= 0;
594 out
[cur_ext
].bmv_unused2
= 0;
597 * delayed allocation extents that start beyond EOF can
598 * occur due to speculative EOF allocation when the
599 * delalloc extent is larger than the largest freespace
600 * extent at conversion time. These extents cannot be
601 * converted by data writeback, so can exist here even
602 * if we are not supposed to be finding delalloc
605 if (map
[i
].br_startblock
== DELAYSTARTBLOCK
&&
606 map
[i
].br_startoff
<= XFS_B_TO_FSB(mp
, XFS_ISIZE(ip
)))
607 ASSERT((iflags
& BMV_IF_DELALLOC
) != 0);
609 if (map
[i
].br_startblock
== HOLESTARTBLOCK
&&
610 whichfork
== XFS_ATTR_FORK
) {
611 /* came to the end of attribute fork */
612 out
[cur_ext
].bmv_oflags
|= BMV_OF_LAST
;
616 if (!xfs_getbmapx_fix_eof_hole(ip
, &out
[cur_ext
],
618 map
[i
].br_startblock
))
622 out
[cur_ext
].bmv_offset
+
623 out
[cur_ext
].bmv_length
;
625 max_t(__int64_t
, 0, bmvend
- bmv
->bmv_offset
);
628 * In case we don't want to return the hole,
629 * don't increase cur_ext so that we can reuse
630 * it in the next loop.
632 if ((iflags
& BMV_IF_NO_HOLES
) &&
633 map
[i
].br_startblock
== HOLESTARTBLOCK
) {
634 memset(&out
[cur_ext
], 0, sizeof(out
[cur_ext
]));
642 } while (nmap
&& nexleft
&& bmv
->bmv_length
);
647 xfs_iunlock(ip
, lock
);
649 xfs_iunlock(ip
, XFS_IOLOCK_SHARED
);
651 for (i
= 0; i
< cur_ext
; i
++) {
652 int full
= 0; /* user array is full */
654 /* format results & advance arg */
655 error
= formatter(&arg
, &out
[i
], &full
);
665 * dead simple method of punching delalyed allocation blocks from a range in
666 * the inode. Walks a block at a time so will be slow, but is only executed in
667 * rare error cases so the overhead is not critical. This will always punch out
668 * both the start and end blocks, even if the ranges only partially overlap
669 * them, so it is up to the caller to ensure that partial blocks are not
673 xfs_bmap_punch_delalloc_range(
674 struct xfs_inode
*ip
,
675 xfs_fileoff_t start_fsb
,
676 xfs_fileoff_t length
)
678 xfs_fileoff_t remaining
= length
;
681 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
685 xfs_bmbt_irec_t imap
;
687 xfs_fsblock_t firstblock
;
688 struct xfs_defer_ops dfops
;
691 * Map the range first and check that it is a delalloc extent
692 * before trying to unmap the range. Otherwise we will be
693 * trying to remove a real extent (which requires a
694 * transaction) or a hole, which is probably a bad idea...
696 error
= xfs_bmapi_read(ip
, start_fsb
, 1, &imap
, &nimaps
,
700 /* something screwed, just bail */
701 if (!XFS_FORCED_SHUTDOWN(ip
->i_mount
)) {
702 xfs_alert(ip
->i_mount
,
703 "Failed delalloc mapping lookup ino %lld fsb %lld.",
704 ip
->i_ino
, start_fsb
);
712 if (imap
.br_startblock
!= DELAYSTARTBLOCK
) {
713 /* been converted, ignore */
716 WARN_ON(imap
.br_blockcount
== 0);
719 * Note: while we initialise the firstblock/dfops pair, they
720 * should never be used because blocks should never be
721 * allocated or freed for a delalloc extent and hence we need
722 * don't cancel or finish them after the xfs_bunmapi() call.
724 xfs_defer_init(&dfops
, &firstblock
);
725 error
= xfs_bunmapi(NULL
, ip
, start_fsb
, 1, 0, 1, &firstblock
,
730 ASSERT(!xfs_defer_has_unfinished_work(&dfops
));
734 } while(remaining
> 0);
740 * Test whether it is appropriate to check an inode for and free post EOF
741 * blocks. The 'force' parameter determines whether we should also consider
742 * regular files that are marked preallocated or append-only.
745 xfs_can_free_eofblocks(struct xfs_inode
*ip
, bool force
)
747 /* prealloc/delalloc exists only on regular files */
748 if (!S_ISREG(VFS_I(ip
)->i_mode
))
752 * Zero sized files with no cached pages and delalloc blocks will not
753 * have speculative prealloc/delalloc blocks to remove.
755 if (VFS_I(ip
)->i_size
== 0 &&
756 VFS_I(ip
)->i_mapping
->nrpages
== 0 &&
757 ip
->i_delayed_blks
== 0)
760 /* If we haven't read in the extent list, then don't do it now. */
761 if (!(ip
->i_df
.if_flags
& XFS_IFEXTENTS
))
765 * Do not free real preallocated or append-only files unless the file
766 * has delalloc blocks and we are forced to remove them.
768 if (ip
->i_d
.di_flags
& (XFS_DIFLAG_PREALLOC
| XFS_DIFLAG_APPEND
))
769 if (!force
|| ip
->i_delayed_blks
== 0)
776 * This is called by xfs_inactive to free any blocks beyond eof
777 * when the link count isn't zero and by xfs_dm_punch_hole() when
778 * punching a hole to EOF.
788 xfs_fileoff_t end_fsb
;
789 xfs_fileoff_t last_fsb
;
790 xfs_filblks_t map_len
;
792 xfs_bmbt_irec_t imap
;
795 * Figure out if there are any blocks beyond the end
796 * of the file. If not, then there is nothing to do.
798 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)XFS_ISIZE(ip
));
799 last_fsb
= XFS_B_TO_FSB(mp
, mp
->m_super
->s_maxbytes
);
800 if (last_fsb
<= end_fsb
)
802 map_len
= last_fsb
- end_fsb
;
805 xfs_ilock(ip
, XFS_ILOCK_SHARED
);
806 error
= xfs_bmapi_read(ip
, end_fsb
, map_len
, &imap
, &nimaps
, 0);
807 xfs_iunlock(ip
, XFS_ILOCK_SHARED
);
809 if (!error
&& (nimaps
!= 0) &&
810 (imap
.br_startblock
!= HOLESTARTBLOCK
||
811 ip
->i_delayed_blks
)) {
813 * Attach the dquots to the inode up front.
815 error
= xfs_qm_dqattach(ip
, 0);
820 * There are blocks after the end of file.
821 * Free them up now by truncating the file to
825 if (!xfs_ilock_nowait(ip
, XFS_IOLOCK_EXCL
))
829 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_itruncate
, 0, 0, 0,
832 ASSERT(XFS_FORCED_SHUTDOWN(mp
));
834 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
838 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
839 xfs_trans_ijoin(tp
, ip
, 0);
842 * Do not update the on-disk file size. If we update the
843 * on-disk file size and then the system crashes before the
844 * contents of the file are flushed to disk then the files
845 * may be full of holes (ie NULL files bug).
847 error
= xfs_itruncate_extents(&tp
, ip
, XFS_DATA_FORK
,
851 * If we get an error at this point we simply don't
852 * bother truncating the file.
854 xfs_trans_cancel(tp
);
856 error
= xfs_trans_commit(tp
);
858 xfs_inode_clear_eofblocks_tag(ip
);
861 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
863 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
869 xfs_alloc_file_space(
870 struct xfs_inode
*ip
,
875 xfs_mount_t
*mp
= ip
->i_mount
;
877 xfs_filblks_t allocated_fsb
;
878 xfs_filblks_t allocatesize_fsb
;
879 xfs_extlen_t extsz
, temp
;
880 xfs_fileoff_t startoffset_fsb
;
881 xfs_fsblock_t firstfsb
;
886 xfs_bmbt_irec_t imaps
[1], *imapp
;
887 struct xfs_defer_ops dfops
;
888 uint qblocks
, resblks
, resrtextents
;
891 trace_xfs_alloc_file_space(ip
);
893 if (XFS_FORCED_SHUTDOWN(mp
))
896 error
= xfs_qm_dqattach(ip
, 0);
903 rt
= XFS_IS_REALTIME_INODE(ip
);
904 extsz
= xfs_get_extsz_hint(ip
);
909 startoffset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
910 allocatesize_fsb
= XFS_B_TO_FSB(mp
, count
);
913 * Allocate file space until done or until there is an error
915 while (allocatesize_fsb
&& !error
) {
919 * Determine space reservations for data/realtime.
921 if (unlikely(extsz
)) {
925 e
= startoffset_fsb
+ allocatesize_fsb
;
926 if ((temp
= do_mod(startoffset_fsb
, extsz
)))
928 if ((temp
= do_mod(e
, extsz
)))
932 e
= allocatesize_fsb
;
936 * The transaction reservation is limited to a 32-bit block
937 * count, hence we need to limit the number of blocks we are
938 * trying to reserve to avoid an overflow. We can't allocate
939 * more than @nimaps extents, and an extent is limited on disk
940 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
942 resblks
= min_t(xfs_fileoff_t
, (e
- s
), (MAXEXTLEN
* nimaps
));
944 resrtextents
= qblocks
= resblks
;
945 resrtextents
/= mp
->m_sb
.sb_rextsize
;
946 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
947 quota_flag
= XFS_QMOPT_RES_RTBLKS
;
950 resblks
= qblocks
= XFS_DIOSTRAT_SPACE_RES(mp
, resblks
);
951 quota_flag
= XFS_QMOPT_RES_REGBLKS
;
955 * Allocate and setup the transaction.
957 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
,
958 resrtextents
, 0, &tp
);
961 * Check for running out of space
965 * Free the transaction structure.
967 ASSERT(error
== -ENOSPC
|| XFS_FORCED_SHUTDOWN(mp
));
970 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
971 error
= xfs_trans_reserve_quota_nblks(tp
, ip
, qblocks
,
976 xfs_trans_ijoin(tp
, ip
, 0);
978 xfs_defer_init(&dfops
, &firstfsb
);
979 error
= xfs_bmapi_write(tp
, ip
, startoffset_fsb
,
980 allocatesize_fsb
, alloc_type
, &firstfsb
,
981 resblks
, imapp
, &nimaps
, &dfops
);
986 * Complete the transaction
988 error
= xfs_defer_finish(&tp
, &dfops
, NULL
);
992 error
= xfs_trans_commit(tp
);
993 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
997 allocated_fsb
= imapp
->br_blockcount
;
1004 startoffset_fsb
+= allocated_fsb
;
1005 allocatesize_fsb
-= allocated_fsb
;
1010 error0
: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
1011 xfs_defer_cancel(&dfops
);
1012 xfs_trans_unreserve_quota_nblks(tp
, ip
, (long)qblocks
, 0, quota_flag
);
1014 error1
: /* Just cancel transaction */
1015 xfs_trans_cancel(tp
);
1016 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1022 struct xfs_inode
*ip
,
1023 xfs_fileoff_t startoffset_fsb
,
1024 xfs_filblks_t len_fsb
,
1027 struct xfs_mount
*mp
= ip
->i_mount
;
1028 struct xfs_trans
*tp
;
1029 struct xfs_defer_ops dfops
;
1030 xfs_fsblock_t firstfsb
;
1031 uint resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
1034 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, 0, 0, &tp
);
1036 ASSERT(error
== -ENOSPC
|| XFS_FORCED_SHUTDOWN(mp
));
1040 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1041 error
= xfs_trans_reserve_quota(tp
, mp
, ip
->i_udquot
, ip
->i_gdquot
,
1042 ip
->i_pdquot
, resblks
, 0, XFS_QMOPT_RES_REGBLKS
);
1044 goto out_trans_cancel
;
1046 xfs_trans_ijoin(tp
, ip
, 0);
1048 xfs_defer_init(&dfops
, &firstfsb
);
1049 error
= xfs_bunmapi(tp
, ip
, startoffset_fsb
, len_fsb
, 0, 2, &firstfsb
,
1052 goto out_bmap_cancel
;
1054 error
= xfs_defer_finish(&tp
, &dfops
, ip
);
1056 goto out_bmap_cancel
;
1058 error
= xfs_trans_commit(tp
);
1060 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
1064 xfs_defer_cancel(&dfops
);
1066 xfs_trans_cancel(tp
);
1071 xfs_adjust_extent_unmap_boundaries(
1072 struct xfs_inode
*ip
,
1073 xfs_fileoff_t
*startoffset_fsb
,
1074 xfs_fileoff_t
*endoffset_fsb
)
1076 struct xfs_mount
*mp
= ip
->i_mount
;
1077 struct xfs_bmbt_irec imap
;
1079 xfs_extlen_t mod
= 0;
1082 error
= xfs_bmapi_read(ip
, *startoffset_fsb
, 1, &imap
, &nimap
, 0);
1086 if (nimap
&& imap
.br_startblock
!= HOLESTARTBLOCK
) {
1089 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
1090 block
= imap
.br_startblock
;
1091 mod
= do_div(block
, mp
->m_sb
.sb_rextsize
);
1093 *startoffset_fsb
+= mp
->m_sb
.sb_rextsize
- mod
;
1097 error
= xfs_bmapi_read(ip
, *endoffset_fsb
- 1, 1, &imap
, &nimap
, 0);
1101 if (nimap
&& imap
.br_startblock
!= HOLESTARTBLOCK
) {
1102 ASSERT(imap
.br_startblock
!= DELAYSTARTBLOCK
);
1104 if (mod
&& mod
!= mp
->m_sb
.sb_rextsize
)
1105 *endoffset_fsb
-= mod
;
1112 xfs_flush_unmap_range(
1113 struct xfs_inode
*ip
,
1117 struct xfs_mount
*mp
= ip
->i_mount
;
1118 struct inode
*inode
= VFS_I(ip
);
1119 xfs_off_t rounding
, start
, end
;
1122 /* wait for the completion of any pending DIOs */
1123 inode_dio_wait(inode
);
1125 rounding
= max_t(xfs_off_t
, 1 << mp
->m_sb
.sb_blocklog
, PAGE_SIZE
);
1126 start
= round_down(offset
, rounding
);
1127 end
= round_up(offset
+ len
, rounding
) - 1;
1129 error
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
1132 truncate_pagecache_range(inode
, start
, end
);
1137 xfs_free_file_space(
1138 struct xfs_inode
*ip
,
1142 struct xfs_mount
*mp
= ip
->i_mount
;
1143 xfs_fileoff_t startoffset_fsb
;
1144 xfs_fileoff_t endoffset_fsb
;
1145 int done
= 0, error
;
1147 trace_xfs_free_file_space(ip
);
1149 error
= xfs_qm_dqattach(ip
, 0);
1153 if (len
<= 0) /* if nothing being freed */
1156 error
= xfs_flush_unmap_range(ip
, offset
, len
);
1160 startoffset_fsb
= XFS_B_TO_FSB(mp
, offset
);
1161 endoffset_fsb
= XFS_B_TO_FSBT(mp
, offset
+ len
);
1164 * Need to zero the stuff we're not freeing, on disk. If it's a RT file
1165 * and we can't use unwritten extents then we actually need to ensure
1166 * to zero the whole extent, otherwise we just need to take of block
1167 * boundaries, and xfs_bunmapi will handle the rest.
1169 if (XFS_IS_REALTIME_INODE(ip
) &&
1170 !xfs_sb_version_hasextflgbit(&mp
->m_sb
)) {
1171 error
= xfs_adjust_extent_unmap_boundaries(ip
, &startoffset_fsb
,
1177 if (endoffset_fsb
> startoffset_fsb
) {
1179 error
= xfs_unmap_extent(ip
, startoffset_fsb
,
1180 endoffset_fsb
- startoffset_fsb
, &done
);
1187 * Now that we've unmap all full blocks we'll have to zero out any
1188 * partial block at the beginning and/or end. xfs_zero_range is
1189 * smart enough to skip any holes, including those we just created.
1191 return xfs_zero_range(ip
, offset
, len
, NULL
);
1195 * Preallocate and zero a range of a file. This mechanism has the allocation
1196 * semantics of fallocate and in addition converts data in the range to zeroes.
1199 xfs_zero_file_space(
1200 struct xfs_inode
*ip
,
1204 struct xfs_mount
*mp
= ip
->i_mount
;
1208 trace_xfs_zero_file_space(ip
);
1210 blksize
= 1 << mp
->m_sb
.sb_blocklog
;
1213 * Punch a hole and prealloc the range. We use hole punch rather than
1214 * unwritten extent conversion for two reasons:
1216 * 1.) Hole punch handles partial block zeroing for us.
1218 * 2.) If prealloc returns ENOSPC, the file range is still zero-valued
1219 * by virtue of the hole punch.
1221 error
= xfs_free_file_space(ip
, offset
, len
);
1225 error
= xfs_alloc_file_space(ip
, round_down(offset
, blksize
),
1226 round_up(offset
+ len
, blksize
) -
1227 round_down(offset
, blksize
),
1228 XFS_BMAPI_PREALLOC
);
1235 * @next_fsb will keep track of the extent currently undergoing shift.
1236 * @stop_fsb will keep track of the extent at which we have to stop.
1237 * If we are shifting left, we will start with block (offset + len) and
1238 * shift each extent till last extent.
1239 * If we are shifting right, we will start with last extent inside file space
1240 * and continue until we reach the block corresponding to offset.
1243 xfs_shift_file_space(
1244 struct xfs_inode
*ip
,
1247 enum shift_direction direction
)
1250 struct xfs_mount
*mp
= ip
->i_mount
;
1251 struct xfs_trans
*tp
;
1253 struct xfs_defer_ops dfops
;
1254 xfs_fsblock_t first_block
;
1255 xfs_fileoff_t stop_fsb
;
1256 xfs_fileoff_t next_fsb
;
1257 xfs_fileoff_t shift_fsb
;
1259 ASSERT(direction
== SHIFT_LEFT
|| direction
== SHIFT_RIGHT
);
1261 if (direction
== SHIFT_LEFT
) {
1262 next_fsb
= XFS_B_TO_FSB(mp
, offset
+ len
);
1263 stop_fsb
= XFS_B_TO_FSB(mp
, VFS_I(ip
)->i_size
);
1266 * If right shift, delegate the work of initialization of
1267 * next_fsb to xfs_bmap_shift_extent as it has ilock held.
1269 next_fsb
= NULLFSBLOCK
;
1270 stop_fsb
= XFS_B_TO_FSB(mp
, offset
);
1273 shift_fsb
= XFS_B_TO_FSB(mp
, len
);
1276 * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1277 * into the accessible region of the file.
1279 if (xfs_can_free_eofblocks(ip
, true)) {
1280 error
= xfs_free_eofblocks(mp
, ip
, false);
1286 * Writeback and invalidate cache for the remainder of the file as we're
1287 * about to shift down every extent from offset to EOF.
1289 error
= filemap_write_and_wait_range(VFS_I(ip
)->i_mapping
,
1293 error
= invalidate_inode_pages2_range(VFS_I(ip
)->i_mapping
,
1294 offset
>> PAGE_SHIFT
, -1);
1299 * The extent shiting code works on extent granularity. So, if
1300 * stop_fsb is not the starting block of extent, we need to split
1301 * the extent at stop_fsb.
1303 if (direction
== SHIFT_RIGHT
) {
1304 error
= xfs_bmap_split_extent(ip
, stop_fsb
);
1309 while (!error
&& !done
) {
1311 * We would need to reserve permanent block for transaction.
1312 * This will come into picture when after shifting extent into
1313 * hole we found that adjacent extents can be merged which
1314 * may lead to freeing of a block during record update.
1316 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
,
1317 XFS_DIOSTRAT_SPACE_RES(mp
, 0), 0, 0, &tp
);
1321 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
1322 error
= xfs_trans_reserve_quota(tp
, mp
, ip
->i_udquot
,
1323 ip
->i_gdquot
, ip
->i_pdquot
,
1324 XFS_DIOSTRAT_SPACE_RES(mp
, 0), 0,
1325 XFS_QMOPT_RES_REGBLKS
);
1327 goto out_trans_cancel
;
1329 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
1331 xfs_defer_init(&dfops
, &first_block
);
1334 * We are using the write transaction in which max 2 bmbt
1335 * updates are allowed
1337 error
= xfs_bmap_shift_extents(tp
, ip
, &next_fsb
, shift_fsb
,
1338 &done
, stop_fsb
, &first_block
, &dfops
,
1339 direction
, XFS_BMAP_MAX_SHIFT_EXTENTS
);
1341 goto out_bmap_cancel
;
1343 error
= xfs_defer_finish(&tp
, &dfops
, NULL
);
1345 goto out_bmap_cancel
;
1347 error
= xfs_trans_commit(tp
);
1353 xfs_defer_cancel(&dfops
);
1355 xfs_trans_cancel(tp
);
1360 * xfs_collapse_file_space()
1361 * This routine frees disk space and shift extent for the given file.
1362 * The first thing we do is to free data blocks in the specified range
1363 * by calling xfs_free_file_space(). It would also sync dirty data
1364 * and invalidate page cache over the region on which collapse range
1365 * is working. And Shift extent records to the left to cover a hole.
1372 xfs_collapse_file_space(
1373 struct xfs_inode
*ip
,
1379 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_EXCL
));
1380 trace_xfs_collapse_file_space(ip
);
1382 error
= xfs_free_file_space(ip
, offset
, len
);
1386 return xfs_shift_file_space(ip
, offset
, len
, SHIFT_LEFT
);
1390 * xfs_insert_file_space()
1391 * This routine create hole space by shifting extents for the given file.
1392 * The first thing we do is to sync dirty data and invalidate page cache
1393 * over the region on which insert range is working. And split an extent
1394 * to two extents at given offset by calling xfs_bmap_split_extent.
1395 * And shift all extent records which are laying between [offset,
1396 * last allocated extent] to the right to reserve hole range.
1402 xfs_insert_file_space(
1403 struct xfs_inode
*ip
,
1407 ASSERT(xfs_isilocked(ip
, XFS_IOLOCK_EXCL
));
1408 trace_xfs_insert_file_space(ip
);
1410 return xfs_shift_file_space(ip
, offset
, len
, SHIFT_RIGHT
);
1414 * We need to check that the format of the data fork in the temporary inode is
1415 * valid for the target inode before doing the swap. This is not a problem with
1416 * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
1417 * data fork depending on the space the attribute fork is taking so we can get
1418 * invalid formats on the target inode.
1420 * E.g. target has space for 7 extents in extent format, temp inode only has
1421 * space for 6. If we defragment down to 7 extents, then the tmp format is a
1422 * btree, but when swapped it needs to be in extent format. Hence we can't just
1423 * blindly swap data forks on attr2 filesystems.
1425 * Note that we check the swap in both directions so that we don't end up with
1426 * a corrupt temporary inode, either.
1428 * Note that fixing the way xfs_fsr sets up the attribute fork in the source
1429 * inode will prevent this situation from occurring, so all we do here is
1430 * reject and log the attempt. basically we are putting the responsibility on
1431 * userspace to get this right.
1434 xfs_swap_extents_check_format(
1435 xfs_inode_t
*ip
, /* target inode */
1436 xfs_inode_t
*tip
) /* tmp inode */
1439 /* Should never get a local format */
1440 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
||
1441 tip
->i_d
.di_format
== XFS_DINODE_FMT_LOCAL
)
1445 * if the target inode has less extents that then temporary inode then
1446 * why did userspace call us?
1448 if (ip
->i_d
.di_nextents
< tip
->i_d
.di_nextents
)
1452 * if the target inode is in extent form and the temp inode is in btree
1453 * form then we will end up with the target inode in the wrong format
1454 * as we already know there are less extents in the temp inode.
1456 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1457 tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
)
1460 /* Check temp in extent form to max in target */
1461 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1462 XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) >
1463 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
1466 /* Check target in extent form to max in temp */
1467 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_EXTENTS
&&
1468 XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) >
1469 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
1473 * If we are in a btree format, check that the temp root block will fit
1474 * in the target and that it has enough extents to be in btree format
1477 * Note that we have to be careful to allow btree->extent conversions
1478 * (a common defrag case) which will occur when the temp inode is in
1481 if (tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1482 if (XFS_IFORK_BOFF(ip
) &&
1483 XFS_BMAP_BMDR_SPACE(tip
->i_df
.if_broot
) > XFS_IFORK_BOFF(ip
))
1485 if (XFS_IFORK_NEXTENTS(tip
, XFS_DATA_FORK
) <=
1486 XFS_IFORK_MAXEXT(ip
, XFS_DATA_FORK
))
1490 /* Reciprocal target->temp btree format checks */
1491 if (ip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1492 if (XFS_IFORK_BOFF(tip
) &&
1493 XFS_BMAP_BMDR_SPACE(ip
->i_df
.if_broot
) > XFS_IFORK_BOFF(tip
))
1495 if (XFS_IFORK_NEXTENTS(ip
, XFS_DATA_FORK
) <=
1496 XFS_IFORK_MAXEXT(tip
, XFS_DATA_FORK
))
1504 xfs_swap_extent_flush(
1505 struct xfs_inode
*ip
)
1509 error
= filemap_write_and_wait(VFS_I(ip
)->i_mapping
);
1512 truncate_pagecache_range(VFS_I(ip
), 0, -1);
1514 /* Verify O_DIRECT for ftmp */
1515 if (VFS_I(ip
)->i_mapping
->nrpages
)
1522 xfs_inode_t
*ip
, /* target inode */
1523 xfs_inode_t
*tip
, /* tmp inode */
1526 xfs_mount_t
*mp
= ip
->i_mount
;
1528 xfs_bstat_t
*sbp
= &sxp
->sx_stat
;
1529 xfs_ifork_t
*tempifp
, *ifp
, *tifp
;
1530 int src_log_flags
, target_log_flags
;
1537 tempifp
= kmem_alloc(sizeof(xfs_ifork_t
), KM_MAYFAIL
);
1544 * Lock the inodes against other IO, page faults and truncate to
1545 * begin with. Then we can ensure the inodes are flushed and have no
1546 * page cache safely. Once we have done this we can take the ilocks and
1547 * do the rest of the checks.
1549 lock_flags
= XFS_IOLOCK_EXCL
| XFS_MMAPLOCK_EXCL
;
1550 xfs_lock_two_inodes(ip
, tip
, XFS_IOLOCK_EXCL
);
1551 xfs_lock_two_inodes(ip
, tip
, XFS_MMAPLOCK_EXCL
);
1553 /* Verify that both files have the same format */
1554 if ((VFS_I(ip
)->i_mode
& S_IFMT
) != (VFS_I(tip
)->i_mode
& S_IFMT
)) {
1559 /* Verify both files are either real-time or non-realtime */
1560 if (XFS_IS_REALTIME_INODE(ip
) != XFS_IS_REALTIME_INODE(tip
)) {
1565 error
= xfs_swap_extent_flush(ip
);
1568 error
= xfs_swap_extent_flush(tip
);
1572 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_ichange
, 0, 0, 0, &tp
);
1577 * Lock and join the inodes to the tansaction so that transaction commit
1578 * or cancel will unlock the inodes from this point onwards.
1580 xfs_lock_two_inodes(ip
, tip
, XFS_ILOCK_EXCL
);
1581 lock_flags
|= XFS_ILOCK_EXCL
;
1582 xfs_trans_ijoin(tp
, ip
, lock_flags
);
1583 xfs_trans_ijoin(tp
, tip
, lock_flags
);
1586 /* Verify all data are being swapped */
1587 if (sxp
->sx_offset
!= 0 ||
1588 sxp
->sx_length
!= ip
->i_d
.di_size
||
1589 sxp
->sx_length
!= tip
->i_d
.di_size
) {
1591 goto out_trans_cancel
;
1594 trace_xfs_swap_extent_before(ip
, 0);
1595 trace_xfs_swap_extent_before(tip
, 1);
1597 /* check inode formats now that data is flushed */
1598 error
= xfs_swap_extents_check_format(ip
, tip
);
1601 "%s: inode 0x%llx format is incompatible for exchanging.",
1602 __func__
, ip
->i_ino
);
1603 goto out_trans_cancel
;
1607 * Compare the current change & modify times with that
1608 * passed in. If they differ, we abort this swap.
1609 * This is the mechanism used to ensure the calling
1610 * process that the file was not changed out from
1613 if ((sbp
->bs_ctime
.tv_sec
!= VFS_I(ip
)->i_ctime
.tv_sec
) ||
1614 (sbp
->bs_ctime
.tv_nsec
!= VFS_I(ip
)->i_ctime
.tv_nsec
) ||
1615 (sbp
->bs_mtime
.tv_sec
!= VFS_I(ip
)->i_mtime
.tv_sec
) ||
1616 (sbp
->bs_mtime
.tv_nsec
!= VFS_I(ip
)->i_mtime
.tv_nsec
)) {
1618 goto out_trans_cancel
;
1621 * Count the number of extended attribute blocks
1623 if ( ((XFS_IFORK_Q(ip
) != 0) && (ip
->i_d
.di_anextents
> 0)) &&
1624 (ip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
1625 error
= xfs_bmap_count_blocks(tp
, ip
, XFS_ATTR_FORK
, &aforkblks
);
1627 goto out_trans_cancel
;
1629 if ( ((XFS_IFORK_Q(tip
) != 0) && (tip
->i_d
.di_anextents
> 0)) &&
1630 (tip
->i_d
.di_aformat
!= XFS_DINODE_FMT_LOCAL
)) {
1631 error
= xfs_bmap_count_blocks(tp
, tip
, XFS_ATTR_FORK
,
1634 goto out_trans_cancel
;
1638 * Before we've swapped the forks, lets set the owners of the forks
1639 * appropriately. We have to do this as we are demand paging the btree
1640 * buffers, and so the validation done on read will expect the owner
1641 * field to be correctly set. Once we change the owners, we can swap the
1644 * Note the trickiness in setting the log flags - we set the owner log
1645 * flag on the opposite inode (i.e. the inode we are setting the new
1646 * owner to be) because once we swap the forks and log that, log
1647 * recovery is going to see the fork as owned by the swapped inode,
1648 * not the pre-swapped inodes.
1650 src_log_flags
= XFS_ILOG_CORE
;
1651 target_log_flags
= XFS_ILOG_CORE
;
1652 if (ip
->i_d
.di_version
== 3 &&
1653 ip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1654 target_log_flags
|= XFS_ILOG_DOWNER
;
1655 error
= xfs_bmbt_change_owner(tp
, ip
, XFS_DATA_FORK
,
1658 goto out_trans_cancel
;
1661 if (tip
->i_d
.di_version
== 3 &&
1662 tip
->i_d
.di_format
== XFS_DINODE_FMT_BTREE
) {
1663 src_log_flags
|= XFS_ILOG_DOWNER
;
1664 error
= xfs_bmbt_change_owner(tp
, tip
, XFS_DATA_FORK
,
1667 goto out_trans_cancel
;
1671 * Swap the data forks of the inodes
1675 *tempifp
= *ifp
; /* struct copy */
1676 *ifp
= *tifp
; /* struct copy */
1677 *tifp
= *tempifp
; /* struct copy */
1680 * Fix the on-disk inode values
1682 tmp
= (__uint64_t
)ip
->i_d
.di_nblocks
;
1683 ip
->i_d
.di_nblocks
= tip
->i_d
.di_nblocks
- taforkblks
+ aforkblks
;
1684 tip
->i_d
.di_nblocks
= tmp
+ taforkblks
- aforkblks
;
1686 tmp
= (__uint64_t
) ip
->i_d
.di_nextents
;
1687 ip
->i_d
.di_nextents
= tip
->i_d
.di_nextents
;
1688 tip
->i_d
.di_nextents
= tmp
;
1690 tmp
= (__uint64_t
) ip
->i_d
.di_format
;
1691 ip
->i_d
.di_format
= tip
->i_d
.di_format
;
1692 tip
->i_d
.di_format
= tmp
;
1695 * The extents in the source inode could still contain speculative
1696 * preallocation beyond EOF (e.g. the file is open but not modified
1697 * while defrag is in progress). In that case, we need to copy over the
1698 * number of delalloc blocks the data fork in the source inode is
1699 * tracking beyond EOF so that when the fork is truncated away when the
1700 * temporary inode is unlinked we don't underrun the i_delayed_blks
1701 * counter on that inode.
1703 ASSERT(tip
->i_delayed_blks
== 0);
1704 tip
->i_delayed_blks
= ip
->i_delayed_blks
;
1705 ip
->i_delayed_blks
= 0;
1707 switch (ip
->i_d
.di_format
) {
1708 case XFS_DINODE_FMT_EXTENTS
:
1709 /* If the extents fit in the inode, fix the
1710 * pointer. Otherwise it's already NULL or
1711 * pointing to the extent.
1713 if (ip
->i_d
.di_nextents
<= XFS_INLINE_EXTS
) {
1714 ifp
->if_u1
.if_extents
=
1715 ifp
->if_u2
.if_inline_ext
;
1717 src_log_flags
|= XFS_ILOG_DEXT
;
1719 case XFS_DINODE_FMT_BTREE
:
1720 ASSERT(ip
->i_d
.di_version
< 3 ||
1721 (src_log_flags
& XFS_ILOG_DOWNER
));
1722 src_log_flags
|= XFS_ILOG_DBROOT
;
1726 switch (tip
->i_d
.di_format
) {
1727 case XFS_DINODE_FMT_EXTENTS
:
1728 /* If the extents fit in the inode, fix the
1729 * pointer. Otherwise it's already NULL or
1730 * pointing to the extent.
1732 if (tip
->i_d
.di_nextents
<= XFS_INLINE_EXTS
) {
1733 tifp
->if_u1
.if_extents
=
1734 tifp
->if_u2
.if_inline_ext
;
1736 target_log_flags
|= XFS_ILOG_DEXT
;
1738 case XFS_DINODE_FMT_BTREE
:
1739 target_log_flags
|= XFS_ILOG_DBROOT
;
1740 ASSERT(tip
->i_d
.di_version
< 3 ||
1741 (target_log_flags
& XFS_ILOG_DOWNER
));
1745 xfs_trans_log_inode(tp
, ip
, src_log_flags
);
1746 xfs_trans_log_inode(tp
, tip
, target_log_flags
);
1749 * If this is a synchronous mount, make sure that the
1750 * transaction goes to disk before returning to the user.
1752 if (mp
->m_flags
& XFS_MOUNT_WSYNC
)
1753 xfs_trans_set_sync(tp
);
1755 error
= xfs_trans_commit(tp
);
1757 trace_xfs_swap_extent_after(ip
, 0);
1758 trace_xfs_swap_extent_after(tip
, 1);
1764 xfs_iunlock(ip
, lock_flags
);
1765 xfs_iunlock(tip
, lock_flags
);
1769 xfs_trans_cancel(tp
);