2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 20:58:39 -07:00
|
|
|
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
|
|
|
|
* 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"
|
2013-10-29 05:11:58 -06:00
|
|
|
#include "xfs_shared.h"
|
2013-08-12 04:49:26 -06:00
|
|
|
#include "xfs_format.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_bit.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_inode.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_trans.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_inode_item.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_alloc.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_btree.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_bmap_btree.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_bmap.h"
|
|
|
|
#include "xfs_error.h"
|
|
|
|
#include "xfs_quota.h"
|
2012-11-12 04:54:08 -07:00
|
|
|
#include "xfs_trace.h"
|
2013-04-21 13:53:46 -06:00
|
|
|
#include "xfs_cksum.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine the extent state.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
|
|
|
STATIC xfs_exntst_t
|
|
|
|
xfs_extent_state(
|
|
|
|
xfs_filblks_t blks,
|
|
|
|
int extent_flag)
|
|
|
|
{
|
|
|
|
if (extent_flag) {
|
|
|
|
ASSERT(blks != 0); /* saved for DMIG */
|
|
|
|
return XFS_EXT_UNWRITTEN;
|
|
|
|
}
|
|
|
|
return XFS_EXT_NORM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert on-disk form of btree root to in-memory form.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmdr_to_bmbt(
|
2013-04-21 13:53:46 -06:00
|
|
|
struct xfs_inode *ip,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_bmdr_block_t *dblock,
|
|
|
|
int dblocklen,
|
2008-10-30 00:14:34 -06:00
|
|
|
struct xfs_btree_block *rblock,
|
2005-04-16 16:20:36 -06:00
|
|
|
int rblocklen)
|
|
|
|
{
|
2013-04-21 13:53:46 -06:00
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2005-04-16 16:20:36 -06:00
|
|
|
int dmxr;
|
|
|
|
xfs_bmbt_key_t *fkp;
|
2006-09-27 18:58:06 -06:00
|
|
|
__be64 *fpp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_bmbt_key_t *tkp;
|
2006-09-27 18:58:06 -06:00
|
|
|
__be64 *tpp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-04-21 13:53:46 -06:00
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
xfs_btree_init_block_int(mp, rblock, XFS_BUF_DADDR_NULL,
|
|
|
|
XFS_BMAP_CRC_MAGIC, 0, 0, ip->i_ino,
|
|
|
|
XFS_BTREE_LONG_PTRS | XFS_BTREE_CRC_BLOCKS);
|
|
|
|
else
|
|
|
|
xfs_btree_init_block_int(mp, rblock, XFS_BUF_DADDR_NULL,
|
|
|
|
XFS_BMAP_MAGIC, 0, 0, ip->i_ino,
|
|
|
|
XFS_BTREE_LONG_PTRS);
|
|
|
|
|
2005-11-01 21:11:25 -07:00
|
|
|
rblock->bb_level = dblock->bb_level;
|
|
|
|
ASSERT(be16_to_cpu(rblock->bb_level) > 0);
|
|
|
|
rblock->bb_numrecs = dblock->bb_numrecs;
|
2014-04-14 02:58:51 -06:00
|
|
|
dmxr = xfs_bmdr_maxrecs(dblocklen, 0);
|
2008-10-30 00:11:40 -06:00
|
|
|
fkp = XFS_BMDR_KEY_ADDR(dblock, 1);
|
|
|
|
tkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1);
|
|
|
|
fpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr);
|
2008-10-30 00:11:19 -06:00
|
|
|
tpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen);
|
2005-11-01 21:11:25 -07:00
|
|
|
dmxr = be16_to_cpu(dblock->bb_numrecs);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
|
2006-09-27 18:58:06 -06:00
|
|
|
memcpy(tpp, fpp, sizeof(*fpp) * dmxr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert a compressed bmap extent record to an uncompressed form.
|
|
|
|
* This code must be in sync with the routines xfs_bmbt_get_startoff,
|
|
|
|
* xfs_bmbt_get_startblock, xfs_bmbt_get_blockcount and xfs_bmbt_get_state.
|
|
|
|
*/
|
2009-11-14 09:17:22 -07:00
|
|
|
STATIC void
|
2005-04-16 16:20:36 -06:00
|
|
|
__xfs_bmbt_get_all(
|
|
|
|
__uint64_t l0,
|
|
|
|
__uint64_t l1,
|
|
|
|
xfs_bmbt_irec_t *s)
|
|
|
|
{
|
|
|
|
int ext_flag;
|
|
|
|
xfs_exntst_t st;
|
|
|
|
|
|
|
|
ext_flag = (int)(l0 >> (64 - BMBT_EXNTFLAG_BITLEN));
|
|
|
|
s->br_startoff = ((xfs_fileoff_t)l0 &
|
2009-01-08 21:53:54 -07:00
|
|
|
xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
|
|
|
|
s->br_startblock = (((xfs_fsblock_t)l0 & xfs_mask64lo(9)) << 43) |
|
2005-04-16 16:20:36 -06:00
|
|
|
(((xfs_fsblock_t)l1) >> 21);
|
2009-01-08 21:53:54 -07:00
|
|
|
s->br_blockcount = (xfs_filblks_t)(l1 & xfs_mask64lo(21));
|
2005-04-16 16:20:36 -06:00
|
|
|
/* This is xfs_extent_state() in-line */
|
|
|
|
if (ext_flag) {
|
|
|
|
ASSERT(s->br_blockcount != 0); /* saved for DMIG */
|
|
|
|
st = XFS_EXT_UNWRITTEN;
|
|
|
|
} else
|
|
|
|
st = XFS_EXT_NORM;
|
|
|
|
s->br_state = st;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_bmbt_get_all(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_bmbt_irec_t *s)
|
|
|
|
{
|
|
|
|
__xfs_bmbt_get_all(r->l0, r->l1, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract the blockcount field from an in memory bmap extent record.
|
|
|
|
*/
|
|
|
|
xfs_filblks_t
|
|
|
|
xfs_bmbt_get_blockcount(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-01-08 21:53:54 -07:00
|
|
|
return (xfs_filblks_t)(r->l1 & xfs_mask64lo(21));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract the startblock field from an in memory bmap extent record.
|
|
|
|
*/
|
|
|
|
xfs_fsblock_t
|
|
|
|
xfs_bmbt_get_startblock(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-01-08 21:53:54 -07:00
|
|
|
return (((xfs_fsblock_t)r->l0 & xfs_mask64lo(9)) << 43) |
|
2005-04-16 16:20:36 -06:00
|
|
|
(((xfs_fsblock_t)r->l1) >> 21);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract the startoff field from an in memory bmap extent record.
|
|
|
|
*/
|
|
|
|
xfs_fileoff_t
|
|
|
|
xfs_bmbt_get_startoff(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return ((xfs_fileoff_t)r->l0 &
|
2009-01-08 21:53:54 -07:00
|
|
|
xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
xfs_exntst_t
|
|
|
|
xfs_bmbt_get_state(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int ext_flag;
|
|
|
|
|
|
|
|
ext_flag = (int)((r->l0) >> (64 - BMBT_EXNTFLAG_BITLEN));
|
|
|
|
return xfs_extent_state(xfs_bmbt_get_blockcount(r),
|
|
|
|
ext_flag);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract the blockcount field from an on disk bmap extent record.
|
|
|
|
*/
|
|
|
|
xfs_filblks_t
|
|
|
|
xfs_bmbt_disk_get_blockcount(
|
|
|
|
xfs_bmbt_rec_t *r)
|
|
|
|
{
|
2009-01-08 21:53:54 -07:00
|
|
|
return (xfs_filblks_t)(be64_to_cpu(r->l1) & xfs_mask64lo(21));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extract the startoff field from a disk format bmap extent record.
|
|
|
|
*/
|
|
|
|
xfs_fileoff_t
|
|
|
|
xfs_bmbt_disk_get_startoff(
|
|
|
|
xfs_bmbt_rec_t *r)
|
|
|
|
{
|
2007-08-16 00:24:15 -06:00
|
|
|
return ((xfs_fileoff_t)be64_to_cpu(r->l0) &
|
2009-01-08 21:53:54 -07:00
|
|
|
xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set all the fields in a bmap extent record from the arguments.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmbt_set_allf(
|
2007-08-16 00:23:53 -06:00
|
|
|
xfs_bmbt_rec_host_t *r,
|
|
|
|
xfs_fileoff_t startoff,
|
|
|
|
xfs_fsblock_t startblock,
|
|
|
|
xfs_filblks_t blockcount,
|
|
|
|
xfs_exntst_t state)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-08-16 00:23:53 -06:00
|
|
|
int extent_flag = (state == XFS_EXT_NORM) ? 0 : 1;
|
|
|
|
|
|
|
|
ASSERT(state == XFS_EXT_NORM || state == XFS_EXT_UNWRITTEN);
|
2009-01-08 21:53:54 -07:00
|
|
|
ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0);
|
|
|
|
ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-08 21:53:54 -07:00
|
|
|
ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0);
|
2007-08-16 00:23:53 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
|
2007-08-16 00:23:53 -06:00
|
|
|
((xfs_bmbt_rec_base_t)startoff << 9) |
|
|
|
|
((xfs_bmbt_rec_base_t)startblock >> 43);
|
|
|
|
r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) |
|
|
|
|
((xfs_bmbt_rec_base_t)blockcount &
|
2009-01-08 21:53:54 -07:00
|
|
|
(xfs_bmbt_rec_base_t)xfs_mask64lo(21));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set all the fields in a bmap extent record from the uncompressed form.
|
|
|
|
*/
|
|
|
|
void
|
2007-08-16 00:23:53 -06:00
|
|
|
xfs_bmbt_set_all(
|
|
|
|
xfs_bmbt_rec_host_t *r,
|
|
|
|
xfs_bmbt_irec_t *s)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-08-16 00:23:53 -06:00
|
|
|
xfs_bmbt_set_allf(r, s->br_startoff, s->br_startblock,
|
|
|
|
s->br_blockcount, s->br_state);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-08-16 00:23:53 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Set all the fields in a disk format bmap extent record from the arguments.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmbt_disk_set_allf(
|
2007-08-16 00:23:53 -06:00
|
|
|
xfs_bmbt_rec_t *r,
|
|
|
|
xfs_fileoff_t startoff,
|
|
|
|
xfs_fsblock_t startblock,
|
|
|
|
xfs_filblks_t blockcount,
|
|
|
|
xfs_exntst_t state)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-08-16 00:23:53 -06:00
|
|
|
int extent_flag = (state == XFS_EXT_NORM) ? 0 : 1;
|
|
|
|
|
|
|
|
ASSERT(state == XFS_EXT_NORM || state == XFS_EXT_UNWRITTEN);
|
2009-01-08 21:53:54 -07:00
|
|
|
ASSERT((startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)) == 0);
|
|
|
|
ASSERT((blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
|
|
|
|
ASSERT((startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)) == 0);
|
2007-08-16 00:23:53 -06:00
|
|
|
|
2007-08-16 00:24:15 -06:00
|
|
|
r->l0 = cpu_to_be64(
|
2007-08-16 00:23:53 -06:00
|
|
|
((xfs_bmbt_rec_base_t)extent_flag << 63) |
|
|
|
|
((xfs_bmbt_rec_base_t)startoff << 9) |
|
|
|
|
((xfs_bmbt_rec_base_t)startblock >> 43));
|
2007-08-16 00:24:15 -06:00
|
|
|
r->l1 = cpu_to_be64(
|
2007-08-16 00:23:53 -06:00
|
|
|
((xfs_bmbt_rec_base_t)startblock << 21) |
|
|
|
|
((xfs_bmbt_rec_base_t)blockcount &
|
2009-01-08 21:53:54 -07:00
|
|
|
(xfs_bmbt_rec_base_t)xfs_mask64lo(21)));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-08-16 00:23:53 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set all the fields in a bmap extent record from the uncompressed form.
|
|
|
|
*/
|
2009-11-19 08:52:00 -07:00
|
|
|
STATIC void
|
2007-08-16 00:23:53 -06:00
|
|
|
xfs_bmbt_disk_set_all(
|
|
|
|
xfs_bmbt_rec_t *r,
|
|
|
|
xfs_bmbt_irec_t *s)
|
|
|
|
{
|
|
|
|
xfs_bmbt_disk_set_allf(r, s->br_startoff, s->br_startblock,
|
|
|
|
s->br_blockcount, s->br_state);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the blockcount field in a bmap extent record.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmbt_set_blockcount(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_filblks_t v)
|
|
|
|
{
|
2009-01-08 21:53:54 -07:00
|
|
|
ASSERT((v & xfs_mask64hi(43)) == 0);
|
|
|
|
r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64hi(43)) |
|
|
|
|
(xfs_bmbt_rec_base_t)(v & xfs_mask64lo(21));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the startblock field in a bmap extent record.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmbt_set_startblock(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_fsblock_t v)
|
|
|
|
{
|
2009-01-08 21:53:54 -07:00
|
|
|
ASSERT((v & xfs_mask64hi(12)) == 0);
|
|
|
|
r->l0 = (r->l0 & (xfs_bmbt_rec_base_t)xfs_mask64hi(55)) |
|
2005-04-16 16:20:36 -06:00
|
|
|
(xfs_bmbt_rec_base_t)(v >> 43);
|
2009-01-08 21:53:54 -07:00
|
|
|
r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)xfs_mask64lo(21)) |
|
2005-04-16 16:20:36 -06:00
|
|
|
(xfs_bmbt_rec_base_t)(v << 21);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the startoff field in a bmap extent record.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmbt_set_startoff(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_fileoff_t v)
|
|
|
|
{
|
2009-01-08 21:53:54 -07:00
|
|
|
ASSERT((v & xfs_mask64hi(9)) == 0);
|
|
|
|
r->l0 = (r->l0 & (xfs_bmbt_rec_base_t) xfs_mask64hi(1)) |
|
2005-04-16 16:20:36 -06:00
|
|
|
((xfs_bmbt_rec_base_t)v << 9) |
|
2009-01-08 21:53:54 -07:00
|
|
|
(r->l0 & (xfs_bmbt_rec_base_t)xfs_mask64lo(9));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the extent state field in a bmap extent record.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmbt_set_state(
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *r,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_exntst_t v)
|
|
|
|
{
|
|
|
|
ASSERT(v == XFS_EXT_NORM || v == XFS_EXT_UNWRITTEN);
|
|
|
|
if (v == XFS_EXT_NORM)
|
2009-01-08 21:53:54 -07:00
|
|
|
r->l0 &= xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2009-01-08 21:53:54 -07:00
|
|
|
r->l0 |= xfs_mask64hi(BMBT_EXNTFLAG_BITLEN);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert in-memory form of btree root to on-disk form.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_bmbt_to_bmdr(
|
2008-10-30 00:11:19 -06:00
|
|
|
struct xfs_mount *mp,
|
2008-10-30 00:14:34 -06:00
|
|
|
struct xfs_btree_block *rblock,
|
2005-04-16 16:20:36 -06:00
|
|
|
int rblocklen,
|
|
|
|
xfs_bmdr_block_t *dblock,
|
|
|
|
int dblocklen)
|
|
|
|
{
|
|
|
|
int dmxr;
|
|
|
|
xfs_bmbt_key_t *fkp;
|
2006-09-27 18:58:06 -06:00
|
|
|
__be64 *fpp;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_bmbt_key_t *tkp;
|
2006-09-27 18:58:06 -06:00
|
|
|
__be64 *tpp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-04-21 13:53:46 -06:00
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb)) {
|
|
|
|
ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_CRC_MAGIC));
|
|
|
|
ASSERT(uuid_equal(&rblock->bb_u.l.bb_uuid, &mp->m_sb.sb_uuid));
|
|
|
|
ASSERT(rblock->bb_u.l.bb_blkno ==
|
|
|
|
cpu_to_be64(XFS_BUF_DADDR_NULL));
|
|
|
|
} else
|
|
|
|
ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC));
|
2014-07-29 17:12:05 -06:00
|
|
|
ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK));
|
|
|
|
ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK));
|
2011-07-08 06:36:05 -06:00
|
|
|
ASSERT(rblock->bb_level != 0);
|
2005-11-01 21:11:25 -07:00
|
|
|
dblock->bb_level = rblock->bb_level;
|
|
|
|
dblock->bb_numrecs = rblock->bb_numrecs;
|
2014-04-14 02:58:51 -06:00
|
|
|
dmxr = xfs_bmdr_maxrecs(dblocklen, 0);
|
2008-10-30 00:11:40 -06:00
|
|
|
fkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1);
|
|
|
|
tkp = XFS_BMDR_KEY_ADDR(dblock, 1);
|
2008-10-30 00:11:19 -06:00
|
|
|
fpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen);
|
2008-10-30 00:11:40 -06:00
|
|
|
tpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr);
|
2005-11-01 21:11:25 -07:00
|
|
|
dmxr = be16_to_cpu(dblock->bb_numrecs);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
|
2006-09-27 18:58:06 -06:00
|
|
|
memcpy(tpp, fpp, sizeof(*fpp) * dmxr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-03-13 19:29:52 -07:00
|
|
|
* Check extent records, which have just been read, for
|
2005-04-16 16:20:36 -06:00
|
|
|
* any bit in the extent flag field. ASSERT on debug
|
|
|
|
* kernels, as this condition should not occur.
|
|
|
|
* Return an error condition (1) if any flags found,
|
|
|
|
* otherwise return 0.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_check_nostate_extents(
|
2006-03-13 19:29:52 -07:00
|
|
|
xfs_ifork_t *ifp,
|
|
|
|
xfs_extnum_t idx,
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_extnum_t num)
|
|
|
|
{
|
2006-03-13 19:29:52 -07:00
|
|
|
for (; num > 0; num--, idx++) {
|
2007-08-16 00:23:40 -06:00
|
|
|
xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, idx);
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((ep->l0 >>
|
|
|
|
(64 - BMBT_EXNTFLAG_BITLEN)) != 0) {
|
|
|
|
ASSERT(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2008-10-29 23:53:59 -06:00
|
|
|
|
|
|
|
|
|
|
|
STATIC struct xfs_btree_cur *
|
|
|
|
xfs_bmbt_dup_cursor(
|
|
|
|
struct xfs_btree_cur *cur)
|
|
|
|
{
|
|
|
|
struct xfs_btree_cur *new;
|
|
|
|
|
|
|
|
new = xfs_bmbt_init_cursor(cur->bc_mp, cur->bc_tp,
|
|
|
|
cur->bc_private.b.ip, cur->bc_private.b.whichfork);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the firstblock, flist, and flags values,
|
|
|
|
* since init cursor doesn't get them.
|
|
|
|
*/
|
|
|
|
new->bc_private.b.firstblock = cur->bc_private.b.firstblock;
|
|
|
|
new->bc_private.b.flist = cur->bc_private.b.flist;
|
|
|
|
new->bc_private.b.flags = cur->bc_private.b.flags;
|
|
|
|
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
2008-10-29 23:57:40 -06:00
|
|
|
STATIC void
|
|
|
|
xfs_bmbt_update_cursor(
|
|
|
|
struct xfs_btree_cur *src,
|
|
|
|
struct xfs_btree_cur *dst)
|
|
|
|
{
|
|
|
|
ASSERT((dst->bc_private.b.firstblock != NULLFSBLOCK) ||
|
|
|
|
(dst->bc_private.b.ip->i_d.di_flags & XFS_DIFLAG_REALTIME));
|
|
|
|
ASSERT(dst->bc_private.b.flist == src->bc_private.b.flist);
|
|
|
|
|
|
|
|
dst->bc_private.b.allocated += src->bc_private.b.allocated;
|
|
|
|
dst->bc_private.b.firstblock = src->bc_private.b.firstblock;
|
|
|
|
|
|
|
|
src->bc_private.b.allocated = 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 23:57:03 -06:00
|
|
|
STATIC int
|
|
|
|
xfs_bmbt_alloc_block(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
union xfs_btree_ptr *start,
|
|
|
|
union xfs_btree_ptr *new,
|
|
|
|
int *stat)
|
|
|
|
{
|
|
|
|
xfs_alloc_arg_t args; /* block allocation args */
|
|
|
|
int error; /* error return value */
|
|
|
|
|
|
|
|
memset(&args, 0, sizeof(args));
|
|
|
|
args.tp = cur->bc_tp;
|
|
|
|
args.mp = cur->bc_mp;
|
|
|
|
args.fsbno = cur->bc_private.b.firstblock;
|
|
|
|
args.firstblock = args.fsbno;
|
|
|
|
|
|
|
|
if (args.fsbno == NULLFSBLOCK) {
|
|
|
|
args.fsbno = be64_to_cpu(start->l);
|
|
|
|
args.type = XFS_ALLOCTYPE_START_BNO;
|
|
|
|
/*
|
|
|
|
* Make sure there is sufficient room left in the AG to
|
|
|
|
* complete a full tree split for an extent insert. If
|
|
|
|
* we are converting the middle part of an extent then
|
|
|
|
* we may need space for two tree splits.
|
|
|
|
*
|
|
|
|
* We are relying on the caller to make the correct block
|
|
|
|
* reservation for this operation to succeed. If the
|
|
|
|
* reservation amount is insufficient then we may fail a
|
|
|
|
* block allocation here and corrupt the filesystem.
|
|
|
|
*/
|
|
|
|
args.minleft = xfs_trans_get_block_res(args.tp);
|
|
|
|
} else if (cur->bc_private.b.flist->xbf_low) {
|
|
|
|
args.type = XFS_ALLOCTYPE_START_BNO;
|
|
|
|
} else {
|
|
|
|
args.type = XFS_ALLOCTYPE_NEAR_BNO;
|
|
|
|
}
|
|
|
|
|
|
|
|
args.minlen = args.maxlen = args.prod = 1;
|
|
|
|
args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;
|
|
|
|
if (!args.wasdel && xfs_trans_get_block_res(args.tp) == 0) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENOSPC;
|
2008-10-29 23:57:03 -06:00
|
|
|
goto error0;
|
|
|
|
}
|
|
|
|
error = xfs_alloc_vextent(&args);
|
|
|
|
if (error)
|
|
|
|
goto error0;
|
|
|
|
|
|
|
|
if (args.fsbno == NULLFSBLOCK && args.minleft) {
|
|
|
|
/*
|
|
|
|
* Could not find an AG with enough free space to satisfy
|
|
|
|
* a full btree split. Try again without minleft and if
|
|
|
|
* successful activate the lowspace algorithm.
|
|
|
|
*/
|
|
|
|
args.fsbno = 0;
|
|
|
|
args.type = XFS_ALLOCTYPE_FIRST_AG;
|
|
|
|
args.minleft = 0;
|
|
|
|
error = xfs_alloc_vextent(&args);
|
|
|
|
if (error)
|
|
|
|
goto error0;
|
|
|
|
cur->bc_private.b.flist->xbf_low = 1;
|
|
|
|
}
|
|
|
|
if (args.fsbno == NULLFSBLOCK) {
|
|
|
|
XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
|
|
|
|
*stat = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
ASSERT(args.len == 1);
|
|
|
|
cur->bc_private.b.firstblock = args.fsbno;
|
|
|
|
cur->bc_private.b.allocated++;
|
|
|
|
cur->bc_private.b.ip->i_d.di_nblocks++;
|
|
|
|
xfs_trans_log_inode(args.tp, cur->bc_private.b.ip, XFS_ILOG_CORE);
|
2009-06-08 07:33:32 -06:00
|
|
|
xfs_trans_mod_dquot_byino(args.tp, cur->bc_private.b.ip,
|
2008-10-29 23:57:03 -06:00
|
|
|
XFS_TRANS_DQ_BCOUNT, 1L);
|
|
|
|
|
|
|
|
new->l = cpu_to_be64(args.fsbno);
|
|
|
|
|
|
|
|
XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
|
|
|
|
*stat = 1;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error0:
|
|
|
|
XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-10-29 23:57:51 -06:00
|
|
|
STATIC int
|
|
|
|
xfs_bmbt_free_block(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = cur->bc_mp;
|
|
|
|
struct xfs_inode *ip = cur->bc_private.b.ip;
|
|
|
|
struct xfs_trans *tp = cur->bc_tp;
|
|
|
|
xfs_fsblock_t fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp));
|
|
|
|
|
|
|
|
xfs_bmap_add_free(fsbno, 1, cur->bc_private.b.flist, mp);
|
|
|
|
ip->i_d.di_nblocks--;
|
|
|
|
|
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
2009-06-08 07:33:32 -06:00
|
|
|
xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
|
2008-10-29 23:57:51 -06:00
|
|
|
xfs_trans_binval(tp, bp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 23:58:01 -06:00
|
|
|
STATIC int
|
|
|
|
xfs_bmbt_get_minrecs(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
int level)
|
|
|
|
{
|
2008-10-30 00:11:19 -06:00
|
|
|
if (level == cur->bc_nlevels - 1) {
|
|
|
|
struct xfs_ifork *ifp;
|
|
|
|
|
|
|
|
ifp = XFS_IFORK_PTR(cur->bc_private.b.ip,
|
|
|
|
cur->bc_private.b.whichfork);
|
|
|
|
|
|
|
|
return xfs_bmbt_maxrecs(cur->bc_mp,
|
|
|
|
ifp->if_broot_bytes, level == 0) / 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cur->bc_mp->m_bmap_dmnr[level != 0];
|
2008-10-29 23:58:01 -06:00
|
|
|
}
|
|
|
|
|
2008-10-30 00:11:19 -06:00
|
|
|
int
|
2008-10-29 23:55:23 -06:00
|
|
|
xfs_bmbt_get_maxrecs(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
int level)
|
|
|
|
{
|
2008-10-30 00:11:19 -06:00
|
|
|
if (level == cur->bc_nlevels - 1) {
|
|
|
|
struct xfs_ifork *ifp;
|
|
|
|
|
|
|
|
ifp = XFS_IFORK_PTR(cur->bc_private.b.ip,
|
|
|
|
cur->bc_private.b.whichfork);
|
|
|
|
|
|
|
|
return xfs_bmbt_maxrecs(cur->bc_mp,
|
|
|
|
ifp->if_broot_bytes, level == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cur->bc_mp->m_bmap_dmxr[level != 0];
|
|
|
|
|
2008-10-29 23:55:23 -06:00
|
|
|
}
|
|
|
|
|
2008-10-29 23:57:40 -06:00
|
|
|
/*
|
|
|
|
* Get the maximum records we could store in the on-disk format.
|
|
|
|
*
|
|
|
|
* For non-root nodes this is equivalent to xfs_bmbt_get_maxrecs, but
|
|
|
|
* for the root node this checks the available space in the dinode fork
|
|
|
|
* so that we can resize the in-memory buffer to match it. After a
|
|
|
|
* resize to the maximum size this function returns the same value
|
|
|
|
* as xfs_bmbt_get_maxrecs for the root node, too.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_bmbt_get_dmaxrecs(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
int level)
|
|
|
|
{
|
2008-10-30 00:11:19 -06:00
|
|
|
if (level != cur->bc_nlevels - 1)
|
|
|
|
return cur->bc_mp->m_bmap_dmxr[level != 0];
|
2014-04-14 02:58:51 -06:00
|
|
|
return xfs_bmdr_maxrecs(cur->bc_private.b.forksize, level == 0);
|
2008-10-29 23:57:40 -06:00
|
|
|
}
|
|
|
|
|
2008-10-29 23:56:09 -06:00
|
|
|
STATIC void
|
|
|
|
xfs_bmbt_init_key_from_rec(
|
|
|
|
union xfs_btree_key *key,
|
|
|
|
union xfs_btree_rec *rec)
|
|
|
|
{
|
|
|
|
key->bmbt.br_startoff =
|
|
|
|
cpu_to_be64(xfs_bmbt_disk_get_startoff(&rec->bmbt));
|
|
|
|
}
|
|
|
|
|
2008-10-29 23:57:40 -06:00
|
|
|
STATIC void
|
|
|
|
xfs_bmbt_init_rec_from_key(
|
|
|
|
union xfs_btree_key *key,
|
|
|
|
union xfs_btree_rec *rec)
|
|
|
|
{
|
|
|
|
ASSERT(key->bmbt.br_startoff != 0);
|
|
|
|
|
|
|
|
xfs_bmbt_disk_set_allf(&rec->bmbt, be64_to_cpu(key->bmbt.br_startoff),
|
|
|
|
0, 0, XFS_EXT_NORM);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xfs_bmbt_init_rec_from_cur(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
union xfs_btree_rec *rec)
|
|
|
|
{
|
|
|
|
xfs_bmbt_disk_set_all(&rec->bmbt, &cur->bc_rec.b);
|
|
|
|
}
|
|
|
|
|
2008-10-29 23:56:09 -06:00
|
|
|
STATIC void
|
|
|
|
xfs_bmbt_init_ptr_from_cur(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
union xfs_btree_ptr *ptr)
|
|
|
|
{
|
|
|
|
ptr->l = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC __int64_t
|
|
|
|
xfs_bmbt_key_diff(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
union xfs_btree_key *key)
|
|
|
|
{
|
|
|
|
return (__int64_t)be64_to_cpu(key->bmbt.br_startoff) -
|
|
|
|
cur->bc_rec.b.br_startoff;
|
|
|
|
}
|
|
|
|
|
2013-08-12 04:49:43 -06:00
|
|
|
static bool
|
2012-11-13 23:52:32 -07:00
|
|
|
xfs_bmbt_verify(
|
2012-11-12 04:54:08 -07:00
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = bp->b_target->bt_mount;
|
|
|
|
struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp);
|
|
|
|
unsigned int level;
|
|
|
|
|
2013-04-21 13:53:46 -06:00
|
|
|
switch (block->bb_magic) {
|
|
|
|
case cpu_to_be32(XFS_BMAP_CRC_MAGIC):
|
|
|
|
if (!xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
return false;
|
|
|
|
if (!uuid_equal(&block->bb_u.l.bb_uuid, &mp->m_sb.sb_uuid))
|
|
|
|
return false;
|
|
|
|
if (be64_to_cpu(block->bb_u.l.bb_blkno) != bp->b_bn)
|
|
|
|
return false;
|
|
|
|
/*
|
|
|
|
* XXX: need a better way of verifying the owner here. Right now
|
|
|
|
* just make sure there has been one set.
|
|
|
|
*/
|
|
|
|
if (be64_to_cpu(block->bb_u.l.bb_owner) == 0)
|
|
|
|
return false;
|
|
|
|
/* fall through */
|
|
|
|
case cpu_to_be32(XFS_BMAP_MAGIC):
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* numrecs and level verification.
|
2012-11-12 04:54:08 -07:00
|
|
|
*
|
2013-04-21 13:53:46 -06:00
|
|
|
* We don't know what fork we belong to, so just verify that the level
|
2012-11-12 04:54:08 -07:00
|
|
|
* is less than the maximum of the two. Later checks will be more
|
|
|
|
* precise.
|
|
|
|
*/
|
|
|
|
level = be16_to_cpu(block->bb_level);
|
2013-04-21 13:53:46 -06:00
|
|
|
if (level > max(mp->m_bm_maxlevels[0], mp->m_bm_maxlevels[1]))
|
|
|
|
return false;
|
|
|
|
if (be16_to_cpu(block->bb_numrecs) > mp->m_bmap_dmxr[level != 0])
|
|
|
|
return false;
|
2012-11-12 04:54:08 -07:00
|
|
|
|
|
|
|
/* sibling pointer verification */
|
2013-04-21 13:53:46 -06:00
|
|
|
if (!block->bb_u.l.bb_leftsib ||
|
2014-07-29 17:12:05 -06:00
|
|
|
(block->bb_u.l.bb_leftsib != cpu_to_be64(NULLFSBLOCK) &&
|
2013-04-21 13:53:46 -06:00
|
|
|
!XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_leftsib))))
|
|
|
|
return false;
|
|
|
|
if (!block->bb_u.l.bb_rightsib ||
|
2014-07-29 17:12:05 -06:00
|
|
|
(block->bb_u.l.bb_rightsib != cpu_to_be64(NULLFSBLOCK) &&
|
2013-04-21 13:53:46 -06:00
|
|
|
!XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_u.l.bb_rightsib))))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
2012-11-13 23:52:32 -07:00
|
|
|
}
|
2012-11-12 04:54:08 -07:00
|
|
|
|
2012-11-13 23:54:40 -07:00
|
|
|
static void
|
|
|
|
xfs_bmbt_read_verify(
|
2012-11-13 23:52:32 -07:00
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2014-02-26 21:23:10 -07:00
|
|
|
if (!xfs_btree_lblock_verify_crc(bp))
|
2014-06-24 22:58:08 -06:00
|
|
|
xfs_buf_ioerror(bp, -EFSBADCRC);
|
2014-02-26 21:23:10 -07:00
|
|
|
else if (!xfs_bmbt_verify(bp))
|
2014-06-24 22:58:08 -06:00
|
|
|
xfs_buf_ioerror(bp, -EFSCORRUPTED);
|
2014-02-26 21:23:10 -07:00
|
|
|
|
|
|
|
if (bp->b_error) {
|
|
|
|
trace_xfs_btree_corrupt(bp, _RET_IP_);
|
|
|
|
xfs_verifier_error(bp);
|
2013-04-21 13:53:46 -06:00
|
|
|
}
|
2012-11-13 23:52:32 -07:00
|
|
|
}
|
|
|
|
|
2012-11-13 23:54:40 -07:00
|
|
|
static void
|
|
|
|
xfs_bmbt_write_verify(
|
2012-11-13 23:52:32 -07:00
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2013-04-21 13:53:46 -06:00
|
|
|
if (!xfs_bmbt_verify(bp)) {
|
|
|
|
trace_xfs_btree_corrupt(bp, _RET_IP_);
|
2014-06-24 22:58:08 -06:00
|
|
|
xfs_buf_ioerror(bp, -EFSCORRUPTED);
|
2014-02-26 21:23:10 -07:00
|
|
|
xfs_verifier_error(bp);
|
2013-04-21 13:53:46 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
xfs_btree_lblock_calc_crc(bp);
|
2012-11-12 04:54:08 -07:00
|
|
|
}
|
|
|
|
|
2012-11-13 23:54:40 -07:00
|
|
|
const struct xfs_buf_ops xfs_bmbt_buf_ops = {
|
|
|
|
.verify_read = xfs_bmbt_read_verify,
|
|
|
|
.verify_write = xfs_bmbt_write_verify,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2013-04-30 05:39:34 -06:00
|
|
|
#if defined(DEBUG) || defined(XFS_WARN)
|
2008-10-29 23:58:32 -06:00
|
|
|
STATIC int
|
|
|
|
xfs_bmbt_keys_inorder(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
union xfs_btree_key *k1,
|
|
|
|
union xfs_btree_key *k2)
|
|
|
|
{
|
|
|
|
return be64_to_cpu(k1->bmbt.br_startoff) <
|
|
|
|
be64_to_cpu(k2->bmbt.br_startoff);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xfs_bmbt_recs_inorder(
|
|
|
|
struct xfs_btree_cur *cur,
|
|
|
|
union xfs_btree_rec *r1,
|
|
|
|
union xfs_btree_rec *r2)
|
|
|
|
{
|
|
|
|
return xfs_bmbt_disk_get_startoff(&r1->bmbt) +
|
|
|
|
xfs_bmbt_disk_get_blockcount(&r1->bmbt) <=
|
|
|
|
xfs_bmbt_disk_get_startoff(&r2->bmbt);
|
|
|
|
}
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
2008-10-29 23:53:59 -06:00
|
|
|
static const struct xfs_btree_ops xfs_bmbt_ops = {
|
2008-10-29 23:55:34 -06:00
|
|
|
.rec_len = sizeof(xfs_bmbt_rec_t),
|
|
|
|
.key_len = sizeof(xfs_bmbt_key_t),
|
|
|
|
|
2008-10-29 23:53:59 -06:00
|
|
|
.dup_cursor = xfs_bmbt_dup_cursor,
|
2008-10-29 23:57:40 -06:00
|
|
|
.update_cursor = xfs_bmbt_update_cursor,
|
2008-10-29 23:57:03 -06:00
|
|
|
.alloc_block = xfs_bmbt_alloc_block,
|
2008-10-29 23:57:51 -06:00
|
|
|
.free_block = xfs_bmbt_free_block,
|
2008-10-29 23:55:23 -06:00
|
|
|
.get_maxrecs = xfs_bmbt_get_maxrecs,
|
2008-10-29 23:58:01 -06:00
|
|
|
.get_minrecs = xfs_bmbt_get_minrecs,
|
2008-10-29 23:57:40 -06:00
|
|
|
.get_dmaxrecs = xfs_bmbt_get_dmaxrecs,
|
2008-10-29 23:56:09 -06:00
|
|
|
.init_key_from_rec = xfs_bmbt_init_key_from_rec,
|
2008-10-29 23:57:40 -06:00
|
|
|
.init_rec_from_key = xfs_bmbt_init_rec_from_key,
|
|
|
|
.init_rec_from_cur = xfs_bmbt_init_rec_from_cur,
|
2008-10-29 23:56:09 -06:00
|
|
|
.init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur,
|
|
|
|
.key_diff = xfs_bmbt_key_diff,
|
2012-11-13 23:54:40 -07:00
|
|
|
.buf_ops = &xfs_bmbt_buf_ops,
|
2013-04-30 05:39:34 -06:00
|
|
|
#if defined(DEBUG) || defined(XFS_WARN)
|
2008-10-29 23:58:32 -06:00
|
|
|
.keys_inorder = xfs_bmbt_keys_inorder,
|
|
|
|
.recs_inorder = xfs_bmbt_recs_inorder,
|
|
|
|
#endif
|
2008-10-29 23:53:59 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a new bmap btree cursor.
|
|
|
|
*/
|
|
|
|
struct xfs_btree_cur * /* new bmap btree cursor */
|
|
|
|
xfs_bmbt_init_cursor(
|
|
|
|
struct xfs_mount *mp, /* file system mount point */
|
|
|
|
struct xfs_trans *tp, /* transaction pointer */
|
|
|
|
struct xfs_inode *ip, /* inode owning the btree */
|
|
|
|
int whichfork) /* data or attr fork */
|
|
|
|
{
|
|
|
|
struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
|
|
|
|
struct xfs_btree_cur *cur;
|
|
|
|
|
|
|
|
cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
|
|
|
|
|
|
|
|
cur->bc_tp = tp;
|
|
|
|
cur->bc_mp = mp;
|
|
|
|
cur->bc_nlevels = be16_to_cpu(ifp->if_broot->bb_level) + 1;
|
|
|
|
cur->bc_btnum = XFS_BTNUM_BMAP;
|
|
|
|
cur->bc_blocklog = mp->m_sb.sb_blocklog;
|
|
|
|
|
|
|
|
cur->bc_ops = &xfs_bmbt_ops;
|
2008-10-29 23:54:33 -06:00
|
|
|
cur->bc_flags = XFS_BTREE_LONG_PTRS | XFS_BTREE_ROOT_IN_INODE;
|
2013-04-21 13:53:46 -06:00
|
|
|
if (xfs_sb_version_hascrc(&mp->m_sb))
|
|
|
|
cur->bc_flags |= XFS_BTREE_CRC_BLOCKS;
|
2008-10-29 23:53:59 -06:00
|
|
|
|
|
|
|
cur->bc_private.b.forksize = XFS_IFORK_SIZE(ip, whichfork);
|
|
|
|
cur->bc_private.b.ip = ip;
|
|
|
|
cur->bc_private.b.firstblock = NULLFSBLOCK;
|
|
|
|
cur->bc_private.b.flist = NULL;
|
|
|
|
cur->bc_private.b.allocated = 0;
|
|
|
|
cur->bc_private.b.flags = 0;
|
|
|
|
cur->bc_private.b.whichfork = whichfork;
|
|
|
|
|
|
|
|
return cur;
|
|
|
|
}
|
2008-10-30 00:11:19 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate number of records in a bmap btree block.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_bmbt_maxrecs(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int blocklen,
|
|
|
|
int leaf)
|
|
|
|
{
|
2008-10-30 00:14:34 -06:00
|
|
|
blocklen -= XFS_BMBT_BLOCK_LEN(mp);
|
2008-10-30 00:11:19 -06:00
|
|
|
|
|
|
|
if (leaf)
|
|
|
|
return blocklen / sizeof(xfs_bmbt_rec_t);
|
|
|
|
return blocklen / (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate number of records in a bmap btree inode root.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_bmdr_maxrecs(
|
|
|
|
int blocklen,
|
|
|
|
int leaf)
|
|
|
|
{
|
|
|
|
blocklen -= sizeof(xfs_bmdr_block_t);
|
|
|
|
|
|
|
|
if (leaf)
|
|
|
|
return blocklen / sizeof(xfs_bmdr_rec_t);
|
|
|
|
return blocklen / (sizeof(xfs_bmdr_key_t) + sizeof(xfs_bmdr_ptr_t));
|
|
|
|
}
|
2013-08-29 18:23:44 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Change the owner of a btree format fork fo the inode passed in. Change it to
|
|
|
|
* the owner of that is passed in so that we can change owners before or after
|
|
|
|
* we switch forks between inodes. The operation that the caller is doing will
|
|
|
|
* determine whether is needs to change owner before or after the switch.
|
|
|
|
*
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
* For demand paged transactional modification, the fork switch should be done
|
|
|
|
* after reading in all the blocks, modifying them and pinning them in the
|
|
|
|
* transaction. For modification when the buffers are already pinned in memory,
|
|
|
|
* the fork switch can be done before changing the owner as we won't need to
|
|
|
|
* validate the owner until the btree buffers are unpinned and writes can occur
|
|
|
|
* again.
|
|
|
|
*
|
|
|
|
* For recovery based ownership change, there is no transactional context and
|
|
|
|
* so a buffer list must be supplied so that we can record the buffers that we
|
|
|
|
* modified for the caller to issue IO on.
|
2013-08-29 18:23:44 -06:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_bmbt_change_owner(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
int whichfork,
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
xfs_ino_t new_owner,
|
|
|
|
struct list_head *buffer_list)
|
2013-08-29 18:23:44 -06:00
|
|
|
{
|
|
|
|
struct xfs_btree_cur *cur;
|
|
|
|
int error;
|
|
|
|
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
ASSERT(tp || buffer_list);
|
|
|
|
ASSERT(!(tp && buffer_list));
|
2013-08-29 18:23:44 -06:00
|
|
|
if (whichfork == XFS_DATA_FORK)
|
2013-09-11 15:17:31 -06:00
|
|
|
ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_BTREE);
|
2013-08-29 18:23:44 -06:00
|
|
|
else
|
2013-09-11 15:17:31 -06:00
|
|
|
ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE);
|
2013-08-29 18:23:44 -06:00
|
|
|
|
|
|
|
cur = xfs_bmbt_init_cursor(ip->i_mount, tp, ip, whichfork);
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
if (!cur)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
xfs: recovery of swap extents operations for CRC filesystems
This is the recovery side of the btree block owner change operation
performed by swapext on CRC enabled filesystems. We detect that an
owner change is needed by the flag that has been placed on the inode
log format flag field. Because the inode recovery is being replayed
after the buffers that make up the BMBT in the given checkpoint, we
can walk all the buffers and directly modify them when we see the
flag set on an inode.
Because the inode can be relogged and hence present in multiple
chekpoints with the "change owner" flag set, we could do multiple
passes across the inode to do this change. While this isn't optimal,
we can't directly ignore the flag as there may be multiple
independent swap extent operations being replayed on the same inode
in different checkpoints so we can't ignore them.
Further, because the owner change operation uses ordered buffers, we
might have buffers that are newer on disk than the current
checkpoint and so already have the owner changed in them. Hence we
cannot just peek at a buffer in the tree and check that it has the
correct owner and assume that the change was completed.
So, for the moment just brute force the owner change every time we
see an inode with the flag set. Note that we have to be careful here
because the owner of the buffers may point to either the old owner
or the new owner. Currently the verifier can't verify the owner
directly, so there is no failure case here right now. If we verify
the owner exactly in future, then we'll have to take this into
account.
This was tested in terms of normal operation via xfstests - all of
the fsr tests now pass without failure. however, we really need to
modify xfs/227 to stress v3 inodes correctly to ensure we fully
cover this case for v5 filesystems.
In terms of recovery testing, I used a hacked version of xfs_fsr
that held the temp inode open for a few seconds before exiting so
that the filesystem could be shut down with an open owner change
recovery flags set on at least the temp inode. fsr leaves the temp
inode unlinked and in btree format, so this was necessary for the
owner change to be reliably replayed.
logprint confirmed the tmp inode in the log had the correct flag set:
INO: cnt:3 total:3 a:0x69e9e0 len:56 a:0x69ea20 len:176 a:0x69eae0 len:88
INODE: #regs:3 ino:0x44 flags:0x209 dsize:88
^^^^^
0x200 is set, indicating a data fork owner change needed to be
replayed on inode 0x44. A printk in the revoery code confirmed that
the inode change was recovered:
XFS (vdc): Mounting Filesystem
XFS (vdc): Starting recovery (logdev: internal)
recovering owner change ino 0x44
XFS (vdc): Version 5 superblock detected. This kernel L support enabled!
Use of these features in this kernel is at your own risk!
XFS (vdc): Ending recovery (logdev: internal)
The script used to test this was:
$ cat ./recovery-fsr.sh
#!/bin/bash
dev=/dev/vdc
mntpt=/mnt/scratch
testfile=$mntpt/testfile
umount $mntpt
mkfs.xfs -f -m crc=1 $dev
mount $dev $mntpt
chmod 777 $mntpt
for i in `seq 10000 -1 0`; do
xfs_io -f -d -c "pwrite $(($i * 4096)) 4096" $testfile > /dev/null 2>&1
done
xfs_bmap -vp $testfile |head -20
xfs_fsr -d -v $testfile &
sleep 10
/home/dave/src/xfstests-dev/src/godown -f $mntpt
wait
umount $mntpt
xfs_logprint -t $dev |tail -20
time mount $dev $mntpt
xfs_bmap -vp $testfile
umount $mntpt
$
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-08-29 18:23:45 -06:00
|
|
|
|
|
|
|
error = xfs_btree_change_owner(cur, new_owner, buffer_list);
|
2013-08-29 18:23:44 -06:00
|
|
|
xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
|
|
|
|
return error;
|
|
|
|
}
|