2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-06-08 22:48:12 -06:00
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
2005-11-01 20:58:39 -07:00
|
|
|
* All Rights Reserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 16:20:36 -06:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_fs.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_types.h"
|
|
|
|
#include "xfs_log.h"
|
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_sb.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_ag.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_bmap_btree.h"
|
|
|
|
#include "xfs_dinode.h"
|
|
|
|
#include "xfs_inode.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_inode_item.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_bmap.h"
|
|
|
|
#include "xfs_itable.h"
|
|
|
|
#include "xfs_dfrag.h"
|
|
|
|
#include "xfs_error.h"
|
2007-08-28 18:58:01 -06:00
|
|
|
#include "xfs_vnodeops.h"
|
2009-12-14 16:14:59 -07:00
|
|
|
#include "xfs_trace.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-13 18:33:56 -07:00
|
|
|
|
|
|
|
static int xfs_swap_extents(
|
|
|
|
xfs_inode_t *ip, /* target inode */
|
|
|
|
xfs_inode_t *tip, /* tmp inode */
|
|
|
|
xfs_swapext_t *sxp);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2010-01-13 18:33:56 -07:00
|
|
|
* ioctl interface for swapext
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_swapext(
|
2008-11-25 20:20:06 -07:00
|
|
|
xfs_swapext_t *sxp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-04 18:13:07 -07:00
|
|
|
xfs_inode_t *ip, *tip;
|
2012-08-28 10:52:22 -06:00
|
|
|
struct fd f, tmp;
|
|
|
|
int error = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Pull information for the target fd */
|
2012-08-28 10:52:22 -06:00
|
|
|
f = fdget((int)sxp->sx_fdtarget);
|
|
|
|
if (!f.file) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = XFS_ERROR(EINVAL);
|
2009-01-25 19:53:00 -07:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-08-28 10:52:22 -06:00
|
|
|
if (!(f.file->f_mode & FMODE_WRITE) ||
|
|
|
|
!(f.file->f_mode & FMODE_READ) ||
|
|
|
|
(f.file->f_flags & O_APPEND)) {
|
2008-02-04 18:13:15 -07:00
|
|
|
error = XFS_ERROR(EBADF);
|
|
|
|
goto out_put_file;
|
|
|
|
}
|
|
|
|
|
2012-08-28 10:52:22 -06:00
|
|
|
tmp = fdget((int)sxp->sx_fdtmp);
|
|
|
|
if (!tmp.file) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = XFS_ERROR(EINVAL);
|
2008-02-04 18:13:07 -07:00
|
|
|
goto out_put_file;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-08-28 10:52:22 -06:00
|
|
|
if (!(tmp.file->f_mode & FMODE_WRITE) ||
|
|
|
|
!(tmp.file->f_mode & FMODE_READ) ||
|
|
|
|
(tmp.file->f_flags & O_APPEND)) {
|
2008-02-04 18:13:15 -07:00
|
|
|
error = XFS_ERROR(EBADF);
|
2010-01-13 18:33:56 -07:00
|
|
|
goto out_put_tmp_file;
|
2008-02-04 18:13:15 -07:00
|
|
|
}
|
|
|
|
|
2012-08-28 10:52:22 -06:00
|
|
|
if (IS_SWAPFILE(f.file->f_path.dentry->d_inode) ||
|
|
|
|
IS_SWAPFILE(tmp.file->f_path.dentry->d_inode)) {
|
2009-02-12 11:56:00 -07:00
|
|
|
error = XFS_ERROR(EINVAL);
|
2010-01-13 18:33:56 -07:00
|
|
|
goto out_put_tmp_file;
|
2009-02-12 11:56:00 -07:00
|
|
|
}
|
|
|
|
|
2012-08-28 10:52:22 -06:00
|
|
|
ip = XFS_I(f.file->f_path.dentry->d_inode);
|
|
|
|
tip = XFS_I(tmp.file->f_path.dentry->d_inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (ip->i_mount != tip->i_mount) {
|
2008-02-04 18:13:07 -07:00
|
|
|
error = XFS_ERROR(EINVAL);
|
2010-01-13 18:33:56 -07:00
|
|
|
goto out_put_tmp_file;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ip->i_ino == tip->i_ino) {
|
2008-02-04 18:13:07 -07:00
|
|
|
error = XFS_ERROR(EINVAL);
|
2010-01-13 18:33:56 -07:00
|
|
|
goto out_put_tmp_file;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-04 18:13:07 -07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
|
|
|
|
error = XFS_ERROR(EIO);
|
2010-01-13 18:33:56 -07:00
|
|
|
goto out_put_tmp_file;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-10-11 01:34:33 -06:00
|
|
|
error = xfs_swap_extents(ip, tip, sxp);
|
2006-06-08 22:48:12 -06:00
|
|
|
|
2010-01-13 18:33:56 -07:00
|
|
|
out_put_tmp_file:
|
2012-08-28 10:52:22 -06:00
|
|
|
fdput(tmp);
|
2008-02-04 18:13:07 -07:00
|
|
|
out_put_file:
|
2012-08-28 10:52:22 -06:00
|
|
|
fdput(f);
|
2008-02-04 18:13:07 -07:00
|
|
|
out:
|
2006-06-08 22:48:12 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-01-13 18:33:54 -07: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(
|
|
|
|
xfs_inode_t *ip, /* target inode */
|
|
|
|
xfs_inode_t *tip) /* tmp inode */
|
|
|
|
{
|
|
|
|
|
|
|
|
/* Should never get a local format */
|
|
|
|
if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL ||
|
|
|
|
tip->i_d.di_format == XFS_DINODE_FMT_LOCAL)
|
|
|
|
return EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if the target inode has less extents that then temporary inode then
|
|
|
|
* why did userspace call us?
|
|
|
|
*/
|
|
|
|
if (ip->i_d.di_nextents < tip->i_d.di_nextents)
|
|
|
|
return EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
|
|
|
|
tip->i_d.di_format == XFS_DINODE_FMT_BTREE)
|
|
|
|
return EINVAL;
|
|
|
|
|
|
|
|
/* Check temp in extent form to max in target */
|
|
|
|
if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
|
2011-12-18 13:00:07 -07:00
|
|
|
XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) >
|
|
|
|
XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
|
2010-01-13 18:33:54 -07:00
|
|
|
return EINVAL;
|
|
|
|
|
|
|
|
/* Check target in extent form to max in temp */
|
|
|
|
if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
|
2011-12-18 13:00:07 -07:00
|
|
|
XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) >
|
|
|
|
XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
|
2010-01-13 18:33:54 -07:00
|
|
|
return EINVAL;
|
|
|
|
|
xfs: more swap extent fixes for dynamic fork offsets
A new xfsqa test (226) with a prototype xfs_fsr change to try to
handle dynamic fork offsets better triggers an assertion failure
where the inode data fork is in btree format, yet there is room in
the inode for it to be in extent format. The two inodes look like:
before: ino 0x101 (target), num_extents 11, Max in-fork extents 6, broot size 40, fork offset 96
before: ino 0x115 (temp), num_extents 5, Max in-fork extents 3, broot size 40, fork offset 56
after: ino 0x101 (target), num_extents 5, Max in-fork extents 6, broot size 40, fork offset 96
after: ino 0x115 (temp), num_extents 11, Max in-fork extents 3, broot size 40, fork offset 56
Basically the target inode ends up with 5 extents in btree format,
but it had space for 6 extents in extent format, so ends up
incorrect. Notably here the broot size is the same, and that is
where the kernel code is going wrong - the btree root will fit, so
it lets the swap go ahead.
The check should not allow the swap to take place if the number of
extents while in btree format is less than the number of extents
that can fit in the inode in extent format. Adding that check will
prevent this swap and corruption from occurring.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-04-20 01:00:37 -06: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...
|
|
|
|
*/
|
2011-12-18 13:00:07 -07:00
|
|
|
if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
|
|
|
|
if (XFS_IFORK_BOFF(ip) &&
|
|
|
|
tip->i_df.if_broot_bytes > XFS_IFORK_BOFF(ip))
|
|
|
|
return EINVAL;
|
|
|
|
if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <=
|
|
|
|
XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
|
|
|
|
return EINVAL;
|
|
|
|
}
|
2010-01-13 18:33:54 -07:00
|
|
|
|
xfs: more swap extent fixes for dynamic fork offsets
A new xfsqa test (226) with a prototype xfs_fsr change to try to
handle dynamic fork offsets better triggers an assertion failure
where the inode data fork is in btree format, yet there is room in
the inode for it to be in extent format. The two inodes look like:
before: ino 0x101 (target), num_extents 11, Max in-fork extents 6, broot size 40, fork offset 96
before: ino 0x115 (temp), num_extents 5, Max in-fork extents 3, broot size 40, fork offset 56
after: ino 0x101 (target), num_extents 5, Max in-fork extents 6, broot size 40, fork offset 96
after: ino 0x115 (temp), num_extents 11, Max in-fork extents 3, broot size 40, fork offset 56
Basically the target inode ends up with 5 extents in btree format,
but it had space for 6 extents in extent format, so ends up
incorrect. Notably here the broot size is the same, and that is
where the kernel code is going wrong - the btree root will fit, so
it lets the swap go ahead.
The check should not allow the swap to take place if the number of
extents while in btree format is less than the number of extents
that can fit in the inode in extent format. Adding that check will
prevent this swap and corruption from occurring.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-04-20 01:00:37 -06:00
|
|
|
/* Reciprocal target->temp btree format checks */
|
2011-12-18 13:00:07 -07:00
|
|
|
if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
|
|
|
|
if (XFS_IFORK_BOFF(tip) &&
|
|
|
|
ip->i_df.if_broot_bytes > XFS_IFORK_BOFF(tip))
|
|
|
|
return EINVAL;
|
|
|
|
|
|
|
|
if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <=
|
|
|
|
XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
|
|
|
|
return EINVAL;
|
|
|
|
}
|
2010-01-13 18:33:54 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-13 18:33:56 -07:00
|
|
|
static int
|
2006-06-08 22:48:12 -06:00
|
|
|
xfs_swap_extents(
|
2010-01-13 18:33:54 -07:00
|
|
|
xfs_inode_t *ip, /* target inode */
|
|
|
|
xfs_inode_t *tip, /* tmp inode */
|
2006-06-08 22:48:12 -06:00
|
|
|
xfs_swapext_t *sxp)
|
|
|
|
{
|
2011-04-13 16:03:28 -06:00
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
2006-06-08 22:48:12 -06:00
|
|
|
xfs_trans_t *tp;
|
|
|
|
xfs_bstat_t *sbp = &sxp->sx_stat;
|
|
|
|
xfs_ifork_t *tempifp, *ifp, *tifp;
|
2012-02-29 02:53:54 -07:00
|
|
|
int src_log_flags, target_log_flags;
|
2006-06-08 22:48:12 -06:00
|
|
|
int error = 0;
|
|
|
|
int aforkblks = 0;
|
|
|
|
int taforkblks = 0;
|
|
|
|
__uint64_t tmp;
|
|
|
|
|
|
|
|
tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
|
|
|
|
if (!tempifp) {
|
|
|
|
error = XFS_ERROR(ENOMEM);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out;
|
2006-06-08 22:48:12 -06:00
|
|
|
}
|
|
|
|
|
2008-09-17 00:51:21 -06:00
|
|
|
/*
|
|
|
|
* we have to do two separate lock calls here to keep lockdep
|
|
|
|
* happy. If we try to get all the locks in one call, lock will
|
|
|
|
* report false positives when we drop the ILOCK and regain them
|
|
|
|
* below.
|
|
|
|
*/
|
|
|
|
xfs_lock_two_inodes(ip, tip, XFS_IOLOCK_EXCL);
|
|
|
|
xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Verify that both files have the same format */
|
|
|
|
if ((ip->i_d.di_mode & S_IFMT) != (tip->i_d.di_mode & S_IFMT)) {
|
|
|
|
error = XFS_ERROR(EINVAL);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify both files are either real-time or non-realtime */
|
2007-11-22 22:29:42 -07:00
|
|
|
if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = XFS_ERROR(EINVAL);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-11-12 04:53:57 -07:00
|
|
|
error = -filemap_write_and_wait(VFS_I(ip)->i_mapping);
|
|
|
|
if (error)
|
|
|
|
goto out_unlock;
|
|
|
|
truncate_pagecache_range(VFS_I(ip), 0, -1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Verify O_DIRECT for ftmp */
|
2008-08-13 00:22:09 -06:00
|
|
|
if (VN_CACHED(VFS_I(tip)) != 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = XFS_ERROR(EINVAL);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify all data are being swapped */
|
2005-11-01 16:29:04 -07:00
|
|
|
if (sxp->sx_offset != 0 ||
|
|
|
|
sxp->sx_length != ip->i_d.di_size ||
|
|
|
|
sxp->sx_length != tip->i_d.di_size) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = XFS_ERROR(EFAULT);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-01-13 18:33:55 -07:00
|
|
|
trace_xfs_swap_extent_before(ip, 0);
|
|
|
|
trace_xfs_swap_extent_before(tip, 1);
|
|
|
|
|
2010-01-13 18:33:54 -07:00
|
|
|
/* check inode formats now that data is flushed */
|
|
|
|
error = xfs_swap_extents_check_format(ip, tip);
|
|
|
|
if (error) {
|
2011-03-06 16:05:35 -07:00
|
|
|
xfs_notice(mp,
|
2010-01-13 18:33:54 -07:00
|
|
|
"%s: inode 0x%llx format is incompatible for exchanging.",
|
2011-03-06 16:05:35 -07:00
|
|
|
__func__, ip->i_ino);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2009-10-06 14:29:26 -06:00
|
|
|
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)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = XFS_ERROR(EBUSY);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* We need to fail if the file is memory mapped. Once we have tossed
|
|
|
|
* all existing pages, the page fault will have no option
|
|
|
|
* but to go to the filesystem for pages. By making the page fault call
|
2006-06-09 01:00:52 -06:00
|
|
|
* vop_read (or write in the case of autogrow) they block on the iolock
|
2005-04-16 16:20:36 -06:00
|
|
|
* until we have switched the extents.
|
|
|
|
*/
|
2008-08-13 00:22:09 -06:00
|
|
|
if (VN_MAPPED(VFS_I(ip))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
error = XFS_ERROR(EBUSY);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_iunlock(tip, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There is a race condition here since we gave up the
|
|
|
|
* ilock. However, the data fork will not change since
|
|
|
|
* we have the iolock (locked for truncation too) so we
|
|
|
|
* are safe. We don't really care if non-io related
|
|
|
|
* fields change.
|
|
|
|
*/
|
2012-11-13 23:42:47 -07:00
|
|
|
truncate_pagecache_range(VFS_I(ip), 0, -1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
|
|
|
|
if ((error = xfs_trans_reserve(tp, 0,
|
|
|
|
XFS_ICHANGE_LOG_RES(mp), 0,
|
|
|
|
0, 0))) {
|
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
|
|
|
|
xfs_iunlock(tip, XFS_IOLOCK_EXCL);
|
|
|
|
xfs_trans_cancel(tp, 0);
|
2009-02-04 01:37:43 -07:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-08-13 00:18:07 -06:00
|
|
|
xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Count the number of extended attribute blocks
|
|
|
|
*/
|
|
|
|
if ( ((XFS_IFORK_Q(ip) != 0) && (ip->i_d.di_anextents > 0)) &&
|
|
|
|
(ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
|
|
|
|
error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &aforkblks);
|
2009-02-04 01:37:43 -07:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if ( ((XFS_IFORK_Q(tip) != 0) && (tip->i_d.di_anextents > 0)) &&
|
|
|
|
(tip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
|
|
|
|
error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK,
|
|
|
|
&taforkblks);
|
2009-02-04 01:37:43 -07:00
|
|
|
if (error)
|
|
|
|
goto out_trans_cancel;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Swap the data forks of the inodes
|
|
|
|
*/
|
|
|
|
ifp = &ip->i_df;
|
|
|
|
tifp = &tip->i_df;
|
2005-11-01 16:29:04 -07:00
|
|
|
*tempifp = *ifp; /* struct copy */
|
|
|
|
*ifp = *tifp; /* struct copy */
|
|
|
|
*tifp = *tempifp; /* struct copy */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fix the on-disk inode values
|
|
|
|
*/
|
|
|
|
tmp = (__uint64_t)ip->i_d.di_nblocks;
|
|
|
|
ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks;
|
|
|
|
tip->i_d.di_nblocks = tmp + taforkblks - aforkblks;
|
|
|
|
|
|
|
|
tmp = (__uint64_t) ip->i_d.di_nextents;
|
|
|
|
ip->i_d.di_nextents = tip->i_d.di_nextents;
|
|
|
|
tip->i_d.di_nextents = tmp;
|
|
|
|
|
|
|
|
tmp = (__uint64_t) ip->i_d.di_format;
|
|
|
|
ip->i_d.di_format = tip->i_d.di_format;
|
|
|
|
tip->i_d.di_format = tmp;
|
|
|
|
|
2010-11-29 21:16:02 -07: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;
|
|
|
|
|
2012-02-29 02:53:54 -07:00
|
|
|
src_log_flags = XFS_ILOG_CORE;
|
|
|
|
switch (ip->i_d.di_format) {
|
2005-04-16 16:20:36 -06:00
|
|
|
case XFS_DINODE_FMT_EXTENTS:
|
|
|
|
/* If the extents fit in the inode, fix the
|
|
|
|
* pointer. Otherwise it's already NULL or
|
|
|
|
* pointing to the extent.
|
|
|
|
*/
|
|
|
|
if (ip->i_d.di_nextents <= XFS_INLINE_EXTS) {
|
|
|
|
ifp->if_u1.if_extents =
|
|
|
|
ifp->if_u2.if_inline_ext;
|
|
|
|
}
|
2012-02-29 02:53:54 -07:00
|
|
|
src_log_flags |= XFS_ILOG_DEXT;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case XFS_DINODE_FMT_BTREE:
|
2012-02-29 02:53:54 -07:00
|
|
|
src_log_flags |= XFS_ILOG_DBROOT;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-02-29 02:53:54 -07:00
|
|
|
target_log_flags = XFS_ILOG_CORE;
|
|
|
|
switch (tip->i_d.di_format) {
|
2005-04-16 16:20:36 -06:00
|
|
|
case XFS_DINODE_FMT_EXTENTS:
|
|
|
|
/* If the extents fit in the inode, fix the
|
|
|
|
* pointer. Otherwise it's already NULL or
|
|
|
|
* pointing to the extent.
|
|
|
|
*/
|
|
|
|
if (tip->i_d.di_nextents <= XFS_INLINE_EXTS) {
|
|
|
|
tifp->if_u1.if_extents =
|
|
|
|
tifp->if_u2.if_inline_ext;
|
|
|
|
}
|
2012-02-29 02:53:54 -07:00
|
|
|
target_log_flags |= XFS_ILOG_DEXT;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case XFS_DINODE_FMT_BTREE:
|
2012-02-29 02:53:54 -07:00
|
|
|
target_log_flags |= XFS_ILOG_DBROOT;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-19 09:00:54 -06:00
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-29 02:53:54 -07:00
|
|
|
xfs_trans_log_inode(tp, ip, src_log_flags);
|
|
|
|
xfs_trans_log_inode(tp, tip, target_log_flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a synchronous mount, make sure that the
|
|
|
|
* transaction goes to disk before returning to the user.
|
|
|
|
*/
|
2009-02-04 01:37:43 -07:00
|
|
|
if (mp->m_flags & XFS_MOUNT_WSYNC)
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_trans_set_sync(tp);
|
|
|
|
|
2011-09-26 03:14:34 -06:00
|
|
|
error = xfs_trans_commit(tp, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-13 18:33:55 -07:00
|
|
|
trace_xfs_swap_extent_after(ip, 0);
|
|
|
|
trace_xfs_swap_extent_after(tip, 1);
|
2009-02-04 01:37:43 -07:00
|
|
|
out:
|
|
|
|
kmem_free(tempifp);
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
2009-02-04 01:37:43 -07:00
|
|
|
|
2009-05-07 18:49:45 -06:00
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
|
|
|
|
xfs_iunlock(tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
|
|
|
|
goto out;
|
|
|
|
|
2009-02-04 01:37:43 -07:00
|
|
|
out_trans_cancel:
|
|
|
|
xfs_trans_cancel(tp, 0);
|
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|