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"
|
2019-11-02 16:40:53 +00:00
|
|
|
#include "xfs_error.h"
|
2020-05-01 23:00:49 +00:00
|
|
|
#include "xfs_log_priv.h"
|
2020-05-01 23:00:45 +00:00
|
|
|
#include "xfs_log_recover.h"
|
2023-04-12 01:59:54 +00:00
|
|
|
#include "xfs_ag.h"
|
2016-08-03 02:04:45 +00:00
|
|
|
|
2021-10-12 18:09:23 +00:00
|
|
|
struct kmem_cache *xfs_rui_cache;
|
|
|
|
|
struct kmem_cache *xfs_rud_cache;
|
2016-08-03 02:04:45 +00:00
|
|
|
|
2020-05-01 23:00:51 +00:00
|
|
|
static const struct xfs_item_ops xfs_rui_item_ops;
|
|
|
|
|
|
2016-08-03 02:04:45 +00:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-01 23:00:49 +00:00
|
|
|
STATIC void
|
2016-08-03 02:04:45 +00:00
|
|
|
xfs_rui_item_free(
|
|
|
|
|
struct xfs_rui_log_item *ruip)
|
|
|
|
|
{
|
2024-01-15 22:59:42 +00:00
|
|
|
kvfree(ruip->rui_item.li_lv_shadow);
|
2016-08-03 02:04:45 +00:00
|
|
|
if (ruip->rui_format.rui_nextents > XFS_RUI_MAX_FAST_EXTENTS)
|
2024-01-15 22:59:43 +00:00
|
|
|
kfree(ruip);
|
2016-08-03 02:04:45 +00:00
|
|
|
else
|
2021-10-12 18:09:23 +00:00
|
|
|
kmem_cache_free(xfs_rui_cache, ruip);
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
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.
|
|
|
|
|
*/
|
2020-05-01 23:00:51 +00:00
|
|
|
STATIC void
|
2018-04-03 03:08:27 +00:00
|
|
|
xfs_rui_release(
|
|
|
|
|
struct xfs_rui_log_item *ruip)
|
|
|
|
|
{
|
|
|
|
|
ASSERT(atomic_read(&ruip->rui_refcount) > 0);
|
2022-05-04 01:46:47 +00:00
|
|
|
if (!atomic_dec_and_test(&ruip->rui_refcount))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
xfs_trans_ail_delete(&ruip->rui_item, 0);
|
|
|
|
|
xfs_rui_item_free(ruip);
|
2018-04-03 03:08:27 +00:00
|
|
|
}
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate and initialize an rui item with the given number of extents.
|
|
|
|
|
*/
|
2020-05-01 23:00:49 +00:00
|
|
|
STATIC struct xfs_rui_log_item *
|
2016-08-03 02:04:45 +00:00
|
|
|
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)
|
2024-01-15 22:59:39 +00:00
|
|
|
ruip = kzalloc(xfs_rui_log_item_sizeof(nextents),
|
|
|
|
|
GFP_KERNEL | __GFP_NOFAIL);
|
2016-09-19 00:24:27 +00:00
|
|
|
else
|
2021-10-12 18:09:23 +00:00
|
|
|
ruip = kmem_cache_zalloc(xfs_rui_cache,
|
2020-07-22 16:23:10 +00:00
|
|
|
GFP_KERNEL | __GFP_NOFAIL);
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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);
|
2024-01-15 22:59:42 +00:00
|
|
|
kvfree(rudp->rud_item.li_lv_shadow);
|
2021-10-12 18:09:23 +00:00
|
|
|
kmem_cache_free(xfs_rud_cache, rudp);
|
2016-08-03 02:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
2022-05-04 01:46:39 +00:00
|
|
|
static struct xfs_log_item *
|
|
|
|
|
xfs_rud_item_intent(
|
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
|
{
|
|
|
|
|
return &RUD_ITEM(lip)->rud_ruip->rui_item;
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-03 02:04:45 +00:00
|
|
|
static const struct xfs_item_ops xfs_rud_item_ops = {
|
2022-05-04 01:46:09 +00:00
|
|
|
.flags = XFS_ITEM_RELEASE_WHEN_COMMITTED |
|
|
|
|
|
XFS_ITEM_INTENT_DONE,
|
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,
|
2022-05-04 01:46:39 +00:00
|
|
|
.iop_intent = xfs_rud_item_intent,
|
2016-08-03 02:04:45 +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(
|
2023-02-01 18:16:03 +00:00
|
|
|
struct xfs_map_extent *map,
|
2019-06-29 02:29:41 +00:00
|
|
|
enum xfs_rmap_intent_type type,
|
|
|
|
|
int whichfork,
|
|
|
|
|
xfs_exntst_t state)
|
|
|
|
|
{
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags = 0;
|
2019-06-29 02:29:41 +00:00
|
|
|
if (state == XFS_EXT_UNWRITTEN)
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_UNWRITTEN;
|
2019-06-29 02:29:41 +00:00
|
|
|
if (whichfork == XFS_ATTR_FORK)
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_ATTR_FORK;
|
2019-06-29 02:29:41 +00:00
|
|
|
switch (type) {
|
|
|
|
|
case XFS_RMAP_MAP:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_MAP;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_MAP_SHARED:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_MAP_SHARED;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_UNMAP:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_UNMAP;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_UNMAP_SHARED:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_UNMAP_SHARED;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_CONVERT:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_CONVERT;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_CONVERT_SHARED:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_CONVERT_SHARED;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_ALLOC:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_ALLOC;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_FREE:
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_flags |= XFS_RMAP_EXTENT_FREE;
|
2019-06-29 02:29:41 +00:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ASSERT(0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sort rmap intents by AG. */
|
|
|
|
|
static int
|
|
|
|
|
xfs_rmap_update_diff_items(
|
|
|
|
|
void *priv,
|
2021-04-08 18:28:34 +00:00
|
|
|
const struct list_head *a,
|
|
|
|
|
const struct list_head *b)
|
2019-06-29 02:29:41 +00:00
|
|
|
{
|
|
|
|
|
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);
|
2023-04-12 01:59:54 +00:00
|
|
|
|
|
|
|
|
return ra->ri_pag->pag_agno - rb->ri_pag->pag_agno;
|
2019-06-29 02:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Log rmap updates in the intent item. */
|
|
|
|
|
STATIC void
|
|
|
|
|
xfs_rmap_update_log_item(
|
|
|
|
|
struct xfs_trans *tp,
|
2020-04-30 19:52:20 +00:00
|
|
|
struct xfs_rui_log_item *ruip,
|
2023-02-01 18:16:03 +00:00
|
|
|
struct xfs_rmap_intent *ri)
|
2019-06-29 02:29:41 +00:00
|
|
|
{
|
|
|
|
|
uint next_extent;
|
|
|
|
|
struct xfs_map_extent *map;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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];
|
2023-02-01 18:16:03 +00:00
|
|
|
map->me_owner = ri->ri_owner;
|
|
|
|
|
map->me_startblock = ri->ri_bmap.br_startblock;
|
|
|
|
|
map->me_startoff = ri->ri_bmap.br_startoff;
|
|
|
|
|
map->me_len = ri->ri_bmap.br_blockcount;
|
|
|
|
|
xfs_trans_set_rmap_flags(map, ri->ri_type, ri->ri_whichfork,
|
|
|
|
|
ri->ri_bmap.br_state);
|
2019-06-29 02:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
2020-04-30 19:52:21 +00:00
|
|
|
static struct xfs_log_item *
|
2020-04-30 19:52:20 +00:00
|
|
|
xfs_rmap_update_create_intent(
|
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
|
struct list_head *items,
|
2020-04-30 19:52:20 +00:00
|
|
|
unsigned int count,
|
|
|
|
|
bool sort)
|
2020-04-30 19:52:20 +00:00
|
|
|
{
|
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
|
struct xfs_rui_log_item *ruip = xfs_rui_init(mp, count);
|
2023-02-01 18:16:03 +00:00
|
|
|
struct xfs_rmap_intent *ri;
|
2020-04-30 19:52:20 +00:00
|
|
|
|
|
|
|
|
ASSERT(count > 0);
|
|
|
|
|
|
2020-04-30 19:52:20 +00:00
|
|
|
if (sort)
|
|
|
|
|
list_sort(mp, items, xfs_rmap_update_diff_items);
|
2023-02-01 18:16:03 +00:00
|
|
|
list_for_each_entry(ri, items, ri_list)
|
|
|
|
|
xfs_rmap_update_log_item(tp, ruip, ri);
|
2020-04-30 19:52:21 +00:00
|
|
|
return &ruip->rui_item;
|
2020-04-30 19:52:20 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-29 02:29:41 +00:00
|
|
|
/* Get an RUD so we can process all the deferred rmap updates. */
|
2020-04-30 19:52:22 +00:00
|
|
|
static struct xfs_log_item *
|
2019-06-29 02:29:41 +00:00
|
|
|
xfs_rmap_update_create_done(
|
|
|
|
|
struct xfs_trans *tp,
|
2020-04-30 19:52:21 +00:00
|
|
|
struct xfs_log_item *intent,
|
2019-06-29 02:29:41 +00:00
|
|
|
unsigned int count)
|
|
|
|
|
{
|
2023-11-30 20:17:37 +00:00
|
|
|
struct xfs_rui_log_item *ruip = RUI_ITEM(intent);
|
|
|
|
|
struct xfs_rud_log_item *rudp;
|
|
|
|
|
|
|
|
|
|
rudp = kmem_cache_zalloc(xfs_rud_cache, GFP_KERNEL | __GFP_NOFAIL);
|
|
|
|
|
xfs_log_item_init(tp->t_mountp, &rudp->rud_item, XFS_LI_RUD,
|
|
|
|
|
&xfs_rud_item_ops);
|
|
|
|
|
rudp->rud_ruip = ruip;
|
|
|
|
|
rudp->rud_format.rud_rui_id = ruip->rui_format.rui_id;
|
|
|
|
|
|
|
|
|
|
return &rudp->rud_item;
|
2019-06-29 02:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
2023-04-12 01:59:54 +00:00
|
|
|
/* Take a passive ref to the AG containing the space we're rmapping. */
|
|
|
|
|
void
|
|
|
|
|
xfs_rmap_update_get_group(
|
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
|
struct xfs_rmap_intent *ri)
|
|
|
|
|
{
|
|
|
|
|
xfs_agnumber_t agno;
|
|
|
|
|
|
|
|
|
|
agno = XFS_FSB_TO_AGNO(mp, ri->ri_bmap.br_startblock);
|
xfs: allow queued AG intents to drain before scrubbing
When a writer thread executes a chain of log intent items, the AG header
buffer locks will cycle during a transaction roll to get from one intent
item to the next in a chain. Although scrub takes all AG header buffer
locks, this isn't sufficient to guard against scrub checking an AG while
that writer thread is in the middle of finishing a chain because there's
no higher level locking primitive guarding allocation groups.
When there's a collision, cross-referencing between data structures
(e.g. rmapbt and refcountbt) yields false corruption events; if repair
is running, this results in incorrect repairs, which is catastrophic.
Fix this by adding to the perag structure the count of active intents
and make scrub wait until it has both AG header buffer locks and the
intent counter reaches zero.
One quirk of the drain code is that deferred bmap updates also bump and
drop the intent counter. A fundamental decision made during the design
phase of the reverse mapping feature is that updates to the rmapbt
records are always made by the same code that updates the primary
metadata. In other words, callers of bmapi functions expect that the
bmapi functions will queue deferred rmap updates.
Some parts of the reflink code queue deferred refcount (CUI) and bmap
(BUI) updates in the same head transaction, but the deferred work
manager completely finishes the CUI before the BUI work is started. As
a result, the CUI drops the intent count long before the deferred rmap
(RUI) update even has a chance to bump the intent count. The only way
to keep the intent count elevated between the CUI and RUI is for the BUI
to bump the counter until the RUI has been created.
A second quirk of the intent drain code is that deferred work items must
increment the intent counter as soon as the work item is added to the
transaction. When a BUI completes and queues an RUI, the RUI must
increment the counter before the BUI decrements it. The only way to
accomplish this is to require that the counter be bumped as soon as the
deferred work item is created in memory.
In the next patches we'll improve on this facility, but this patch
provides the basic functionality.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
2023-04-12 01:59:58 +00:00
|
|
|
ri->ri_pag = xfs_perag_intent_get(mp, agno);
|
2023-04-12 01:59:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Release a passive AG ref after finishing rmapping work. */
|
|
|
|
|
static inline void
|
|
|
|
|
xfs_rmap_update_put_group(
|
|
|
|
|
struct xfs_rmap_intent *ri)
|
|
|
|
|
{
|
xfs: allow queued AG intents to drain before scrubbing
When a writer thread executes a chain of log intent items, the AG header
buffer locks will cycle during a transaction roll to get from one intent
item to the next in a chain. Although scrub takes all AG header buffer
locks, this isn't sufficient to guard against scrub checking an AG while
that writer thread is in the middle of finishing a chain because there's
no higher level locking primitive guarding allocation groups.
When there's a collision, cross-referencing between data structures
(e.g. rmapbt and refcountbt) yields false corruption events; if repair
is running, this results in incorrect repairs, which is catastrophic.
Fix this by adding to the perag structure the count of active intents
and make scrub wait until it has both AG header buffer locks and the
intent counter reaches zero.
One quirk of the drain code is that deferred bmap updates also bump and
drop the intent counter. A fundamental decision made during the design
phase of the reverse mapping feature is that updates to the rmapbt
records are always made by the same code that updates the primary
metadata. In other words, callers of bmapi functions expect that the
bmapi functions will queue deferred rmap updates.
Some parts of the reflink code queue deferred refcount (CUI) and bmap
(BUI) updates in the same head transaction, but the deferred work
manager completely finishes the CUI before the BUI work is started. As
a result, the CUI drops the intent count long before the deferred rmap
(RUI) update even has a chance to bump the intent count. The only way
to keep the intent count elevated between the CUI and RUI is for the BUI
to bump the counter until the RUI has been created.
A second quirk of the intent drain code is that deferred work items must
increment the intent counter as soon as the work item is added to the
transaction. When a BUI completes and queues an RUI, the RUI must
increment the counter before the BUI decrements it. The only way to
accomplish this is to require that the counter be bumped as soon as the
deferred work item is created in memory.
In the next patches we'll improve on this facility, but this patch
provides the basic functionality.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
2023-04-12 01:59:58 +00:00
|
|
|
xfs_perag_intent_put(ri->ri_pag);
|
2023-04-12 01:59:54 +00:00
|
|
|
}
|
|
|
|
|
|
2019-06-29 02:29:41 +00:00
|
|
|
/* Process a deferred rmap update. */
|
|
|
|
|
STATIC int
|
|
|
|
|
xfs_rmap_update_finish_item(
|
|
|
|
|
struct xfs_trans *tp,
|
2020-04-30 19:52:22 +00:00
|
|
|
struct xfs_log_item *done,
|
2019-06-29 02:29:41 +00:00
|
|
|
struct list_head *item,
|
2020-04-30 19:52:22 +00:00
|
|
|
struct xfs_btree_cur **state)
|
2019-06-29 02:29:41 +00:00
|
|
|
{
|
2023-02-01 18:16:03 +00:00
|
|
|
struct xfs_rmap_intent *ri;
|
2019-06-29 02:29:41 +00:00
|
|
|
int error;
|
|
|
|
|
|
2023-02-01 18:16:03 +00:00
|
|
|
ri = container_of(item, struct xfs_rmap_intent, ri_list);
|
|
|
|
|
|
2023-11-30 18:23:19 +00:00
|
|
|
error = xfs_rmap_finish_one(tp, ri, state);
|
2023-04-12 01:59:54 +00:00
|
|
|
|
|
|
|
|
xfs_rmap_update_put_group(ri);
|
2023-02-01 18:16:03 +00:00
|
|
|
kmem_cache_free(xfs_rmap_intent_cache, ri);
|
2019-06-29 02:29:41 +00:00
|
|
|
return error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Abort all pending RUIs. */
|
|
|
|
|
STATIC void
|
|
|
|
|
xfs_rmap_update_abort_intent(
|
2020-04-30 19:52:21 +00:00
|
|
|
struct xfs_log_item *intent)
|
2019-06-29 02:29:41 +00:00
|
|
|
{
|
2020-04-30 19:52:21 +00:00
|
|
|
xfs_rui_release(RUI_ITEM(intent));
|
2019-06-29 02:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Cancel a deferred rmap update. */
|
|
|
|
|
STATIC void
|
|
|
|
|
xfs_rmap_update_cancel_item(
|
|
|
|
|
struct list_head *item)
|
|
|
|
|
{
|
2023-02-01 18:16:03 +00:00
|
|
|
struct xfs_rmap_intent *ri;
|
2019-06-29 02:29:41 +00:00
|
|
|
|
2023-02-01 18:16:03 +00:00
|
|
|
ri = container_of(item, struct xfs_rmap_intent, ri_list);
|
2023-04-12 01:59:54 +00:00
|
|
|
|
|
|
|
|
xfs_rmap_update_put_group(ri);
|
2023-02-01 18:16:03 +00:00
|
|
|
kmem_cache_free(xfs_rmap_intent_cache, ri);
|
2019-06-29 02:29:41 +00:00
|
|
|
}
|
|
|
|
|
|
2020-11-30 00:33:36 +00:00
|
|
|
/* Is this recovered RUI ok? */
|
|
|
|
|
static inline bool
|
|
|
|
|
xfs_rui_validate_map(
|
|
|
|
|
struct xfs_mount *mp,
|
2023-02-01 18:16:03 +00:00
|
|
|
struct xfs_map_extent *map)
|
2020-11-30 00:33:36 +00:00
|
|
|
{
|
2021-08-19 01:46:37 +00:00
|
|
|
if (!xfs_has_rmapbt(mp))
|
2020-11-30 00:33:39 +00:00
|
|
|
return false;
|
|
|
|
|
|
2023-02-01 18:16:03 +00:00
|
|
|
if (map->me_flags & ~XFS_RMAP_EXTENT_FLAGS)
|
2020-11-30 00:33:37 +00:00
|
|
|
return false;
|
2020-11-30 00:33:36 +00:00
|
|
|
|
2023-02-01 18:16:03 +00:00
|
|
|
switch (map->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
|
2020-11-30 00:33:36 +00:00
|
|
|
case XFS_RMAP_EXTENT_MAP:
|
|
|
|
|
case XFS_RMAP_EXTENT_MAP_SHARED:
|
|
|
|
|
case XFS_RMAP_EXTENT_UNMAP:
|
|
|
|
|
case XFS_RMAP_EXTENT_UNMAP_SHARED:
|
|
|
|
|
case XFS_RMAP_EXTENT_CONVERT:
|
|
|
|
|
case XFS_RMAP_EXTENT_CONVERT_SHARED:
|
|
|
|
|
case XFS_RMAP_EXTENT_ALLOC:
|
|
|
|
|
case XFS_RMAP_EXTENT_FREE:
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2020-11-30 00:33:37 +00:00
|
|
|
return false;
|
2020-11-30 00:33:36 +00:00
|
|
|
}
|
2020-11-30 00:33:37 +00:00
|
|
|
|
2023-02-01 18:16:03 +00:00
|
|
|
if (!XFS_RMAP_NON_INODE_OWNER(map->me_owner) &&
|
|
|
|
|
!xfs_verify_ino(mp, map->me_owner))
|
2020-11-30 00:33:37 +00:00
|
|
|
return false;
|
|
|
|
|
|
2023-02-01 18:16:03 +00:00
|
|
|
if (!xfs_verify_fileext(mp, map->me_startoff, map->me_len))
|
2020-11-30 00:33:37 +00:00
|
|
|
return false;
|
|
|
|
|
|
2023-02-01 18:16:03 +00:00
|
|
|
return xfs_verify_fsbext(mp, map->me_startblock, map->me_len);
|
2020-11-30 00:33:36 +00:00
|
|
|
}
|
|
|
|
|
|
2023-11-22 19:13:03 +00:00
|
|
|
static inline void
|
|
|
|
|
xfs_rui_recover_work(
|
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
|
struct xfs_defer_pending *dfp,
|
|
|
|
|
const struct xfs_map_extent *map)
|
|
|
|
|
{
|
|
|
|
|
struct xfs_rmap_intent *ri;
|
|
|
|
|
|
2024-01-15 22:59:47 +00:00
|
|
|
ri = kmem_cache_alloc(xfs_rmap_intent_cache, GFP_KERNEL | __GFP_NOFAIL);
|
2023-11-22 19:13:03 +00:00
|
|
|
|
|
|
|
|
switch (map->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
|
|
|
|
|
case XFS_RMAP_EXTENT_MAP:
|
|
|
|
|
ri->ri_type = XFS_RMAP_MAP;
|
|
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_EXTENT_MAP_SHARED:
|
|
|
|
|
ri->ri_type = XFS_RMAP_MAP_SHARED;
|
|
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_EXTENT_UNMAP:
|
|
|
|
|
ri->ri_type = XFS_RMAP_UNMAP;
|
|
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_EXTENT_UNMAP_SHARED:
|
|
|
|
|
ri->ri_type = XFS_RMAP_UNMAP_SHARED;
|
|
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_EXTENT_CONVERT:
|
|
|
|
|
ri->ri_type = XFS_RMAP_CONVERT;
|
|
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_EXTENT_CONVERT_SHARED:
|
|
|
|
|
ri->ri_type = XFS_RMAP_CONVERT_SHARED;
|
|
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_EXTENT_ALLOC:
|
|
|
|
|
ri->ri_type = XFS_RMAP_ALLOC;
|
|
|
|
|
break;
|
|
|
|
|
case XFS_RMAP_EXTENT_FREE:
|
|
|
|
|
ri->ri_type = XFS_RMAP_FREE;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
ASSERT(0);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ri->ri_owner = map->me_owner;
|
|
|
|
|
ri->ri_whichfork = (map->me_flags & XFS_RMAP_EXTENT_ATTR_FORK) ?
|
|
|
|
|
XFS_ATTR_FORK : XFS_DATA_FORK;
|
|
|
|
|
ri->ri_bmap.br_startblock = map->me_startblock;
|
|
|
|
|
ri->ri_bmap.br_startoff = map->me_startoff;
|
|
|
|
|
ri->ri_bmap.br_blockcount = map->me_len;
|
|
|
|
|
ri->ri_bmap.br_state = (map->me_flags & XFS_RMAP_EXTENT_UNWRITTEN) ?
|
|
|
|
|
XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
|
2023-11-22 19:25:45 +00:00
|
|
|
xfs_rmap_update_get_group(mp, ri);
|
2023-11-22 19:13:03 +00:00
|
|
|
|
|
|
|
|
xfs_defer_add_item(dfp, &ri->ri_list);
|
|
|
|
|
}
|
|
|
|
|
|
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.
|
|
|
|
|
*/
|
2020-05-01 23:00:51 +00:00
|
|
|
STATIC int
|
2023-11-22 21:39:25 +00:00
|
|
|
xfs_rmap_recover_work(
|
2023-11-22 18:38:10 +00:00
|
|
|
struct xfs_defer_pending *dfp,
|
xfs: proper replay of deferred ops queued during log recovery
When we replay unfinished intent items that have been recovered from the
log, it's possible that the replay will cause the creation of more
deferred work items. As outlined in commit 509955823cc9c ("xfs: log
recovery should replay deferred ops in order"), later work items have an
implicit ordering dependency on earlier work items. Therefore, recovery
must replay the items (both recovered and created) in the same order
that they would have been during normal operation.
For log recovery, we enforce this ordering by using an empty transaction
to collect deferred ops that get created in the process of recovering a
log intent item to prevent them from being committed before the rest of
the recovered intent items. After we finish committing all the
recovered log items, we allocate a transaction with an enormous block
reservation, splice our huge list of created deferred ops into that
transaction, and commit it, thereby finishing all those ops.
This is /really/ hokey -- it's the one place in XFS where we allow
nested transactions; the splicing of the defer ops list is is inelegant
and has to be done twice per recovery function; and the broken way we
handle inode pointers and block reservations cause subtle use-after-free
and allocator problems that will be fixed by this patch and the two
patches after it.
Therefore, replace the hokey empty transaction with a structure designed
to capture each chain of deferred ops that are created as part of
recovering a single unfinished log intent. Finally, refactor the loop
that replays those chains to do so using one transaction per chain.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2020-09-26 00:39:37 +00:00
|
|
|
struct list_head *capture_list)
|
2016-08-03 02:09:48 +00:00
|
|
|
{
|
xfs: reserve less log space when recovering log intent items
Wengang Wang reports that a customer's system was running a number of
truncate operations on a filesystem with a very small log. Contention
on the reserve heads lead to other threads stalling on smaller updates
(e.g. mtime updates) long enough to result in the node being rebooted
on account of the lack of responsivenes. The node failed to recover
because log recovery of an EFI became stuck waiting for a grant of
reserve space. From Wengang's report:
"For the file deletion, log bytes are reserved basing on
xfs_mount->tr_itruncate which is:
tr_logres = 175488,
tr_logcount = 2,
tr_logflags = XFS_TRANS_PERM_LOG_RES,
"You see it's a permanent log reservation with two log operations (two
transactions in rolling mode). After calculation (xlog_calc_unit_res()
adds space for various log headers), the final log space needed per
transaction changes from 175488 to 180208 bytes. So the total log
space needed is 360416 bytes (180208 * 2). [That quantity] of log space
(360416 bytes) needs to be reserved for both run time inode removing
(xfs_inactive_truncate()) and EFI recover (xfs_efi_item_recover())."
In other words, runtime pre-reserves 360K of space in anticipation of
running a chain of two transactions in which each transaction gets a
180K reservation.
Now that we've allocated the transaction, we delete the bmap mapping,
log an EFI to free the space, and roll the transaction as part of
finishing the deferops chain. Rolling creates a new xfs_trans which
shares its ticket with the old transaction. Next, xfs_trans_roll calls
__xfs_trans_commit with regrant == true, which calls xlog_cil_commit
with the same regrant parameter.
xlog_cil_commit calls xfs_log_ticket_regrant, which decrements t_cnt and
subtracts t_curr_res from the reservation and write heads.
If the filesystem is fresh and the first transaction only used (say)
20K, then t_curr_res will be 160K, and we give that much reservation
back to the reservation head. Or if the file is really fragmented and
the first transaction actually uses 170K, then t_curr_res will be 10K,
and that's what we give back to the reservation.
Having done that, we're now headed into the second transaction with an
EFI and 180K of reservation. Other threads apparently consumed all the
reservation for smaller transactions, such as timestamp updates.
Now let's say the first transaction gets written to disk and we crash
without ever completing the second transaction. Now we remount the fs,
log recovery finds the unfinished EFI, and calls xfs_efi_recover to
finish the EFI. However, xfs_efi_recover starts a new tr_itruncate
tranasction, which asks for 360K log reservation. This is a lot more
than the 180K that we had reserved at the time of the crash. If the
first EFI to be recovered is also pinning the tail of the log, we will
be unable to free any space in the log, and recovery livelocks.
Wengang confirmed this:
"Now we have the second transaction which has 180208 log bytes reserved
too. The second transaction is supposed to process intents including
extent freeing. With my hacking patch, I blocked the extent freeing 5
hours. So in that 5 hours, 180208 (NOT 360416) log bytes are reserved.
"With my test case, other transactions (update timestamps) then happen.
As my hacking patch pins the journal tail, those timestamp-updating
transactions finally use up (almost) all the left available log space
(in memory in on disk). And finally the on disk (and in memory)
available log space goes down near to 180208 bytes. Those 180208 bytes
are reserved by [the] second (extent-free) transaction [in the chain]."
Wengang and I noticed that EFI recovery starts a transaction, completes
one step of the chain, and commits the transaction without completing
any other steps of the chain. Those subsequent steps are completed by
xlog_finish_defer_ops, which allocates yet another transaction to
finish the rest of the chain. That transaction gets the same tr_logres
as the head transaction, but with tr_logcount = 1 to force regranting
with every roll to avoid livelocks.
In other words, we already figured this out in commit 929b92f64048d
("xfs: xfs_defer_capture should absorb remaining transaction
reservation"), but should have applied that logic to each intent item's
recovery function. For Wengang's case, the xfs_trans_alloc call in the
EFI recovery function should only be asking for a single transaction's
worth of log reservation -- 180K, not 360K.
Quoting Wengang again:
"With log recovery, during EFI recovery, we use tr_itruncate again to
reserve two transactions that needs 360416 log bytes. Reserving 360416
bytes fails [stalls] because we now only have about 180208 available.
"Actually during the EFI recover, we only need one transaction to free
the extents just like the 2nd transaction at RUNTIME. So it only needs
to reserve 180208 rather than 360416 bytes. We have (a bit) more than
180208 available log bytes on disk, so [if we decrease the reservation
to 180K] the reservation goes and the recovery [finishes]. That is to
say: we can fix the log recover part to fix the issue. We can introduce
a new xfs_trans_res xfs_mount->tr_ext_free
{
tr_logres = 175488,
tr_logcount = 0,
tr_logflags = 0,
}
"and use tr_ext_free instead of tr_itruncate in EFI recover."
However, I don't think it quite makes sense to create an entirely new
transaction reservation type to handle single-stepping during log
recovery. Instead, we should copy the transaction reservation
information in the xfs_mount, change tr_logcount to 1, and pass that
into xfs_trans_alloc. We know this won't risk changing the min log size
computation since we always ask for a fraction of the reservation for
all known transaction types.
This looks like it's been lurking in the codebase since commit
3d3c8b5222b92, which changed the xfs_trans_reserve call in
xlog_recover_process_efi to use the tr_logcount in tr_itruncate.
That changed the EFI recovery transaction from making a
non-XFS_TRANS_PERM_LOG_RES request for one transaction's worth of log
space to a XFS_TRANS_PERM_LOG_RES request for two transactions worth.
Fixes: 3d3c8b5222b92 ("xfs: refactor xfs_trans_reserve() interface")
Complements: 929b92f64048d ("xfs: xfs_defer_capture should absorb remaining transaction reservation")
Suggested-by: Wengang Wang <wen.gang.wang@oracle.com>
Cc: Srikanth C S <srikanth.c.s@oracle.com>
[djwong: apply the same transformation to all log intent recovery]
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
2023-09-11 15:39:05 +00:00
|
|
|
struct xfs_trans_res resv;
|
2023-11-22 18:38:10 +00:00
|
|
|
struct xfs_log_item *lip = dfp->dfp_intent;
|
2020-05-01 23:00:55 +00:00
|
|
|
struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
|
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_trans *tp;
|
2022-03-17 16:09:12 +00:00
|
|
|
struct xfs_mount *mp = lip->li_log->l_mp;
|
2020-05-01 23:00:55 +00:00
|
|
|
int i;
|
|
|
|
|
int error = 0;
|
2016-08-03 02:09:48 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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++) {
|
2020-11-30 00:33:36 +00:00
|
|
|
if (!xfs_rui_validate_map(mp,
|
|
|
|
|
&ruip->rui_format.rui_extents[i])) {
|
|
|
|
|
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
|
|
|
|
|
&ruip->rui_format,
|
|
|
|
|
sizeof(ruip->rui_format));
|
2019-11-06 17:17:43 +00:00
|
|
|
return -EFSCORRUPTED;
|
2020-11-30 00:33:36 +00:00
|
|
|
}
|
2023-11-22 19:13:03 +00:00
|
|
|
|
|
|
|
|
xfs_rui_recover_work(mp, dfp, &ruip->rui_format.rui_extents[i]);
|
2016-08-03 02:09:48 +00:00
|
|
|
}
|
|
|
|
|
|
xfs: reserve less log space when recovering log intent items
Wengang Wang reports that a customer's system was running a number of
truncate operations on a filesystem with a very small log. Contention
on the reserve heads lead to other threads stalling on smaller updates
(e.g. mtime updates) long enough to result in the node being rebooted
on account of the lack of responsivenes. The node failed to recover
because log recovery of an EFI became stuck waiting for a grant of
reserve space. From Wengang's report:
"For the file deletion, log bytes are reserved basing on
xfs_mount->tr_itruncate which is:
tr_logres = 175488,
tr_logcount = 2,
tr_logflags = XFS_TRANS_PERM_LOG_RES,
"You see it's a permanent log reservation with two log operations (two
transactions in rolling mode). After calculation (xlog_calc_unit_res()
adds space for various log headers), the final log space needed per
transaction changes from 175488 to 180208 bytes. So the total log
space needed is 360416 bytes (180208 * 2). [That quantity] of log space
(360416 bytes) needs to be reserved for both run time inode removing
(xfs_inactive_truncate()) and EFI recover (xfs_efi_item_recover())."
In other words, runtime pre-reserves 360K of space in anticipation of
running a chain of two transactions in which each transaction gets a
180K reservation.
Now that we've allocated the transaction, we delete the bmap mapping,
log an EFI to free the space, and roll the transaction as part of
finishing the deferops chain. Rolling creates a new xfs_trans which
shares its ticket with the old transaction. Next, xfs_trans_roll calls
__xfs_trans_commit with regrant == true, which calls xlog_cil_commit
with the same regrant parameter.
xlog_cil_commit calls xfs_log_ticket_regrant, which decrements t_cnt and
subtracts t_curr_res from the reservation and write heads.
If the filesystem is fresh and the first transaction only used (say)
20K, then t_curr_res will be 160K, and we give that much reservation
back to the reservation head. Or if the file is really fragmented and
the first transaction actually uses 170K, then t_curr_res will be 10K,
and that's what we give back to the reservation.
Having done that, we're now headed into the second transaction with an
EFI and 180K of reservation. Other threads apparently consumed all the
reservation for smaller transactions, such as timestamp updates.
Now let's say the first transaction gets written to disk and we crash
without ever completing the second transaction. Now we remount the fs,
log recovery finds the unfinished EFI, and calls xfs_efi_recover to
finish the EFI. However, xfs_efi_recover starts a new tr_itruncate
tranasction, which asks for 360K log reservation. This is a lot more
than the 180K that we had reserved at the time of the crash. If the
first EFI to be recovered is also pinning the tail of the log, we will
be unable to free any space in the log, and recovery livelocks.
Wengang confirmed this:
"Now we have the second transaction which has 180208 log bytes reserved
too. The second transaction is supposed to process intents including
extent freeing. With my hacking patch, I blocked the extent freeing 5
hours. So in that 5 hours, 180208 (NOT 360416) log bytes are reserved.
"With my test case, other transactions (update timestamps) then happen.
As my hacking patch pins the journal tail, those timestamp-updating
transactions finally use up (almost) all the left available log space
(in memory in on disk). And finally the on disk (and in memory)
available log space goes down near to 180208 bytes. Those 180208 bytes
are reserved by [the] second (extent-free) transaction [in the chain]."
Wengang and I noticed that EFI recovery starts a transaction, completes
one step of the chain, and commits the transaction without completing
any other steps of the chain. Those subsequent steps are completed by
xlog_finish_defer_ops, which allocates yet another transaction to
finish the rest of the chain. That transaction gets the same tr_logres
as the head transaction, but with tr_logcount = 1 to force regranting
with every roll to avoid livelocks.
In other words, we already figured this out in commit 929b92f64048d
("xfs: xfs_defer_capture should absorb remaining transaction
reservation"), but should have applied that logic to each intent item's
recovery function. For Wengang's case, the xfs_trans_alloc call in the
EFI recovery function should only be asking for a single transaction's
worth of log reservation -- 180K, not 360K.
Quoting Wengang again:
"With log recovery, during EFI recovery, we use tr_itruncate again to
reserve two transactions that needs 360416 log bytes. Reserving 360416
bytes fails [stalls] because we now only have about 180208 available.
"Actually during the EFI recover, we only need one transaction to free
the extents just like the 2nd transaction at RUNTIME. So it only needs
to reserve 180208 rather than 360416 bytes. We have (a bit) more than
180208 available log bytes on disk, so [if we decrease the reservation
to 180K] the reservation goes and the recovery [finishes]. That is to
say: we can fix the log recover part to fix the issue. We can introduce
a new xfs_trans_res xfs_mount->tr_ext_free
{
tr_logres = 175488,
tr_logcount = 0,
tr_logflags = 0,
}
"and use tr_ext_free instead of tr_itruncate in EFI recover."
However, I don't think it quite makes sense to create an entirely new
transaction reservation type to handle single-stepping during log
recovery. Instead, we should copy the transaction reservation
information in the xfs_mount, change tr_logcount to 1, and pass that
into xfs_trans_alloc. We know this won't risk changing the min log size
computation since we always ask for a fraction of the reservation for
all known transaction types.
This looks like it's been lurking in the codebase since commit
3d3c8b5222b92, which changed the xfs_trans_reserve call in
xlog_recover_process_efi to use the tr_logcount in tr_itruncate.
That changed the EFI recovery transaction from making a
non-XFS_TRANS_PERM_LOG_RES request for one transaction's worth of log
space to a XFS_TRANS_PERM_LOG_RES request for two transactions worth.
Fixes: 3d3c8b5222b92 ("xfs: refactor xfs_trans_reserve() interface")
Complements: 929b92f64048d ("xfs: xfs_defer_capture should absorb remaining transaction reservation")
Suggested-by: Wengang Wang <wen.gang.wang@oracle.com>
Cc: Srikanth C S <srikanth.c.s@oracle.com>
[djwong: apply the same transformation to all log intent recovery]
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
2023-09-11 15:39:05 +00:00
|
|
|
resv = xlog_recover_resv(&M_RES(mp)->tr_itruncate);
|
|
|
|
|
error = xfs_trans_alloc(mp, &resv, 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;
|
2023-11-22 18:47:10 +00:00
|
|
|
|
2023-11-22 19:25:45 +00:00
|
|
|
error = xlog_recover_finish_intent(tp, dfp);
|
|
|
|
|
if (error == -EFSCORRUPTED)
|
|
|
|
|
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
|
|
|
|
|
&ruip->rui_format,
|
|
|
|
|
sizeof(ruip->rui_format));
|
|
|
|
|
if (error)
|
|
|
|
|
goto abort_error;
|
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
|
|
|
|
2021-09-17 00:28:07 +00:00
|
|
|
return xfs_defer_ops_capture_and_commit(tp, capture_list);
|
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
|
|
|
|
|
|
|
|
abort_error:
|
|
|
|
|
xfs_trans_cancel(tp);
|
2016-08-03 02:09:48 +00:00
|
|
|
return error;
|
|
|
|
|
}
|
2020-05-01 23:00:45 +00:00
|
|
|
|
2023-11-30 20:31:30 +00:00
|
|
|
/* Relog an intent item to push the log tail forward. */
|
|
|
|
|
static struct xfs_log_item *
|
|
|
|
|
xfs_rmap_relog_intent(
|
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
|
struct xfs_log_item *intent,
|
|
|
|
|
struct xfs_log_item *done_item)
|
|
|
|
|
{
|
|
|
|
|
struct xfs_rui_log_item *ruip;
|
|
|
|
|
struct xfs_map_extent *map;
|
|
|
|
|
unsigned int count;
|
|
|
|
|
|
|
|
|
|
count = RUI_ITEM(intent)->rui_format.rui_nextents;
|
|
|
|
|
map = RUI_ITEM(intent)->rui_format.rui_extents;
|
|
|
|
|
|
|
|
|
|
ruip = xfs_rui_init(tp->t_mountp, count);
|
|
|
|
|
memcpy(ruip->rui_format.rui_extents, map, count * sizeof(*map));
|
|
|
|
|
atomic_set(&ruip->rui_next_extent, count);
|
|
|
|
|
|
|
|
|
|
return &ruip->rui_item;
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-22 21:39:25 +00:00
|
|
|
const struct xfs_defer_op_type xfs_rmap_update_defer_type = {
|
2023-12-13 09:06:31 +00:00
|
|
|
.name = "rmap",
|
2023-11-22 21:39:25 +00:00
|
|
|
.max_items = XFS_RUI_MAX_FAST_EXTENTS,
|
|
|
|
|
.create_intent = xfs_rmap_update_create_intent,
|
|
|
|
|
.abort_intent = xfs_rmap_update_abort_intent,
|
|
|
|
|
.create_done = xfs_rmap_update_create_done,
|
|
|
|
|
.finish_item = xfs_rmap_update_finish_item,
|
|
|
|
|
.finish_cleanup = xfs_rmap_finish_one_cleanup,
|
|
|
|
|
.cancel_item = xfs_rmap_update_cancel_item,
|
|
|
|
|
.recover_work = xfs_rmap_recover_work,
|
2023-11-30 20:31:30 +00:00
|
|
|
.relog_intent = xfs_rmap_relog_intent,
|
2023-11-22 21:39:25 +00:00
|
|
|
};
|
|
|
|
|
|
2020-05-01 23:00:54 +00:00
|
|
|
STATIC bool
|
|
|
|
|
xfs_rui_item_match(
|
|
|
|
|
struct xfs_log_item *lip,
|
|
|
|
|
uint64_t intent_id)
|
|
|
|
|
{
|
|
|
|
|
return RUI_ITEM(lip)->rui_format.rui_id == intent_id;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-01 23:00:51 +00:00
|
|
|
static const struct xfs_item_ops xfs_rui_item_ops = {
|
2022-05-04 01:46:09 +00:00
|
|
|
.flags = XFS_ITEM_INTENT,
|
2020-05-01 23:00:51 +00:00
|
|
|
.iop_size = xfs_rui_item_size,
|
|
|
|
|
.iop_format = xfs_rui_item_format,
|
|
|
|
|
.iop_unpin = xfs_rui_item_unpin,
|
|
|
|
|
.iop_release = xfs_rui_item_release,
|
2020-05-01 23:00:54 +00:00
|
|
|
.iop_match = xfs_rui_item_match,
|
2020-05-01 23:00:51 +00:00
|
|
|
};
|
|
|
|
|
|
2022-10-20 23:26:36 +00:00
|
|
|
static inline void
|
|
|
|
|
xfs_rui_copy_format(
|
|
|
|
|
struct xfs_rui_log_format *dst,
|
|
|
|
|
const struct xfs_rui_log_format *src)
|
|
|
|
|
{
|
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
|
|
memcpy(dst, src, offsetof(struct xfs_rui_log_format, rui_extents));
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < src->rui_nextents; i++)
|
|
|
|
|
memcpy(&dst->rui_extents[i], &src->rui_extents[i],
|
|
|
|
|
sizeof(struct xfs_map_extent));
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-01 23:00:49 +00:00
|
|
|
/*
|
|
|
|
|
* This routine is called to create an in-core extent rmap update
|
|
|
|
|
* item from the rui format structure which was logged on disk.
|
|
|
|
|
* It allocates an in-core rui, copies the extents from the format
|
|
|
|
|
* structure into it, and adds the rui to the AIL with the given
|
|
|
|
|
* LSN.
|
|
|
|
|
*/
|
|
|
|
|
STATIC int
|
|
|
|
|
xlog_recover_rui_commit_pass2(
|
|
|
|
|
struct xlog *log,
|
|
|
|
|
struct list_head *buffer_list,
|
|
|
|
|
struct xlog_recover_item *item,
|
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
|
{
|
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
|
struct xfs_rui_log_item *ruip;
|
|
|
|
|
struct xfs_rui_log_format *rui_formatp;
|
2022-10-20 23:26:36 +00:00
|
|
|
size_t len;
|
2020-05-01 23:00:49 +00:00
|
|
|
|
|
|
|
|
rui_formatp = item->ri_buf[0].i_addr;
|
|
|
|
|
|
2022-10-20 23:26:36 +00:00
|
|
|
if (item->ri_buf[0].i_len < xfs_rui_log_format_sizeof(0)) {
|
2022-10-25 22:07:14 +00:00
|
|
|
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
|
|
|
|
|
item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
|
2022-10-20 23:26:36 +00:00
|
|
|
return -EFSCORRUPTED;
|
2020-05-01 23:00:49 +00:00
|
|
|
}
|
2022-10-20 23:26:36 +00:00
|
|
|
|
|
|
|
|
len = xfs_rui_log_format_sizeof(rui_formatp->rui_nextents);
|
|
|
|
|
if (item->ri_buf[0].i_len != len) {
|
2022-10-25 22:07:14 +00:00
|
|
|
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp,
|
|
|
|
|
item->ri_buf[0].i_addr, item->ri_buf[0].i_len);
|
2022-10-20 23:26:36 +00:00
|
|
|
return -EFSCORRUPTED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ruip = xfs_rui_init(mp, rui_formatp->rui_nextents);
|
|
|
|
|
xfs_rui_copy_format(&ruip->rui_format, rui_formatp);
|
2020-05-01 23:00:49 +00:00
|
|
|
atomic_set(&ruip->rui_next_extent, rui_formatp->rui_nextents);
|
2023-11-22 18:23:23 +00:00
|
|
|
|
|
|
|
|
xlog_recover_intent_item(log, &ruip->rui_item, lsn,
|
2023-12-14 05:16:32 +00:00
|
|
|
&xfs_rmap_update_defer_type);
|
2020-05-01 23:00:49 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-01 23:00:45 +00:00
|
|
|
const struct xlog_recover_item_ops xlog_rui_item_ops = {
|
|
|
|
|
.item_type = XFS_LI_RUI,
|
2020-05-01 23:00:49 +00:00
|
|
|
.commit_pass2 = xlog_recover_rui_commit_pass2,
|
2020-05-01 23:00:45 +00:00
|
|
|
};
|
|
|
|
|
|
2020-05-01 23:00:49 +00:00
|
|
|
/*
|
|
|
|
|
* This routine is called when an RUD format structure is found in a committed
|
|
|
|
|
* transaction in the log. Its purpose is to cancel the corresponding RUI if it
|
|
|
|
|
* was still in the log. To do this it searches the AIL for the RUI with an id
|
|
|
|
|
* equal to that in the RUD format structure. If we find it we drop the RUD
|
|
|
|
|
* reference, which removes the RUI from the AIL and frees it.
|
|
|
|
|
*/
|
|
|
|
|
STATIC int
|
|
|
|
|
xlog_recover_rud_commit_pass2(
|
|
|
|
|
struct xlog *log,
|
|
|
|
|
struct list_head *buffer_list,
|
|
|
|
|
struct xlog_recover_item *item,
|
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
|
{
|
|
|
|
|
struct xfs_rud_log_format *rud_formatp;
|
|
|
|
|
|
|
|
|
|
rud_formatp = item->ri_buf[0].i_addr;
|
2022-10-25 22:14:06 +00:00
|
|
|
if (item->ri_buf[0].i_len != sizeof(struct xfs_rud_log_format)) {
|
|
|
|
|
XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, log->l_mp,
|
|
|
|
|
rud_formatp, item->ri_buf[0].i_len);
|
|
|
|
|
return -EFSCORRUPTED;
|
|
|
|
|
}
|
2020-05-01 23:00:49 +00:00
|
|
|
|
2020-05-01 23:00:54 +00:00
|
|
|
xlog_recover_release_intent(log, XFS_LI_RUI, rud_formatp->rud_rui_id);
|
2020-05-01 23:00:49 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-01 23:00:45 +00:00
|
|
|
const struct xlog_recover_item_ops xlog_rud_item_ops = {
|
|
|
|
|
.item_type = XFS_LI_RUD,
|
2020-05-01 23:00:49 +00:00
|
|
|
.commit_pass2 = xlog_recover_rud_commit_pass2,
|
2020-05-01 23:00:45 +00:00
|
|
|
};
|