2018-06-06 02:42:14 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2016-08-03 02:04:45 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2016 Oracle. All Rights Reserved.
|
|
|
|
* Author: Darrick J. Wong <darrick.wong@oracle.com>
|
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
|
|
|
#include "xfs_format.h"
|
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2016-08-03 02:09:48 +00:00
|
|
|
#include "xfs_bit.h"
|
2018-02-22 22:41:25 +00:00
|
|
|
#include "xfs_shared.h"
|
2016-08-03 02:04:45 +00:00
|
|
|
#include "xfs_mount.h"
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
#include "xfs_defer.h"
|
2016-08-03 02:04:45 +00:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_trans_priv.h"
|
|
|
|
#include "xfs_rmap_item.h"
|
|
|
|
#include "xfs_log.h"
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
#include "xfs_rmap.h"
|
2016-08-03 02:04:45 +00:00
|
|
|
|
|
|
|
|
|
|
|
kmem_zone_t *xfs_rui_zone;
|
|
|
|
kmem_zone_t *xfs_rud_zone;
|
|
|
|
|
|
|
|
static inline struct xfs_rui_log_item *RUI_ITEM(struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
return container_of(lip, struct xfs_rui_log_item, rui_item);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_rui_item_free(
|
|
|
|
struct xfs_rui_log_item *ruip)
|
|
|
|
{
|
|
|
|
if (ruip->rui_format.rui_nextents > XFS_RUI_MAX_FAST_EXTENTS)
|
|
|
|
kmem_free(ruip);
|
|
|
|
else
|
|
|
|
kmem_zone_free(xfs_rui_zone, ruip);
|
|
|
|
}
|
|
|
|
|
2018-04-03 03:08:27 +00:00
|
|
|
/*
|
|
|
|
* Freeing the RUI requires that we remove it from the AIL if it has already
|
|
|
|
* been placed there. However, the RUI may not yet have been placed in the AIL
|
|
|
|
* when called by xfs_rui_release() from RUD processing due to the ordering of
|
|
|
|
* committed vs unpin operations in bulk insert operations. Hence the reference
|
|
|
|
* count to ensure only the last caller frees the RUI.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_rui_release(
|
|
|
|
struct xfs_rui_log_item *ruip)
|
|
|
|
{
|
|
|
|
ASSERT(atomic_read(&ruip->rui_refcount) > 0);
|
|
|
|
if (atomic_dec_and_test(&ruip->rui_refcount)) {
|
|
|
|
xfs_trans_ail_remove(&ruip->rui_item, SHUTDOWN_LOG_IO_ERROR);
|
|
|
|
xfs_rui_item_free(ruip);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-03 02:04:45 +00:00
|
|
|
STATIC void
|
|
|
|
xfs_rui_item_size(
|
|
|
|
struct xfs_log_item *lip,
|
|
|
|
int *nvecs,
|
|
|
|
int *nbytes)
|
|
|
|
{
|
2016-09-19 00:24:27 +00:00
|
|
|
struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
|
|
|
|
|
2016-08-03 02:04:45 +00:00
|
|
|
*nvecs += 1;
|
2016-09-19 00:24:27 +00:00
|
|
|
*nbytes += xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents);
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called to fill in the vector of log iovecs for the
|
|
|
|
* given rui log item. We use only 1 iovec, and we point that
|
|
|
|
* at the rui_log_format structure embedded in the rui item.
|
|
|
|
* It is at this point that we assert that all of the extent
|
|
|
|
* slots in the rui item have been filled.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_rui_item_format(
|
|
|
|
struct xfs_log_item *lip,
|
|
|
|
struct xfs_log_vec *lv)
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
|
|
|
|
struct xfs_log_iovec *vecp = NULL;
|
|
|
|
|
|
|
|
ASSERT(atomic_read(&ruip->rui_next_extent) ==
|
|
|
|
ruip->rui_format.rui_nextents);
|
|
|
|
|
|
|
|
ruip->rui_format.rui_type = XFS_LI_RUI;
|
|
|
|
ruip->rui_format.rui_size = 1;
|
|
|
|
|
|
|
|
xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUI_FORMAT, &ruip->rui_format,
|
2016-09-19 00:24:27 +00:00
|
|
|
xfs_rui_log_format_sizeof(ruip->rui_format.rui_nextents));
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The unpin operation is the last place an RUI is manipulated in the log. It is
|
|
|
|
* either inserted in the AIL or aborted in the event of a log I/O error. In
|
|
|
|
* either case, the RUI transaction has been successfully committed to make it
|
|
|
|
* this far. Therefore, we expect whoever committed the RUI to either construct
|
|
|
|
* and commit the RUD or drop the RUD's reference in the event of error. Simply
|
|
|
|
* drop the log's RUI reference now that the log is done with it.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_rui_item_unpin(
|
|
|
|
struct xfs_log_item *lip,
|
|
|
|
int remove)
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
|
|
|
|
|
|
|
|
xfs_rui_release(ruip);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The RUI has been either committed or aborted if the transaction has been
|
|
|
|
* cancelled. If the transaction was cancelled, an RUD isn't going to be
|
|
|
|
* constructed and thus we free the RUI here directly.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2019-06-29 02:27:32 +00:00
|
|
|
xfs_rui_item_release(
|
2016-08-03 02:04:45 +00:00
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
2019-06-29 02:27:32 +00:00
|
|
|
xfs_rui_release(RUI_ITEM(lip));
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct xfs_item_ops xfs_rui_item_ops = {
|
|
|
|
.iop_size = xfs_rui_item_size,
|
|
|
|
.iop_format = xfs_rui_item_format,
|
|
|
|
.iop_unpin = xfs_rui_item_unpin,
|
2019-06-29 02:27:32 +00:00
|
|
|
.iop_release = xfs_rui_item_release,
|
2016-08-03 02:04:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate and initialize an rui item with the given number of extents.
|
|
|
|
*/
|
|
|
|
struct xfs_rui_log_item *
|
|
|
|
xfs_rui_init(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
uint nextents)
|
|
|
|
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_item *ruip;
|
|
|
|
|
|
|
|
ASSERT(nextents > 0);
|
2016-09-19 00:24:27 +00:00
|
|
|
if (nextents > XFS_RUI_MAX_FAST_EXTENTS)
|
2019-08-26 19:06:22 +00:00
|
|
|
ruip = kmem_zalloc(xfs_rui_log_item_sizeof(nextents), 0);
|
2016-09-19 00:24:27 +00:00
|
|
|
else
|
2019-08-26 19:06:22 +00:00
|
|
|
ruip = kmem_zone_zalloc(xfs_rui_zone, 0);
|
2016-08-03 02:04:45 +00:00
|
|
|
|
|
|
|
xfs_log_item_init(mp, &ruip->rui_item, XFS_LI_RUI, &xfs_rui_item_ops);
|
|
|
|
ruip->rui_format.rui_nextents = nextents;
|
|
|
|
ruip->rui_format.rui_id = (uintptr_t)(void *)ruip;
|
|
|
|
atomic_set(&ruip->rui_next_extent, 0);
|
|
|
|
atomic_set(&ruip->rui_refcount, 2);
|
|
|
|
|
|
|
|
return ruip;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy an RUI format buffer from the given buf, and into the destination
|
|
|
|
* RUI format structure. The RUI/RUD items were designed not to need any
|
|
|
|
* special alignment handling.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_rui_copy_format(
|
|
|
|
struct xfs_log_iovec *buf,
|
|
|
|
struct xfs_rui_log_format *dst_rui_fmt)
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_format *src_rui_fmt;
|
|
|
|
uint len;
|
|
|
|
|
|
|
|
src_rui_fmt = buf->i_addr;
|
2016-09-19 00:24:27 +00:00
|
|
|
len = xfs_rui_log_format_sizeof(src_rui_fmt->rui_nextents);
|
2016-08-03 02:04:45 +00:00
|
|
|
|
|
|
|
if (buf->i_len != len)
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
|
2016-09-19 00:24:27 +00:00
|
|
|
memcpy(dst_rui_fmt, src_rui_fmt, len);
|
2016-08-03 02:04:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct xfs_rud_log_item *RUD_ITEM(struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
return container_of(lip, struct xfs_rud_log_item, rud_item);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xfs_rud_item_size(
|
|
|
|
struct xfs_log_item *lip,
|
|
|
|
int *nvecs,
|
|
|
|
int *nbytes)
|
|
|
|
{
|
|
|
|
*nvecs += 1;
|
2016-08-03 02:28:43 +00:00
|
|
|
*nbytes += sizeof(struct xfs_rud_log_format);
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called to fill in the vector of log iovecs for the
|
|
|
|
* given rud log item. We use only 1 iovec, and we point that
|
|
|
|
* at the rud_log_format structure embedded in the rud item.
|
|
|
|
* It is at this point that we assert that all of the extent
|
|
|
|
* slots in the rud item have been filled.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_rud_item_format(
|
|
|
|
struct xfs_log_item *lip,
|
|
|
|
struct xfs_log_vec *lv)
|
|
|
|
{
|
|
|
|
struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
|
|
|
|
struct xfs_log_iovec *vecp = NULL;
|
|
|
|
|
|
|
|
rudp->rud_format.rud_type = XFS_LI_RUD;
|
|
|
|
rudp->rud_format.rud_size = 1;
|
|
|
|
|
|
|
|
xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUD_FORMAT, &rudp->rud_format,
|
2016-08-03 02:28:43 +00:00
|
|
|
sizeof(struct xfs_rud_log_format));
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The RUD is either committed or aborted if the transaction is cancelled. If
|
|
|
|
* the transaction is cancelled, drop our reference to the RUI and free the
|
|
|
|
* RUD.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2019-06-29 02:27:32 +00:00
|
|
|
xfs_rud_item_release(
|
2016-08-03 02:04:45 +00:00
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
|
|
|
struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
|
|
|
|
|
2019-06-29 02:27:32 +00:00
|
|
|
xfs_rui_release(rudp->rud_ruip);
|
|
|
|
kmem_zone_free(xfs_rud_zone, rudp);
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct xfs_item_ops xfs_rud_item_ops = {
|
2019-06-29 02:27:32 +00:00
|
|
|
.flags = XFS_ITEM_RELEASE_WHEN_COMMITTED,
|
2016-08-03 02:04:45 +00:00
|
|
|
.iop_size = xfs_rud_item_size,
|
|
|
|
.iop_format = xfs_rud_item_format,
|
2019-06-29 02:27:32 +00:00
|
|
|
.iop_release = xfs_rud_item_release,
|
2016-08-03 02:04:45 +00:00
|
|
|
};
|
|
|
|
|
2019-06-29 02:29:41 +00:00
|
|
|
static struct xfs_rud_log_item *
|
2019-06-29 02:27:36 +00:00
|
|
|
xfs_trans_get_rud(
|
|
|
|
struct xfs_trans *tp,
|
2016-08-03 02:28:43 +00:00
|
|
|
struct xfs_rui_log_item *ruip)
|
2016-08-03 02:04:45 +00:00
|
|
|
{
|
2019-06-29 02:27:36 +00:00
|
|
|
struct xfs_rud_log_item *rudp;
|
2016-08-03 02:04:45 +00:00
|
|
|
|
2019-08-26 19:06:22 +00:00
|
|
|
rudp = kmem_zone_zalloc(xfs_rud_zone, 0);
|
2019-06-29 02:27:36 +00:00
|
|
|
xfs_log_item_init(tp->t_mountp, &rudp->rud_item, XFS_LI_RUD,
|
|
|
|
&xfs_rud_item_ops);
|
2016-08-03 02:04:45 +00:00
|
|
|
rudp->rud_ruip = ruip;
|
|
|
|
rudp->rud_format.rud_rui_id = ruip->rui_format.rui_id;
|
|
|
|
|
2019-06-29 02:27:36 +00:00
|
|
|
xfs_trans_add_item(tp, &rudp->rud_item);
|
2016-08-03 02:04:45 +00:00
|
|
|
return rudp;
|
|
|
|
}
|
2016-08-03 02:09:48 +00:00
|
|
|
|
2019-06-29 02:29:41 +00:00
|
|
|
/* Set the map extent flags for this reverse mapping. */
|
|
|
|
static void
|
|
|
|
xfs_trans_set_rmap_flags(
|
|
|
|
struct xfs_map_extent *rmap,
|
|
|
|
enum xfs_rmap_intent_type type,
|
|
|
|
int whichfork,
|
|
|
|
xfs_exntst_t state)
|
|
|
|
{
|
|
|
|
rmap->me_flags = 0;
|
|
|
|
if (state == XFS_EXT_UNWRITTEN)
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_UNWRITTEN;
|
|
|
|
if (whichfork == XFS_ATTR_FORK)
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_ATTR_FORK;
|
|
|
|
switch (type) {
|
|
|
|
case XFS_RMAP_MAP:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_MAP;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_MAP_SHARED:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_MAP_SHARED;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_UNMAP:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_UNMAP;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_UNMAP_SHARED:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_UNMAP_SHARED;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_CONVERT:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_CONVERT;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_CONVERT_SHARED:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_CONVERT_SHARED;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_ALLOC:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_ALLOC;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_FREE:
|
|
|
|
rmap->me_flags |= XFS_RMAP_EXTENT_FREE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ASSERT(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Finish an rmap update and log it to the RUD. Note that the transaction is
|
|
|
|
* marked dirty regardless of whether the rmap update succeeds or fails to
|
|
|
|
* support the RUI/RUD lifecycle rules.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_trans_log_finish_rmap_update(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_rud_log_item *rudp,
|
|
|
|
enum xfs_rmap_intent_type type,
|
|
|
|
uint64_t owner,
|
|
|
|
int whichfork,
|
|
|
|
xfs_fileoff_t startoff,
|
|
|
|
xfs_fsblock_t startblock,
|
|
|
|
xfs_filblks_t blockcount,
|
|
|
|
xfs_exntst_t state,
|
|
|
|
struct xfs_btree_cur **pcur)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = xfs_rmap_finish_one(tp, type, owner, whichfork, startoff,
|
|
|
|
startblock, blockcount, state, pcur);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark the transaction dirty, even on error. This ensures the
|
|
|
|
* transaction is aborted, which:
|
|
|
|
*
|
|
|
|
* 1.) releases the RUI and frees the RUD
|
|
|
|
* 2.) shuts down the filesystem
|
|
|
|
*/
|
|
|
|
tp->t_flags |= XFS_TRANS_DIRTY;
|
|
|
|
set_bit(XFS_LI_DIRTY, &rudp->rud_item.li_flags);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sort rmap intents by AG. */
|
|
|
|
static int
|
|
|
|
xfs_rmap_update_diff_items(
|
|
|
|
void *priv,
|
|
|
|
struct list_head *a,
|
|
|
|
struct list_head *b)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = priv;
|
|
|
|
struct xfs_rmap_intent *ra;
|
|
|
|
struct xfs_rmap_intent *rb;
|
|
|
|
|
|
|
|
ra = container_of(a, struct xfs_rmap_intent, ri_list);
|
|
|
|
rb = container_of(b, struct xfs_rmap_intent, ri_list);
|
|
|
|
return XFS_FSB_TO_AGNO(mp, ra->ri_bmap.br_startblock) -
|
|
|
|
XFS_FSB_TO_AGNO(mp, rb->ri_bmap.br_startblock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get an RUI. */
|
|
|
|
STATIC void *
|
|
|
|
xfs_rmap_update_create_intent(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
unsigned int count)
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_item *ruip;
|
|
|
|
|
|
|
|
ASSERT(tp != NULL);
|
|
|
|
ASSERT(count > 0);
|
|
|
|
|
|
|
|
ruip = xfs_rui_init(tp->t_mountp, count);
|
|
|
|
ASSERT(ruip != NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a log_item_desc to point at the new item.
|
|
|
|
*/
|
|
|
|
xfs_trans_add_item(tp, &ruip->rui_item);
|
|
|
|
return ruip;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Log rmap updates in the intent item. */
|
|
|
|
STATIC void
|
|
|
|
xfs_rmap_update_log_item(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
void *intent,
|
|
|
|
struct list_head *item)
|
|
|
|
{
|
|
|
|
struct xfs_rui_log_item *ruip = intent;
|
|
|
|
struct xfs_rmap_intent *rmap;
|
|
|
|
uint next_extent;
|
|
|
|
struct xfs_map_extent *map;
|
|
|
|
|
|
|
|
rmap = container_of(item, struct xfs_rmap_intent, ri_list);
|
|
|
|
|
|
|
|
tp->t_flags |= XFS_TRANS_DIRTY;
|
|
|
|
set_bit(XFS_LI_DIRTY, &ruip->rui_item.li_flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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(&ruip->rui_next_extent) - 1;
|
|
|
|
ASSERT(next_extent < ruip->rui_format.rui_nextents);
|
|
|
|
map = &ruip->rui_format.rui_extents[next_extent];
|
|
|
|
map->me_owner = rmap->ri_owner;
|
|
|
|
map->me_startblock = rmap->ri_bmap.br_startblock;
|
|
|
|
map->me_startoff = rmap->ri_bmap.br_startoff;
|
|
|
|
map->me_len = rmap->ri_bmap.br_blockcount;
|
|
|
|
xfs_trans_set_rmap_flags(map, rmap->ri_type, rmap->ri_whichfork,
|
|
|
|
rmap->ri_bmap.br_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get an RUD so we can process all the deferred rmap updates. */
|
|
|
|
STATIC void *
|
|
|
|
xfs_rmap_update_create_done(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
void *intent,
|
|
|
|
unsigned int count)
|
|
|
|
{
|
|
|
|
return xfs_trans_get_rud(tp, intent);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Process a deferred rmap update. */
|
|
|
|
STATIC int
|
|
|
|
xfs_rmap_update_finish_item(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct list_head *item,
|
|
|
|
void *done_item,
|
|
|
|
void **state)
|
|
|
|
{
|
|
|
|
struct xfs_rmap_intent *rmap;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
rmap = container_of(item, struct xfs_rmap_intent, ri_list);
|
|
|
|
error = xfs_trans_log_finish_rmap_update(tp, done_item,
|
|
|
|
rmap->ri_type,
|
|
|
|
rmap->ri_owner, rmap->ri_whichfork,
|
|
|
|
rmap->ri_bmap.br_startoff,
|
|
|
|
rmap->ri_bmap.br_startblock,
|
|
|
|
rmap->ri_bmap.br_blockcount,
|
|
|
|
rmap->ri_bmap.br_state,
|
|
|
|
(struct xfs_btree_cur **)state);
|
|
|
|
kmem_free(rmap);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clean up after processing deferred rmaps. */
|
|
|
|
STATIC void
|
|
|
|
xfs_rmap_update_finish_cleanup(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
void *state,
|
|
|
|
int error)
|
|
|
|
{
|
|
|
|
struct xfs_btree_cur *rcur = state;
|
|
|
|
|
|
|
|
xfs_rmap_finish_one_cleanup(tp, rcur, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Abort all pending RUIs. */
|
|
|
|
STATIC void
|
|
|
|
xfs_rmap_update_abort_intent(
|
|
|
|
void *intent)
|
|
|
|
{
|
|
|
|
xfs_rui_release(intent);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Cancel a deferred rmap update. */
|
|
|
|
STATIC void
|
|
|
|
xfs_rmap_update_cancel_item(
|
|
|
|
struct list_head *item)
|
|
|
|
{
|
|
|
|
struct xfs_rmap_intent *rmap;
|
|
|
|
|
|
|
|
rmap = container_of(item, struct xfs_rmap_intent, ri_list);
|
|
|
|
kmem_free(rmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct xfs_defer_op_type xfs_rmap_update_defer_type = {
|
|
|
|
.max_items = XFS_RUI_MAX_FAST_EXTENTS,
|
|
|
|
.diff_items = xfs_rmap_update_diff_items,
|
|
|
|
.create_intent = xfs_rmap_update_create_intent,
|
|
|
|
.abort_intent = xfs_rmap_update_abort_intent,
|
|
|
|
.log_item = xfs_rmap_update_log_item,
|
|
|
|
.create_done = xfs_rmap_update_create_done,
|
|
|
|
.finish_item = xfs_rmap_update_finish_item,
|
|
|
|
.finish_cleanup = xfs_rmap_update_finish_cleanup,
|
|
|
|
.cancel_item = xfs_rmap_update_cancel_item,
|
|
|
|
};
|
|
|
|
|
2016-08-03 02:09:48 +00:00
|
|
|
/*
|
|
|
|
* Process an rmap update intent item that was recovered from the log.
|
|
|
|
* We need to update the rmapbt.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_rui_recover(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_rui_log_item *ruip)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int error = 0;
|
|
|
|
struct xfs_map_extent *rmap;
|
|
|
|
xfs_fsblock_t startblock_fsb;
|
|
|
|
bool op_ok;
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
struct xfs_rud_log_item *rudp;
|
|
|
|
enum xfs_rmap_intent_type type;
|
|
|
|
int whichfork;
|
|
|
|
xfs_exntst_t state;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
struct xfs_btree_cur *rcur = NULL;
|
2016-08-03 02:09:48 +00:00
|
|
|
|
|
|
|
ASSERT(!test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First check the validity of the extents described by the
|
|
|
|
* RUI. If any are bad, then assume that all are bad and
|
|
|
|
* just toss the RUI.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < ruip->rui_format.rui_nextents; i++) {
|
2016-08-03 02:29:32 +00:00
|
|
|
rmap = &ruip->rui_format.rui_extents[i];
|
2016-08-03 02:09:48 +00:00
|
|
|
startblock_fsb = XFS_BB_TO_FSB(mp,
|
|
|
|
XFS_FSB_TO_DADDR(mp, rmap->me_startblock));
|
|
|
|
switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
|
|
|
|
case XFS_RMAP_EXTENT_MAP:
|
2016-10-03 16:11:47 +00:00
|
|
|
case XFS_RMAP_EXTENT_MAP_SHARED:
|
2016-08-03 02:09:48 +00:00
|
|
|
case XFS_RMAP_EXTENT_UNMAP:
|
2016-10-03 16:11:47 +00:00
|
|
|
case XFS_RMAP_EXTENT_UNMAP_SHARED:
|
2016-08-03 02:09:48 +00:00
|
|
|
case XFS_RMAP_EXTENT_CONVERT:
|
2016-10-03 16:11:47 +00:00
|
|
|
case XFS_RMAP_EXTENT_CONVERT_SHARED:
|
2016-08-03 02:09:48 +00:00
|
|
|
case XFS_RMAP_EXTENT_ALLOC:
|
|
|
|
case XFS_RMAP_EXTENT_FREE:
|
|
|
|
op_ok = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
op_ok = false;
|
|
|
|
break;
|
|
|
|
}
|
2016-08-03 02:29:32 +00:00
|
|
|
if (!op_ok || startblock_fsb == 0 ||
|
|
|
|
rmap->me_len == 0 ||
|
|
|
|
startblock_fsb >= mp->m_sb.sb_dblocks ||
|
|
|
|
rmap->me_len >= mp->m_sb.sb_agblocks ||
|
2016-08-03 02:09:48 +00:00
|
|
|
(rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS)) {
|
|
|
|
/*
|
|
|
|
* This will pull the RUI from the AIL and
|
|
|
|
* free the memory associated with it.
|
|
|
|
*/
|
|
|
|
set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags);
|
|
|
|
xfs_rui_release(ruip);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-22 22:41:25 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
|
|
|
|
mp->m_rmap_maxlevels, 0, XFS_TRANS_RESERVE, &tp);
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
2016-08-03 02:28:43 +00:00
|
|
|
rudp = xfs_trans_get_rud(tp, ruip);
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
|
|
|
|
for (i = 0; i < ruip->rui_format.rui_nextents; i++) {
|
2016-08-03 02:29:32 +00:00
|
|
|
rmap = &ruip->rui_format.rui_extents[i];
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
state = (rmap->me_flags & XFS_RMAP_EXTENT_UNWRITTEN) ?
|
|
|
|
XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
|
|
|
|
whichfork = (rmap->me_flags & XFS_RMAP_EXTENT_ATTR_FORK) ?
|
|
|
|
XFS_ATTR_FORK : XFS_DATA_FORK;
|
|
|
|
switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
|
|
|
|
case XFS_RMAP_EXTENT_MAP:
|
|
|
|
type = XFS_RMAP_MAP;
|
|
|
|
break;
|
2016-10-03 16:11:48 +00:00
|
|
|
case XFS_RMAP_EXTENT_MAP_SHARED:
|
|
|
|
type = XFS_RMAP_MAP_SHARED;
|
|
|
|
break;
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
case XFS_RMAP_EXTENT_UNMAP:
|
|
|
|
type = XFS_RMAP_UNMAP;
|
|
|
|
break;
|
2016-10-03 16:11:48 +00:00
|
|
|
case XFS_RMAP_EXTENT_UNMAP_SHARED:
|
|
|
|
type = XFS_RMAP_UNMAP_SHARED;
|
|
|
|
break;
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
case XFS_RMAP_EXTENT_CONVERT:
|
|
|
|
type = XFS_RMAP_CONVERT;
|
|
|
|
break;
|
2016-10-03 16:11:48 +00:00
|
|
|
case XFS_RMAP_EXTENT_CONVERT_SHARED:
|
|
|
|
type = XFS_RMAP_CONVERT_SHARED;
|
|
|
|
break;
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
case XFS_RMAP_EXTENT_ALLOC:
|
|
|
|
type = XFS_RMAP_ALLOC;
|
|
|
|
break;
|
|
|
|
case XFS_RMAP_EXTENT_FREE:
|
|
|
|
type = XFS_RMAP_FREE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = -EFSCORRUPTED;
|
|
|
|
goto abort_error;
|
|
|
|
}
|
|
|
|
error = xfs_trans_log_finish_rmap_update(tp, rudp, type,
|
|
|
|
rmap->me_owner, whichfork,
|
|
|
|
rmap->me_startoff, rmap->me_startblock,
|
|
|
|
rmap->me_len, state, &rcur);
|
|
|
|
if (error)
|
|
|
|
goto abort_error;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_rmap_finish_one_cleanup(tp, rcur, error);
|
2016-08-03 02:09:48 +00:00
|
|
|
set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags);
|
xfs: propagate bmap updates to rmapbt
When we map, unmap, or convert an extent in a file's data or attr
fork, schedule a respective update in the rmapbt. Previous versions
of this patch required a 1:1 correspondence between bmap and rmap,
but this is no longer true as we now have ability to make interval
queries against the rmapbt.
We use the deferred operations code to handle redo operations
atomically and deadlock free. This plumbs in all five rmap actions
(map, unmap, convert extent, alloc, free); we'll use the first three
now for file data, and reflink will want the last two. We also add
an error injection site to test log recovery.
Finally, we need to fix the bmap shift extent code to adjust the
rmaps correctly.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2016-08-03 02:16:05 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
|
|
|
return error;
|
|
|
|
|
|
|
|
abort_error:
|
|
|
|
xfs_rmap_finish_one_cleanup(tp, rcur, error);
|
|
|
|
xfs_trans_cancel(tp);
|
2016-08-03 02:09:48 +00:00
|
|
|
return error;
|
|
|
|
}
|