2018-06-06 02:42:14 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2013-08-12 10:49:42 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
2013-08-12 10:49:45 +00:00
|
|
|
* Copyright (c) 2012 Red Hat, Inc.
|
2013-08-12 10:49:42 +00:00
|
|
|
* All Rights Reserved.
|
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
2013-10-22 23:36:05 +00:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_format.h"
|
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2013-08-12 10:49:42 +00:00
|
|
|
#include "xfs_bit.h"
|
|
|
|
#include "xfs_mount.h"
|
2016-08-03 01:15:38 +00:00
|
|
|
#include "xfs_defer.h"
|
2013-08-12 10:49:42 +00:00
|
|
|
#include "xfs_inode.h"
|
|
|
|
#include "xfs_btree.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_trans.h"
|
2013-08-12 10:49:42 +00:00
|
|
|
#include "xfs_alloc.h"
|
|
|
|
#include "xfs_bmap.h"
|
|
|
|
#include "xfs_bmap_util.h"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_bmap_btree.h"
|
2013-08-12 10:49:42 +00:00
|
|
|
#include "xfs_rtalloc.h"
|
|
|
|
#include "xfs_error.h"
|
|
|
|
#include "xfs_quota.h"
|
|
|
|
#include "xfs_trans_space.h"
|
|
|
|
#include "xfs_trace.h"
|
2013-08-12 10:49:45 +00:00
|
|
|
#include "xfs_icache.h"
|
2016-10-03 16:11:41 +00:00
|
|
|
#include "xfs_iomap.h"
|
|
|
|
#include "xfs_reflink.h"
|
2013-08-12 10:49:42 +00:00
|
|
|
|
|
|
|
/* Kernel only BMAP related definitions and functions */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert the given file system block to a disk block. We have to treat it
|
|
|
|
* differently based on whether the file is a real time file or not, because the
|
|
|
|
* bmap code does.
|
|
|
|
*/
|
|
|
|
xfs_daddr_t
|
|
|
|
xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
|
|
|
|
{
|
2019-08-30 15:56:55 +00:00
|
|
|
if (XFS_IS_REALTIME_INODE(ip))
|
|
|
|
return XFS_FSB_TO_BB(ip->i_mount, fsb);
|
|
|
|
return XFS_FSB_TO_DADDR(ip->i_mount, fsb);
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
|
|
|
|
2015-11-03 01:27:22 +00:00
|
|
|
/*
|
|
|
|
* Routine to zero an extent on disk allocated to the specific inode.
|
|
|
|
*
|
|
|
|
* The VFS functions take a linearised filesystem block offset, so we have to
|
|
|
|
* convert the sparse xfs fsb to the right format first.
|
|
|
|
* VFS types are real funky, too.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_zero_extent(
|
2019-10-25 05:25:38 +00:00
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_fsblock_t start_fsb,
|
|
|
|
xfs_off_t count_fsb)
|
2015-11-03 01:27:22 +00:00
|
|
|
{
|
2019-10-25 05:25:38 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_buftarg *target = xfs_inode_buftarg(ip);
|
|
|
|
xfs_daddr_t sector = xfs_fsb_to_db(ip, start_fsb);
|
|
|
|
sector_t block = XFS_BB_TO_FSBT(mp, sector);
|
2015-11-03 01:27:22 +00:00
|
|
|
|
2019-10-25 05:25:38 +00:00
|
|
|
return blkdev_issue_zeroout(target->bt_bdev,
|
2016-03-15 17:20:41 +00:00
|
|
|
block << (mp->m_super->s_blocksize_bits - 9),
|
|
|
|
count_fsb << (mp->m_super->s_blocksize_bits - 9),
|
2017-04-05 17:21:08 +00:00
|
|
|
GFP_NOFS, 0);
|
2015-11-03 01:27:22 +00:00
|
|
|
}
|
|
|
|
|
2017-10-09 18:37:22 +00:00
|
|
|
#ifdef CONFIG_XFS_RT
|
2013-08-12 10:49:42 +00:00
|
|
|
int
|
|
|
|
xfs_bmap_rtalloc(
|
2021-05-09 23:22:54 +00:00
|
|
|
struct xfs_bmalloca *ap)
|
2013-08-12 10:49:42 +00:00
|
|
|
{
|
2021-05-09 23:22:54 +00:00
|
|
|
struct xfs_mount *mp = ap->ip->i_mount;
|
|
|
|
xfs_fileoff_t orig_offset = ap->offset;
|
|
|
|
xfs_rtblock_t rtb;
|
|
|
|
xfs_extlen_t prod = 0; /* product factor for allocators */
|
|
|
|
xfs_extlen_t mod = 0; /* product factor for allocators */
|
|
|
|
xfs_extlen_t ralen = 0; /* realtime allocation length */
|
|
|
|
xfs_extlen_t align; /* minimum allocation alignment */
|
|
|
|
xfs_extlen_t orig_length = ap->length;
|
|
|
|
xfs_extlen_t minlen = mp->m_sb.sb_rextsize;
|
|
|
|
xfs_extlen_t raminlen;
|
|
|
|
bool rtlocked = false;
|
2021-05-09 23:22:55 +00:00
|
|
|
bool ignore_locality = false;
|
2021-05-09 23:22:54 +00:00
|
|
|
int error;
|
|
|
|
|
2013-08-12 10:49:42 +00:00
|
|
|
align = xfs_get_extsz_hint(ap->ip);
|
2021-05-09 23:22:54 +00:00
|
|
|
retry:
|
2013-08-12 10:49:42 +00:00
|
|
|
prod = align / mp->m_sb.sb_rextsize;
|
|
|
|
error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
|
|
|
|
align, 1, ap->eof, 0,
|
|
|
|
ap->conv, &ap->offset, &ap->length);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
ASSERT(ap->length);
|
|
|
|
ASSERT(ap->length % mp->m_sb.sb_rextsize == 0);
|
|
|
|
|
2021-05-09 23:22:54 +00:00
|
|
|
/*
|
|
|
|
* If we shifted the file offset downward to satisfy an extent size
|
|
|
|
* hint, increase minlen by that amount so that the allocator won't
|
|
|
|
* give us an allocation that's too short to cover at least one of the
|
|
|
|
* blocks that the caller asked for.
|
|
|
|
*/
|
|
|
|
if (ap->offset != orig_offset)
|
|
|
|
minlen += orig_offset - ap->offset;
|
|
|
|
|
2013-08-12 10:49:42 +00:00
|
|
|
/*
|
|
|
|
* If the offset & length are not perfectly aligned
|
|
|
|
* then kill prod, it will just get us in trouble.
|
|
|
|
*/
|
2018-06-08 16:54:22 +00:00
|
|
|
div_u64_rem(ap->offset, align, &mod);
|
|
|
|
if (mod || ap->length % align)
|
2013-08-12 10:49:42 +00:00
|
|
|
prod = 1;
|
|
|
|
/*
|
|
|
|
* Set ralen to be the actual requested length in rtextents.
|
|
|
|
*/
|
|
|
|
ralen = ap->length / mp->m_sb.sb_rextsize;
|
|
|
|
/*
|
|
|
|
* If the old value was close enough to MAXEXTLEN that
|
|
|
|
* we rounded up to it, cut it back so it's valid again.
|
|
|
|
* Note that if it's a really large request (bigger than
|
|
|
|
* MAXEXTLEN), we don't hear about that number, and can't
|
|
|
|
* adjust the starting point to match it.
|
|
|
|
*/
|
|
|
|
if (ralen * mp->m_sb.sb_rextsize >= MAXEXTLEN)
|
|
|
|
ralen = MAXEXTLEN / mp->m_sb.sb_rextsize;
|
|
|
|
|
|
|
|
/*
|
2016-02-07 23:46:51 +00:00
|
|
|
* Lock out modifications to both the RT bitmap and summary inodes
|
2013-08-12 10:49:42 +00:00
|
|
|
*/
|
2021-05-09 23:22:54 +00:00
|
|
|
if (!rtlocked) {
|
|
|
|
xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
|
|
|
|
xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
|
|
|
|
xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL);
|
|
|
|
rtlocked = true;
|
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If it's an allocation to an empty file at offset 0,
|
|
|
|
* pick an extent that will space things out in the rt area.
|
|
|
|
*/
|
|
|
|
if (ap->eof && ap->offset == 0) {
|
treewide: Remove uninitialized_var() usage
Using uninitialized_var() is dangerous as it papers over real bugs[1]
(or can in the future), and suppresses unrelated compiler warnings
(e.g. "unused variable"). If the compiler thinks it is uninitialized,
either simply initialize the variable or make compiler changes.
In preparation for removing[2] the[3] macro[4], remove all remaining
needless uses with the following script:
git grep '\buninitialized_var\b' | cut -d: -f1 | sort -u | \
xargs perl -pi -e \
's/\buninitialized_var\(([^\)]+)\)/\1/g;
s:\s*/\* (GCC be quiet|to make compiler happy) \*/$::g;'
drivers/video/fbdev/riva/riva_hw.c was manually tweaked to avoid
pathological white-space.
No outstanding warnings were found building allmodconfig with GCC 9.3.0
for x86_64, i386, arm64, arm, powerpc, powerpc64le, s390x, mips, sparc64,
alpha, and m68k.
[1] https://lore.kernel.org/lkml/20200603174714.192027-1-glider@google.com/
[2] https://lore.kernel.org/lkml/CA+55aFw+Vbj0i=1TGqCR5vQkCzWJ0QxK6CernOU6eedsudAixw@mail.gmail.com/
[3] https://lore.kernel.org/lkml/CA+55aFwgbgqhbp1fkxvRKEpzyR5J8n1vKT1VZdz9knmPuXhOeg@mail.gmail.com/
[4] https://lore.kernel.org/lkml/CA+55aFz2500WfbKXAx8s67wrm9=yVJu65TpLgN_ybYNv0VEOKA@mail.gmail.com/
Reviewed-by: Leon Romanovsky <leonro@mellanox.com> # drivers/infiniband and mlx4/mlx5
Acked-by: Jason Gunthorpe <jgg@mellanox.com> # IB
Acked-by: Kalle Valo <kvalo@codeaurora.org> # wireless drivers
Reviewed-by: Chao Yu <yuchao0@huawei.com> # erofs
Signed-off-by: Kees Cook <keescook@chromium.org>
2020-06-03 20:09:38 +00:00
|
|
|
xfs_rtblock_t rtx; /* realtime extent no */
|
2013-08-12 10:49:42 +00:00
|
|
|
|
|
|
|
error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
ap->blkno = rtx * mp->m_sb.sb_rextsize;
|
|
|
|
} else {
|
|
|
|
ap->blkno = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_bmap_adjacent(ap);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Realtime allocation, done through xfs_rtallocate_extent.
|
|
|
|
*/
|
2021-05-09 23:22:55 +00:00
|
|
|
if (ignore_locality)
|
|
|
|
ap->blkno = 0;
|
|
|
|
else
|
|
|
|
do_div(ap->blkno, mp->m_sb.sb_rextsize);
|
2013-08-12 10:49:42 +00:00
|
|
|
rtb = ap->blkno;
|
|
|
|
ap->length = ralen;
|
2021-05-09 23:22:54 +00:00
|
|
|
raminlen = max_t(xfs_extlen_t, 1, minlen / mp->m_sb.sb_rextsize);
|
|
|
|
error = xfs_rtallocate_extent(ap->tp, ap->blkno, raminlen, ap->length,
|
|
|
|
&ralen, ap->wasdel, prod, &rtb);
|
2017-02-17 16:21:06 +00:00
|
|
|
if (error)
|
2013-08-12 10:49:42 +00:00
|
|
|
return error;
|
2017-02-17 16:21:06 +00:00
|
|
|
|
2021-05-09 23:22:54 +00:00
|
|
|
if (rtb != NULLRTBLOCK) {
|
|
|
|
ap->blkno = rtb * mp->m_sb.sb_rextsize;
|
|
|
|
ap->length = ralen * mp->m_sb.sb_rextsize;
|
|
|
|
ap->ip->i_nblocks += ap->length;
|
2013-08-12 10:49:42 +00:00
|
|
|
xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
|
|
|
|
if (ap->wasdel)
|
2021-05-09 23:22:54 +00:00
|
|
|
ap->ip->i_delayed_blks -= ap->length;
|
2013-08-12 10:49:42 +00:00
|
|
|
/*
|
|
|
|
* Adjust the disk quota also. This was reserved
|
|
|
|
* earlier.
|
|
|
|
*/
|
|
|
|
xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
|
|
|
|
ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
|
2021-05-09 23:22:54 +00:00
|
|
|
XFS_TRANS_DQ_RTBCOUNT, ap->length);
|
|
|
|
return 0;
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
2021-05-09 23:22:54 +00:00
|
|
|
|
|
|
|
if (align > mp->m_sb.sb_rextsize) {
|
|
|
|
/*
|
|
|
|
* We previously enlarged the request length to try to satisfy
|
|
|
|
* an extent size hint. The allocator didn't return anything,
|
|
|
|
* so reset the parameters to the original values and try again
|
|
|
|
* without alignment criteria.
|
|
|
|
*/
|
|
|
|
ap->offset = orig_offset;
|
|
|
|
ap->length = orig_length;
|
|
|
|
minlen = align = mp->m_sb.sb_rextsize;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2021-05-09 23:22:55 +00:00
|
|
|
if (!ignore_locality && ap->blkno != 0) {
|
|
|
|
/*
|
|
|
|
* If we can't allocate near a specific rt extent, try again
|
|
|
|
* without locality criteria.
|
|
|
|
*/
|
|
|
|
ignore_locality = true;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2021-05-09 23:22:54 +00:00
|
|
|
ap->blkno = NULLFSBLOCK;
|
|
|
|
ap->length = 0;
|
2013-08-12 10:49:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2017-10-09 18:37:22 +00:00
|
|
|
#endif /* CONFIG_XFS_RT */
|
2013-08-12 10:49:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Extent tree block counting routines.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2017-06-16 18:00:12 +00:00
|
|
|
* Count leaf blocks given a range of extent records. Delayed allocation
|
|
|
|
* extents are not counted towards the totals.
|
2013-08-12 10:49:42 +00:00
|
|
|
*/
|
2017-08-29 22:44:14 +00:00
|
|
|
xfs_extnum_t
|
2013-08-12 10:49:42 +00:00
|
|
|
xfs_bmap_count_leaves(
|
2017-06-16 18:00:12 +00:00
|
|
|
struct xfs_ifork *ifp,
|
2017-06-16 18:00:12 +00:00
|
|
|
xfs_filblks_t *count)
|
2013-08-12 10:49:42 +00:00
|
|
|
{
|
2017-11-03 17:34:43 +00:00
|
|
|
struct xfs_iext_cursor icur;
|
2017-08-29 22:44:14 +00:00
|
|
|
struct xfs_bmbt_irec got;
|
2017-11-03 17:34:43 +00:00
|
|
|
xfs_extnum_t numrecs = 0;
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-11-03 17:34:43 +00:00
|
|
|
for_each_xfs_iext(ifp, &icur, &got) {
|
2017-08-29 22:44:14 +00:00
|
|
|
if (!isnullstartblock(got.br_startblock)) {
|
|
|
|
*count += got.br_blockcount;
|
|
|
|
numrecs++;
|
2017-06-16 18:00:12 +00:00
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
2017-11-03 17:34:43 +00:00
|
|
|
|
2017-08-29 22:44:14 +00:00
|
|
|
return numrecs;
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-06-16 18:00:12 +00:00
|
|
|
* Count fsblocks of the given fork. Delayed allocation extents are
|
|
|
|
* not counted towards the totals.
|
2013-08-12 10:49:42 +00:00
|
|
|
*/
|
2017-06-16 18:00:12 +00:00
|
|
|
int
|
2013-08-12 10:49:42 +00:00
|
|
|
xfs_bmap_count_blocks(
|
2017-06-16 18:00:12 +00:00
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int whichfork,
|
|
|
|
xfs_extnum_t *nextents,
|
|
|
|
xfs_filblks_t *count)
|
2013-08-12 10:49:42 +00:00
|
|
|
{
|
2019-10-28 23:12:35 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
|
|
|
|
struct xfs_btree_cur *cur;
|
|
|
|
xfs_extlen_t btblocks = 0;
|
2017-06-16 18:00:12 +00:00
|
|
|
int error;
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-06-16 18:00:12 +00:00
|
|
|
*nextents = 0;
|
|
|
|
*count = 0;
|
2019-10-28 23:12:35 +00:00
|
|
|
|
2017-06-16 18:00:12 +00:00
|
|
|
if (!ifp)
|
2013-08-12 10:49:42 +00:00
|
|
|
return 0;
|
|
|
|
|
2020-05-18 17:28:05 +00:00
|
|
|
switch (ifp->if_format) {
|
2017-06-16 18:00:12 +00:00
|
|
|
case XFS_DINODE_FMT_BTREE:
|
2021-04-13 18:15:09 +00:00
|
|
|
error = xfs_iread_extents(tp, ip, whichfork);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2017-06-16 18:00:12 +00:00
|
|
|
|
2019-10-28 23:12:35 +00:00
|
|
|
cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
|
|
|
|
error = xfs_btree_count_blocks(cur, &btblocks);
|
|
|
|
xfs_btree_del_cursor(cur, error);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2017-06-16 18:00:12 +00:00
|
|
|
/*
|
2019-10-28 23:12:35 +00:00
|
|
|
* xfs_btree_count_blocks includes the root block contained in
|
|
|
|
* the inode fork in @btblocks, so subtract one because we're
|
|
|
|
* only interested in allocated disk blocks.
|
2017-06-16 18:00:12 +00:00
|
|
|
*/
|
2019-10-28 23:12:35 +00:00
|
|
|
*count += btblocks - 1;
|
2017-06-16 18:00:12 +00:00
|
|
|
|
2019-10-28 23:12:35 +00:00
|
|
|
/* fall through */
|
|
|
|
case XFS_DINODE_FMT_EXTENTS:
|
|
|
|
*nextents = xfs_bmap_count_leaves(ifp, count);
|
|
|
|
break;
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
static int
|
|
|
|
xfs_getbmap_report_one(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct getbmapx *bmv,
|
2017-10-17 21:16:19 +00:00
|
|
|
struct kgetbmap *out,
|
2017-10-17 21:16:18 +00:00
|
|
|
int64_t bmv_end,
|
|
|
|
struct xfs_bmbt_irec *got)
|
2016-10-03 16:11:41 +00:00
|
|
|
{
|
2017-10-17 21:16:19 +00:00
|
|
|
struct kgetbmap *p = out + bmv->bmv_entries;
|
2018-10-18 06:19:48 +00:00
|
|
|
bool shared = false;
|
2017-10-17 21:16:18 +00:00
|
|
|
int error;
|
2016-10-03 16:11:41 +00:00
|
|
|
|
2018-10-18 06:19:48 +00:00
|
|
|
error = xfs_reflink_trim_around_shared(ip, got, &shared);
|
2016-10-03 16:11:41 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
if (isnullstartblock(got->br_startblock) ||
|
|
|
|
got->br_startblock == DELAYSTARTBLOCK) {
|
2016-10-03 16:11:41 +00:00
|
|
|
/*
|
2017-10-17 21:16:18 +00:00
|
|
|
* Delalloc extents that start beyond EOF can occur due to
|
|
|
|
* speculative EOF allocation when the delalloc extent is larger
|
|
|
|
* than the largest freespace extent at conversion time. These
|
|
|
|
* extents cannot be converted by data writeback, so can exist
|
|
|
|
* here even if we are not supposed to be finding delalloc
|
|
|
|
* extents.
|
2016-10-03 16:11:41 +00:00
|
|
|
*/
|
2017-10-17 21:16:18 +00:00
|
|
|
if (got->br_startoff < XFS_B_TO_FSB(ip->i_mount, XFS_ISIZE(ip)))
|
|
|
|
ASSERT((bmv->bmv_iflags & BMV_IF_DELALLOC) != 0);
|
|
|
|
|
|
|
|
p->bmv_oflags |= BMV_OF_DELALLOC;
|
|
|
|
p->bmv_block = -2;
|
2016-10-03 16:11:41 +00:00
|
|
|
} else {
|
2017-10-17 21:16:18 +00:00
|
|
|
p->bmv_block = xfs_fsb_to_db(ip, got->br_startblock);
|
2016-10-03 16:11:41 +00:00
|
|
|
}
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
if (got->br_state == XFS_EXT_UNWRITTEN &&
|
|
|
|
(bmv->bmv_iflags & BMV_IF_PREALLOC))
|
|
|
|
p->bmv_oflags |= BMV_OF_PREALLOC;
|
|
|
|
|
|
|
|
if (shared)
|
|
|
|
p->bmv_oflags |= BMV_OF_SHARED;
|
|
|
|
|
|
|
|
p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, got->br_startoff);
|
|
|
|
p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, got->br_blockcount);
|
|
|
|
|
|
|
|
bmv->bmv_offset = p->bmv_offset + p->bmv_length;
|
|
|
|
bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
|
|
|
|
bmv->bmv_entries++;
|
2016-10-03 16:11:41 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
static void
|
|
|
|
xfs_getbmap_report_hole(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct getbmapx *bmv,
|
2017-10-17 21:16:19 +00:00
|
|
|
struct kgetbmap *out,
|
2017-10-17 21:16:18 +00:00
|
|
|
int64_t bmv_end,
|
|
|
|
xfs_fileoff_t bno,
|
|
|
|
xfs_fileoff_t end)
|
|
|
|
{
|
2017-10-17 21:16:19 +00:00
|
|
|
struct kgetbmap *p = out + bmv->bmv_entries;
|
2017-10-17 21:16:18 +00:00
|
|
|
|
|
|
|
if (bmv->bmv_iflags & BMV_IF_NO_HOLES)
|
|
|
|
return;
|
|
|
|
|
|
|
|
p->bmv_block = -1;
|
|
|
|
p->bmv_offset = XFS_FSB_TO_BB(ip->i_mount, bno);
|
|
|
|
p->bmv_length = XFS_FSB_TO_BB(ip->i_mount, end - bno);
|
|
|
|
|
|
|
|
bmv->bmv_offset = p->bmv_offset + p->bmv_length;
|
|
|
|
bmv->bmv_length = max(0LL, bmv_end - bmv->bmv_offset);
|
|
|
|
bmv->bmv_entries++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
xfs_getbmap_full(
|
|
|
|
struct getbmapx *bmv)
|
|
|
|
{
|
|
|
|
return bmv->bmv_length == 0 || bmv->bmv_entries >= bmv->bmv_count - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
xfs_getbmap_next_rec(
|
|
|
|
struct xfs_bmbt_irec *rec,
|
|
|
|
xfs_fileoff_t total_end)
|
|
|
|
{
|
|
|
|
xfs_fileoff_t end = rec->br_startoff + rec->br_blockcount;
|
|
|
|
|
|
|
|
if (end == total_end)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
rec->br_startoff += rec->br_blockcount;
|
|
|
|
if (!isnullstartblock(rec->br_startblock) &&
|
|
|
|
rec->br_startblock != DELAYSTARTBLOCK)
|
|
|
|
rec->br_startblock += rec->br_blockcount;
|
|
|
|
rec->br_blockcount = total_end - end;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:42 +00:00
|
|
|
/*
|
|
|
|
* Get inode's extents as described in bmv, and format for output.
|
|
|
|
* Calls formatter to fill the user's buffer until all extents
|
|
|
|
* are mapped, until the passed-in bmv->bmv_count slots have
|
|
|
|
* been filled, or until the formatter short-circuits the loop,
|
|
|
|
* if it is tracking filled-in extents on its own.
|
|
|
|
*/
|
|
|
|
int /* error code */
|
|
|
|
xfs_getbmap(
|
2017-10-17 21:16:19 +00:00
|
|
|
struct xfs_inode *ip,
|
2013-08-12 10:49:42 +00:00
|
|
|
struct getbmapx *bmv, /* user bmap structure */
|
2017-10-17 21:16:19 +00:00
|
|
|
struct kgetbmap *out)
|
2013-08-12 10:49:42 +00:00
|
|
|
{
|
2017-10-17 21:16:18 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
int iflags = bmv->bmv_iflags;
|
2017-10-17 21:16:19 +00:00
|
|
|
int whichfork, lock, error = 0;
|
2017-10-17 21:16:18 +00:00
|
|
|
int64_t bmv_end, max_len;
|
|
|
|
xfs_fileoff_t bno, first_bno;
|
|
|
|
struct xfs_ifork *ifp;
|
|
|
|
struct xfs_bmbt_irec got, rec;
|
|
|
|
xfs_filblks_t len;
|
2017-11-03 17:34:43 +00:00
|
|
|
struct xfs_iext_cursor icur;
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:19 +00:00
|
|
|
if (bmv->bmv_iflags & ~BMV_IF_VALID)
|
|
|
|
return -EINVAL;
|
2016-10-03 16:11:41 +00:00
|
|
|
#ifndef DEBUG
|
|
|
|
/* Only allow CoW fork queries if we're debugging. */
|
|
|
|
if (iflags & BMV_IF_COWFORK)
|
|
|
|
return -EINVAL;
|
|
|
|
#endif
|
|
|
|
if ((iflags & BMV_IF_ATTRFORK) && (iflags & BMV_IF_COWFORK))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
if (bmv->bmv_length < -1)
|
|
|
|
return -EINVAL;
|
|
|
|
bmv->bmv_entries = 0;
|
|
|
|
if (bmv->bmv_length == 0)
|
|
|
|
return 0;
|
|
|
|
|
2016-10-03 16:11:41 +00:00
|
|
|
if (iflags & BMV_IF_ATTRFORK)
|
|
|
|
whichfork = XFS_ATTR_FORK;
|
|
|
|
else if (iflags & BMV_IF_COWFORK)
|
|
|
|
whichfork = XFS_COW_FORK;
|
|
|
|
else
|
|
|
|
whichfork = XFS_DATA_FORK;
|
2017-10-17 21:16:18 +00:00
|
|
|
ifp = XFS_IFORK_PTR(ip, whichfork);
|
2016-10-03 16:11:41 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
xfs_ilock(ip, XFS_IOLOCK_SHARED);
|
2016-10-03 16:11:41 +00:00
|
|
|
switch (whichfork) {
|
|
|
|
case XFS_ATTR_FORK:
|
2017-10-17 21:16:18 +00:00
|
|
|
if (!XFS_IFORK_Q(ip))
|
|
|
|
goto out_unlock_iolock;
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
max_len = 1LL << 32;
|
|
|
|
lock = xfs_ilock_attr_map_shared(ip);
|
2016-10-03 16:11:41 +00:00
|
|
|
break;
|
|
|
|
case XFS_COW_FORK:
|
2017-10-17 21:16:18 +00:00
|
|
|
/* No CoW fork? Just return */
|
|
|
|
if (!ifp)
|
|
|
|
goto out_unlock_iolock;
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
if (xfs_get_cowextsz_hint(ip))
|
|
|
|
max_len = mp->m_super->s_maxbytes;
|
|
|
|
else
|
|
|
|
max_len = XFS_ISIZE(ip);
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
lock = XFS_ILOCK_SHARED;
|
|
|
|
xfs_ilock(ip, lock);
|
|
|
|
break;
|
2016-10-03 16:11:41 +00:00
|
|
|
case XFS_DATA_FORK:
|
2013-12-18 10:14:39 +00:00
|
|
|
if (!(iflags & BMV_IF_DELALLOC) &&
|
2021-03-29 18:11:40 +00:00
|
|
|
(ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_disk_size)) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
|
2013-08-12 10:49:42 +00:00
|
|
|
if (error)
|
|
|
|
goto out_unlock_iolock;
|
2013-12-18 10:14:39 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Even after flushing the inode, there can still be
|
|
|
|
* delalloc blocks on the inode beyond EOF due to
|
|
|
|
* speculative preallocation. These are not removed
|
|
|
|
* until the release function is called or the inode
|
|
|
|
* is inactivated. Hence we cannot assert here that
|
|
|
|
* ip->i_delayed_blks == 0.
|
|
|
|
*/
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
if (xfs_get_extsz_hint(ip) ||
|
2021-03-29 18:11:44 +00:00
|
|
|
(ip->i_diflags &
|
2017-10-17 21:16:18 +00:00
|
|
|
(XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))
|
|
|
|
max_len = mp->m_super->s_maxbytes;
|
|
|
|
else
|
|
|
|
max_len = XFS_ISIZE(ip);
|
|
|
|
|
2013-12-18 10:14:39 +00:00
|
|
|
lock = xfs_ilock_data_map_shared(ip);
|
2016-10-03 16:11:41 +00:00
|
|
|
break;
|
2013-12-18 10:14:39 +00:00
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2020-05-18 17:28:05 +00:00
|
|
|
switch (ifp->if_format) {
|
2017-10-17 21:16:18 +00:00
|
|
|
case XFS_DINODE_FMT_EXTENTS:
|
|
|
|
case XFS_DINODE_FMT_BTREE:
|
|
|
|
break;
|
|
|
|
case XFS_DINODE_FMT_LOCAL:
|
|
|
|
/* Local format inode forks report no extents. */
|
2013-08-12 10:49:42 +00:00
|
|
|
goto out_unlock_ilock;
|
2017-10-17 21:16:18 +00:00
|
|
|
default:
|
|
|
|
error = -EINVAL;
|
|
|
|
goto out_unlock_ilock;
|
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
if (bmv->bmv_length == -1) {
|
|
|
|
max_len = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, max_len));
|
|
|
|
bmv->bmv_length = max(0LL, max_len - bmv->bmv_offset);
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
bmv_end = bmv->bmv_offset + bmv->bmv_length;
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
first_bno = bno = XFS_BB_TO_FSBT(mp, bmv->bmv_offset);
|
|
|
|
len = XFS_BB_TO_FSB(mp, bmv->bmv_length);
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2021-04-13 18:15:09 +00:00
|
|
|
error = xfs_iread_extents(NULL, ip, whichfork);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock_ilock;
|
2016-10-03 16:11:41 +00:00
|
|
|
|
2017-11-03 17:34:43 +00:00
|
|
|
if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
|
2017-10-17 21:16:18 +00:00
|
|
|
/*
|
|
|
|
* Report a whole-file hole if the delalloc flag is set to
|
|
|
|
* stay compatible with the old implementation.
|
|
|
|
*/
|
|
|
|
if (iflags & BMV_IF_DELALLOC)
|
|
|
|
xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
|
|
|
|
XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));
|
|
|
|
goto out_unlock_ilock;
|
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
while (!xfs_getbmap_full(bmv)) {
|
|
|
|
xfs_trim_extent(&got, first_bno, len);
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
/*
|
|
|
|
* Report an entry for a hole if this extent doesn't directly
|
|
|
|
* follow the previous one.
|
|
|
|
*/
|
|
|
|
if (got.br_startoff > bno) {
|
|
|
|
xfs_getbmap_report_hole(ip, bmv, out, bmv_end, bno,
|
|
|
|
got.br_startoff);
|
|
|
|
if (xfs_getbmap_full(bmv))
|
|
|
|
break;
|
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
/*
|
|
|
|
* In order to report shared extents accurately, we report each
|
|
|
|
* distinct shared / unshared part of a single bmbt record with
|
|
|
|
* an individual getbmapx record.
|
|
|
|
*/
|
|
|
|
bno = got.br_startoff + got.br_blockcount;
|
|
|
|
rec = got;
|
|
|
|
do {
|
|
|
|
error = xfs_getbmap_report_one(ip, bmv, out, bmv_end,
|
|
|
|
&rec);
|
|
|
|
if (error || xfs_getbmap_full(bmv))
|
|
|
|
goto out_unlock_ilock;
|
|
|
|
} while (xfs_getbmap_next_rec(&rec, bno));
|
|
|
|
|
2017-11-03 17:34:43 +00:00
|
|
|
if (!xfs_iext_next_extent(ifp, &icur, &got)) {
|
2017-10-17 21:16:18 +00:00
|
|
|
xfs_fileoff_t end = XFS_B_TO_FSB(mp, XFS_ISIZE(ip));
|
|
|
|
|
|
|
|
out[bmv->bmv_entries - 1].bmv_oflags |= BMV_OF_LAST;
|
|
|
|
|
|
|
|
if (whichfork != XFS_ATTR_FORK && bno < end &&
|
|
|
|
!xfs_getbmap_full(bmv)) {
|
|
|
|
xfs_getbmap_report_hole(ip, bmv, out, bmv_end,
|
|
|
|
bno, end);
|
2017-01-26 17:50:30 +00:00
|
|
|
}
|
2017-10-17 21:16:18 +00:00
|
|
|
break;
|
2013-08-12 10:49:42 +00:00
|
|
|
}
|
|
|
|
|
2017-10-17 21:16:18 +00:00
|
|
|
if (bno >= first_bno + len)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_unlock_ilock:
|
2013-12-06 20:30:08 +00:00
|
|
|
xfs_iunlock(ip, lock);
|
2017-10-17 21:16:18 +00:00
|
|
|
out_unlock_iolock:
|
2013-08-12 10:49:42 +00:00
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2018-06-22 06:24:38 +00:00
|
|
|
* Dead simple method of punching delalyed allocation blocks from a range in
|
|
|
|
* the inode. This will always punch out both the start and end blocks, even
|
|
|
|
* if the ranges only partially overlap them, so it is up to the caller to
|
|
|
|
* ensure that partial blocks are not passed in.
|
2013-08-12 10:49:42 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_bmap_punch_delalloc_range(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_fileoff_t start_fsb,
|
|
|
|
xfs_fileoff_t length)
|
|
|
|
{
|
2018-06-22 06:24:38 +00:00
|
|
|
struct xfs_ifork *ifp = &ip->i_df;
|
|
|
|
xfs_fileoff_t end_fsb = start_fsb + length;
|
|
|
|
struct xfs_bmbt_irec got, del;
|
|
|
|
struct xfs_iext_cursor icur;
|
2013-08-12 10:49:42 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2021-04-13 18:15:12 +00:00
|
|
|
ASSERT(!xfs_need_iread_extents(ifp));
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2018-09-29 03:47:46 +00:00
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
2018-06-22 06:24:38 +00:00
|
|
|
if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))
|
2018-07-12 05:25:57 +00:00
|
|
|
goto out_unlock;
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2018-06-22 06:24:38 +00:00
|
|
|
while (got.br_startoff + got.br_blockcount > start_fsb) {
|
|
|
|
del = got;
|
|
|
|
xfs_trim_extent(&del, start_fsb, length);
|
2013-08-12 10:49:42 +00:00
|
|
|
|
|
|
|
/*
|
2018-06-22 06:24:38 +00:00
|
|
|
* A delete can push the cursor forward. Step back to the
|
|
|
|
* previous extent on non-delalloc or extents outside the
|
|
|
|
* target range.
|
2013-08-12 10:49:42 +00:00
|
|
|
*/
|
2018-06-22 06:24:38 +00:00
|
|
|
if (!del.br_blockcount ||
|
|
|
|
!isnullstartblock(del.br_startblock)) {
|
|
|
|
if (!xfs_iext_prev_extent(ifp, &icur, &got))
|
|
|
|
break;
|
|
|
|
continue;
|
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2018-06-22 06:24:38 +00:00
|
|
|
error = xfs_bmap_del_extent_delay(ip, XFS_DATA_FORK, &icur,
|
|
|
|
&got, &del);
|
|
|
|
if (error || !xfs_iext_get_extent(ifp, &icur, &got))
|
|
|
|
break;
|
|
|
|
}
|
2013-08-12 10:49:42 +00:00
|
|
|
|
2018-07-12 05:25:57 +00:00
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:42 +00:00
|
|
|
return error;
|
|
|
|
}
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Test whether it is appropriate to check an inode for and free post EOF
|
|
|
|
* blocks. The 'force' parameter determines whether we should also consider
|
|
|
|
* regular files that are marked preallocated or append-only.
|
|
|
|
*/
|
|
|
|
bool
|
2021-03-23 23:59:31 +00:00
|
|
|
xfs_can_free_eofblocks(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
bool force)
|
2013-08-12 10:49:45 +00:00
|
|
|
{
|
2021-03-23 23:59:31 +00:00
|
|
|
struct xfs_bmbt_irec imap;
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t end_fsb;
|
|
|
|
xfs_fileoff_t last_fsb;
|
|
|
|
int nimaps = 1;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Caller must either hold the exclusive io lock; or be inactivating
|
|
|
|
* the inode, which guarantees there are no other users of the inode.
|
|
|
|
*/
|
|
|
|
ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL) ||
|
|
|
|
(VFS_I(ip)->i_state & I_FREEING));
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/* prealloc/delalloc exists only on regular files */
|
2016-02-09 05:54:58 +00:00
|
|
|
if (!S_ISREG(VFS_I(ip)->i_mode))
|
2013-08-12 10:49:45 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Zero sized files with no cached pages and delalloc blocks will not
|
|
|
|
* have speculative prealloc/delalloc blocks to remove.
|
|
|
|
*/
|
|
|
|
if (VFS_I(ip)->i_size == 0 &&
|
2014-08-04 03:23:15 +00:00
|
|
|
VFS_I(ip)->i_mapping->nrpages == 0 &&
|
2013-08-12 10:49:45 +00:00
|
|
|
ip->i_delayed_blks == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* If we haven't read in the extent list, then don't do it now. */
|
2021-04-13 18:15:12 +00:00
|
|
|
if (xfs_need_iread_extents(&ip->i_df))
|
2013-08-12 10:49:45 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do not free real preallocated or append-only files unless the file
|
|
|
|
* has delalloc blocks and we are forced to remove them.
|
|
|
|
*/
|
2021-03-29 18:11:44 +00:00
|
|
|
if (ip->i_diflags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
|
2013-08-12 10:49:45 +00:00
|
|
|
if (!force || ip->i_delayed_blks == 0)
|
|
|
|
return false;
|
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
/*
|
|
|
|
* Do not try to free post-EOF blocks if EOF is beyond the end of the
|
|
|
|
* range supported by the page cache, because the truncation will loop
|
|
|
|
* forever.
|
|
|
|
*/
|
|
|
|
end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
|
|
|
|
last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
|
|
|
|
if (last_fsb <= end_fsb)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Look up the mapping for the first block past EOF. If we can't find
|
|
|
|
* it, there's nothing to free.
|
|
|
|
*/
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_SHARED);
|
|
|
|
error = xfs_bmapi_read(ip, end_fsb, last_fsb - end_fsb, &imap, &nimaps,
|
|
|
|
0);
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_SHARED);
|
|
|
|
if (error || nimaps == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's a real mapping there or there are delayed allocation
|
|
|
|
* reservations, then we have post-EOF blocks to try to free.
|
|
|
|
*/
|
|
|
|
return imap.br_startblock != HOLESTARTBLOCK || ip->i_delayed_blks;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-04-11 17:50:05 +00:00
|
|
|
* This is called to free any blocks beyond eof. The caller must hold
|
|
|
|
* IOLOCK_EXCL unless we are in the inode reclaim path and have the only
|
|
|
|
* reference to the inode.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_free_eofblocks(
|
2017-01-28 07:22:55 +00:00
|
|
|
struct xfs_inode *ip)
|
2013-08-12 10:49:45 +00:00
|
|
|
{
|
2017-01-28 07:22:55 +00:00
|
|
|
struct xfs_trans *tp;
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2021-03-23 23:59:31 +00:00
|
|
|
int error;
|
2017-01-28 07:22:55 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
/* Attach the dquots to the inode up front. */
|
|
|
|
error = xfs_qm_dqattach(ip);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
/* Wait on dio to ensure i_size has settled. */
|
|
|
|
inode_dio_wait(VFS_I(ip));
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
|
|
|
|
if (error) {
|
|
|
|
ASSERT(XFS_FORCED_SHUTDOWN(mp));
|
|
|
|
return error;
|
|
|
|
}
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
2017-01-28 07:22:57 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
/*
|
|
|
|
* Do not update the on-disk file size. If we update the on-disk file
|
|
|
|
* size and then the system crashes before the contents of the file are
|
|
|
|
* flushed to disk then the files may be full of holes (ie NULL files
|
|
|
|
* bug).
|
|
|
|
*/
|
|
|
|
error = xfs_itruncate_extents_flags(&tp, ip, XFS_DATA_FORK,
|
|
|
|
XFS_ISIZE(ip), XFS_BMAPI_NODISCARD);
|
|
|
|
if (error)
|
|
|
|
goto err_cancel;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
xfs_inode_clear_eofblocks_tag(ip);
|
|
|
|
goto out_unlock;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-03-23 23:59:31 +00:00
|
|
|
err_cancel:
|
|
|
|
/*
|
|
|
|
* If we get an error at this point we simply don't
|
|
|
|
* bother truncating the file.
|
|
|
|
*/
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2013-08-12 10:49:45 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-10-12 07:55:07 +00:00
|
|
|
int
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_alloc_file_space(
|
2013-10-12 07:55:07 +00:00
|
|
|
struct xfs_inode *ip,
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_off_t offset,
|
|
|
|
xfs_off_t len,
|
2013-10-12 07:55:06 +00:00
|
|
|
int alloc_type)
|
2013-08-12 10:49:45 +00:00
|
|
|
{
|
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
|
|
|
xfs_off_t count;
|
|
|
|
xfs_filblks_t allocated_fsb;
|
|
|
|
xfs_filblks_t allocatesize_fsb;
|
|
|
|
xfs_extlen_t extsz, temp;
|
|
|
|
xfs_fileoff_t startoffset_fsb;
|
2019-09-30 18:29:44 +00:00
|
|
|
xfs_fileoff_t endoffset_fsb;
|
2013-08-12 10:49:45 +00:00
|
|
|
int nimaps;
|
|
|
|
int rt;
|
|
|
|
xfs_trans_t *tp;
|
|
|
|
xfs_bmbt_irec_t imaps[1], *imapp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
trace_xfs_alloc_file_space(ip);
|
|
|
|
|
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EIO;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(ip);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
if (len <= 0)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
rt = XFS_IS_REALTIME_INODE(ip);
|
|
|
|
extsz = xfs_get_extsz_hint(ip);
|
|
|
|
|
|
|
|
count = len;
|
|
|
|
imapp = &imaps[0];
|
|
|
|
nimaps = 1;
|
|
|
|
startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
|
2019-09-30 18:29:44 +00:00
|
|
|
endoffset_fsb = XFS_B_TO_FSB(mp, offset + count);
|
|
|
|
allocatesize_fsb = endoffset_fsb - startoffset_fsb;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate file space until done or until there is an error
|
|
|
|
*/
|
|
|
|
while (allocatesize_fsb && !error) {
|
|
|
|
xfs_fileoff_t s, e;
|
2021-01-27 00:44:07 +00:00
|
|
|
unsigned int dblocks, rblocks, resblks;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine space reservations for data/realtime.
|
|
|
|
*/
|
|
|
|
if (unlikely(extsz)) {
|
|
|
|
s = startoffset_fsb;
|
|
|
|
do_div(s, extsz);
|
|
|
|
s *= extsz;
|
|
|
|
e = startoffset_fsb + allocatesize_fsb;
|
2018-06-08 16:54:22 +00:00
|
|
|
div_u64_rem(startoffset_fsb, extsz, &temp);
|
|
|
|
if (temp)
|
2013-08-12 10:49:45 +00:00
|
|
|
e += temp;
|
2018-06-08 16:54:22 +00:00
|
|
|
div_u64_rem(e, extsz, &temp);
|
|
|
|
if (temp)
|
2013-08-12 10:49:45 +00:00
|
|
|
e += extsz - temp;
|
|
|
|
} else {
|
|
|
|
s = 0;
|
|
|
|
e = allocatesize_fsb;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The transaction reservation is limited to a 32-bit block
|
|
|
|
* count, hence we need to limit the number of blocks we are
|
|
|
|
* trying to reserve to avoid an overflow. We can't allocate
|
|
|
|
* more than @nimaps extents, and an extent is limited on disk
|
|
|
|
* to MAXEXTLEN (21 bits), so use that to enforce the limit.
|
|
|
|
*/
|
|
|
|
resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
|
|
|
|
if (unlikely(rt)) {
|
2021-01-27 01:20:42 +00:00
|
|
|
dblocks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
|
|
|
|
rblocks = resblks;
|
2013-08-12 10:49:45 +00:00
|
|
|
} else {
|
2021-01-27 01:20:42 +00:00
|
|
|
dblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
|
|
|
|
rblocks = 0;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate and setup the transaction.
|
|
|
|
*/
|
2021-01-27 00:44:07 +00:00
|
|
|
error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write,
|
|
|
|
dblocks, rblocks, false, &tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
2021-01-27 00:44:07 +00:00
|
|
|
break;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-01-23 00:48:11 +00:00
|
|
|
error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_ADD_NOSPLIT_CNT);
|
|
|
|
if (error)
|
2021-01-27 01:23:30 +00:00
|
|
|
goto error;
|
2021-01-23 00:48:11 +00:00
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
error = xfs_bmapi_write(tp, ip, startoffset_fsb,
|
xfs: don't set bmapi total block req where minleft is
xfs_bmapi_write() takes a total block requirement parameter that is
passed down to the block allocation code and is used to specify the
total block requirement of the associated transaction. This is used
to try and select an AG that can not only satisfy the requested
extent allocation, but can also accommodate subsequent allocations
that might be required to complete the transaction. For example,
additional bmbt block allocations may be required on insertion of
the resulting extent to an inode data fork.
While it's important for callers to calculate and reserve such extra
blocks in the transaction, it is not necessary to pass the total
value to xfs_bmapi_write() in all cases. The latter automatically
sets minleft to ensure that sufficient free blocks remain after the
allocation attempt to expand the format of the associated inode
(i.e., such as extent to btree conversion, btree splits, etc).
Therefore, any callers that pass a total block requirement of the
bmap mapping length plus worst case bmbt expansion essentially
specify the additional reservation requirement twice. These callers
can pass a total of zero to rely on the bmapi minleft policy.
Beyond being superfluous, the primary motivation for this change is
that the total reservation logic in the bmbt code is dubious in
scenarios where minlen < maxlen and a maxlen extent cannot be
allocated (which is more common for data extent allocations where
contiguity is not required). The total value is based on maxlen in
the xfs_bmapi_write() caller. If the bmbt code falls back to an
allocation between minlen and maxlen, that allocation will not
succeed until total is reset to minlen, which essentially throws
away any additional reservation included in total by the caller. In
addition, the total value is not reset until after alignment is
dropped, which means that such callers drop alignment far too
aggressively than necessary.
Update all callers of xfs_bmapi_write() that pass a total block
value of the mapping length plus bmbt reservation to instead pass
zero and rely on xfs_bmapi_minleft() to enforce the bmbt reservation
requirement. This trades off slightly less conservative AG selection
for the ability to preserve alignment in more scenarios.
xfs_bmapi_write() callers that incorporate unrelated or additional
reservations in total beyond what is already included in minleft
must continue to use the former.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2019-10-21 16:26:48 +00:00
|
|
|
allocatesize_fsb, alloc_type, 0, imapp,
|
|
|
|
&nimaps);
|
xfs: eliminate committed arg from xfs_bmap_finish
Calls to xfs_bmap_finish() and xfs_trans_ijoin(), and the
associated comments were replicated several times across
the attribute code, all dealing with what to do if the
transaction was or wasn't committed.
And in that replicated code, an ASSERT() test of an
uninitialized variable occurs in several locations:
error = xfs_attr_thing(&args);
if (!error) {
error = xfs_bmap_finish(&args.trans, args.flist,
&committed);
}
if (error) {
ASSERT(committed);
If the first xfs_attr_thing() failed, we'd skip the xfs_bmap_finish,
never set "committed", and then test it in the ASSERT.
Fix this up by moving the committed state internal to xfs_bmap_finish,
and add a new inode argument. If an inode is passed in, it is passed
through to __xfs_trans_roll() and joined to the transaction there if
the transaction was committed.
xfs_qm_dqalloc() was a little unique in that it called bjoin rather
than ijoin, but as Dave points out we can detect the committed state
but checking whether (*tpp != tp).
Addresses-Coverity-Id: 102360
Addresses-Coverity-Id: 102361
Addresses-Coverity-Id: 102363
Addresses-Coverity-Id: 102364
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-01-11 00:34:01 +00:00
|
|
|
if (error)
|
2021-01-27 01:23:30 +00:00
|
|
|
goto error;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Complete the transaction
|
|
|
|
*/
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
xfs: eliminate committed arg from xfs_bmap_finish
Calls to xfs_bmap_finish() and xfs_trans_ijoin(), and the
associated comments were replicated several times across
the attribute code, all dealing with what to do if the
transaction was or wasn't committed.
And in that replicated code, an ASSERT() test of an
uninitialized variable occurs in several locations:
error = xfs_attr_thing(&args);
if (!error) {
error = xfs_bmap_finish(&args.trans, args.flist,
&committed);
}
if (error) {
ASSERT(committed);
If the first xfs_attr_thing() failed, we'd skip the xfs_bmap_finish,
never set "committed", and then test it in the ASSERT.
Fix this up by moving the committed state internal to xfs_bmap_finish,
and add a new inode argument. If an inode is passed in, it is passed
through to __xfs_trans_roll() and joined to the transaction there if
the transaction was committed.
xfs_qm_dqalloc() was a little unique in that it called bjoin rather
than ijoin, but as Dave points out we can detect the committed state
but checking whether (*tpp != tp).
Addresses-Coverity-Id: 102360
Addresses-Coverity-Id: 102361
Addresses-Coverity-Id: 102363
Addresses-Coverity-Id: 102364
Signed-off-by: Eric Sandeen <sandeen@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-01-11 00:34:01 +00:00
|
|
|
if (error)
|
2013-08-12 10:49:45 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
allocated_fsb = imapp->br_blockcount;
|
|
|
|
|
|
|
|
if (nimaps == 0) {
|
2014-06-25 04:58:08 +00:00
|
|
|
error = -ENOSPC;
|
2013-08-12 10:49:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
startoffset_fsb += allocated_fsb;
|
|
|
|
allocatesize_fsb -= allocated_fsb;
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
|
2021-01-27 01:23:30 +00:00
|
|
|
error:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-06-21 00:00:55 +00:00
|
|
|
static int
|
|
|
|
xfs_unmap_extent(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_fileoff_t startoffset_fsb,
|
|
|
|
xfs_filblks_t len_fsb,
|
|
|
|
int *done)
|
2013-08-12 10:49:45 +00:00
|
|
|
{
|
2016-06-21 00:00:55 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
uint resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
|
|
|
|
int error;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2021-01-27 00:44:07 +00:00
|
|
|
error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_write, resblks, 0,
|
2021-01-27 00:33:29 +00:00
|
|
|
false, &tp);
|
2016-06-21 00:00:55 +00:00
|
|
|
if (error)
|
2021-01-27 00:33:29 +00:00
|
|
|
return error;
|
2013-12-06 20:30:12 +00:00
|
|
|
|
2021-01-23 00:48:11 +00:00
|
|
|
error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_PUNCH_HOLE_CNT);
|
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
|
2018-07-12 05:26:25 +00:00
|
|
|
error = xfs_bunmapi(tp, ip, startoffset_fsb, len_fsb, 0, 2, done);
|
2016-06-21 00:00:55 +00:00
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2013-12-06 20:30:12 +00:00
|
|
|
|
2016-06-21 00:00:55 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return error;
|
2015-06-03 23:19:08 +00:00
|
|
|
|
2016-06-21 00:00:55 +00:00
|
|
|
out_trans_cancel:
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2015-06-03 23:19:08 +00:00
|
|
|
|
xfs: properly serialise fallocate against AIO+DIO
AIO+DIO can extend the file size on IO completion, and it holds
no inode locks while the IO is in flight. Therefore, a race
condition exists in file size updates if we do something like this:
aio-thread fallocate-thread
lock inode
submit IO beyond inode->i_size
unlock inode
.....
lock inode
break layouts
if (off + len > inode->i_size)
new_size = off + len
.....
inode_dio_wait()
<blocks>
.....
completes
inode->i_size updated
inode_dio_done()
....
<wakes>
<does stuff no long beyond EOF>
if (new_size)
xfs_vn_setattr(inode, new_size)
Yup, that attempt to extend the file size in the fallocate code
turns into a truncate - it removes the whatever the aio write
allocated and put to disk, and reduced the inode size back down to
where the fallocate operation ends.
Fundamentally, xfs_file_fallocate() not compatible with racing
AIO+DIO completions, so we need to move the inode_dio_wait() call
up to where the lock the inode and break the layouts.
Secondly, storing the inode size and then using it unchecked without
holding the ILOCK is not safe; we can only do such a thing if we've
locked out and drained all IO and other modification operations,
which we don't do initially in xfs_file_fallocate.
It should be noted that some of the fallocate operations are
compound operations - they are made up of multiple manipulations
that may zero data, and so we may need to flush and invalidate the
file multiple times during an operation. However, we only need to
lock out IO and other space manipulation operations once, as that
lockout is maintained until the entire fallocate operation has been
completed.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
2019-10-29 20:04:32 +00:00
|
|
|
/* Caller must first wait for the completion of any pending DIOs if required. */
|
2018-11-19 21:31:10 +00:00
|
|
|
int
|
2016-06-21 00:00:55 +00:00
|
|
|
xfs_flush_unmap_range(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_off_t offset,
|
|
|
|
xfs_off_t len)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct inode *inode = VFS_I(ip);
|
|
|
|
xfs_off_t rounding, start, end;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_SIZE);
|
|
|
|
start = round_down(offset, rounding);
|
|
|
|
end = round_up(offset + len, rounding) - 1;
|
|
|
|
|
|
|
|
error = filemap_write_and_wait_range(inode->i_mapping, start, end);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
truncate_pagecache_range(inode, start, end);
|
|
|
|
return 0;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
2013-10-12 07:55:07 +00:00
|
|
|
int
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_free_file_space(
|
2013-10-12 07:55:07 +00:00
|
|
|
struct xfs_inode *ip,
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_off_t offset,
|
2013-10-12 07:55:06 +00:00
|
|
|
xfs_off_t len)
|
2013-08-12 10:49:45 +00:00
|
|
|
{
|
2016-06-21 00:00:55 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2013-08-12 10:49:45 +00:00
|
|
|
xfs_fileoff_t startoffset_fsb;
|
2016-06-21 00:00:55 +00:00
|
|
|
xfs_fileoff_t endoffset_fsb;
|
2016-06-21 00:02:23 +00:00
|
|
|
int done = 0, error;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
|
|
|
trace_xfs_free_file_space(ip);
|
|
|
|
|
2018-05-04 22:30:21 +00:00
|
|
|
error = xfs_qm_dqattach(ip);
|
2013-08-12 10:49:45 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
if (len <= 0) /* if nothing being freed */
|
2016-06-21 00:00:55 +00:00
|
|
|
return 0;
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2016-06-21 00:00:55 +00:00
|
|
|
startoffset_fsb = XFS_B_TO_FSB(mp, offset);
|
|
|
|
endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
|
2013-08-12 10:49:45 +00:00
|
|
|
|
2020-09-09 21:21:06 +00:00
|
|
|
/* We can only free complete realtime extents. */
|
2020-10-09 23:42:59 +00:00
|
|
|
if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1) {
|
|
|
|
startoffset_fsb = roundup_64(startoffset_fsb,
|
|
|
|
mp->m_sb.sb_rextsize);
|
|
|
|
endoffset_fsb = rounddown_64(endoffset_fsb,
|
|
|
|
mp->m_sb.sb_rextsize);
|
2020-09-09 21:21:06 +00:00
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:45 +00:00
|
|
|
/*
|
2018-10-18 06:18:58 +00:00
|
|
|
* Need to zero the stuff we're not freeing, on disk.
|
2013-08-12 10:49:45 +00:00
|
|
|
*/
|
2016-06-21 00:02:23 +00:00
|
|
|
if (endoffset_fsb > startoffset_fsb) {
|
|
|
|
while (!done) {
|
|
|
|
error = xfs_unmap_extent(ip, startoffset_fsb,
|
|
|
|
endoffset_fsb - startoffset_fsb, &done);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-21 00:02:23 +00:00
|
|
|
/*
|
|
|
|
* Now that we've unmap all full blocks we'll have to zero out any
|
2018-03-14 06:15:32 +00:00
|
|
|
* partial block at the beginning and/or end. iomap_zero_range is smart
|
|
|
|
* enough to skip any holes, including those we just created, but we
|
|
|
|
* must take care not to zero beyond EOF and enlarge i_size.
|
2016-06-21 00:02:23 +00:00
|
|
|
*/
|
2017-04-03 19:22:29 +00:00
|
|
|
if (offset >= XFS_ISIZE(ip))
|
|
|
|
return 0;
|
|
|
|
if (offset + len > XFS_ISIZE(ip))
|
|
|
|
len = XFS_ISIZE(ip) - offset;
|
2019-10-19 16:09:46 +00:00
|
|
|
error = iomap_zero_range(VFS_I(ip), offset, len, NULL,
|
|
|
|
&xfs_buffered_write_iomap_ops);
|
2018-06-22 06:26:58 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we zeroed right up to EOF and EOF straddles a page boundary we
|
|
|
|
* must make sure that the post-EOF area is also zeroed because the
|
|
|
|
* page could be mmap'd and iomap_zero_range doesn't do that for us.
|
|
|
|
* Writeback of the eof page will do this, albeit clumsily.
|
|
|
|
*/
|
2018-11-27 19:01:43 +00:00
|
|
|
if (offset + len >= XFS_ISIZE(ip) && offset_in_page(offset + len) > 0) {
|
2018-06-22 06:26:58 +00:00
|
|
|
error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
|
2018-11-27 19:01:43 +00:00
|
|
|
round_down(offset + len, PAGE_SIZE), LLONG_MAX);
|
2018-06-22 06:26:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
2013-08-12 10:49:45 +00:00
|
|
|
}
|
|
|
|
|
2015-04-13 01:25:04 +00:00
|
|
|
static int
|
2017-10-19 18:07:10 +00:00
|
|
|
xfs_prepare_shift(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
loff_t offset)
|
2014-02-23 23:58:19 +00:00
|
|
|
{
|
2019-12-11 21:18:38 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2014-02-23 23:58:19 +00:00
|
|
|
int error;
|
|
|
|
|
2014-09-23 05:39:05 +00:00
|
|
|
/*
|
|
|
|
* Trim eofblocks to avoid shifting uninitialized post-eof preallocation
|
|
|
|
* into the accessible region of the file.
|
|
|
|
*/
|
2014-09-02 02:12:53 +00:00
|
|
|
if (xfs_can_free_eofblocks(ip, true)) {
|
2017-01-28 07:22:55 +00:00
|
|
|
error = xfs_free_eofblocks(ip);
|
2014-09-02 02:12:53 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
2014-09-02 02:12:53 +00:00
|
|
|
|
2019-12-11 21:18:38 +00:00
|
|
|
/*
|
|
|
|
* Shift operations must stabilize the start block offset boundary along
|
|
|
|
* with the full range of the operation. If we don't, a COW writeback
|
|
|
|
* completion could race with an insert, front merge with the start
|
|
|
|
* extent (after split) during the shift and corrupt the file. Start
|
|
|
|
* with the block just prior to the start to stabilize the boundary.
|
|
|
|
*/
|
|
|
|
offset = round_down(offset, 1 << mp->m_sb.sb_blocklog);
|
|
|
|
if (offset)
|
|
|
|
offset -= (1 << mp->m_sb.sb_blocklog);
|
|
|
|
|
2014-09-23 05:39:05 +00:00
|
|
|
/*
|
|
|
|
* Writeback and invalidate cache for the remainder of the file as we're
|
2015-03-25 04:08:56 +00:00
|
|
|
* about to shift down every extent from offset to EOF.
|
2014-09-23 05:39:05 +00:00
|
|
|
*/
|
2018-11-19 21:31:09 +00:00
|
|
|
error = xfs_flush_unmap_range(ip, offset, XFS_ISIZE(ip));
|
2019-04-26 14:30:24 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
2014-02-23 23:58:19 +00:00
|
|
|
|
2015-03-25 04:08:56 +00:00
|
|
|
/*
|
2017-09-18 16:41:17 +00:00
|
|
|
* Clean out anything hanging around in the cow fork now that
|
|
|
|
* we've flushed all the dirty data out to disk to avoid having
|
|
|
|
* CoW extents at the wrong offsets.
|
|
|
|
*/
|
2018-07-17 23:51:51 +00:00
|
|
|
if (xfs_inode_has_cow_data(ip)) {
|
2017-09-18 16:41:17 +00:00
|
|
|
error = xfs_reflink_cancel_cow_range(ip, offset, NULLFILEOFF,
|
|
|
|
true);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2017-10-19 18:07:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_collapse_file_space()
|
|
|
|
* This routine frees disk space and shift extent for the given file.
|
|
|
|
* The first thing we do is to free data blocks in the specified range
|
|
|
|
* by calling xfs_free_file_space(). It would also sync dirty data
|
|
|
|
* and invalidate page cache over the region on which collapse range
|
|
|
|
* is working. And Shift extent records to the left to cover a hole.
|
|
|
|
* RETURNS:
|
|
|
|
* 0 on success
|
|
|
|
* errno on error
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_collapse_file_space(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
xfs_off_t offset,
|
|
|
|
xfs_off_t len)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
int error;
|
|
|
|
xfs_fileoff_t next_fsb = XFS_B_TO_FSB(mp, offset + len);
|
|
|
|
xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
|
2017-10-19 18:07:11 +00:00
|
|
|
bool done = false;
|
2017-10-19 18:07:10 +00:00
|
|
|
|
|
|
|
ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
|
2017-10-23 23:32:38 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
|
|
|
|
|
2017-10-19 18:07:10 +00:00
|
|
|
trace_xfs_collapse_file_space(ip);
|
|
|
|
|
|
|
|
error = xfs_free_file_space(ip, offset, len);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = xfs_prepare_shift(ip, offset);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2015-03-25 04:08:56 +00:00
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0, 0, &tp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2014-02-23 23:58:19 +00:00
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
2014-02-23 23:58:19 +00:00
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
while (!done) {
|
2017-10-19 18:07:11 +00:00
|
|
|
error = xfs_bmap_collapse_extents(tp, ip, &next_fsb, shift_fsb,
|
2018-07-12 05:26:27 +00:00
|
|
|
&done);
|
2014-02-23 23:58:19 +00:00
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2020-02-26 17:43:16 +00:00
|
|
|
if (done)
|
|
|
|
break;
|
2014-02-23 23:58:19 +00:00
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
/* finish any deferred frees and roll the transaction */
|
|
|
|
error = xfs_defer_finish(&tp);
|
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
2014-02-23 23:58:19 +00:00
|
|
|
}
|
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2014-02-23 23:58:19 +00:00
|
|
|
return error;
|
|
|
|
|
2015-08-19 00:01:40 +00:00
|
|
|
out_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2020-02-26 17:43:16 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2014-02-23 23:58:19 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2015-03-25 04:08:56 +00:00
|
|
|
/*
|
|
|
|
* xfs_insert_file_space()
|
|
|
|
* This routine create hole space by shifting extents for the given file.
|
|
|
|
* The first thing we do is to sync dirty data and invalidate page cache
|
|
|
|
* over the region on which insert range is working. And split an extent
|
|
|
|
* to two extents at given offset by calling xfs_bmap_split_extent.
|
|
|
|
* And shift all extent records which are laying between [offset,
|
|
|
|
* last allocated extent] to the right to reserve hole range.
|
|
|
|
* RETURNS:
|
|
|
|
* 0 on success
|
|
|
|
* errno on error
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_insert_file_space(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
loff_t offset,
|
|
|
|
loff_t len)
|
|
|
|
{
|
2017-10-19 18:07:10 +00:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
int error;
|
|
|
|
xfs_fileoff_t stop_fsb = XFS_B_TO_FSB(mp, offset);
|
|
|
|
xfs_fileoff_t next_fsb = NULLFSBLOCK;
|
|
|
|
xfs_fileoff_t shift_fsb = XFS_B_TO_FSB(mp, len);
|
2017-10-19 18:07:11 +00:00
|
|
|
bool done = false;
|
2017-10-19 18:07:10 +00:00
|
|
|
|
2015-03-25 04:08:56 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
|
2017-10-23 23:32:38 +00:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
|
|
|
|
|
2015-03-25 04:08:56 +00:00
|
|
|
trace_xfs_insert_file_space(ip);
|
|
|
|
|
2018-06-22 06:26:57 +00:00
|
|
|
error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2017-10-19 18:07:10 +00:00
|
|
|
error = xfs_prepare_shift(ip, offset);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2020-02-26 17:43:15 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write,
|
|
|
|
XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
2020-02-26 17:43:16 +00:00
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
2020-02-26 17:43:15 +00:00
|
|
|
|
2021-01-23 00:48:11 +00:00
|
|
|
error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_PUNCH_HOLE_CNT);
|
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
/*
|
|
|
|
* The extent shifting code works on extent granularity. So, if stop_fsb
|
|
|
|
* is not the starting block of extent, we need to split the extent at
|
|
|
|
* stop_fsb.
|
|
|
|
*/
|
2020-02-26 17:43:15 +00:00
|
|
|
error = xfs_bmap_split_extent(tp, ip, stop_fsb);
|
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
do {
|
2020-08-18 15:05:58 +00:00
|
|
|
error = xfs_defer_finish(&tp);
|
2017-10-19 18:07:10 +00:00
|
|
|
if (error)
|
2020-02-26 17:43:16 +00:00
|
|
|
goto out_trans_cancel;
|
2017-10-19 18:07:10 +00:00
|
|
|
|
2017-10-19 18:07:11 +00:00
|
|
|
error = xfs_bmap_insert_extents(tp, ip, &next_fsb, shift_fsb,
|
2018-07-12 05:26:27 +00:00
|
|
|
&done, stop_fsb);
|
2017-10-19 18:07:10 +00:00
|
|
|
if (error)
|
2018-07-24 20:43:13 +00:00
|
|
|
goto out_trans_cancel;
|
2020-02-26 17:43:16 +00:00
|
|
|
} while (!done);
|
2017-10-19 18:07:10 +00:00
|
|
|
|
2020-02-26 17:43:16 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2017-10-19 18:07:10 +00:00
|
|
|
return error;
|
|
|
|
|
2018-07-24 20:43:13 +00:00
|
|
|
out_trans_cancel:
|
2017-10-19 18:07:10 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2020-02-26 17:43:16 +00:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
2017-10-19 18:07:10 +00:00
|
|
|
return error;
|
2015-03-25 04:08:56 +00:00
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:48 +00:00
|
|
|
/*
|
|
|
|
* We need to check that the format of the data fork in the temporary inode is
|
|
|
|
* valid for the target inode before doing the swap. This is not a problem with
|
|
|
|
* attr1 because of the fixed fork offset, but attr2 has a dynamically sized
|
|
|
|
* data fork depending on the space the attribute fork is taking so we can get
|
|
|
|
* invalid formats on the target inode.
|
|
|
|
*
|
|
|
|
* E.g. target has space for 7 extents in extent format, temp inode only has
|
|
|
|
* space for 6. If we defragment down to 7 extents, then the tmp format is a
|
|
|
|
* btree, but when swapped it needs to be in extent format. Hence we can't just
|
|
|
|
* blindly swap data forks on attr2 filesystems.
|
|
|
|
*
|
|
|
|
* Note that we check the swap in both directions so that we don't end up with
|
|
|
|
* a corrupt temporary inode, either.
|
|
|
|
*
|
|
|
|
* Note that fixing the way xfs_fsr sets up the attribute fork in the source
|
|
|
|
* inode will prevent this situation from occurring, so all we do here is
|
|
|
|
* reject and log the attempt. basically we are putting the responsibility on
|
|
|
|
* userspace to get this right.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_swap_extents_check_format(
|
2016-10-03 16:11:52 +00:00
|
|
|
struct xfs_inode *ip, /* target inode */
|
|
|
|
struct xfs_inode *tip) /* tmp inode */
|
2013-08-12 10:49:48 +00:00
|
|
|
{
|
2020-05-18 17:28:05 +00:00
|
|
|
struct xfs_ifork *ifp = &ip->i_df;
|
|
|
|
struct xfs_ifork *tifp = &tip->i_df;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
2020-05-12 23:42:51 +00:00
|
|
|
/* User/group/project quota ids must match if quotas are enforced. */
|
|
|
|
if (XFS_IS_QUOTA_ON(ip->i_mount) &&
|
|
|
|
(!uid_eq(VFS_I(ip)->i_uid, VFS_I(tip)->i_uid) ||
|
|
|
|
!gid_eq(VFS_I(ip)->i_gid, VFS_I(tip)->i_gid) ||
|
2021-03-29 18:11:39 +00:00
|
|
|
ip->i_projid != tip->i_projid))
|
2020-05-12 23:42:51 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-08-12 10:49:48 +00:00
|
|
|
/* Should never get a local format */
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ifp->if_format == XFS_DINODE_FMT_LOCAL ||
|
|
|
|
tifp->if_format == XFS_DINODE_FMT_LOCAL)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if the target inode has less extents that then temporary inode then
|
|
|
|
* why did userspace call us?
|
|
|
|
*/
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ifp->if_nextents < tifp->if_nextents)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
/*
|
|
|
|
* If we have to use the (expensive) rmap swap method, we can
|
|
|
|
* handle any number of extents and any format.
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hasrmapbt(&ip->i_mount->m_sb))
|
|
|
|
return 0;
|
|
|
|
|
2013-08-12 10:49:48 +00:00
|
|
|
/*
|
|
|
|
* if the target inode is in extent form and the temp inode is in btree
|
|
|
|
* form then we will end up with the target inode in the wrong format
|
|
|
|
* as we already know there are less extents in the temp inode.
|
|
|
|
*/
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
|
|
|
|
tifp->if_format == XFS_DINODE_FMT_BTREE)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
/* Check temp in extent form to max in target */
|
2020-05-18 17:28:05 +00:00
|
|
|
if (tifp->if_format == XFS_DINODE_FMT_EXTENTS &&
|
|
|
|
tifp->if_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
/* Check target in extent form to max in temp */
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
|
|
|
|
ifp->if_nextents > XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are in a btree format, check that the temp root block will fit
|
|
|
|
* in the target and that it has enough extents to be in btree format
|
|
|
|
* in the target.
|
|
|
|
*
|
|
|
|
* Note that we have to be careful to allow btree->extent conversions
|
|
|
|
* (a common defrag case) which will occur when the temp inode is in
|
|
|
|
* extent format...
|
|
|
|
*/
|
2020-05-18 17:28:05 +00:00
|
|
|
if (tifp->if_format == XFS_DINODE_FMT_BTREE) {
|
2017-06-15 04:35:34 +00:00
|
|
|
if (XFS_IFORK_Q(ip) &&
|
2020-05-18 17:28:05 +00:00
|
|
|
XFS_BMAP_BMDR_SPACE(tifp->if_broot) > XFS_IFORK_BOFF(ip))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2020-05-18 17:28:05 +00:00
|
|
|
if (tifp->if_nextents <= XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Reciprocal target->temp btree format checks */
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
|
2017-06-15 04:35:34 +00:00
|
|
|
if (XFS_IFORK_Q(tip) &&
|
2013-08-12 10:49:48 +00:00
|
|
|
XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ifp->if_nextents <= XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2013-08-12 10:49:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-23 06:20:11 +00:00
|
|
|
static int
|
2014-08-04 03:44:08 +00:00
|
|
|
xfs_swap_extent_flush(
|
|
|
|
struct xfs_inode *ip)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
truncate_pagecache_range(VFS_I(ip), 0, -1);
|
|
|
|
|
|
|
|
/* Verify O_DIRECT for ftmp */
|
|
|
|
if (VFS_I(ip)->i_mapping->nrpages)
|
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
/*
|
|
|
|
* Move extents from one file to another, when rmap is enabled.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_swap_extent_rmap(
|
|
|
|
struct xfs_trans **tpp,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_inode *tip)
|
|
|
|
{
|
2018-07-12 05:26:17 +00:00
|
|
|
struct xfs_trans *tp = *tpp;
|
2016-10-03 16:11:53 +00:00
|
|
|
struct xfs_bmbt_irec irec;
|
|
|
|
struct xfs_bmbt_irec uirec;
|
|
|
|
struct xfs_bmbt_irec tirec;
|
|
|
|
xfs_fileoff_t offset_fsb;
|
|
|
|
xfs_fileoff_t end_fsb;
|
|
|
|
xfs_filblks_t count_fsb;
|
|
|
|
int error;
|
|
|
|
xfs_filblks_t ilen;
|
|
|
|
xfs_filblks_t rlen;
|
|
|
|
int nimaps;
|
2017-06-16 18:00:05 +00:00
|
|
|
uint64_t tip_flags2;
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the source file has shared blocks, we must flag the donor
|
|
|
|
* file as having shared blocks so that we get the shared-block
|
|
|
|
* rmap functions when we go to fix up the rmaps. The flags
|
|
|
|
* will be switch for reals later.
|
|
|
|
*/
|
2021-03-29 18:11:45 +00:00
|
|
|
tip_flags2 = tip->i_diflags2;
|
|
|
|
if (ip->i_diflags2 & XFS_DIFLAG2_REFLINK)
|
|
|
|
tip->i_diflags2 |= XFS_DIFLAG2_REFLINK;
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
offset_fsb = 0;
|
|
|
|
end_fsb = XFS_B_TO_FSB(ip->i_mount, i_size_read(VFS_I(ip)));
|
|
|
|
count_fsb = (xfs_filblks_t)(end_fsb - offset_fsb);
|
|
|
|
|
|
|
|
while (count_fsb) {
|
|
|
|
/* Read extent from the donor file */
|
|
|
|
nimaps = 1;
|
|
|
|
error = xfs_bmapi_read(tip, offset_fsb, count_fsb, &tirec,
|
|
|
|
&nimaps, 0);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
ASSERT(nimaps == 1);
|
|
|
|
ASSERT(tirec.br_startblock != DELAYSTARTBLOCK);
|
|
|
|
|
|
|
|
trace_xfs_swap_extent_rmap_remap(tip, &tirec);
|
|
|
|
ilen = tirec.br_blockcount;
|
|
|
|
|
|
|
|
/* Unmap the old blocks in the source file. */
|
|
|
|
while (tirec.br_blockcount) {
|
2018-07-24 20:43:13 +00:00
|
|
|
ASSERT(tp->t_firstblock == NULLFSBLOCK);
|
2016-10-03 16:11:53 +00:00
|
|
|
trace_xfs_swap_extent_rmap_remap_piece(tip, &tirec);
|
|
|
|
|
|
|
|
/* Read extent from the source file */
|
|
|
|
nimaps = 1;
|
|
|
|
error = xfs_bmapi_read(ip, tirec.br_startoff,
|
|
|
|
tirec.br_blockcount, &irec,
|
|
|
|
&nimaps, 0);
|
|
|
|
if (error)
|
2018-09-29 03:41:58 +00:00
|
|
|
goto out;
|
2016-10-03 16:11:53 +00:00
|
|
|
ASSERT(nimaps == 1);
|
|
|
|
ASSERT(tirec.br_startoff == irec.br_startoff);
|
|
|
|
trace_xfs_swap_extent_rmap_remap_piece(ip, &irec);
|
|
|
|
|
|
|
|
/* Trim the extent. */
|
|
|
|
uirec = tirec;
|
|
|
|
uirec.br_blockcount = rlen = min_t(xfs_filblks_t,
|
|
|
|
tirec.br_blockcount,
|
|
|
|
irec.br_blockcount);
|
|
|
|
trace_xfs_swap_extent_rmap_remap_piece(tip, &uirec);
|
|
|
|
|
2021-01-23 00:48:15 +00:00
|
|
|
if (xfs_bmap_is_real_extent(&uirec)) {
|
|
|
|
error = xfs_iext_count_may_overflow(ip,
|
|
|
|
XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_SWAP_RMAP_CNT);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xfs_bmap_is_real_extent(&irec)) {
|
|
|
|
error = xfs_iext_count_may_overflow(tip,
|
|
|
|
XFS_DATA_FORK,
|
|
|
|
XFS_IEXT_SWAP_RMAP_CNT);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
/* Remove the mapping from the donor file. */
|
2019-08-27 00:06:04 +00:00
|
|
|
xfs_bmap_unmap_extent(tp, tip, &uirec);
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
/* Remove the mapping from the source file. */
|
2019-08-27 00:06:04 +00:00
|
|
|
xfs_bmap_unmap_extent(tp, ip, &irec);
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
/* Map the donor file's blocks into the source file. */
|
2019-08-27 00:06:04 +00:00
|
|
|
xfs_bmap_map_extent(tp, ip, &uirec);
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
/* Map the source file's blocks into the donor file. */
|
2019-08-27 00:06:04 +00:00
|
|
|
xfs_bmap_map_extent(tp, tip, &irec);
|
2016-10-03 16:11:53 +00:00
|
|
|
|
2018-07-24 20:43:15 +00:00
|
|
|
error = xfs_defer_finish(tpp);
|
2018-07-12 05:26:17 +00:00
|
|
|
tp = *tpp;
|
2016-10-03 16:11:53 +00:00
|
|
|
if (error)
|
2018-08-01 14:20:33 +00:00
|
|
|
goto out;
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
tirec.br_startoff += rlen;
|
|
|
|
if (tirec.br_startblock != HOLESTARTBLOCK &&
|
|
|
|
tirec.br_startblock != DELAYSTARTBLOCK)
|
|
|
|
tirec.br_startblock += rlen;
|
|
|
|
tirec.br_blockcount -= rlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Roll on... */
|
|
|
|
count_fsb -= ilen;
|
|
|
|
offset_fsb += ilen;
|
|
|
|
}
|
|
|
|
|
2021-03-29 18:11:45 +00:00
|
|
|
tip->i_diflags2 = tip_flags2;
|
2016-10-03 16:11:53 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
trace_xfs_swap_extent_rmap_error(ip, error, _RET_IP_);
|
2021-03-29 18:11:45 +00:00
|
|
|
tip->i_diflags2 = tip_flags2;
|
2016-10-03 16:11:53 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
/* Swap the extents of two files by swapping data forks. */
|
|
|
|
STATIC int
|
|
|
|
xfs_swap_extent_forks(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_inode *tip,
|
|
|
|
int *src_log_flags,
|
|
|
|
int *target_log_flags)
|
2013-08-12 10:49:48 +00:00
|
|
|
{
|
2017-06-16 18:00:12 +00:00
|
|
|
xfs_filblks_t aforkblks = 0;
|
|
|
|
xfs_filblks_t taforkblks = 0;
|
|
|
|
xfs_extnum_t junk;
|
2017-06-16 18:00:05 +00:00
|
|
|
uint64_t tmp;
|
2016-10-03 16:11:53 +00:00
|
|
|
int error;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Count the number of extended attribute blocks
|
|
|
|
*/
|
2020-05-18 17:27:22 +00:00
|
|
|
if (XFS_IFORK_Q(ip) && ip->i_afp->if_nextents > 0 &&
|
2020-05-18 17:28:05 +00:00
|
|
|
ip->i_afp->if_format != XFS_DINODE_FMT_LOCAL) {
|
2017-06-16 18:00:12 +00:00
|
|
|
error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &junk,
|
2016-10-03 16:11:53 +00:00
|
|
|
&aforkblks);
|
2013-08-12 10:49:48 +00:00
|
|
|
if (error)
|
2016-10-03 16:11:53 +00:00
|
|
|
return error;
|
2013-08-12 10:49:48 +00:00
|
|
|
}
|
2020-05-18 17:27:22 +00:00
|
|
|
if (XFS_IFORK_Q(tip) && tip->i_afp->if_nextents > 0 &&
|
2020-05-18 17:28:05 +00:00
|
|
|
tip->i_afp->if_format != XFS_DINODE_FMT_LOCAL) {
|
2017-06-16 18:00:12 +00:00
|
|
|
error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK, &junk,
|
2016-10-03 16:11:53 +00:00
|
|
|
&taforkblks);
|
2013-08-12 10:49:48 +00:00
|
|
|
if (error)
|
2016-10-03 16:11:53 +00:00
|
|
|
return error;
|
2013-08-12 10:49:48 +00:00
|
|
|
}
|
|
|
|
|
2013-08-30 00:23:44 +00:00
|
|
|
/*
|
2017-08-29 17:08:39 +00:00
|
|
|
* Btree format (v3) inodes have the inode number stamped in the bmbt
|
|
|
|
* block headers. We can't start changing the bmbt blocks until the
|
|
|
|
* inode owner change is logged so recovery does the right thing in the
|
|
|
|
* event of a crash. Set the owner change log flags now and leave the
|
|
|
|
* bmbt scan as the last step.
|
2013-08-30 00:23:44 +00:00
|
|
|
*/
|
2020-03-18 15:15:11 +00:00
|
|
|
if (xfs_sb_version_has_v3inode(&ip->i_mount->m_sb)) {
|
2020-05-18 17:28:05 +00:00
|
|
|
if (ip->i_df.if_format == XFS_DINODE_FMT_BTREE)
|
2020-03-18 15:15:11 +00:00
|
|
|
(*target_log_flags) |= XFS_ILOG_DOWNER;
|
2020-05-18 17:28:05 +00:00
|
|
|
if (tip->i_df.if_format == XFS_DINODE_FMT_BTREE)
|
2020-03-18 15:15:11 +00:00
|
|
|
(*src_log_flags) |= XFS_ILOG_DOWNER;
|
|
|
|
}
|
2013-08-30 00:23:44 +00:00
|
|
|
|
2013-08-12 10:49:48 +00:00
|
|
|
/*
|
|
|
|
* Swap the data forks of the inodes
|
|
|
|
*/
|
2018-07-12 05:26:38 +00:00
|
|
|
swap(ip->i_df, tip->i_df);
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fix the on-disk inode values
|
|
|
|
*/
|
2021-03-29 18:11:40 +00:00
|
|
|
tmp = (uint64_t)ip->i_nblocks;
|
|
|
|
ip->i_nblocks = tip->i_nblocks - taforkblks + aforkblks;
|
|
|
|
tip->i_nblocks = tmp + taforkblks - aforkblks;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The extents in the source inode could still contain speculative
|
|
|
|
* preallocation beyond EOF (e.g. the file is open but not modified
|
|
|
|
* while defrag is in progress). In that case, we need to copy over the
|
|
|
|
* number of delalloc blocks the data fork in the source inode is
|
|
|
|
* tracking beyond EOF so that when the fork is truncated away when the
|
|
|
|
* temporary inode is unlinked we don't underrun the i_delayed_blks
|
|
|
|
* counter on that inode.
|
|
|
|
*/
|
|
|
|
ASSERT(tip->i_delayed_blks == 0);
|
|
|
|
tip->i_delayed_blks = ip->i_delayed_blks;
|
|
|
|
ip->i_delayed_blks = 0;
|
|
|
|
|
2020-05-18 17:28:05 +00:00
|
|
|
switch (ip->i_df.if_format) {
|
2013-08-12 10:49:48 +00:00
|
|
|
case XFS_DINODE_FMT_EXTENTS:
|
2016-10-03 16:11:53 +00:00
|
|
|
(*src_log_flags) |= XFS_ILOG_DEXT;
|
2013-08-12 10:49:48 +00:00
|
|
|
break;
|
|
|
|
case XFS_DINODE_FMT_BTREE:
|
2020-03-18 15:15:11 +00:00
|
|
|
ASSERT(!xfs_sb_version_has_v3inode(&ip->i_mount->m_sb) ||
|
2016-10-03 16:11:53 +00:00
|
|
|
(*src_log_flags & XFS_ILOG_DOWNER));
|
|
|
|
(*src_log_flags) |= XFS_ILOG_DBROOT;
|
2013-08-12 10:49:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-05-18 17:28:05 +00:00
|
|
|
switch (tip->i_df.if_format) {
|
2013-08-12 10:49:48 +00:00
|
|
|
case XFS_DINODE_FMT_EXTENTS:
|
2016-10-03 16:11:53 +00:00
|
|
|
(*target_log_flags) |= XFS_ILOG_DEXT;
|
2013-08-12 10:49:48 +00:00
|
|
|
break;
|
|
|
|
case XFS_DINODE_FMT_BTREE:
|
2016-10-03 16:11:53 +00:00
|
|
|
(*target_log_flags) |= XFS_ILOG_DBROOT;
|
2020-03-18 15:15:11 +00:00
|
|
|
ASSERT(!xfs_sb_version_has_v3inode(&ip->i_mount->m_sb) ||
|
2016-10-03 16:11:53 +00:00
|
|
|
(*target_log_flags & XFS_ILOG_DOWNER));
|
2013-08-12 10:49:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-08-29 17:08:40 +00:00
|
|
|
/*
|
|
|
|
* Fix up the owners of the bmbt blocks to refer to the current inode. The
|
|
|
|
* change owner scan attempts to order all modified buffers in the current
|
|
|
|
* transaction. In the event of ordered buffer failure, the offending buffer is
|
|
|
|
* physically logged as a fallback and the scan returns -EAGAIN. We must roll
|
|
|
|
* the transaction in this case to replenish the fallback log reservation and
|
|
|
|
* restart the scan. This process repeats until the scan completes.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_swap_change_owner(
|
|
|
|
struct xfs_trans **tpp,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_inode *tmpip)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
struct xfs_trans *tp = *tpp;
|
|
|
|
|
|
|
|
do {
|
|
|
|
error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK, ip->i_ino,
|
|
|
|
NULL);
|
|
|
|
/* success or fatal error */
|
|
|
|
if (error != -EAGAIN)
|
|
|
|
break;
|
|
|
|
|
|
|
|
error = xfs_trans_roll(tpp);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
tp = *tpp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Redirty both inodes so they can relog and keep the log tail
|
|
|
|
* moving forward.
|
|
|
|
*/
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
|
|
|
xfs_trans_ijoin(tp, tmpip, 0);
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
xfs_trans_log_inode(tp, tmpip, XFS_ILOG_CORE);
|
|
|
|
} while (true);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
int
|
|
|
|
xfs_swap_extents(
|
|
|
|
struct xfs_inode *ip, /* target inode */
|
|
|
|
struct xfs_inode *tip, /* tmp inode */
|
|
|
|
struct xfs_swapext *sxp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
struct xfs_bstat *sbp = &sxp->sx_stat;
|
|
|
|
int src_log_flags, target_log_flags;
|
|
|
|
int error = 0;
|
|
|
|
int lock_flags;
|
2017-06-16 18:00:05 +00:00
|
|
|
uint64_t f;
|
2017-08-29 17:08:40 +00:00
|
|
|
int resblks = 0;
|
2020-06-29 21:44:36 +00:00
|
|
|
unsigned int flags = 0;
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock the inodes against other IO, page faults and truncate to
|
|
|
|
* begin with. Then we can ensure the inodes are flushed and have no
|
|
|
|
* page cache safely. Once we have done this we can take the ilocks and
|
|
|
|
* do the rest of the checks.
|
|
|
|
*/
|
2016-11-30 03:33:25 +00:00
|
|
|
lock_two_nondirectories(VFS_I(ip), VFS_I(tip));
|
|
|
|
lock_flags = XFS_MMAPLOCK_EXCL;
|
2018-01-26 23:27:33 +00:00
|
|
|
xfs_lock_two_inodes(ip, XFS_MMAPLOCK_EXCL, tip, XFS_MMAPLOCK_EXCL);
|
2016-10-03 16:11:53 +00:00
|
|
|
|
|
|
|
/* Verify that both files have the same format */
|
|
|
|
if ((VFS_I(ip)->i_mode & S_IFMT) != (VFS_I(tip)->i_mode & S_IFMT)) {
|
|
|
|
error = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify both files are either real-time or non-realtime */
|
|
|
|
if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
|
|
|
|
error = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2019-11-09 20:04:30 +00:00
|
|
|
error = xfs_qm_dqattach(ip);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
error = xfs_qm_dqattach(tip);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
error = xfs_swap_extent_flush(ip);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
error = xfs_swap_extent_flush(tip);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2018-10-18 06:21:55 +00:00
|
|
|
if (xfs_inode_has_cow_data(tip)) {
|
|
|
|
error = xfs_reflink_cancel_cow_range(tip, 0, NULLFILEOFF, true);
|
|
|
|
if (error)
|
2020-05-04 21:06:27 +00:00
|
|
|
goto out_unlock;
|
2018-10-18 06:21:55 +00:00
|
|
|
}
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
/*
|
|
|
|
* Extent "swapping" with rmap requires a permanent reservation and
|
|
|
|
* a block reservation because it's really just a remap operation
|
|
|
|
* performed with log redo items!
|
|
|
|
*/
|
|
|
|
if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
|
2020-05-18 17:27:22 +00:00
|
|
|
int w = XFS_DATA_FORK;
|
|
|
|
uint32_t ipnext = ip->i_df.if_nextents;
|
|
|
|
uint32_t tipnext = tip->i_df.if_nextents;
|
2018-03-09 22:01:58 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Conceptually this shouldn't affect the shape of either bmbt,
|
|
|
|
* but since we atomically move extents one by one, we reserve
|
|
|
|
* enough space to rebuild both trees.
|
|
|
|
*/
|
|
|
|
resblks = XFS_SWAP_RMAP_SPACE_RES(mp, ipnext, w);
|
|
|
|
resblks += XFS_SWAP_RMAP_SPACE_RES(mp, tipnext, w);
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
/*
|
2020-06-29 21:44:36 +00:00
|
|
|
* If either inode straddles a bmapbt block allocation boundary,
|
|
|
|
* the rmapbt algorithm triggers repeated allocs and frees as
|
|
|
|
* extents are remapped. This can exhaust the block reservation
|
|
|
|
* prematurely and cause shutdown. Return freed blocks to the
|
|
|
|
* transaction reservation to counter this behavior.
|
2016-10-03 16:11:53 +00:00
|
|
|
*/
|
2020-06-29 21:44:36 +00:00
|
|
|
flags |= XFS_TRANS_RES_FDBLKS;
|
2017-08-29 17:08:40 +00:00
|
|
|
}
|
2020-06-29 21:44:36 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0, flags,
|
|
|
|
&tp);
|
2016-10-03 16:11:53 +00:00
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock and join the inodes to the tansaction so that transaction commit
|
|
|
|
* or cancel will unlock the inodes from this point onwards.
|
|
|
|
*/
|
2018-01-26 23:27:33 +00:00
|
|
|
xfs_lock_two_inodes(ip, XFS_ILOCK_EXCL, tip, XFS_ILOCK_EXCL);
|
2016-10-03 16:11:53 +00:00
|
|
|
lock_flags |= XFS_ILOCK_EXCL;
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
|
|
|
xfs_trans_ijoin(tp, tip, 0);
|
|
|
|
|
|
|
|
|
|
|
|
/* Verify all data are being swapped */
|
|
|
|
if (sxp->sx_offset != 0 ||
|
2021-03-29 18:11:40 +00:00
|
|
|
sxp->sx_length != ip->i_disk_size ||
|
|
|
|
sxp->sx_length != tip->i_disk_size) {
|
2016-10-03 16:11:53 +00:00
|
|
|
error = -EFAULT;
|
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
|
|
|
|
trace_xfs_swap_extent_before(ip, 0);
|
|
|
|
trace_xfs_swap_extent_before(tip, 1);
|
|
|
|
|
|
|
|
/* check inode formats now that data is flushed */
|
|
|
|
error = xfs_swap_extents_check_format(ip, tip);
|
|
|
|
if (error) {
|
|
|
|
xfs_notice(mp,
|
|
|
|
"%s: inode 0x%llx format is incompatible for exchanging.",
|
|
|
|
__func__, ip->i_ino);
|
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare the current change & modify times with that
|
|
|
|
* passed in. If they differ, we abort this swap.
|
|
|
|
* This is the mechanism used to ensure the calling
|
|
|
|
* process that the file was not changed out from
|
|
|
|
* under it.
|
|
|
|
*/
|
|
|
|
if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
|
|
|
|
(sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
|
|
|
|
(sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
|
|
|
|
(sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
|
|
|
|
error = -EBUSY;
|
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note the trickiness in setting the log flags - we set the owner log
|
|
|
|
* flag on the opposite inode (i.e. the inode we are setting the new
|
|
|
|
* owner to be) because once we swap the forks and log that, log
|
|
|
|
* recovery is going to see the fork as owned by the swapped inode,
|
|
|
|
* not the pre-swapped inodes.
|
|
|
|
*/
|
|
|
|
src_log_flags = XFS_ILOG_CORE;
|
|
|
|
target_log_flags = XFS_ILOG_CORE;
|
|
|
|
|
2016-10-03 16:11:53 +00:00
|
|
|
if (xfs_sb_version_hasrmapbt(&mp->m_sb))
|
|
|
|
error = xfs_swap_extent_rmap(&tp, ip, tip);
|
|
|
|
else
|
|
|
|
error = xfs_swap_extent_forks(tp, ip, tip, &src_log_flags,
|
|
|
|
&target_log_flags);
|
2016-10-03 16:11:53 +00:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
|
2016-10-03 16:11:42 +00:00
|
|
|
/* Do we have to swap reflink flags? */
|
2021-03-29 18:11:45 +00:00
|
|
|
if ((ip->i_diflags2 & XFS_DIFLAG2_REFLINK) ^
|
|
|
|
(tip->i_diflags2 & XFS_DIFLAG2_REFLINK)) {
|
|
|
|
f = ip->i_diflags2 & XFS_DIFLAG2_REFLINK;
|
|
|
|
ip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
|
|
|
|
ip->i_diflags2 |= tip->i_diflags2 & XFS_DIFLAG2_REFLINK;
|
|
|
|
tip->i_diflags2 &= ~XFS_DIFLAG2_REFLINK;
|
|
|
|
tip->i_diflags2 |= f & XFS_DIFLAG2_REFLINK;
|
2017-09-18 16:41:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Swap the cow forks. */
|
|
|
|
if (xfs_sb_version_hasreflink(&mp->m_sb)) {
|
2020-05-18 17:28:05 +00:00
|
|
|
ASSERT(!ip->i_cowfp ||
|
|
|
|
ip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
|
|
|
|
ASSERT(!tip->i_cowfp ||
|
|
|
|
tip->i_cowfp->if_format == XFS_DINODE_FMT_EXTENTS);
|
2017-09-18 16:41:18 +00:00
|
|
|
|
2018-07-12 05:26:38 +00:00
|
|
|
swap(ip->i_cowfp, tip->i_cowfp);
|
2017-09-18 16:41:18 +00:00
|
|
|
|
2018-03-14 06:15:30 +00:00
|
|
|
if (ip->i_cowfp && ip->i_cowfp->if_bytes)
|
2017-09-18 16:41:18 +00:00
|
|
|
xfs_inode_set_cowblocks_tag(ip);
|
|
|
|
else
|
|
|
|
xfs_inode_clear_cowblocks_tag(ip);
|
2018-03-14 06:15:30 +00:00
|
|
|
if (tip->i_cowfp && tip->i_cowfp->if_bytes)
|
2017-09-18 16:41:18 +00:00
|
|
|
xfs_inode_set_cowblocks_tag(tip);
|
|
|
|
else
|
|
|
|
xfs_inode_clear_cowblocks_tag(tip);
|
2016-10-03 16:11:42 +00:00
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:48 +00:00
|
|
|
xfs_trans_log_inode(tp, ip, src_log_flags);
|
|
|
|
xfs_trans_log_inode(tp, tip, target_log_flags);
|
|
|
|
|
2017-08-29 17:08:39 +00:00
|
|
|
/*
|
|
|
|
* The extent forks have been swapped, but crc=1,rmapbt=0 filesystems
|
|
|
|
* have inode number owner values in the bmbt blocks that still refer to
|
|
|
|
* the old inode. Scan each bmbt to fix up the owner values with the
|
|
|
|
* inode number of the current inode.
|
|
|
|
*/
|
|
|
|
if (src_log_flags & XFS_ILOG_DOWNER) {
|
2017-08-29 17:08:40 +00:00
|
|
|
error = xfs_swap_change_owner(&tp, ip, tip);
|
2017-08-29 17:08:39 +00:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
if (target_log_flags & XFS_ILOG_DOWNER) {
|
2017-08-29 17:08:40 +00:00
|
|
|
error = xfs_swap_change_owner(&tp, tip, ip);
|
2017-08-29 17:08:39 +00:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
|
|
|
}
|
|
|
|
|
2013-08-12 10:49:48 +00:00
|
|
|
/*
|
|
|
|
* If this is a synchronous mount, make sure that the
|
|
|
|
* transaction goes to disk before returning to the user.
|
|
|
|
*/
|
|
|
|
if (mp->m_flags & XFS_MOUNT_WSYNC)
|
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
trace_xfs_swap_extent_after(ip, 0);
|
|
|
|
trace_xfs_swap_extent_after(tip, 1);
|
|
|
|
|
2016-11-30 03:33:25 +00:00
|
|
|
out_unlock:
|
2014-08-04 03:29:32 +00:00
|
|
|
xfs_iunlock(ip, lock_flags);
|
|
|
|
xfs_iunlock(tip, lock_flags);
|
2016-11-30 03:33:25 +00:00
|
|
|
unlock_two_nondirectories(VFS_I(ip), VFS_I(tip));
|
2016-10-03 16:11:53 +00:00
|
|
|
return error;
|
2013-08-12 10:49:48 +00:00
|
|
|
|
|
|
|
out_trans_cancel:
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2016-11-30 03:33:25 +00:00
|
|
|
goto out_unlock;
|
2013-08-12 10:49:48 +00:00
|
|
|
}
|