240 lines
6.1 KiB
C
240 lines
6.1 KiB
C
|
/*
|
||
|
|
* Copyright (c) 2000,2005 Silicon Graphics, Inc.
|
||
|
|
* All Rights Reserved.
|
||
|
|
*
|
||
|
|
* This program is free software; you can redistribute it and/or
|
||
|
|
* modify it under the terms of the GNU General Public License as
|
||
|
|
* published by the Free Software Foundation.
|
||
|
|
*
|
||
|
|
* 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.
|
||
|
|
*
|
||
|
|
* 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
|
||
|
|
*/
|
||
|
|
#include "xfs.h"
|
||
|
|
#include "xfs_fs.h"
|
||
|
|
#include "xfs_shared.h"
|
||
|
|
#include "xfs_format.h"
|
||
|
|
#include "xfs_log_format.h"
|
||
|
|
#include "xfs_trans_resv.h"
|
||
|
|
#include "xfs_bit.h"
|
||
|
|
#include "xfs_mount.h"
|
||
|
|
#include "xfs_defer.h"
|
||
|
|
#include "xfs_trans.h"
|
||
|
|
#include "xfs_trans_priv.h"
|
||
|
|
#include "xfs_extfree_item.h"
|
||
|
|
#include "xfs_alloc.h"
|
||
|
|
#include "xfs_bmap.h"
|
||
|
|
#include "xfs_trace.h"
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This routine is called to allocate an "extent free done"
|
||
|
|
* log item that will hold nextents worth of extents. The
|
||
|
|
* caller must use all nextents extents, because we are not
|
||
|
|
* flexible about this at all.
|
||
|
|
*/
|
||
|
|
struct xfs_efd_log_item *
|
||
|
|
xfs_trans_get_efd(struct xfs_trans *tp,
|
||
|
|
struct xfs_efi_log_item *efip,
|
||
|
|
uint nextents)
|
||
|
|
{
|
||
|
|
struct xfs_efd_log_item *efdp;
|
||
|
|
|
||
|
|
ASSERT(tp != NULL);
|
||
|
|
ASSERT(nextents > 0);
|
||
|
|
|
||
|
|
efdp = xfs_efd_init(tp->t_mountp, efip, nextents);
|
||
|
|
ASSERT(efdp != NULL);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Get a log_item_desc to point at the new item.
|
||
|
|
*/
|
||
|
|
xfs_trans_add_item(tp, &efdp->efd_item);
|
||
|
|
return efdp;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Free an extent and log it to the EFD. Note that the transaction is marked
|
||
|
|
* dirty regardless of whether the extent free succeeds or fails to support the
|
||
|
|
* EFI/EFD lifecycle rules.
|
||
|
|
*/
|
||
|
|
int
|
||
|
|
xfs_trans_free_extent(
|
||
|
|
struct xfs_trans *tp,
|
||
|
|
struct xfs_efd_log_item *efdp,
|
||
|
|
xfs_fsblock_t start_block,
|
||
|
|
xfs_extlen_t ext_len,
|
||
|
|
struct xfs_owner_info *oinfo)
|
||
|
|
{
|
||
|
|
struct xfs_mount *mp = tp->t_mountp;
|
||
|
|
uint next_extent;
|
||
|
|
xfs_agnumber_t agno = XFS_FSB_TO_AGNO(mp, start_block);
|
||
|
|
xfs_agblock_t agbno = XFS_FSB_TO_AGBNO(mp, start_block);
|
||
|
|
struct xfs_extent *extp;
|
||
|
|
int error;
|
||
|
|
|
||
|
|
trace_xfs_bmap_free_deferred(tp->t_mountp, agno, 0, agbno, ext_len);
|
||
|
|
|
||
|
|
error = xfs_free_extent(tp, start_block, ext_len, oinfo,
|
||
|
|
XFS_AG_RESV_NONE);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Mark the transaction dirty, even on error. This ensures the
|
||
|
|
* transaction is aborted, which:
|
||
|
|
*
|
||
|
|
* 1.) releases the EFI and frees the EFD
|
||
|
|
* 2.) shuts down the filesystem
|
||
|
|
*/
|
||
|
|
tp->t_flags |= XFS_TRANS_DIRTY;
|
||
|
|
efdp->efd_item.li_desc->lid_flags |= XFS_LID_DIRTY;
|
||
|
|
|
||
|
|
next_extent = efdp->efd_next_extent;
|
||
|
|
ASSERT(next_extent < efdp->efd_format.efd_nextents);
|
||
|
|
extp = &(efdp->efd_format.efd_extents[next_extent]);
|
||
|
|
extp->ext_start = start_block;
|
||
|
|
extp->ext_len = ext_len;
|
||
|
|
efdp->efd_next_extent++;
|
||
|
|
|
||
|
|
return error;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Sort bmap items by AG. */
|
||
|
|
static int
|
||
|
|
xfs_extent_free_diff_items(
|
||
|
|
void *priv,
|
||
|
|
struct list_head *a,
|
||
|
|
struct list_head *b)
|
||
|
|
{
|
||
|
|
struct xfs_mount *mp = priv;
|
||
|
|
struct xfs_extent_free_item *ra;
|
||
|
|
struct xfs_extent_free_item *rb;
|
||
|
|
|
||
|
|
ra = container_of(a, struct xfs_extent_free_item, xefi_list);
|
||
|
|
rb = container_of(b, struct xfs_extent_free_item, xefi_list);
|
||
|
|
return XFS_FSB_TO_AGNO(mp, ra->xefi_startblock) -
|
||
|
|
XFS_FSB_TO_AGNO(mp, rb->xefi_startblock);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Get an EFI. */
|
||
|
|
STATIC void *
|
||
|
|
xfs_extent_free_create_intent(
|
||
|
|
struct xfs_trans *tp,
|
||
|
|
unsigned int count)
|
||
|
|
{
|
||
|
|
struct xfs_efi_log_item *efip;
|
||
|
|
|
||
|
|
ASSERT(tp != NULL);
|
||
|
|
ASSERT(count > 0);
|
||
|
|
|
||
|
|
efip = xfs_efi_init(tp->t_mountp, count);
|
||
|
|
ASSERT(efip != NULL);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Get a log_item_desc to point at the new item.
|
||
|
|
*/
|
||
|
|
xfs_trans_add_item(tp, &efip->efi_item);
|
||
|
|
return efip;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Log a free extent to the intent item. */
|
||
|
|
STATIC void
|
||
|
|
xfs_extent_free_log_item(
|
||
|
|
struct xfs_trans *tp,
|
||
|
|
void *intent,
|
||
|
|
struct list_head *item)
|
||
|
|
{
|
||
|
|
struct xfs_efi_log_item *efip = intent;
|
||
|
|
struct xfs_extent_free_item *free;
|
||
|
|
uint next_extent;
|
||
|
|
struct xfs_extent *extp;
|
||
|
|
|
||
|
|
free = container_of(item, struct xfs_extent_free_item, xefi_list);
|
||
|
|
|
||
|
|
tp->t_flags |= XFS_TRANS_DIRTY;
|
||
|
|
efip->efi_item.li_desc->lid_flags |= XFS_LID_DIRTY;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* atomic_inc_return gives us the value after the increment;
|
||
|
|
* we want to use it as an array index so we need to subtract 1 from
|
||
|
|
* it.
|
||
|
|
*/
|
||
|
|
next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
|
||
|
|
ASSERT(next_extent < efip->efi_format.efi_nextents);
|
||
|
|
extp = &efip->efi_format.efi_extents[next_extent];
|
||
|
|
extp->ext_start = free->xefi_startblock;
|
||
|
|
extp->ext_len = free->xefi_blockcount;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Get an EFD so we can process all the free extents. */
|
||
|
|
STATIC void *
|
||
|
|
xfs_extent_free_create_done(
|
||
|
|
struct xfs_trans *tp,
|
||
|
|
void *intent,
|
||
|
|
unsigned int count)
|
||
|
|
{
|
||
|
|
return xfs_trans_get_efd(tp, intent, count);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Process a free extent. */
|
||
|
|
STATIC int
|
||
|
|
xfs_extent_free_finish_item(
|
||
|
|
struct xfs_trans *tp,
|
||
|
|
struct xfs_defer_ops *dop,
|
||
|
|
struct list_head *item,
|
||
|
|
void *done_item,
|
||
|
|
void **state)
|
||
|
|
{
|
||
|
|
struct xfs_extent_free_item *free;
|
||
|
|
int error;
|
||
|
|
|
||
|
|
free = container_of(item, struct xfs_extent_free_item, xefi_list);
|
||
|
|
error = xfs_trans_free_extent(tp, done_item,
|
||
|
|
free->xefi_startblock,
|
||
|
|
free->xefi_blockcount,
|
||
|
|
&free->xefi_oinfo);
|
||
|
|
kmem_free(free);
|
||
|
|
return error;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Abort all pending EFIs. */
|
||
|
|
STATIC void
|
||
|
|
xfs_extent_free_abort_intent(
|
||
|
|
void *intent)
|
||
|
|
{
|
||
|
|
xfs_efi_release(intent);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Cancel a free extent. */
|
||
|
|
STATIC void
|
||
|
|
xfs_extent_free_cancel_item(
|
||
|
|
struct list_head *item)
|
||
|
|
{
|
||
|
|
struct xfs_extent_free_item *free;
|
||
|
|
|
||
|
|
free = container_of(item, struct xfs_extent_free_item, xefi_list);
|
||
|
|
kmem_free(free);
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct xfs_defer_op_type xfs_extent_free_defer_type = {
|
||
|
|
.type = XFS_DEFER_OPS_TYPE_FREE,
|
||
|
|
.max_items = XFS_EFI_MAX_FAST_EXTENTS,
|
||
|
|
.diff_items = xfs_extent_free_diff_items,
|
||
|
|
.create_intent = xfs_extent_free_create_intent,
|
||
|
|
.abort_intent = xfs_extent_free_abort_intent,
|
||
|
|
.log_item = xfs_extent_free_log_item,
|
||
|
|
.create_done = xfs_extent_free_create_done,
|
||
|
|
.finish_item = xfs_extent_free_finish_item,
|
||
|
|
.cancel_item = xfs_extent_free_cancel_item,
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Register the deferred op type. */
|
||
|
|
void
|
||
|
|
xfs_extent_free_init_defer_op(void)
|
||
|
|
{
|
||
|
|
xfs_defer_init_op_type(&xfs_extent_free_defer_type);
|
||
|
|
}
|