From: "Darrick J. Wong" <djwong@kernel.org>
To: djwong@kernel.org, cem@kernel.org
Cc: linux-xfs@vger.kernel.org
Subject: [PATCH 3/3] xfs_repair: rebuild block mappings from rmapbt data
Date: Sun, 31 Dec 2023 14:08:17 -0800 [thread overview]
Message-ID: <170404990842.1793572.11558699389826458485.stgit@frogsfrogsfrogs> (raw)
In-Reply-To: <170404990800.1793572.4237173751599480312.stgit@frogsfrogsfrogs>
From: Darrick J. Wong <djwong@kernel.org>
Use rmap records to rebuild corrupt inode forks instead of zapping
the whole inode if we think the rmap data is reasonably sane.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
---
include/xfs_trans.h | 2
libxfs/libxfs_api_defs.h | 15 +
libxfs/trans.c | 48 +++
repair/Makefile | 2
repair/agbtree.c | 2
repair/bmap_repair.c | 749 ++++++++++++++++++++++++++++++++++++++++++++++
repair/bmap_repair.h | 13 +
repair/bulkload.c | 205 ++++++++++++-
repair/bulkload.h | 24 +
repair/dinode.c | 54 +++
repair/rmap.c | 2
repair/rmap.h | 1
12 files changed, 1106 insertions(+), 11 deletions(-)
create mode 100644 repair/bmap_repair.c
create mode 100644 repair/bmap_repair.h
diff --git a/include/xfs_trans.h b/include/xfs_trans.h
index ab298ccfe55..ac82c3bc480 100644
--- a/include/xfs_trans.h
+++ b/include/xfs_trans.h
@@ -98,6 +98,8 @@ int libxfs_trans_alloc_rollable(struct xfs_mount *mp, uint blocks,
int libxfs_trans_alloc_empty(struct xfs_mount *mp, struct xfs_trans **tpp);
int libxfs_trans_commit(struct xfs_trans *);
void libxfs_trans_cancel(struct xfs_trans *);
+int libxfs_trans_reserve_more(struct xfs_trans *tp, uint blocks,
+ uint rtextents);
/* cancel dfops associated with a transaction */
void xfs_defer_cancel(struct xfs_trans *);
diff --git a/libxfs/libxfs_api_defs.h b/libxfs/libxfs_api_defs.h
index 0b89b503990..8495590966f 100644
--- a/libxfs/libxfs_api_defs.h
+++ b/libxfs/libxfs_api_defs.h
@@ -32,7 +32,7 @@
#define xfs_alloc_fix_freelist libxfs_alloc_fix_freelist
#define xfs_alloc_min_freelist libxfs_alloc_min_freelist
#define xfs_alloc_read_agf libxfs_alloc_read_agf
-#define xfs_alloc_vextent libxfs_alloc_vextent
+#define xfs_alloc_vextent_start_ag libxfs_alloc_vextent_start_ag
#define xfs_ascii_ci_hashname libxfs_ascii_ci_hashname
@@ -43,11 +43,18 @@
#define xfs_attr_shortform_verify libxfs_attr_shortform_verify
#define __xfs_bmap_add_free __libxfs_bmap_add_free
+#define xfs_bmap_validate_extent libxfs_bmap_validate_extent
#define xfs_bmapi_read libxfs_bmapi_read
+#define xfs_bmapi_remap libxfs_bmapi_remap
#define xfs_bmapi_write libxfs_bmapi_write
#define xfs_bmap_last_offset libxfs_bmap_last_offset
+#define xfs_bmbt_calc_size libxfs_bmbt_calc_size
+#define xfs_bmbt_commit_staged_btree libxfs_bmbt_commit_staged_btree
+#define xfs_bmbt_disk_get_startoff libxfs_bmbt_disk_get_startoff
+#define xfs_bmbt_disk_set_all libxfs_bmbt_disk_set_all
#define xfs_bmbt_maxlevels_ondisk libxfs_bmbt_maxlevels_ondisk
#define xfs_bmbt_maxrecs libxfs_bmbt_maxrecs
+#define xfs_bmbt_stage_cursor libxfs_bmbt_stage_cursor
#define xfs_bmdr_maxrecs libxfs_bmdr_maxrecs
#define xfs_btree_bload libxfs_btree_bload
@@ -116,6 +123,7 @@
#define xfs_finobt_calc_reserves libxfs_finobt_calc_reserves
#define xfs_free_extent libxfs_free_extent
+#define xfs_free_extent_later libxfs_free_extent_later
#define xfs_free_perag libxfs_free_perag
#define xfs_fs_geometry libxfs_fs_geometry
#define xfs_highbit32 libxfs_highbit32
@@ -126,7 +134,10 @@
#define xfs_ialloc_read_agi libxfs_ialloc_read_agi
#define xfs_idata_realloc libxfs_idata_realloc
#define xfs_idestroy_fork libxfs_idestroy_fork
+#define xfs_iext_first libxfs_iext_first
+#define xfs_iext_insert_raw libxfs_iext_insert_raw
#define xfs_iext_lookup_extent libxfs_iext_lookup_extent
+#define xfs_iext_next libxfs_iext_next
#define xfs_ifork_zap_attr libxfs_ifork_zap_attr
#define xfs_imap_to_bp libxfs_imap_to_bp
#define xfs_initialize_perag libxfs_initialize_perag
@@ -173,10 +184,12 @@
#define xfs_rmapbt_stage_cursor libxfs_rmapbt_stage_cursor
#define xfs_rmap_compare libxfs_rmap_compare
#define xfs_rmap_get_rec libxfs_rmap_get_rec
+#define xfs_rmap_ino_bmbt_owner libxfs_rmap_ino_bmbt_owner
#define xfs_rmap_irec_offset_pack libxfs_rmap_irec_offset_pack
#define xfs_rmap_irec_offset_unpack libxfs_rmap_irec_offset_unpack
#define xfs_rmap_lookup_le libxfs_rmap_lookup_le
#define xfs_rmap_lookup_le_range libxfs_rmap_lookup_le_range
+#define xfs_rmap_query_all libxfs_rmap_query_all
#define xfs_rmap_query_range libxfs_rmap_query_range
#define xfs_rtbitmap_getword libxfs_rtbitmap_getword
diff --git a/libxfs/trans.c b/libxfs/trans.c
index bd1186b24e6..8143a6a99f6 100644
--- a/libxfs/trans.c
+++ b/libxfs/trans.c
@@ -1143,3 +1143,51 @@ libxfs_trans_alloc_inode(
*tpp = tp;
return 0;
}
+
+/*
+ * Try to reserve more blocks for a transaction. The single use case we
+ * support is for offline repair -- use a transaction to gather data without
+ * fear of btree cycle deadlocks; calculate how many blocks we really need
+ * from that data; and only then start modifying data. This can fail due to
+ * ENOSPC, so we have to be able to cancel the transaction.
+ */
+int
+libxfs_trans_reserve_more(
+ struct xfs_trans *tp,
+ uint blocks,
+ uint rtextents)
+{
+ int error = 0;
+
+ ASSERT(!(tp->t_flags & XFS_TRANS_DIRTY));
+
+ /*
+ * Attempt to reserve the needed disk blocks by decrementing
+ * the number needed from the number available. This will
+ * fail if the count would go below zero.
+ */
+ if (blocks > 0) {
+ if (tp->t_mountp->m_sb.sb_fdblocks < blocks)
+ return -ENOSPC;
+ tp->t_blk_res += blocks;
+ }
+
+ /*
+ * Attempt to reserve the needed realtime extents by decrementing
+ * the number needed from the number available. This will
+ * fail if the count would go below zero.
+ */
+ if (rtextents > 0) {
+ if (tp->t_mountp->m_sb.sb_rextents < rtextents) {
+ error = -ENOSPC;
+ goto out_blocks;
+ }
+ }
+
+ return 0;
+out_blocks:
+ if (blocks > 0)
+ tp->t_blk_res -= blocks;
+
+ return error;
+}
diff --git a/repair/Makefile b/repair/Makefile
index 2c40e59a30f..e5014deb0ce 100644
--- a/repair/Makefile
+++ b/repair/Makefile
@@ -16,6 +16,7 @@ HFILES = \
avl.h \
bulkload.h \
bmap.h \
+ bmap_repair.h \
btree.h \
da_util.h \
dinode.h \
@@ -41,6 +42,7 @@ CFILES = \
avl.c \
bulkload.c \
bmap.c \
+ bmap_repair.c \
btree.c \
da_util.c \
dino_chunks.c \
diff --git a/repair/agbtree.c b/repair/agbtree.c
index c6f0512fe7d..38f3f7b8fea 100644
--- a/repair/agbtree.c
+++ b/repair/agbtree.c
@@ -22,7 +22,7 @@ init_rebuild(
{
memset(btr, 0, sizeof(struct bt_rebuild));
- bulkload_init_ag(&btr->newbt, sc, oinfo);
+ bulkload_init_ag(&btr->newbt, sc, oinfo, NULLFSBLOCK);
btr->bload.max_dirty = XFS_B_TO_FSBT(sc->mp, 256U << 10); /* 256K */
bulkload_estimate_ag_slack(sc, &btr->bload, est_agfreeblocks);
}
diff --git a/repair/bmap_repair.c b/repair/bmap_repair.c
new file mode 100644
index 00000000000..7705980621c
--- /dev/null
+++ b/repair/bmap_repair.c
@@ -0,0 +1,749 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2019-2024 Oracle. All Rights Reserved.
+ * Author: Darrick J. Wong <djwong@kernel.org>
+ */
+#include <libxfs.h>
+#include "btree.h"
+#include "err_protos.h"
+#include "libxlog.h"
+#include "incore.h"
+#include "globals.h"
+#include "dinode.h"
+#include "slab.h"
+#include "rmap.h"
+#include "bulkload.h"
+#include "bmap_repair.h"
+
+#define min_t(type, x, y) ( ((type)(x)) > ((type)(y)) ? ((type)(y)) : ((type)(x)) )
+
+/*
+ * Inode Fork Block Mapping (BMBT) Repair
+ * ======================================
+ *
+ * Gather all the rmap records for the inode and fork we're fixing, reset the
+ * incore fork, then recreate the btree.
+ */
+struct xrep_bmap {
+ /* List of new bmap records. */
+ struct xfs_slab *bmap_records;
+ struct xfs_slab_cursor *bmap_cursor;
+
+ /* New fork. */
+ struct bulkload new_fork_info;
+ struct xfs_btree_bload bmap_bload;
+
+ struct repair_ctx *sc;
+
+ /* How many blocks did we find allocated to this file? */
+ xfs_rfsblock_t nblocks;
+
+ /* How many bmbt blocks did we find for this fork? */
+ xfs_rfsblock_t old_bmbt_block_count;
+
+ /* Which fork are we fixing? */
+ int whichfork;
+};
+
+/* Remember this reverse-mapping as a series of bmap records. */
+STATIC int
+xrep_bmap_from_rmap(
+ struct xrep_bmap *rb,
+ xfs_fileoff_t startoff,
+ xfs_fsblock_t startblock,
+ xfs_filblks_t blockcount,
+ bool unwritten)
+{
+ struct xfs_bmbt_rec rbe;
+ struct xfs_bmbt_irec irec;
+ int error = 0;
+
+ irec.br_startoff = startoff;
+ irec.br_startblock = startblock;
+ irec.br_state = unwritten ? XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
+
+ do {
+ xfs_failaddr_t fa;
+
+ irec.br_blockcount = min_t(xfs_filblks_t, blockcount,
+ XFS_MAX_BMBT_EXTLEN);
+
+ fa = libxfs_bmap_validate_extent(rb->sc->ip, rb->whichfork,
+ &irec);
+ if (fa)
+ return -EFSCORRUPTED;
+
+ libxfs_bmbt_disk_set_all(&rbe, &irec);
+
+ error = slab_add(rb->bmap_records, &rbe);
+ if (error)
+ return error;
+
+ irec.br_startblock += irec.br_blockcount;
+ irec.br_startoff += irec.br_blockcount;
+ blockcount -= irec.br_blockcount;
+ } while (blockcount > 0);
+
+ return 0;
+}
+
+/* Check for any obvious errors or conflicts in the file mapping. */
+STATIC int
+xrep_bmap_check_fork_rmap(
+ struct xrep_bmap *rb,
+ struct xfs_btree_cur *cur,
+ const struct xfs_rmap_irec *rec)
+{
+ struct repair_ctx *sc = rb->sc;
+
+ /*
+ * Data extents for rt files are never stored on the data device, but
+ * everything else (xattrs, bmbt blocks) can be.
+ */
+ if (XFS_IS_REALTIME_INODE(sc->ip) &&
+ !(rec->rm_flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK)))
+ return EFSCORRUPTED;
+
+ /* Check that this is within the AG. */
+ if (!xfs_verify_agbext(cur->bc_ag.pag, rec->rm_startblock,
+ rec->rm_blockcount))
+ return EFSCORRUPTED;
+
+ /* No contradictory flags. */
+ if ((rec->rm_flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK)) &&
+ (rec->rm_flags & XFS_RMAP_UNWRITTEN))
+ return EFSCORRUPTED;
+
+ /* Check the file offset range. */
+ if (!(rec->rm_flags & XFS_RMAP_BMBT_BLOCK) &&
+ !xfs_verify_fileext(sc->mp, rec->rm_offset, rec->rm_blockcount))
+ return EFSCORRUPTED;
+
+ return 0;
+}
+
+/* Record extents that belong to this inode's fork. */
+STATIC int
+xrep_bmap_walk_rmap(
+ struct xfs_btree_cur *cur,
+ const struct xfs_rmap_irec *rec,
+ void *priv)
+{
+ struct xrep_bmap *rb = priv;
+ struct xfs_mount *mp = cur->bc_mp;
+ xfs_fsblock_t fsbno;
+ int error;
+
+ /* Skip extents which are not owned by this inode and fork. */
+ if (rec->rm_owner != rb->sc->ip->i_ino)
+ return 0;
+
+ error = xrep_bmap_check_fork_rmap(rb, cur, rec);
+ if (error)
+ return error;
+
+ /*
+ * Record all blocks allocated to this file even if the extent isn't
+ * for the fork we're rebuilding so that we can reset di_nblocks later.
+ */
+ rb->nblocks += rec->rm_blockcount;
+
+ /* If this rmap isn't for the fork we want, we're done. */
+ if (rb->whichfork == XFS_DATA_FORK &&
+ (rec->rm_flags & XFS_RMAP_ATTR_FORK))
+ return 0;
+ if (rb->whichfork == XFS_ATTR_FORK &&
+ !(rec->rm_flags & XFS_RMAP_ATTR_FORK))
+ return 0;
+
+ fsbno = XFS_AGB_TO_FSB(mp, cur->bc_ag.pag->pag_agno,
+ rec->rm_startblock);
+
+ if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK) {
+ rb->old_bmbt_block_count += rec->rm_blockcount;
+ return 0;
+ }
+
+ return xrep_bmap_from_rmap(rb, rec->rm_offset, fsbno,
+ rec->rm_blockcount,
+ rec->rm_flags & XFS_RMAP_UNWRITTEN);
+}
+
+/* Compare two bmap extents. */
+static int
+xrep_bmap_extent_cmp(
+ const void *a,
+ const void *b)
+{
+ xfs_fileoff_t ao;
+ xfs_fileoff_t bo;
+
+ ao = libxfs_bmbt_disk_get_startoff((struct xfs_bmbt_rec *)a);
+ bo = libxfs_bmbt_disk_get_startoff((struct xfs_bmbt_rec *)b);
+
+ if (ao > bo)
+ return 1;
+ else if (ao < bo)
+ return -1;
+ return 0;
+}
+
+/* Scan one AG for reverse mappings that we can turn into extent maps. */
+STATIC int
+xrep_bmap_scan_ag(
+ struct xrep_bmap *rb,
+ struct xfs_perag *pag)
+{
+ struct repair_ctx *sc = rb->sc;
+ struct xfs_mount *mp = sc->mp;
+ struct xfs_buf *agf_bp = NULL;
+ struct xfs_btree_cur *cur;
+ int error;
+
+ error = -libxfs_alloc_read_agf(pag, sc->tp, 0, &agf_bp);
+ if (error)
+ return error;
+ if (!agf_bp)
+ return ENOMEM;
+ cur = libxfs_rmapbt_init_cursor(mp, sc->tp, agf_bp, pag);
+ error = -libxfs_rmap_query_all(cur, xrep_bmap_walk_rmap, rb);
+ libxfs_btree_del_cursor(cur, error);
+ libxfs_trans_brelse(sc->tp, agf_bp);
+ return error;
+}
+
+/*
+ * Collect block mappings for this fork of this inode and decide if we have
+ * enough space to rebuild. Caller is responsible for cleaning up the list if
+ * anything goes wrong.
+ */
+STATIC int
+xrep_bmap_find_mappings(
+ struct xrep_bmap *rb)
+{
+ struct xfs_perag *pag;
+ xfs_agnumber_t agno;
+ int error;
+
+ /* Iterate the rmaps for extents. */
+ for_each_perag(rb->sc->mp, agno, pag) {
+ error = xrep_bmap_scan_ag(rb, pag);
+ if (error) {
+ libxfs_perag_put(pag);
+ return error;
+ }
+ }
+
+ return 0;
+}
+
+/* Retrieve bmap data for bulk load. */
+STATIC int
+xrep_bmap_get_records(
+ struct xfs_btree_cur *cur,
+ unsigned int idx,
+ struct xfs_btree_block *block,
+ unsigned int nr_wanted,
+ void *priv)
+{
+ struct xfs_bmbt_rec *rec;
+ struct xfs_bmbt_irec *irec = &cur->bc_rec.b;
+ struct xrep_bmap *rb = priv;
+ union xfs_btree_rec *block_rec;
+ unsigned int loaded;
+
+ for (loaded = 0; loaded < nr_wanted; loaded++, idx++) {
+ rec = pop_slab_cursor(rb->bmap_cursor);
+ libxfs_bmbt_disk_get_all(rec, irec);
+
+ block_rec = libxfs_btree_rec_addr(cur, idx, block);
+ cur->bc_ops->init_rec_from_cur(cur, block_rec);
+ }
+
+ return loaded;
+}
+
+/* Feed one of the new btree blocks to the bulk loader. */
+STATIC int
+xrep_bmap_claim_block(
+ struct xfs_btree_cur *cur,
+ union xfs_btree_ptr *ptr,
+ void *priv)
+{
+ struct xrep_bmap *rb = priv;
+
+ return bulkload_claim_block(cur, &rb->new_fork_info, ptr);
+}
+
+/* Figure out how much space we need to create the incore btree root block. */
+STATIC size_t
+xrep_bmap_iroot_size(
+ struct xfs_btree_cur *cur,
+ unsigned int level,
+ unsigned int nr_this_level,
+ void *priv)
+{
+ ASSERT(level > 0);
+
+ return XFS_BMAP_BROOT_SPACE_CALC(cur->bc_mp, nr_this_level);
+}
+
+/* Update the inode counters. */
+STATIC int
+xrep_bmap_reset_counters(
+ struct xrep_bmap *rb)
+{
+ struct repair_ctx *sc = rb->sc;
+ struct xbtree_ifakeroot *ifake = &rb->new_fork_info.ifake;
+ int64_t delta;
+
+ /*
+ * Update the inode block counts to reflect the extents we found in the
+ * rmapbt.
+ */
+ delta = ifake->if_blocks - rb->old_bmbt_block_count;
+ sc->ip->i_nblocks = rb->nblocks + delta;
+ libxfs_trans_log_inode(sc->tp, sc->ip, XFS_ILOG_CORE);
+
+ /* Quotas don't exist so we're done. */
+ return 0;
+}
+
+/*
+ * Ensure that the inode being repaired is ready to handle a certain number of
+ * extents, or return EFSCORRUPTED. Caller must hold the ILOCK of the inode
+ * being repaired and have joined it to the scrub transaction.
+ */
+static int
+xrep_ino_ensure_extent_count(
+ struct repair_ctx *sc,
+ int whichfork,
+ xfs_extnum_t nextents)
+{
+ xfs_extnum_t max_extents;
+ bool large_extcount;
+
+ large_extcount = xfs_inode_has_large_extent_counts(sc->ip);
+ max_extents = xfs_iext_max_nextents(large_extcount, whichfork);
+ if (nextents <= max_extents)
+ return 0;
+ if (large_extcount)
+ return EFSCORRUPTED;
+ if (!xfs_has_large_extent_counts(sc->mp))
+ return EFSCORRUPTED;
+
+ max_extents = xfs_iext_max_nextents(true, whichfork);
+ if (nextents > max_extents)
+ return EFSCORRUPTED;
+
+ sc->ip->i_diflags2 |= XFS_DIFLAG2_NREXT64;
+ libxfs_trans_log_inode(sc->tp, sc->ip, XFS_ILOG_CORE);
+ return 0;
+}
+
+/*
+ * Create a new iext tree and load it with block mappings. If the inode is
+ * in extents format, that's all we need to do to commit the new mappings.
+ * If it is in btree format, this takes care of preloading the incore tree.
+ */
+STATIC int
+xrep_bmap_extents_load(
+ struct xrep_bmap *rb,
+ struct xfs_btree_cur *bmap_cur,
+ uint64_t nextents)
+{
+ struct xfs_iext_cursor icur;
+ struct xbtree_ifakeroot *ifake = &rb->new_fork_info.ifake;
+ struct xfs_ifork *ifp = ifake->if_fork;
+ unsigned int i;
+ int error;
+
+ ASSERT(ifp->if_bytes == 0);
+
+ error = init_slab_cursor(rb->bmap_records, xrep_bmap_extent_cmp,
+ &rb->bmap_cursor);
+ if (error)
+ return error;
+
+ /* Add all the mappings to the incore extent tree. */
+ libxfs_iext_first(ifp, &icur);
+ for (i = 0; i < nextents; i++) {
+ struct xfs_bmbt_rec *rec;
+
+ rec = pop_slab_cursor(rb->bmap_cursor);
+ libxfs_bmbt_disk_get_all(rec, &bmap_cur->bc_rec.b);
+ libxfs_iext_insert_raw(ifp, &icur, &bmap_cur->bc_rec.b);
+ ifp->if_nextents++;
+ libxfs_iext_next(ifp, &icur);
+ }
+ free_slab_cursor(&rb->bmap_cursor);
+
+ return xrep_ino_ensure_extent_count(rb->sc, rb->whichfork,
+ ifp->if_nextents);
+}
+
+/*
+ * Reserve new btree blocks, bulk load the bmap records into the ondisk btree,
+ * and load the incore extent tree.
+ */
+STATIC int
+xrep_bmap_btree_load(
+ struct xrep_bmap *rb,
+ struct xfs_btree_cur *bmap_cur,
+ uint64_t nextents)
+{
+ struct repair_ctx *sc = rb->sc;
+ int error;
+
+ rb->bmap_bload.get_records = xrep_bmap_get_records;
+ rb->bmap_bload.claim_block = xrep_bmap_claim_block;
+ rb->bmap_bload.iroot_size = xrep_bmap_iroot_size;
+ rb->bmap_bload.max_dirty = XFS_B_TO_FSBT(sc->mp, 256U << 10); /* 256K */
+
+ /*
+ * Always make the btree as small as possible, since we might need the
+ * space to rebuild the space metadata btrees in later phases.
+ */
+ rb->bmap_bload.leaf_slack = 0;
+ rb->bmap_bload.node_slack = 0;
+
+ /* Compute how many blocks we'll need. */
+ error = -libxfs_btree_bload_compute_geometry(bmap_cur, &rb->bmap_bload,
+ nextents);
+ if (error)
+ return error;
+
+ /*
+ * Guess how many blocks we're going to need to rebuild an entire bmap
+ * from the number of extents we found, and pump up our transaction to
+ * have sufficient block reservation.
+ */
+ error = -libxfs_trans_reserve_more(sc->tp, rb->bmap_bload.nr_blocks, 0);
+ if (error)
+ return error;
+
+ /* Reserve the space we'll need for the new btree. */
+ error = bulkload_alloc_file_blocks(&rb->new_fork_info,
+ rb->bmap_bload.nr_blocks);
+ if (error)
+ return error;
+
+ /* Add all observed bmap records. */
+ error = init_slab_cursor(rb->bmap_records, xrep_bmap_extent_cmp,
+ &rb->bmap_cursor);
+ if (error)
+ return error;
+ error = -libxfs_btree_bload(bmap_cur, &rb->bmap_bload, rb);
+ free_slab_cursor(&rb->bmap_cursor);
+ if (error)
+ return error;
+
+ /*
+ * Load the new bmap records into the new incore extent tree to
+ * preserve delalloc reservations for regular files. The directory
+ * code loads the extent tree during xfs_dir_open and assumes
+ * thereafter that it remains loaded, so we must not violate that
+ * assumption.
+ */
+ return xrep_bmap_extents_load(rb, bmap_cur, nextents);
+}
+
+/*
+ * Use the collected bmap information to stage a new bmap fork. If this is
+ * successful we'll return with the new fork information logged to the repair
+ * transaction but not yet committed.
+ */
+STATIC int
+xrep_bmap_build_new_fork(
+ struct xrep_bmap *rb)
+{
+ struct xfs_owner_info oinfo;
+ struct repair_ctx *sc = rb->sc;
+ struct xfs_btree_cur *bmap_cur;
+ struct xbtree_ifakeroot *ifake = &rb->new_fork_info.ifake;
+ uint64_t nextents;
+ int error;
+
+ /*
+ * Sort the bmap extents by startblock to avoid btree splits when we
+ * rebuild the bmbt btree.
+ */
+ qsort_slab(rb->bmap_records, xrep_bmap_extent_cmp);
+
+ /*
+ * Prepare to construct the new fork by initializing the new btree
+ * structure and creating a fake ifork in the ifakeroot structure.
+ */
+ libxfs_rmap_ino_bmbt_owner(&oinfo, sc->ip->i_ino, rb->whichfork);
+ bulkload_init_inode(&rb->new_fork_info, sc, rb->whichfork, &oinfo);
+ bmap_cur = libxfs_bmbt_stage_cursor(sc->mp, sc->ip, ifake);
+
+ /*
+ * Figure out the size and format of the new fork, then fill it with
+ * all the bmap records we've found. Join the inode to the transaction
+ * so that we can roll the transaction while holding the inode locked.
+ */
+ libxfs_trans_ijoin(sc->tp, sc->ip, 0);
+ nextents = slab_count(rb->bmap_records);
+ if (nextents <= XFS_IFORK_MAXEXT(sc->ip, rb->whichfork)) {
+ ifake->if_fork->if_format = XFS_DINODE_FMT_EXTENTS;
+ error = xrep_bmap_extents_load(rb, bmap_cur, nextents);
+ } else {
+ ifake->if_fork->if_format = XFS_DINODE_FMT_BTREE;
+ error = xrep_bmap_btree_load(rb, bmap_cur, nextents);
+ }
+ if (error)
+ goto err_cur;
+
+ /*
+ * Install the new fork in the inode. After this point the old mapping
+ * data are no longer accessible and the new tree is live. We delete
+ * the cursor immediately after committing the staged root because the
+ * staged fork might be in extents format.
+ */
+ libxfs_bmbt_commit_staged_btree(bmap_cur, sc->tp, rb->whichfork);
+ libxfs_btree_del_cursor(bmap_cur, 0);
+
+ /* Reset the inode counters now that we've changed the fork. */
+ error = xrep_bmap_reset_counters(rb);
+ if (error)
+ goto err_newbt;
+
+ /* Dispose of any unused blocks and the accounting infomation. */
+ error = bulkload_commit(&rb->new_fork_info);
+ if (error)
+ return error;
+
+ return -libxfs_trans_roll_inode(&sc->tp, sc->ip);
+err_cur:
+ if (bmap_cur)
+ libxfs_btree_del_cursor(bmap_cur, error);
+err_newbt:
+ bulkload_cancel(&rb->new_fork_info);
+ return error;
+}
+
+/* Check for garbage inputs. Returns ECANCELED if there's nothing to do. */
+STATIC int
+xrep_bmap_check_inputs(
+ struct repair_ctx *sc,
+ int whichfork)
+{
+ struct xfs_ifork *ifp = xfs_ifork_ptr(sc->ip, whichfork);
+
+ ASSERT(whichfork == XFS_DATA_FORK || whichfork == XFS_ATTR_FORK);
+
+ if (!xfs_has_rmapbt(sc->mp))
+ return EOPNOTSUPP;
+
+ /* No fork means nothing to rebuild. */
+ if (!ifp)
+ return ECANCELED;
+
+ /*
+ * We only know how to repair extent mappings, which is to say that we
+ * only support extents and btree fork format. Repairs to a local
+ * format fork require a higher level repair function, so we do not
+ * have any work to do here.
+ */
+ switch (ifp->if_format) {
+ case XFS_DINODE_FMT_DEV:
+ case XFS_DINODE_FMT_LOCAL:
+ case XFS_DINODE_FMT_UUID:
+ return ECANCELED;
+ case XFS_DINODE_FMT_EXTENTS:
+ case XFS_DINODE_FMT_BTREE:
+ break;
+ default:
+ return EFSCORRUPTED;
+ }
+
+ if (whichfork == XFS_ATTR_FORK)
+ return 0;
+
+ /* Only files, symlinks, and directories get to have data forks. */
+ switch (VFS_I(sc->ip)->i_mode & S_IFMT) {
+ case S_IFREG:
+ case S_IFDIR:
+ case S_IFLNK:
+ /* ok */
+ break;
+ default:
+ return EINVAL;
+ }
+
+ /* Don't know how to rebuild realtime data forks. */
+ if (XFS_IS_REALTIME_INODE(sc->ip))
+ return EOPNOTSUPP;
+
+ return 0;
+}
+
+/* Repair an inode fork. */
+STATIC int
+xrep_bmap(
+ struct repair_ctx *sc,
+ int whichfork)
+{
+ struct xrep_bmap *rb;
+ int error = 0;
+
+ error = xrep_bmap_check_inputs(sc, whichfork);
+ if (error == ECANCELED)
+ return 0;
+ if (error)
+ return error;
+
+ rb = kmem_zalloc(sizeof(struct xrep_bmap), KM_NOFS | KM_MAYFAIL);
+ if (!rb)
+ return ENOMEM;
+ rb->sc = sc;
+ rb->whichfork = whichfork;
+
+ /* Set up some storage */
+ error = init_slab(&rb->bmap_records, sizeof(struct xfs_bmbt_rec));
+ if (error)
+ goto out_rb;
+
+ /* Collect all reverse mappings for this fork's extents. */
+ error = xrep_bmap_find_mappings(rb);
+ if (error)
+ goto out_bitmap;
+
+ /* Rebuild the bmap information. */
+ error = xrep_bmap_build_new_fork(rb);
+
+ /*
+ * We don't need to free the old bmbt blocks because we're rebuilding
+ * all the space metadata later.
+ */
+
+out_bitmap:
+ free_slab(&rb->bmap_records);
+out_rb:
+ kmem_free(rb);
+ return error;
+}
+
+/* Rebuild some inode's bmap. */
+int
+rebuild_bmap(
+ struct xfs_mount *mp,
+ xfs_ino_t ino,
+ int whichfork,
+ unsigned long nr_extents,
+ struct xfs_buf **ino_bpp,
+ struct xfs_dinode **dinop,
+ int *dirty)
+{
+ struct repair_ctx sc = {
+ .mp = mp,
+ };
+ const struct xfs_buf_ops *bp_ops;
+ unsigned long boffset;
+ unsigned long long resblks;
+ xfs_daddr_t bp_bn;
+ int bp_length;
+ int error, err2;
+
+ bp_bn = xfs_buf_daddr(*ino_bpp);
+ bp_length = (*ino_bpp)->b_length;
+ bp_ops = (*ino_bpp)->b_ops;
+ boffset = (char *)(*dinop) - (char *)(*ino_bpp)->b_addr;
+
+ /*
+ * Bail out if the inode didn't think it had extents. Otherwise, zap
+ * it back to a zero-extents fork so that we can rebuild it.
+ */
+ switch (whichfork) {
+ case XFS_DATA_FORK:
+ if ((*dinop)->di_nextents == 0)
+ return 0;
+ (*dinop)->di_format = XFS_DINODE_FMT_EXTENTS;
+ (*dinop)->di_nextents = 0;
+ libxfs_dinode_calc_crc(mp, *dinop);
+ *dirty = 1;
+ break;
+ case XFS_ATTR_FORK:
+ if ((*dinop)->di_anextents == 0)
+ return 0;
+ (*dinop)->di_aformat = XFS_DINODE_FMT_EXTENTS;
+ (*dinop)->di_anextents = 0;
+ libxfs_dinode_calc_crc(mp, *dinop);
+ *dirty = 1;
+ break;
+ default:
+ return EINVAL;
+ }
+
+ resblks = libxfs_bmbt_calc_size(mp, nr_extents);
+ error = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, resblks, 0,
+ 0, &sc.tp);
+ if (error)
+ return error;
+
+ /*
+ * Repair magic: the caller passed us the inode cluster buffer for the
+ * inode. The _iget call grabs the buffer to load the incore inode, so
+ * the buffer must be attached to the transaction to avoid recursing
+ * the buffer lock.
+ *
+ * Unfortunately, the _iget call drops the buffer once the inode is
+ * loaded, so if we've made any changes we have to log the buffer, hold
+ * it, and roll the transaction. This persists the caller's changes
+ * and maintains our ownership of the cluster buffer.
+ */
+ libxfs_trans_bjoin(sc.tp, *ino_bpp);
+ if (*dirty) {
+ unsigned int end = BBTOB((*ino_bpp)->b_length) - 1;
+
+ libxfs_trans_log_buf(sc.tp, *ino_bpp, 0, end);
+ *dirty = 0;
+
+ libxfs_trans_bhold(sc.tp, *ino_bpp);
+ error = -libxfs_trans_roll(&sc.tp);
+ libxfs_trans_bjoin(sc.tp, *ino_bpp);
+ if (error)
+ goto out_cancel;
+ }
+
+ /* Grab the inode and fix the bmbt. */
+ error = -libxfs_iget(mp, sc.tp, ino, 0, &sc.ip);
+ if (error)
+ goto out_cancel;
+ error = xrep_bmap(&sc, whichfork);
+ if (error)
+ libxfs_trans_cancel(sc.tp);
+ else
+ error = -libxfs_trans_commit(sc.tp);
+
+ /*
+ * Rebuilding the inode fork rolled the transaction, so we need to
+ * re-grab the inode cluster buffer and dinode pointer for the caller.
+ */
+ err2 = -libxfs_imap_to_bp(mp, NULL, &sc.ip->i_imap, ino_bpp);
+ if (err2)
+ do_error(
+ _("Unable to re-grab inode cluster buffer after failed repair of inode %llu, error %d.\n"),
+ (unsigned long long)ino, err2);
+ *dinop = xfs_buf_offset(*ino_bpp, sc.ip->i_imap.im_boffset);
+ libxfs_irele(sc.ip);
+
+ return error;
+
+out_cancel:
+ libxfs_trans_cancel(sc.tp);
+
+ /*
+ * Try to regrab the old buffer so we have something to return to the
+ * caller.
+ */
+ err2 = -libxfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, bp_bn,
+ bp_length, 0, ino_bpp, bp_ops);
+ if (err2)
+ do_error(
+ _("Unable to re-grab inode cluster buffer after failed repair of inode %llu, error %d.\n"),
+ (unsigned long long)ino, err2);
+ *dinop = xfs_buf_offset(*ino_bpp, boffset);
+ return error;
+}
diff --git a/repair/bmap_repair.h b/repair/bmap_repair.h
new file mode 100644
index 00000000000..6d55359490a
--- /dev/null
+++ b/repair/bmap_repair.h
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (c) 2019-2024 Oracle. All Rights Reserved.
+ * Author: Darrick J. Wong <djwong@kernel.org>
+ */
+#ifndef REBUILD_H_
+#define REBUILD_H_
+
+int rebuild_bmap(struct xfs_mount *mp, xfs_ino_t ino, int whichfork,
+ unsigned long nr_extents, struct xfs_buf **ino_bpp,
+ struct xfs_dinode **dinop, int *dirty);
+
+#endif /* REBUILD_H_ */
diff --git a/repair/bulkload.c b/repair/bulkload.c
index 18158c397f5..a97839f549d 100644
--- a/repair/bulkload.c
+++ b/repair/bulkload.c
@@ -14,14 +14,29 @@ void
bulkload_init_ag(
struct bulkload *bkl,
struct repair_ctx *sc,
- const struct xfs_owner_info *oinfo)
+ const struct xfs_owner_info *oinfo,
+ xfs_fsblock_t alloc_hint)
{
memset(bkl, 0, sizeof(struct bulkload));
bkl->sc = sc;
bkl->oinfo = *oinfo; /* structure copy */
+ bkl->alloc_hint = alloc_hint;
INIT_LIST_HEAD(&bkl->resv_list);
}
+/* Initialize accounting resources for staging a new inode fork btree. */
+void
+bulkload_init_inode(
+ struct bulkload *bkl,
+ struct repair_ctx *sc,
+ int whichfork,
+ const struct xfs_owner_info *oinfo)
+{
+ bulkload_init_ag(bkl, sc, oinfo, XFS_INO_TO_FSB(sc->mp, sc->ip->i_ino));
+ bkl->ifake.if_fork = kmem_cache_zalloc(xfs_ifork_cache, 0);
+ bkl->ifake.if_fork_size = xfs_inode_fork_size(sc->ip, whichfork);
+}
+
/* Designate specific blocks to be used to build our new btree. */
static int
bulkload_add_blocks(
@@ -71,17 +86,199 @@ bulkload_add_extent(
return bulkload_add_blocks(bkl, pag, &args);
}
+/* Don't let our allocation hint take us beyond EOFS */
+static inline void
+bulkload_validate_file_alloc_hint(
+ struct bulkload *bkl)
+{
+ struct repair_ctx *sc = bkl->sc;
+
+ if (libxfs_verify_fsbno(sc->mp, bkl->alloc_hint))
+ return;
+
+ bkl->alloc_hint = XFS_AGB_TO_FSB(sc->mp, 0, XFS_AGFL_BLOCK(sc->mp) + 1);
+}
+
+/* Allocate disk space for our new file-based btree. */
+int
+bulkload_alloc_file_blocks(
+ struct bulkload *bkl,
+ uint64_t nr_blocks)
+{
+ struct repair_ctx *sc = bkl->sc;
+ struct xfs_mount *mp = sc->mp;
+ int error = 0;
+
+ while (nr_blocks > 0) {
+ struct xfs_alloc_arg args = {
+ .tp = sc->tp,
+ .mp = mp,
+ .oinfo = bkl->oinfo,
+ .minlen = 1,
+ .maxlen = nr_blocks,
+ .prod = 1,
+ .resv = XFS_AG_RESV_NONE,
+ };
+ struct xfs_perag *pag;
+ xfs_agnumber_t agno;
+
+ bulkload_validate_file_alloc_hint(bkl);
+
+ error = -libxfs_alloc_vextent_start_ag(&args, bkl->alloc_hint);
+ if (error)
+ return error;
+ if (args.fsbno == NULLFSBLOCK)
+ return ENOSPC;
+
+ agno = XFS_FSB_TO_AGNO(mp, args.fsbno);
+
+ pag = libxfs_perag_get(mp, agno);
+ if (!pag) {
+ ASSERT(0);
+ return -EFSCORRUPTED;
+ }
+
+ error = bulkload_add_blocks(bkl, pag, &args);
+ libxfs_perag_put(pag);
+ if (error)
+ return error;
+
+ nr_blocks -= args.len;
+ bkl->alloc_hint = args.fsbno + args.len;
+
+ error = -libxfs_defer_finish(&sc->tp);
+ if (error)
+ return error;
+ }
+
+ return 0;
+}
+
+/*
+ * Free the unused part of a space extent that was reserved for a new ondisk
+ * structure. Returns the number of EFIs logged or a negative errno.
+ */
+static inline int
+bulkload_free_extent(
+ struct bulkload *bkl,
+ struct bulkload_resv *resv,
+ bool btree_committed)
+{
+ struct repair_ctx *sc = bkl->sc;
+ xfs_agblock_t free_agbno = resv->agbno;
+ xfs_extlen_t free_aglen = resv->len;
+ xfs_fsblock_t fsbno;
+ int error;
+
+ if (!btree_committed || resv->used == 0) {
+ /*
+ * If we're not committing a new btree or we didn't use the
+ * space reservation, free the entire space extent.
+ */
+ goto free;
+ }
+
+ /*
+ * We used space and committed the btree. Remove the written blocks
+ * from the reservation and possibly log a new EFI to free any unused
+ * reservation space.
+ */
+ free_agbno += resv->used;
+ free_aglen -= resv->used;
+
+ if (free_aglen == 0)
+ return 0;
+
+free:
+ /*
+ * Use EFIs to free the reservations. We don't need to use EFIs here
+ * like the kernel, but we'll do it to keep the code matched.
+ */
+ fsbno = XFS_AGB_TO_FSB(sc->mp, resv->pag->pag_agno, free_agbno);
+ error = -libxfs_free_extent_later(sc->tp, fsbno, free_aglen,
+ &bkl->oinfo, XFS_AG_RESV_NONE, true);
+ if (error)
+ return error;
+
+ return 1;
+}
+
/* Free all the accounting info and disk space we reserved for a new btree. */
-void
-bulkload_commit(
- struct bulkload *bkl)
+static int
+bulkload_free(
+ struct bulkload *bkl,
+ bool btree_committed)
{
+ struct repair_ctx *sc = bkl->sc;
struct bulkload_resv *resv, *n;
+ unsigned int freed = 0;
+ int error = 0;
list_for_each_entry_safe(resv, n, &bkl->resv_list, list) {
+ int ret;
+
+ ret = bulkload_free_extent(bkl, resv, btree_committed);
list_del(&resv->list);
+ libxfs_perag_put(resv->pag);
kfree(resv);
+
+ if (ret < 0) {
+ error = ret;
+ goto junkit;
+ }
+
+ freed += ret;
+ if (freed >= XREP_MAX_ITRUNCATE_EFIS) {
+ error = -libxfs_defer_finish(&sc->tp);
+ if (error)
+ goto junkit;
+ freed = 0;
+ }
}
+
+ if (freed)
+ error = -libxfs_defer_finish(&sc->tp);
+junkit:
+ /*
+ * If we still have reservations attached to @newbt, cleanup must have
+ * failed and the filesystem is about to go down. Clean up the incore
+ * reservations.
+ */
+ list_for_each_entry_safe(resv, n, &bkl->resv_list, list) {
+ list_del(&resv->list);
+ libxfs_perag_put(resv->pag);
+ kfree(resv);
+ }
+
+ if (sc->ip) {
+ kmem_cache_free(xfs_ifork_cache, bkl->ifake.if_fork);
+ bkl->ifake.if_fork = NULL;
+ }
+
+ return error;
+}
+
+/*
+ * Free all the accounting info and unused disk space allocations after
+ * committing a new btree.
+ */
+int
+bulkload_commit(
+ struct bulkload *bkl)
+{
+ return bulkload_free(bkl, true);
+}
+
+/*
+ * Free all the accounting info and all of the disk space we reserved for a new
+ * btree that we're not going to commit. We want to try to roll things back
+ * cleanly for things like ENOSPC midway through allocation.
+ */
+void
+bulkload_cancel(
+ struct bulkload *bkl)
+{
+ bulkload_free(bkl, false);
}
/* Feed one of the reserved btree blocks to the bulk loader. */
diff --git a/repair/bulkload.h b/repair/bulkload.h
index f4790e3b3de..a88aafaa678 100644
--- a/repair/bulkload.h
+++ b/repair/bulkload.h
@@ -8,9 +8,17 @@
extern int bload_leaf_slack;
extern int bload_node_slack;
+/*
+ * This is the maximum number of deferred extent freeing item extents (EFIs)
+ * that we'll attach to a transaction without rolling the transaction to avoid
+ * overrunning a tr_itruncate reservation.
+ */
+#define XREP_MAX_ITRUNCATE_EFIS (128)
struct repair_ctx {
struct xfs_mount *mp;
+ struct xfs_inode *ip;
+ struct xfs_trans *tp;
};
struct bulkload_resv {
@@ -36,7 +44,10 @@ struct bulkload {
struct list_head resv_list;
/* Fake root for new btree. */
- struct xbtree_afakeroot afake;
+ union {
+ struct xbtree_afakeroot afake;
+ struct xbtree_ifakeroot ifake;
+ };
/* rmap owner of these blocks */
struct xfs_owner_info oinfo;
@@ -44,6 +55,9 @@ struct bulkload {
/* The last reservation we allocated from. */
struct bulkload_resv *last_resv;
+ /* Hint as to where we should allocate blocks. */
+ xfs_fsblock_t alloc_hint;
+
/* Number of blocks reserved via resv_list. */
unsigned int nr_reserved;
};
@@ -52,12 +66,16 @@ struct bulkload {
list_for_each_entry_safe((resv), (n), &(bkl)->resv_list, list)
void bulkload_init_ag(struct bulkload *bkl, struct repair_ctx *sc,
- const struct xfs_owner_info *oinfo);
+ const struct xfs_owner_info *oinfo, xfs_fsblock_t alloc_hint);
+void bulkload_init_inode(struct bulkload *bkl, struct repair_ctx *sc,
+ int whichfork, const struct xfs_owner_info *oinfo);
int bulkload_claim_block(struct xfs_btree_cur *cur, struct bulkload *bkl,
union xfs_btree_ptr *ptr);
int bulkload_add_extent(struct bulkload *bkl, struct xfs_perag *pag,
xfs_agblock_t agbno, xfs_extlen_t len);
-void bulkload_commit(struct bulkload *bkl);
+int bulkload_alloc_file_blocks(struct bulkload *bkl, uint64_t nr_blocks);
+void bulkload_cancel(struct bulkload *bkl);
+int bulkload_commit(struct bulkload *bkl);
void bulkload_estimate_ag_slack(struct repair_ctx *sc,
struct xfs_btree_bload *bload, unsigned int free);
diff --git a/repair/dinode.c b/repair/dinode.c
index 3f826b3482f..bd91ce14a36 100644
--- a/repair/dinode.c
+++ b/repair/dinode.c
@@ -20,6 +20,7 @@
#include "threads.h"
#include "slab.h"
#include "rmap.h"
+#include "bmap_repair.h"
/*
* gettext lookups for translations of strings use mutexes internally to
@@ -1908,7 +1909,9 @@ process_inode_data_fork(
xfs_ino_t lino = XFS_AGINO_TO_INO(mp, agno, ino);
int err = 0;
xfs_extnum_t nex, max_nex;
+ int try_rebuild = -1; /* don't know yet */
+retry:
/*
* extent count on disk is only valid for positive values. The kernel
* uses negative values in memory. hence if we see negative numbers
@@ -1937,11 +1940,15 @@ process_inode_data_fork(
*totblocks = 0;
break;
case XFS_DINODE_FMT_EXTENTS:
+ if (!rmapbt_suspect && try_rebuild == -1)
+ try_rebuild = 1;
err = process_exinode(mp, agno, ino, dino, type, dirty,
totblocks, nextents, dblkmap, XFS_DATA_FORK,
check_dups);
break;
case XFS_DINODE_FMT_BTREE:
+ if (!rmapbt_suspect && try_rebuild == -1)
+ try_rebuild = 1;
err = process_btinode(mp, agno, ino, dino, type, dirty,
totblocks, nextents, dblkmap, XFS_DATA_FORK,
check_dups);
@@ -1957,8 +1964,28 @@ process_inode_data_fork(
if (err) {
do_warn(_("bad data fork in inode %" PRIu64 "\n"), lino);
if (!no_modify) {
+ if (try_rebuild == 1) {
+ do_warn(
+_("rebuilding inode %"PRIu64" data fork\n"),
+ lino);
+ try_rebuild = 0;
+ err = rebuild_bmap(mp, lino, XFS_DATA_FORK,
+ be32_to_cpu(dino->di_nextents),
+ ino_bpp, dinop, dirty);
+ dino = *dinop;
+ if (!err)
+ goto retry;
+ do_warn(
+_("inode %"PRIu64" data fork rebuild failed, error %d, clearing\n"),
+ lino, err);
+ }
clear_dinode(mp, dino, lino);
*dirty += 1;
+ ASSERT(*dirty > 0);
+ } else if (try_rebuild == 1) {
+ do_warn(
+_("would have tried to rebuild inode %"PRIu64" data fork\n"),
+ lino);
}
return 1;
}
@@ -2024,7 +2051,9 @@ process_inode_attr_fork(
struct blkmap *ablkmap = NULL;
int repair = 0;
int err;
+ int try_rebuild = -1; /* don't know yet */
+retry:
if (!dino->di_forkoff) {
*anextents = 0;
if (dino->di_aformat != XFS_DINODE_FMT_EXTENTS) {
@@ -2051,6 +2080,8 @@ process_inode_attr_fork(
err = process_lclinode(mp, agno, ino, dino, XFS_ATTR_FORK);
break;
case XFS_DINODE_FMT_EXTENTS:
+ if (!rmapbt_suspect && try_rebuild == -1)
+ try_rebuild = 1;
ablkmap = blkmap_alloc(*anextents, XFS_ATTR_FORK);
*anextents = 0;
err = process_exinode(mp, agno, ino, dino, type, dirty,
@@ -2058,6 +2089,8 @@ process_inode_attr_fork(
XFS_ATTR_FORK, check_dups);
break;
case XFS_DINODE_FMT_BTREE:
+ if (!rmapbt_suspect && try_rebuild == -1)
+ try_rebuild = 1;
ablkmap = blkmap_alloc(*anextents, XFS_ATTR_FORK);
*anextents = 0;
err = process_btinode(mp, agno, ino, dino, type, dirty,
@@ -2083,10 +2116,29 @@ process_inode_attr_fork(
do_warn(_("bad attribute fork in inode %" PRIu64 "\n"), lino);
if (!no_modify) {
+ if (try_rebuild == 1) {
+ do_warn(
+_("rebuilding inode %"PRIu64" attr fork\n"),
+ lino);
+ try_rebuild = 0;
+ err = rebuild_bmap(mp, lino, XFS_ATTR_FORK,
+ be16_to_cpu(dino->di_anextents),
+ ino_bpp, dinop, dirty);
+ dino = *dinop;
+ if (!err)
+ goto retry;
+ do_warn(
+_("inode %"PRIu64" attr fork rebuild failed, error %d"),
+ lino, err);
+ }
do_warn(_(", clearing attr fork\n"));
*dirty += clear_dinode_attr(mp, dino, lino);
ASSERT(*dirty > 0);
- } else {
+ } else if (try_rebuild) {
+ do_warn(
+_("would have tried to rebuild inode %"PRIu64" attr fork or cleared it\n"),
+ lino);
+ } else {
do_warn(_(", would clear attr fork\n"));
}
diff --git a/repair/rmap.c b/repair/rmap.c
index 6bb77e08249..a2291c7b3b0 100644
--- a/repair/rmap.c
+++ b/repair/rmap.c
@@ -33,7 +33,7 @@ struct xfs_ag_rmap {
};
static struct xfs_ag_rmap *ag_rmaps;
-static bool rmapbt_suspect;
+bool rmapbt_suspect;
static bool refcbt_suspect;
static inline int rmap_compare(const void *a, const void *b)
diff --git a/repair/rmap.h b/repair/rmap.h
index 6004e9f68b6..1dad2f5890a 100644
--- a/repair/rmap.h
+++ b/repair/rmap.h
@@ -7,6 +7,7 @@
#define RMAP_H_
extern bool collect_rmaps;
+extern bool rmapbt_suspect;
extern bool rmap_needs_work(struct xfs_mount *);
next prev parent reply other threads:[~2023-12-31 22:08 UTC|newest]
Thread overview: 644+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-12-31 18:12 [NYE PATCHRIVER 1/4] xfs: the rest of online repair part 1 Darrick J. Wong
2023-12-31 19:25 ` [PATCHSET v29.0 01/28] xfs: live inode scans for online fsck Darrick J. Wong
2023-12-31 20:04 ` [PATCH 1/7] xfs: speed up xfs_iwalk_adjust_start a little bit Darrick J. Wong
2024-01-02 10:24 ` Christoph Hellwig
2023-12-31 20:04 ` [PATCH 2/7] xfs: implement live inode scan for scrub Darrick J. Wong
2024-01-02 11:22 ` Christoph Hellwig
2023-12-31 20:05 ` [PATCH 3/7] xfs: allow scrub to hook metadata updates in other writers Darrick J. Wong
2024-01-02 11:30 ` Christoph Hellwig
2024-01-03 0:23 ` Darrick J. Wong
2023-12-31 20:05 ` [PATCH 4/7] xfs: allow blocking notifier chains with filesystem hooks Darrick J. Wong
2024-01-02 10:28 ` Christoph Hellwig
2024-01-03 1:07 ` Darrick J. Wong
2024-01-03 7:37 ` Christoph Hellwig
2024-01-03 18:40 ` Darrick J. Wong
2023-12-31 20:05 ` [PATCH 5/7] xfs: stagger the starting AG of scrub iscans to reduce contention Darrick J. Wong
2024-01-02 11:30 ` Christoph Hellwig
2023-12-31 20:06 ` [PATCH 6/7] xfs: cache a bunch of inodes for repair scans Darrick J. Wong
2024-01-02 11:40 ` Christoph Hellwig
2023-12-31 20:06 ` [PATCH 7/7] xfs: iscan batching should handle unallocated inodes too Darrick J. Wong
2024-01-02 11:40 ` Christoph Hellwig
2024-01-03 1:09 ` Darrick J. Wong
2023-12-31 19:25 ` [PATCHSET v29.0 02/28] xfs: repair inode mode by scanning dirs Darrick J. Wong
2023-12-31 20:06 ` [PATCH 1/4] xfs: create a static name for the dot entry too Darrick J. Wong
2024-01-02 11:11 ` Christoph Hellwig
2023-12-31 20:06 ` [PATCH 2/4] xfs: create a predicate to determine if two xfs_names are the same Darrick J. Wong
2024-01-02 11:13 ` Christoph Hellwig
2024-01-03 0:02 ` Darrick J. Wong
2023-12-31 20:07 ` [PATCH 3/4] xfs: create a macro for decoding ftypes in tracepoints Darrick J. Wong
2024-01-02 11:13 ` Christoph Hellwig
2024-01-03 0:06 ` Darrick J. Wong
2023-12-31 20:07 ` [PATCH 4/4] xfs: repair file modes by scanning for a dirent pointing to us Darrick J. Wong
2024-01-02 10:29 ` Christoph Hellwig
2024-01-03 2:50 ` Darrick J. Wong
2024-01-03 7:38 ` Christoph Hellwig
2023-12-31 19:26 ` [PATCHSET v29.0 03/28] xfs: online repair of quota counters Darrick J. Wong
2023-12-31 20:07 ` [PATCH 1/5] xfs: report the health of quota counts Darrick J. Wong
2024-01-02 10:30 ` Christoph Hellwig
2023-12-31 20:07 ` [PATCH 2/5] xfs: implement live quotacheck inode scan Darrick J. Wong
2024-01-05 5:29 ` Christoph Hellwig
2024-01-06 1:16 ` Darrick J. Wong
2024-01-09 1:23 ` Darrick J. Wong
2024-01-09 4:35 ` Christoph Hellwig
2023-12-31 20:08 ` [PATCH 3/5] xfs: track quota updates during live quotacheck Darrick J. Wong
2024-01-05 5:30 ` Christoph Hellwig
2023-12-31 20:08 ` [PATCH 4/5] xfs: repair cannot update the summary counters when logging quota flags Darrick J. Wong
2024-01-05 5:35 ` Christoph Hellwig
2024-01-06 18:52 ` Darrick J. Wong
2023-12-31 20:08 ` [PATCH 5/5] xfs: repair dquots based on live quotacheck results Darrick J. Wong
2024-01-05 5:35 ` Christoph Hellwig
2023-12-31 19:26 ` [PATCHSET v29.0 04/28] xfs: online repair of file link counts Darrick J. Wong
2023-12-31 20:08 ` [PATCH 1/4] xfs: report health of inode " Darrick J. Wong
2024-01-05 5:39 ` Christoph Hellwig
2023-12-31 20:09 ` [PATCH 2/4] xfs: teach scrub to check file nlinks Darrick J. Wong
2024-01-05 5:40 ` Christoph Hellwig
2023-12-31 20:09 ` [PATCH 3/4] xfs: track directory entry updates during live nlinks fsck Darrick J. Wong
2024-01-05 5:41 ` Christoph Hellwig
2023-12-31 20:09 ` [PATCH 4/4] xfs: teach repair to fix file nlinks Darrick J. Wong
2024-01-05 5:42 ` Christoph Hellwig
2023-12-31 19:26 ` [PATCHSET v29.0 05/28] xfs: report corruption to the health trackers Darrick J. Wong
2023-12-31 20:09 ` [PATCH 01/11] xfs: separate the marking of sick and checked metadata Darrick J. Wong
2024-01-05 5:42 ` Christoph Hellwig
2023-12-31 20:10 ` [PATCH 02/11] xfs: report fs corruption errors to the health tracking system Darrick J. Wong
2024-01-05 5:42 ` Christoph Hellwig
2023-12-31 20:10 ` [PATCH 03/11] xfs: report ag header " Darrick J. Wong
2024-01-05 5:43 ` Christoph Hellwig
2023-12-31 20:10 ` [PATCH 04/11] xfs: report block map " Darrick J. Wong
2024-01-05 5:43 ` Christoph Hellwig
2023-12-31 20:10 ` [PATCH 05/11] xfs: report btree block corruption errors to the health system Darrick J. Wong
2024-01-05 5:43 ` Christoph Hellwig
2023-12-31 20:11 ` [PATCH 06/11] xfs: report dir/attr " Darrick J. Wong
2024-01-05 5:44 ` Christoph Hellwig
2023-12-31 20:11 ` [PATCH 07/11] xfs: report symlink " Darrick J. Wong
2024-01-05 5:44 ` Christoph Hellwig
2023-12-31 20:11 ` [PATCH 08/11] xfs: report inode " Darrick J. Wong
2024-01-05 5:44 ` Christoph Hellwig
2023-12-31 20:12 ` [PATCH 09/11] xfs: report quota block " Darrick J. Wong
2024-01-05 5:44 ` Christoph Hellwig
2023-12-31 20:12 ` [PATCH 10/11] xfs: report realtime metadata " Darrick J. Wong
2024-01-05 5:45 ` Christoph Hellwig
2023-12-31 20:12 ` [PATCH 11/11] xfs: report XFS_IS_CORRUPT " Darrick J. Wong
2024-01-05 5:45 ` Christoph Hellwig
2023-12-31 19:26 ` [PATCHSET v29.0 06/28] xfs: indirect health reporting Darrick J. Wong
2023-12-31 20:12 ` [PATCH 1/3] xfs: add secondary and indirect classes to the health tracking system Darrick J. Wong
2024-01-05 5:46 ` Christoph Hellwig
2023-12-31 20:13 ` [PATCH 2/3] xfs: remember sick inodes that get inactivated Darrick J. Wong
2024-01-05 5:46 ` Christoph Hellwig
2023-12-31 20:13 ` [PATCH 3/3] xfs: update health status if we get a clean bill of health Darrick J. Wong
2024-01-05 5:47 ` Christoph Hellwig
2023-12-31 19:27 ` [PATCHSET v29.0 07/28] xfs: online repair for fs summary counters Darrick J. Wong
2023-12-31 20:13 ` [PATCH 1/1] xfs: repair " Darrick J. Wong
2024-01-05 5:48 ` Christoph Hellwig
2023-12-31 19:27 ` [PATCHSET v29.0 08/28] xfs: support in-memory btrees Darrick J. Wong
2023-12-31 20:13 ` [PATCH 1/9] xfs: dump xfiles for debugging purposes Darrick J. Wong
2024-01-01 0:02 ` Matthew Wilcox
2024-01-03 1:52 ` Darrick J. Wong
2024-01-03 8:49 ` Christoph Hellwig
2023-12-31 20:14 ` [PATCH 2/9] xfs: teach buftargs to maintain their own buffer hashtable Darrick J. Wong
2023-12-31 20:14 ` [PATCH 3/9] xfs: create buftarg helpers to abstract block_device operations Darrick J. Wong
2024-01-03 8:51 ` Christoph Hellwig
2024-01-03 19:26 ` Darrick J. Wong
2024-01-03 19:32 ` Christoph Hellwig
2023-12-31 20:14 ` [PATCH 4/9] xfs: make GFP_ usage consistent when allocating buftargs Darrick J. Wong
2024-01-03 8:52 ` Christoph Hellwig
2023-12-31 20:14 ` [PATCH 5/9] xfs: support in-memory buffer cache targets Darrick J. Wong
2023-12-31 20:15 ` [PATCH 6/9] xfs: consolidate btree block freeing tracepoints Darrick J. Wong
2024-01-03 8:53 ` Christoph Hellwig
2024-01-03 19:37 ` Darrick J. Wong
2024-01-04 6:19 ` Christoph Hellwig
2024-01-04 7:15 ` Darrick J. Wong
2023-12-31 20:15 ` [PATCH 7/9] xfs: consolidate btree block allocation tracepoints Darrick J. Wong
2023-12-31 20:15 ` [PATCH 8/9] xfs: support in-memory btrees Darrick J. Wong
2024-01-04 6:47 ` Christoph Hellwig
2024-01-04 7:27 ` Darrick J. Wong
2024-01-04 7:30 ` Christoph Hellwig
2024-01-04 7:33 ` Darrick J. Wong
2024-01-04 7:40 ` Christoph Hellwig
2023-12-31 20:15 ` [PATCH 9/9] xfs: connect in-memory btrees to xfiles Darrick J. Wong
2024-01-01 0:18 ` Matthew Wilcox
2024-01-03 2:04 ` Darrick J. Wong
2024-01-04 6:54 ` Christoph Hellwig
2024-01-04 7:32 ` Darrick J. Wong
2024-01-04 7:41 ` Christoph Hellwig
2023-12-31 19:27 ` [PATCHSET v29.0 09/28] xfs: online repair of rmap btrees Darrick J. Wong
2023-12-31 20:16 ` [PATCH 1/4] xfs: create a helper to decide if a file mapping targets the rt volume Darrick J. Wong
2024-01-05 5:48 ` Christoph Hellwig
2023-12-31 20:16 ` [PATCH 2/4] xfs: repair the rmapbt Darrick J. Wong
2023-12-31 20:16 ` [PATCH 3/4] xfs: create a shadow rmap btree during rmap repair Darrick J. Wong
2023-12-31 20:16 ` [PATCH 4/4] xfs: hook live rmap operations during a repair operation Darrick J. Wong
2023-12-31 19:27 ` [PATCHSET v29.0 10/28] xfs: move btree geometry to ops struct Darrick J. Wong
2023-12-31 20:17 ` [PATCH 1/9] xfs: set the btree cursor bc_ops in xfs_btree_alloc_cursor Darrick J. Wong
2024-01-02 10:31 ` Christoph Hellwig
2023-12-31 20:17 ` [PATCH 2/9] xfs: encode the default bc_flags in the btree ops structure Darrick J. Wong
2024-01-02 10:33 ` Christoph Hellwig
2024-01-03 1:15 ` Darrick J. Wong
2024-01-03 19:58 ` Darrick J. Wong
2024-01-03 20:00 ` Darrick J. Wong
2024-01-03 20:35 ` Christoph Hellwig
2023-12-31 20:17 ` [PATCH 3/9] xfs: export some of the btree ops structures Darrick J. Wong
2024-01-02 10:36 ` Christoph Hellwig
2023-12-31 20:17 ` [PATCH 4/9] xfs: initialize btree blocks using btree_ops structure Darrick J. Wong
2024-01-02 10:36 ` Christoph Hellwig
2023-12-31 20:18 ` [PATCH 5/9] xfs: rename btree block/buffer init functions Darrick J. Wong
2024-01-02 10:37 ` Christoph Hellwig
2023-12-31 20:18 ` [PATCH 6/9] xfs: btree convert xfs_btree_init_block to xfs_btree_init_buf calls Darrick J. Wong
2024-01-02 10:37 ` Christoph Hellwig
2023-12-31 20:18 ` [PATCH 7/9] xfs: remove the unnecessary daddr paramter to _init_block Darrick J. Wong
2024-01-02 10:38 ` Christoph Hellwig
2023-12-31 20:19 ` [PATCH 8/9] xfs: set btree block buffer ops in _init_buf Darrick J. Wong
2024-01-02 10:38 ` Christoph Hellwig
2023-12-31 20:19 ` [PATCH 9/9] xfs: remove unnecessary fields in xfbtree_config Darrick J. Wong
2024-01-02 10:39 ` Christoph Hellwig
2024-01-03 2:51 ` Darrick J. Wong
2024-01-03 7:40 ` Christoph Hellwig
2023-12-31 19:28 ` [PATCHSET v29.0 11/28] xfs: reduce refcount repair memory usage Darrick J. Wong
2023-12-31 20:19 ` [PATCH 1/4] xfs: move lru refs to the btree ops structure Darrick J. Wong
2024-01-02 10:39 ` Christoph Hellwig
2023-12-31 20:19 ` [PATCH 2/4] xfs: define an in-memory btree for storing refcount bag info during repairs Darrick J. Wong
2024-01-02 10:41 ` Christoph Hellwig
2024-01-03 2:29 ` Darrick J. Wong
2023-12-31 20:20 ` [PATCH 3/4] xfs: create refcount bag structure for btree repairs Darrick J. Wong
2024-01-02 10:42 ` Christoph Hellwig
2023-12-31 20:20 ` [PATCH 4/4] xfs: port refcount repair to the new refcount bag structure Darrick J. Wong
2024-01-02 10:43 ` Christoph Hellwig
2024-01-03 2:31 ` Darrick J. Wong
2023-12-31 19:28 ` [PATCHSET v29.0 12/28] xfs: bmap log intent cleanups Darrick J. Wong
2023-12-31 20:20 ` [PATCH 1/7] xfs: split tracepoint classes for deferred items Darrick J. Wong
2024-01-02 10:44 ` Christoph Hellwig
2023-12-31 20:20 ` [PATCH 2/7] xfs: clean up bmap log intent item tracepoint callsites Darrick J. Wong
2024-01-02 10:44 ` Christoph Hellwig
2023-12-31 20:21 ` [PATCH 3/7] xfs: remove xfs_trans_set_bmap_flags Darrick J. Wong
2024-01-02 10:44 ` Christoph Hellwig
2023-12-31 20:21 ` [PATCH 4/7] xfs: add a bi_entry helper Darrick J. Wong
2024-01-02 10:44 ` Christoph Hellwig
2023-12-31 20:21 ` [PATCH 5/7] xfs: reuse xfs_bmap_update_cancel_item Darrick J. Wong
2024-01-02 10:45 ` Christoph Hellwig
2024-01-03 1:21 ` Darrick J. Wong
2023-12-31 20:21 ` [PATCH 6/7] xfs: move xfs_bmap_defer_add to xfs_bmap_item.c Darrick J. Wong
2024-01-02 10:45 ` Christoph Hellwig
2023-12-31 20:22 ` [PATCH 7/7] xfs: add a xattr_entry helper Darrick J. Wong
2024-01-02 10:45 ` Christoph Hellwig
2023-12-31 19:28 ` [PATCHSET v29.0 13/28] xfs: widen BUI formats to support realtime Darrick J. Wong
2023-12-31 20:22 ` [PATCH 1/3] xfs: fix xfs_bunmapi to allow unmapping of partial rt extents Darrick J. Wong
2024-01-02 10:46 ` Christoph Hellwig
2023-12-31 20:22 ` [PATCH 2/3] xfs: add a realtime flag to the bmap update log redo items Darrick J. Wong
2024-01-02 10:46 ` Christoph Hellwig
2023-12-31 20:22 ` [PATCH 3/3] xfs: support recovering bmap intent items targetting realtime extents Darrick J. Wong
2024-01-02 10:46 ` Christoph Hellwig
2023-12-31 19:29 ` [PATCHSET v29.0 14/28] xfs: support attrfork and unwritten BUIs Darrick J. Wong
2023-12-31 20:23 ` [PATCH 1/2] xfs: support deferred bmap updates on the attr fork Darrick J. Wong
2024-01-05 5:50 ` Christoph Hellwig
2023-12-31 20:23 ` [PATCH 2/2] xfs: xfs_bmap_finish_one should map unwritten extents properly Darrick J. Wong
2024-01-05 5:50 ` Christoph Hellwig
2023-12-31 19:29 ` [PATCHSET v29.0 15/28] xfs: clean up symbolic link code Darrick J. Wong
2023-12-31 20:23 ` [PATCH 1/3] xfs: move xfs_symlink_remote.c declarations to xfs_symlink_remote.h Darrick J. Wong
2024-01-05 5:51 ` Christoph Hellwig
2023-12-31 20:23 ` [PATCH 2/3] xfs: move remote symlink target read function to libxfs Darrick J. Wong
2024-01-05 5:51 ` Christoph Hellwig
2023-12-31 20:24 ` [PATCH 3/3] xfs: move symlink target write " Darrick J. Wong
2024-01-05 5:52 ` Christoph Hellwig
2023-12-31 19:29 ` [PATCHSET v29.0 16/28] xfs: atomic file updates Darrick J. Wong
2023-12-31 20:24 ` [PATCH 01/25] xfs: add a libxfs header file for staging new ioctls Darrick J. Wong
2023-12-31 20:24 ` [PATCH 02/25] xfs: introduce new file range exchange ioctl Darrick J. Wong
2023-12-31 20:25 ` [PATCH 03/25] xfs: move inode lease breaking functions to xfs_inode.c Darrick J. Wong
2023-12-31 20:25 ` [PATCH 04/25] xfs: move xfs_iops.c declarations out of xfs_inode.h Darrick J. Wong
2023-12-31 20:25 ` [PATCH 05/25] xfs: declare xfs_file.c symbols in xfs_file.h Darrick J. Wong
2023-12-31 20:25 ` [PATCH 06/25] xfs: create a new helper to return a file's allocation unit Darrick J. Wong
2023-12-31 20:26 ` [PATCH 07/25] xfs: refactor non-power-of-two alignment checks Darrick J. Wong
2023-12-31 20:26 ` [PATCH 08/25] xfs: parameterize all the incompat log feature helpers Darrick J. Wong
2023-12-31 20:26 ` [PATCH 09/25] xfs: create a log incompat flag for atomic extent swapping Darrick J. Wong
2023-12-31 20:26 ` [PATCH 10/25] xfs: introduce a swap-extent log intent item Darrick J. Wong
2023-12-31 20:27 ` [PATCH 11/25] xfs: create deferred log items for extent swapping Darrick J. Wong
2023-12-31 20:27 ` [PATCH 12/25] xfs: enable xlog users to toggle atomic " Darrick J. Wong
2023-12-31 20:27 ` [PATCH 13/25] xfs: bind the xfs-specific extent swap code to the vfs-generic file exchange code Darrick J. Wong
2023-12-31 20:27 ` [PATCH 14/25] xfs: add error injection to test swapext recovery Darrick J. Wong
2023-12-31 20:28 ` [PATCH 15/25] xfs: port xfs_swap_extents_rmap to our new code Darrick J. Wong
2023-12-31 20:28 ` [PATCH 16/25] xfs: consolidate all of the xfs_swap_extent_forks code Darrick J. Wong
2023-12-31 20:28 ` [PATCH 17/25] xfs: port xfs_swap_extent_forks to use xfs_swapext_req Darrick J. Wong
2023-12-31 20:28 ` [PATCH 18/25] xfs: allow xfs_swap_range to use older extent swap algorithms Darrick J. Wong
2023-12-31 20:29 ` [PATCH 19/25] xfs: remove old swap extents implementation Darrick J. Wong
2023-12-31 20:29 ` [PATCH 20/25] xfs: condense extended attributes after an atomic swap Darrick J. Wong
2023-12-31 20:29 ` [PATCH 21/25] xfs: condense directories " Darrick J. Wong
2023-12-31 20:29 ` [PATCH 22/25] xfs: condense symbolic links " Darrick J. Wong
2023-12-31 20:30 ` [PATCH 23/25] xfs: make atomic extent swapping support realtime files Darrick J. Wong
2023-12-31 20:30 ` [PATCH 24/25] xfs: support non-power-of-two rtextsize with exchange-range Darrick J. Wong
2023-12-31 20:30 ` [PATCH 25/25] xfs: enable atomic swapext feature Darrick J. Wong
2023-12-31 19:29 ` [PATCHSET v29.0 17/28] xfs: create temporary files for online repair Darrick J. Wong
2023-12-31 20:31 ` [PATCH 1/4] xfs: hide private inodes from bulkstat and handle functions Darrick J. Wong
2023-12-31 20:31 ` [PATCH 2/4] xfs: create temporary files and directories for online repair Darrick J. Wong
2023-12-31 20:31 ` [PATCH 3/4] xfs: refactor live buffer invalidation for repairs Darrick J. Wong
2023-12-31 20:31 ` [PATCH 4/4] xfs: add the ability to reap entire inode forks Darrick J. Wong
2023-12-31 19:30 ` [PATCHSET v29.0 18/28] xfs: online repair of realtime summaries Darrick J. Wong
2023-12-31 20:32 ` [PATCH 1/3] xfs: support preallocating and copying content into temporary files Darrick J. Wong
2023-12-31 20:32 ` [PATCH 2/3] xfs: teach the tempfile to support atomic extent swapping Darrick J. Wong
2023-12-31 20:32 ` [PATCH 3/3] xfs: online repair of realtime summaries Darrick J. Wong
2023-12-31 19:30 ` [PATCHSET v29.0 19/28] xfs: set and validate dir/attr block owners Darrick J. Wong
2023-12-31 20:32 ` [PATCH 1/9] xfs: add an explicit owner field to xfs_da_args Darrick J. Wong
2023-12-31 20:33 ` [PATCH 2/9] xfs: use the xfs_da_args owner field to set new dir/attr block owner Darrick J. Wong
2023-12-31 20:33 ` [PATCH 3/9] xfs: validate attr leaf buffer owners Darrick J. Wong
2023-12-31 20:33 ` [PATCH 4/9] xfs: validate attr remote value " Darrick J. Wong
2023-12-31 20:33 ` [PATCH 5/9] xfs: validate dabtree node " Darrick J. Wong
2023-12-31 20:34 ` [PATCH 6/9] xfs: validate directory leaf " Darrick J. Wong
2023-12-31 20:34 ` [PATCH 7/9] xfs: validate explicit directory data " Darrick J. Wong
2023-12-31 20:34 ` [PATCH 8/9] xfs: validate explicit directory block " Darrick J. Wong
2023-12-31 20:34 ` [PATCH 9/9] xfs: validate explicit directory free block owners Darrick J. Wong
2023-12-31 19:30 ` [PATCHSET v29.0 20/28] xfs: online repair of extended attributes Darrick J. Wong
2023-12-31 20:35 ` [PATCH 1/6] xfs: create a blob array data structure Darrick J. Wong
2024-01-05 5:53 ` Christoph Hellwig
2024-01-06 1:33 ` Darrick J. Wong
2024-01-06 6:42 ` Christoph Hellwig
2024-01-06 18:55 ` Darrick J. Wong
2024-01-08 17:12 ` Darrick J. Wong
2023-12-31 20:35 ` [PATCH 2/6] xfs: use atomic extent swapping to fix user file fork data Darrick J. Wong
2023-12-31 20:35 ` [PATCH 3/6] xfs: repair extended attributes Darrick J. Wong
2023-12-31 20:35 ` [PATCH 4/6] xfs: scrub should set preen if attr leaf has holes Darrick J. Wong
2023-12-31 20:36 ` [PATCH 5/6] xfs: flag empty xattr leaf blocks for optimization Darrick J. Wong
2023-12-31 20:36 ` [PATCH 6/6] xfs: create an xattr iteration function for scrub Darrick J. Wong
2023-12-31 19:30 ` [PATCHSET v29.0 21/28] xfs: online repair of inode unlinked state Darrick J. Wong
2023-12-31 20:36 ` [PATCH 1/2] xfs: ensure unlinked list state is consistent with nlink during scrub Darrick J. Wong
2023-12-31 20:37 ` [PATCH 2/2] xfs: update the unlinked list when repairing link counts Darrick J. Wong
2023-12-31 19:31 ` [PATCHSET v29.0 22/28] xfs: online repair of directories Darrick J. Wong
2023-12-31 20:37 ` [PATCH 1/4] " Darrick J. Wong
2023-12-31 20:37 ` [PATCH 2/4] xfs: scan the filesystem to repair a directory dotdot entry Darrick J. Wong
2023-12-31 20:37 ` [PATCH 3/4] xfs: online repair of parent pointers Darrick J. Wong
2023-12-31 20:38 ` [PATCH 4/4] xfs: ask the dentry cache if it knows the parent of a directory Darrick J. Wong
2023-12-31 19:31 ` [PATCHSET v29.0 23/28] xfs: move orphan files to lost and found Darrick J. Wong
2023-12-31 20:38 ` [PATCH 1/3] xfs: move orphan files to the orphanage Darrick J. Wong
2023-12-31 20:38 ` [PATCH 2/3] xfs: move files to orphanage instead of letting nlinks drop to zero Darrick J. Wong
2023-12-31 20:38 ` [PATCH 3/3] xfs: ensure dentry consistency when the orphanage adopts a file Darrick J. Wong
2023-12-31 19:31 ` [PATCHSET v29.0 24/28] xfs: online repair of symbolic links Darrick J. Wong
2023-12-31 20:39 ` [PATCH 1/1] " Darrick J. Wong
2023-12-31 19:31 ` [PATCHSET v29.0 25/28] xfs: online fsck of iunlink buckets Darrick J. Wong
2023-12-31 20:39 ` [PATCH 1/3] xfs: check AGI unlinked inode buckets Darrick J. Wong
2023-12-31 20:39 ` [PATCH 2/3] xfs: hoist AGI repair context to a heap object Darrick J. Wong
2023-12-31 20:39 ` [PATCH 3/3] xfs: repair AGI unlinked inode bucket lists Darrick J. Wong
2023-12-31 19:32 ` [PATCHSET v29.0 26/28] xfs: cache xfile pages for better performance Darrick J. Wong
2023-12-31 20:40 ` [PATCH 1/3] xfs: map xfile pages directly into xfs_buf Darrick J. Wong
2023-12-31 20:40 ` [PATCH 2/3] xfs: use b_offset to support direct-mapping pages when blocksize < pagesize Darrick J. Wong
2024-01-03 8:45 ` Christoph Hellwig
2024-01-04 1:27 ` Darrick J. Wong
2023-12-31 20:40 ` [PATCH 3/3] xfile: implement write caching Darrick J. Wong
2024-01-03 8:48 ` Christoph Hellwig
2024-01-04 1:33 ` Darrick J. Wong
2024-01-04 6:20 ` Christoph Hellwig
2024-01-04 7:20 ` Darrick J. Wong
2024-01-04 7:28 ` Christoph Hellwig
2024-01-04 7:34 ` Darrick J. Wong
2024-01-04 7:39 ` Christoph Hellwig
2024-01-04 17:59 ` Darrick J. Wong
2023-12-31 19:32 ` [PATCHSET v29.0 27/28] xfs: inode-related repair fixes Darrick J. Wong
2023-12-31 20:40 ` [PATCH 1/4] xfs: check unused nlink fields in the ondisk inode Darrick J. Wong
2023-12-31 20:41 ` [PATCH 2/4] xfs: try to avoid allocating from sick inode clusters Darrick J. Wong
2023-12-31 20:41 ` [PATCH 3/4] xfs: pin inodes that would otherwise overflow link count Darrick J. Wong
2023-12-31 20:41 ` [PATCH 4/4] xfs: create subordinate scrub contexts for xchk_metadata_inode_subtype Darrick J. Wong
2023-12-31 19:32 ` [PATCHSET v29.0 28/28] xfs: less heavy locks during fstrim Darrick J. Wong
2023-12-31 20:41 ` [PATCH 1/1] xfs: fix severe performance problems when fstrimming a subset of an AG Darrick J. Wong
2023-12-31 19:39 ` [PATCHSET v29.0 01/40] xfs_scrub: fix licensing and copyright notices Darrick J. Wong
2023-12-31 22:04 ` [PATCH 1/3] xfs_scrub: fix author and spdx headers on scrub/ files Darrick J. Wong
2024-01-05 4:49 ` Christoph Hellwig
2023-12-31 22:04 ` [PATCH 2/3] xfs_scrub: add missing license and copyright information Darrick J. Wong
2024-01-05 4:50 ` Christoph Hellwig
2024-01-06 0:34 ` Darrick J. Wong
2023-12-31 22:04 ` [PATCH 3/3] xfs_scrub: update copyright years for scrub/ files Darrick J. Wong
2024-01-05 4:50 ` Christoph Hellwig
2023-12-31 19:40 ` [PATCHSET 02/40] mkfs: scale shards on ssds Darrick J. Wong
2023-12-31 22:04 ` [PATCH 1/2] mkfs: allow sizing allocation groups for concurrency Darrick J. Wong
2024-01-05 4:51 ` Christoph Hellwig
2023-12-31 22:05 ` [PATCH 2/2] mkfs: allow sizing internal logs " Darrick J. Wong
2024-01-05 4:52 ` Christoph Hellwig
2023-12-31 19:40 ` [PATCHSET v29.0 03/40] xfs_scrub: scan metadata files in parallel Darrick J. Wong
2023-12-31 22:05 ` [PATCH 1/3] libfrog: rename XFROG_SCRUB_TYPE_* to XFROG_SCRUB_GROUP_* Darrick J. Wong
2024-01-05 4:52 ` Christoph Hellwig
2023-12-31 22:05 ` [PATCH 2/3] libfrog: promote XFROG_SCRUB_DESCR_SUMMARY to a scrub type Darrick J. Wong
2024-01-05 4:53 ` Christoph Hellwig
2023-12-31 22:05 ` [PATCH 3/3] xfs_scrub: scan whole-fs metadata files in parallel Darrick J. Wong
2024-01-05 4:53 ` Christoph Hellwig
2023-12-31 19:40 ` [PATCHSET v29.0 04/40] xfs: repair inode mode by scanning dirs Darrick J. Wong
2023-12-31 22:06 ` [PATCH 1/3] xfs: create a static name for the dot entry too Darrick J. Wong
2023-12-31 22:06 ` [PATCH 2/3] xfs: create a predicate to determine if two xfs_names are the same Darrick J. Wong
2023-12-31 22:06 ` [PATCH 3/3] xfs: create a macro for decoding ftypes in tracepoints Darrick J. Wong
2023-12-31 19:40 ` [PATCHSET v29.0 05/40] xfsprogs: online repair of quota counters Darrick J. Wong
2023-12-31 22:06 ` [PATCH 1/3] xfs: report the health of quota counts Darrick J. Wong
2023-12-31 22:07 ` [PATCH 2/3] libfrog: create a new scrub group for things requiring full inode scans Darrick J. Wong
2023-12-31 22:07 ` [PATCH 3/3] xfs: implement live quotacheck inode scan Darrick J. Wong
2023-12-31 19:41 ` [PATCHSET v29.0 06/40] xfs_repair: rebuild inode fork mappings Darrick J. Wong
2023-12-31 22:07 ` [PATCH 1/3] xfs_repair: push inode buf and dinode pointers all the way to inode fork processing Darrick J. Wong
2023-12-31 22:08 ` [PATCH 2/3] xfs_repair: sync bulkload data structures with kernel newbt code Darrick J. Wong
2023-12-31 22:08 ` Darrick J. Wong [this message]
2023-12-31 19:41 ` [PATCHSET 07/40] xfs_repair: support more than 4 billion records Darrick J. Wong
2023-12-31 22:08 ` [PATCH 1/8] xfs_db: add a bmbt inflation command Darrick J. Wong
2023-12-31 22:08 ` [PATCH 2/8] xfs_repair: slab and bag structs need to track more than 2^32 items Darrick J. Wong
2023-12-31 22:09 ` [PATCH 3/8] xfs_repair: support more than 2^32 rmapbt records per AG Darrick J. Wong
2023-12-31 22:09 ` [PATCH 4/8] xfs_repair: support more than 2^32 owners per physical block Darrick J. Wong
2023-12-31 22:09 ` [PATCH 5/8] xfs_repair: clean up lock resources Darrick J. Wong
2023-12-31 22:09 ` [PATCH 6/8] xfs_repair: constrain attr fork extent count Darrick J. Wong
2023-12-31 22:10 ` [PATCH 7/8] xfs_repair: don't create block maps for data files Darrick J. Wong
2023-12-31 22:10 ` [PATCH 8/8] xfs_repair: support more than INT_MAX block maps Darrick J. Wong
2023-12-31 19:41 ` [PATCHSET v29.0 08/40] xfsprogs: online repair of file link counts Darrick J. Wong
2023-12-31 22:10 ` [PATCH 1/3] xfs: report health of inode " Darrick J. Wong
2023-12-31 22:10 ` [PATCH 2/3] xfs: teach scrub to check file nlinks Darrick J. Wong
2023-12-31 22:11 ` [PATCH 3/3] xfs_scrub: use multiple threads to run in-kernel metadata scrubs that scan inodes Darrick J. Wong
2023-12-31 19:42 ` [PATCHSET v29.0 09/40] xfsprogs: report corruption to the health trackers Darrick J. Wong
2023-12-31 22:11 ` [PATCH 1/9] xfs: separate the marking of sick and checked metadata Darrick J. Wong
2023-12-31 22:11 ` [PATCH 2/9] xfs: report fs corruption errors to the health tracking system Darrick J. Wong
2023-12-31 22:11 ` [PATCH 3/9] xfs: report ag header " Darrick J. Wong
2023-12-31 22:12 ` [PATCH 4/9] xfs: report block map " Darrick J. Wong
2023-12-31 22:12 ` [PATCH 5/9] xfs: report btree block corruption errors to the health system Darrick J. Wong
2023-12-31 22:12 ` [PATCH 6/9] xfs: report dir/attr " Darrick J. Wong
2023-12-31 22:12 ` [PATCH 7/9] xfs: report inode " Darrick J. Wong
2023-12-31 22:13 ` [PATCH 8/9] xfs: report realtime metadata " Darrick J. Wong
2023-12-31 22:13 ` [PATCH 9/9] xfs: report XFS_IS_CORRUPT " Darrick J. Wong
2023-12-31 19:42 ` [PATCHSET v29.0 10/40] xfsprogs: indirect health reporting Darrick J. Wong
2023-12-31 22:13 ` [PATCH 1/4] xfs: add secondary and indirect classes to the health tracking system Darrick J. Wong
2023-12-31 22:14 ` [PATCH 2/4] xfs: remember sick inodes that get inactivated Darrick J. Wong
2023-12-31 22:14 ` [PATCH 3/4] xfs: update health status if we get a clean bill of health Darrick J. Wong
2023-12-31 22:14 ` [PATCH 4/4] xfs_scrub: upload clean bills " Darrick J. Wong
2023-12-31 19:42 ` [PATCHSET v29.0 11/40] xfsprogs: support in-memory btrees Darrick J. Wong
2023-12-31 22:14 ` [PATCH 01/10] libxfs: clean up xfs_da_unmount usage Darrick J. Wong
2023-12-31 22:15 ` [PATCH 02/10] libxfs: teach buftargs to maintain their own buffer hashtable Darrick J. Wong
2023-12-31 22:15 ` [PATCH 03/10] libxfs: add xfile support Darrick J. Wong
2023-12-31 22:15 ` [PATCH 04/10] xfs: teach buftargs to maintain their own buffer hashtable Darrick J. Wong
2023-12-31 22:15 ` [PATCH 05/10] libxfs: support in-memory buffer cache targets Darrick J. Wong
2023-12-31 22:16 ` [PATCH 06/10] xfs: consolidate btree block freeing tracepoints Darrick J. Wong
2023-12-31 22:16 ` [PATCH 07/10] xfs: consolidate btree block allocation tracepoints Darrick J. Wong
2023-12-31 22:16 ` [PATCH 08/10] xfs: support in-memory btrees Darrick J. Wong
2023-12-31 22:16 ` [PATCH 09/10] xfs: connect in-memory btrees to xfiles Darrick J. Wong
2023-12-31 22:17 ` [PATCH 10/10] xfbtree: let the buffer cache flush dirty buffers to the xfile Darrick J. Wong
2023-12-31 19:42 ` [PATCHSET v29.0 12/40] xfsprogs: online repair of rmap btrees Darrick J. Wong
2023-12-31 22:17 ` [PATCH 1/4] xfs: create a helper to decide if a file mapping targets the rt volume Darrick J. Wong
2023-12-31 22:17 ` [PATCH 2/4] xfs: repair the rmapbt Darrick J. Wong
2023-12-31 22:17 ` [PATCH 3/4] xfs: create a shadow rmap btree during rmap repair Darrick J. Wong
2023-12-31 22:18 ` [PATCH 4/4] xfs: hook live rmap operations during a repair operation Darrick J. Wong
2023-12-31 19:43 ` [PATCHSET v29.0 13/40] xfs_repair: use in-memory rmap btrees Darrick J. Wong
2023-12-31 22:18 ` [PATCH 1/6] libxfs: partition memfd files to avoid using too many fds Darrick J. Wong
2023-12-31 22:18 ` [PATCH 2/6] xfs_repair: convert regular rmap repair to use in-memory btrees Darrick J. Wong
2023-12-31 22:18 ` [PATCH 3/6] xfs_repair: verify on-disk rmap btrees with in-memory btree data Darrick J. Wong
2023-12-31 22:19 ` [PATCH 4/6] xfs_repair: compute refcount data from in-memory rmap btrees Darrick J. Wong
2023-12-31 22:19 ` [PATCH 5/6] xfs_repair: reduce rmap bag memory usage when creating refcounts Darrick J. Wong
2023-12-31 22:19 ` [PATCH 6/6] xfs_repair: remove the old rmap collection slabs Darrick J. Wong
2023-12-31 19:43 ` [PATCHSET v29.0 14/40] xfsprogs: move btree geometry to ops struct Darrick J. Wong
2023-12-31 22:20 ` [PATCH 1/9] xfs: set the btree cursor bc_ops in xfs_btree_alloc_cursor Darrick J. Wong
2023-12-31 22:20 ` [PATCH 2/9] xfs: encode the default bc_flags in the btree ops structure Darrick J. Wong
2023-12-31 22:20 ` [PATCH 3/9] xfs: export some of the btree ops structures Darrick J. Wong
2023-12-31 22:20 ` [PATCH 4/9] xfs: initialize btree blocks using btree_ops structure Darrick J. Wong
2023-12-31 22:21 ` [PATCH 5/9] xfs: rename btree block/buffer init functions Darrick J. Wong
2023-12-31 22:21 ` [PATCH 6/9] xfs: btree convert xfs_btree_init_block to xfs_btree_init_buf calls Darrick J. Wong
2023-12-31 22:21 ` [PATCH 7/9] xfs: remove the unnecessary daddr paramter to _init_block Darrick J. Wong
2023-12-31 22:21 ` [PATCH 8/9] xfs: set btree block buffer ops in _init_buf Darrick J. Wong
2023-12-31 22:22 ` [PATCH 9/9] xfs: remove unnecessary fields in xfbtree_config Darrick J. Wong
2023-12-31 19:43 ` [PATCHSET v29.0 15/40] xfs_repair: reduce refcount repair memory usage Darrick J. Wong
2023-12-31 22:22 ` [PATCH 1/6] xfs: move lru refs to the btree ops structure Darrick J. Wong
2023-12-31 22:22 ` [PATCH 2/6] xfs: define an in-memory btree for storing refcount bag info during repairs Darrick J. Wong
2023-12-31 22:22 ` [PATCH 3/6] xfs_repair: define an in-memory btree for storing refcount bag info Darrick J. Wong
2023-12-31 22:23 ` [PATCH 4/6] xfs_repair: create refcount bag Darrick J. Wong
2023-12-31 22:23 ` [PATCH 5/6] xfs_repair: port to the new refcount bag structure Darrick J. Wong
2023-12-31 22:23 ` [PATCH 6/6] xfs_repair: remove the old bag implementation Darrick J. Wong
2023-12-31 19:43 ` [PATCHSET v29.0 16/40] xfsprogs: bmap log intent cleanups Darrick J. Wong
2023-12-31 22:23 ` [PATCH 1/5] xfs: clean up bmap log intent item tracepoint callsites Darrick J. Wong
2023-12-31 22:24 ` [PATCH 2/5] xfs: add a bi_entry helper Darrick J. Wong
2023-12-31 22:24 ` [PATCH 3/5] xfs: reuse xfs_bmap_update_cancel_item Darrick J. Wong
2023-12-31 22:24 ` [PATCH 4/5] xfs: move xfs_bmap_defer_add to xfs_bmap_item.c Darrick J. Wong
2023-12-31 22:24 ` [PATCH 5/5] xfs: add a xattr_entry helper Darrick J. Wong
2023-12-31 19:44 ` [PATCHSET v29.0 17/40] xfsprogs: widen BUI formats to support realtime Darrick J. Wong
2023-12-31 22:25 ` [PATCH 1/2] xfs: fix xfs_bunmapi to allow unmapping of partial rt extents Darrick J. Wong
2023-12-31 22:25 ` [PATCH 2/2] xfs: add a realtime flag to the bmap update log redo items Darrick J. Wong
2023-12-31 19:44 ` [PATCHSET v29.0 18/40] xfsprogs: support attrfork and unwritten BUIs Darrick J. Wong
2023-12-31 22:25 ` [PATCH 1/2] xfs: support deferred bmap updates on the attr fork Darrick J. Wong
2023-12-31 22:26 ` [PATCH 2/2] xfs: xfs_bmap_finish_one should map unwritten extents properly Darrick J. Wong
2023-12-31 19:44 ` [PATCHSET v29.0 19/40] xfsprogs: clean up symbolic link code Darrick J. Wong
2023-12-31 22:26 ` [PATCH 1/4] xfs: move xfs_symlink_remote.c declarations to xfs_symlink_remote.h Darrick J. Wong
2023-12-31 22:26 ` [PATCH 2/4] xfs: move remote symlink target read function to libxfs Darrick J. Wong
2023-12-31 22:26 ` [PATCH 3/4] xfs: move symlink target write " Darrick J. Wong
2023-12-31 22:27 ` [PATCH 4/4] mkfs: use libxfs to create symlinks Darrick J. Wong
2023-12-31 19:44 ` [PATCHSET v29.0 20/40] xfsprogs: atomic file updates Darrick J. Wong
2023-12-31 22:27 ` [PATCH 01/20] xfs: add a libxfs header file for staging new ioctls Darrick J. Wong
2023-12-31 22:27 ` [PATCH 02/20] xfs: introduce new file range exchange ioctl Darrick J. Wong
2023-12-31 22:27 ` [PATCH 03/20] xfs: parameterize all the incompat log feature helpers Darrick J. Wong
2023-12-31 22:28 ` [PATCH 04/20] xfs: create a log incompat flag for atomic extent swapping Darrick J. Wong
2023-12-31 22:28 ` [PATCH 05/20] xfs: introduce a swap-extent log intent item Darrick J. Wong
2023-12-31 22:28 ` [PATCH 06/20] xfs: create deferred log items for extent swapping Darrick J. Wong
2023-12-31 22:28 ` [PATCH 07/20] xfs: add error injection to test swapext recovery Darrick J. Wong
2023-12-31 22:29 ` [PATCH 08/20] xfs: condense extended attributes after an atomic swap Darrick J. Wong
2023-12-31 22:29 ` [PATCH 09/20] xfs: condense directories " Darrick J. Wong
2023-12-31 22:29 ` [PATCH 10/20] xfs: condense symbolic links " Darrick J. Wong
2023-12-31 22:29 ` [PATCH 11/20] xfs: make atomic extent swapping support realtime files Darrick J. Wong
2023-12-31 22:30 ` [PATCH 12/20] xfs: enable atomic swapext feature Darrick J. Wong
2023-12-31 22:30 ` [PATCH 13/20] libhandle: add support for bulkstat v5 Darrick J. Wong
2023-12-31 22:30 ` [PATCH 14/20] libfrog: convert xfs_io swapext command to use new libfrog wrapper Darrick J. Wong
2023-12-31 22:30 ` [PATCH 15/20] xfs_logprint: support dumping swapext log items Darrick J. Wong
2023-12-31 22:31 ` [PATCH 16/20] xfs_fsr: convert to bulkstat v5 ioctls Darrick J. Wong
2023-12-31 22:31 ` [PATCH 17/20] xfs_fsr: port to new swapext library function Darrick J. Wong
2023-12-31 22:31 ` [PATCH 18/20] xfs_fsr: skip the xattr/forkoff levering with the newer swapext implementations Darrick J. Wong
2023-12-31 22:32 ` [PATCH 19/20] xfs_io: enhance swapext to take advantage of new api Darrick J. Wong
2023-12-31 22:32 ` [PATCH 20/20] xfs_io: add atomic update commands to exercise extent swapping Darrick J. Wong
2023-12-31 19:45 ` [PATCHSET v29.0 21/40] xfsprogs: set and validate dir/attr block owners Darrick J. Wong
2023-12-31 22:32 ` [PATCH 1/9] xfs: add an explicit owner field to xfs_da_args Darrick J. Wong
2023-12-31 22:32 ` [PATCH 2/9] xfs: use the xfs_da_args owner field to set new dir/attr block owner Darrick J. Wong
2023-12-31 22:33 ` [PATCH 3/9] xfs: validate attr leaf buffer owners Darrick J. Wong
2023-12-31 22:33 ` [PATCH 4/9] xfs: validate attr remote value " Darrick J. Wong
2023-12-31 22:33 ` [PATCH 5/9] xfs: validate dabtree node " Darrick J. Wong
2023-12-31 22:33 ` [PATCH 6/9] xfs: validate directory leaf " Darrick J. Wong
2023-12-31 22:34 ` [PATCH 7/9] xfs: validate explicit directory data " Darrick J. Wong
2023-12-31 22:34 ` [PATCH 8/9] xfs: validate explicit directory block " Darrick J. Wong
2023-12-31 22:34 ` [PATCH 9/9] xfs: validate explicit directory free block owners Darrick J. Wong
2023-12-31 19:45 ` [PATCHSET v29.0 22/40] xfsprogs: online repair of extended attributes Darrick J. Wong
2023-12-31 22:34 ` [PATCH 1/1] xfs: repair " Darrick J. Wong
2023-12-31 19:45 ` [PATCHSET v29.0 23/40] xfsprogs: online repair of symbolic links Darrick J. Wong
2023-12-31 22:35 ` [PATCH 1/1] xfs: " Darrick J. Wong
2023-12-31 19:45 ` [PATCHSET v29.0 24/40] libxfs: cache xfile pages for better performance Darrick J. Wong
2023-12-31 22:35 ` [PATCH 1/1] xfs: map xfile pages directly into xfs_buf Darrick J. Wong
2024-01-03 8:24 ` Christoph Hellwig
2024-01-03 8:44 ` Christoph Hellwig
2023-12-31 19:46 ` [PATCHSET v29.0 25/40] xfsprogs: inode-related repair fixes Darrick J. Wong
2023-12-31 22:35 ` [PATCH 1/4] xfs: check unused nlink fields in the ondisk inode Darrick J. Wong
2023-12-31 22:35 ` [PATCH 2/4] xfs: try to avoid allocating from sick inode clusters Darrick J. Wong
2023-12-31 22:36 ` [PATCH 3/4] libxfs: port the bumplink function from the kernel Darrick J. Wong
2023-12-31 22:36 ` [PATCH 4/4] xfs: pin inodes that would otherwise overflow link count Darrick J. Wong
2023-12-31 19:46 ` [PATCHSET v29.0 26/40] xfs_scrub: fixes to the repair code Darrick J. Wong
2023-12-31 22:36 ` [PATCH 1/7] xfs_scrub: flush stdout after printing to it Darrick J. Wong
2024-01-05 4:55 ` Christoph Hellwig
2023-12-31 22:36 ` [PATCH 2/7] xfs_scrub: don't report media errors for space with unknowable owner Darrick J. Wong
2024-01-05 4:56 ` Christoph Hellwig
2023-12-31 22:37 ` [PATCH 3/7] xfs_scrub: remove ALP_* flags namespace Darrick J. Wong
2024-01-05 4:56 ` Christoph Hellwig
2023-12-31 22:37 ` [PATCH 4/7] xfs_scrub: move repair functions to repair.c Darrick J. Wong
2024-01-05 4:56 ` Christoph Hellwig
2023-12-31 22:37 ` [PATCH 5/7] xfs_scrub: log when a repair was unnecessary Darrick J. Wong
2024-01-05 4:57 ` Christoph Hellwig
2023-12-31 22:38 ` [PATCH 6/7] xfs_scrub: require primary superblock repairs to complete before proceeding Darrick J. Wong
2024-01-05 4:57 ` Christoph Hellwig
2023-12-31 22:38 ` [PATCH 7/7] xfs_scrub: actually try to fix summary counters ahead of repairs Darrick J. Wong
2024-01-05 4:57 ` Christoph Hellwig
2023-12-31 19:46 ` [PATCHSET v29.0 27/40] xfs_scrub: improve warnings about difficult repairs Darrick J. Wong
2023-12-31 22:38 ` [PATCH 1/8] xfs_scrub: fix missing scrub coverage for broken inodes Darrick J. Wong
2024-01-05 4:58 ` Christoph Hellwig
2023-12-31 22:38 ` [PATCH 2/8] xfs_scrub: collapse trivial superblock scrub helpers Darrick J. Wong
2024-01-05 4:58 ` Christoph Hellwig
2023-12-31 22:39 ` [PATCH 3/8] xfs_scrub: get rid of trivial fs metadata scanner helpers Darrick J. Wong
2024-01-05 4:58 ` Christoph Hellwig
2023-12-31 22:39 ` [PATCH 4/8] xfs_scrub: split up the mustfix repairs and difficulty assessment functions Darrick J. Wong
2024-01-05 4:59 ` Christoph Hellwig
2023-12-31 22:39 ` [PATCH 5/8] xfs_scrub: add missing repair types to the mustfix and difficulty assessment Darrick J. Wong
2024-01-05 4:59 ` Christoph Hellwig
2023-12-31 22:39 ` [PATCH 6/8] xfs_scrub: any inconsistency in metadata should trigger difficulty warnings Darrick J. Wong
2024-01-05 4:59 ` Christoph Hellwig
2023-12-31 22:40 ` [PATCH 7/8] xfs_scrub: warn about difficult repairs to rt and quota metadata Darrick J. Wong
2024-01-05 5:00 ` Christoph Hellwig
2023-12-31 22:40 ` [PATCH 8/8] xfs_scrub: enable users to bump information messages to warnings Darrick J. Wong
2024-01-05 5:00 ` Christoph Hellwig
2023-12-31 19:46 ` [PATCHSET v29.0 28/40] xfs_scrub: track data dependencies for repairs Darrick J. Wong
2023-12-31 22:40 ` [PATCH 1/9] xfs_scrub: track repair items by principal, not by individual repairs Darrick J. Wong
2024-01-05 5:01 ` Christoph Hellwig
2023-12-31 22:40 ` [PATCH 2/9] xfs_scrub: use repair_item to direct repair activities Darrick J. Wong
2024-01-05 5:01 ` Christoph Hellwig
2023-12-31 22:41 ` [PATCH 3/9] xfs_scrub: remove action lists from phaseX code Darrick J. Wong
2024-01-05 5:02 ` Christoph Hellwig
2023-12-31 22:41 ` [PATCH 4/9] xfs_scrub: remove scrub_metadata_file Darrick J. Wong
2024-01-05 5:02 ` Christoph Hellwig
2023-12-31 22:41 ` [PATCH 5/9] xfs_scrub: boost the repair priority of dependencies of damaged items Darrick J. Wong
2024-01-05 5:02 ` Christoph Hellwig
2023-12-31 22:41 ` [PATCH 6/9] xfs_scrub: clean up repair_item_difficulty a little Darrick J. Wong
2024-01-05 5:03 ` Christoph Hellwig
2023-12-31 22:42 ` [PATCH 7/9] xfs_scrub: check dependencies of a scrub type before repairing Darrick J. Wong
2024-01-05 5:03 ` Christoph Hellwig
2023-12-31 22:42 ` [PATCH 8/9] xfs_scrub: retry incomplete repairs Darrick J. Wong
2024-01-05 5:03 ` Christoph Hellwig
2023-12-31 22:42 ` [PATCH 9/9] xfs_scrub: remove unused action_list fields Darrick J. Wong
2024-01-05 5:04 ` Christoph Hellwig
2023-12-31 19:47 ` [PATCHSET v29.0 29/40] xfs_scrub: use scrub_item to track check progress Darrick J. Wong
2023-12-31 22:42 ` [PATCH 1/5] xfs_scrub: start tracking scrub state in scrub_item Darrick J. Wong
2024-01-05 5:04 ` Christoph Hellwig
2023-12-31 22:43 ` [PATCH 2/5] xfs_scrub: remove enum check_outcome Darrick J. Wong
2024-01-05 5:05 ` Christoph Hellwig
2023-12-31 22:43 ` [PATCH 3/5] xfs_scrub: refactor scrub_meta_type out of existence Darrick J. Wong
2024-01-05 5:05 ` Christoph Hellwig
2023-12-31 22:43 ` [PATCH 4/5] xfs_scrub: hoist repair retry loop to repair_item_class Darrick J. Wong
2024-01-05 5:05 ` Christoph Hellwig
2023-12-31 22:44 ` [PATCH 5/5] xfs_scrub: hoist scrub retry loop to scrub_item_check_file Darrick J. Wong
2024-01-05 5:06 ` Christoph Hellwig
2023-12-31 19:47 ` [PATCHSET v29.0 30/40] xfs_scrub: improve scheduling of repair items Darrick J. Wong
2023-12-31 22:44 ` [PATCH 1/4] libfrog: enhance ptvar to support initializer functions Darrick J. Wong
2024-01-05 5:08 ` Christoph Hellwig
2023-12-31 22:44 ` [PATCH 2/4] xfs_scrub: improve thread scheduling repair items during phase 4 Darrick J. Wong
2024-01-05 5:08 ` Christoph Hellwig
2023-12-31 22:44 ` [PATCH 3/4] xfs_scrub: recheck entire metadata objects after corruption repairs Darrick J. Wong
2024-01-05 5:08 ` Christoph Hellwig
2023-12-31 22:45 ` [PATCH 4/4] xfs_scrub: try to repair space metadata before file metadata Darrick J. Wong
2024-01-05 5:09 ` Christoph Hellwig
2023-12-31 19:47 ` [PATCHSET v29.0 31/40] xfs_scrub: detect deceptive filename extensions Darrick J. Wong
2023-12-31 22:45 ` [PATCH 01/13] xfs_scrub: use proper UChar string iterators Darrick J. Wong
2023-12-31 22:45 ` [PATCH 02/13] xfs_scrub: hoist code that removes ignorable characters Darrick J. Wong
2023-12-31 22:45 ` [PATCH 03/13] xfs_scrub: add a couple of omitted invisible code points Darrick J. Wong
2023-12-31 22:46 ` [PATCH 04/13] xfs_scrub: avoid potential UAF after freeing a duplicate name entry Darrick J. Wong
2023-12-31 22:46 ` [PATCH 05/13] xfs_scrub: guard against libicu returning negative buffer lengths Darrick J. Wong
2023-12-31 22:46 ` [PATCH 06/13] xfs_scrub: hoist non-rendering character predicate Darrick J. Wong
2023-12-31 22:46 ` [PATCH 07/13] xfs_scrub: store bad flags with the name entry Darrick J. Wong
2023-12-31 22:47 ` [PATCH 08/13] xfs_scrub: rename UNICRASH_ZERO_WIDTH to UNICRASH_INVISIBLE Darrick J. Wong
2023-12-31 22:47 ` [PATCH 09/13] xfs_scrub: type-coerce the UNICRASH_* flags Darrick J. Wong
2023-12-31 22:47 ` [PATCH 10/13] xfs_scrub: reduce size of struct name_entry Darrick J. Wong
2023-12-31 22:47 ` [PATCH 11/13] xfs_scrub: rename struct unicrash.normalizer Darrick J. Wong
2023-12-31 22:48 ` [PATCH 12/13] xfs_scrub: report deceptive file extensions Darrick J. Wong
2023-12-31 22:48 ` [PATCH 13/13] xfs_scrub: dump unicode points Darrick J. Wong
2023-12-31 19:48 ` [PATCHSET v29.0 32/40] xfs_scrub: move fstrim to a separate phase Darrick J. Wong
2023-12-31 22:48 ` [PATCH 1/8] xfs_scrub: move FITRIM to phase 8 Darrick J. Wong
2023-12-31 22:48 ` [PATCH 2/8] xfs_scrub: ignore phase 8 if the user disabled fstrim Darrick J. Wong
2023-12-31 22:49 ` [PATCH 3/8] xfs_scrub: collapse trim_filesystem Darrick J. Wong
2023-12-31 22:49 ` [PATCH 4/8] xfs_scrub: fix the work estimation for phase 8 Darrick J. Wong
2023-12-31 22:49 ` [PATCH 5/8] xfs_scrub: report FITRIM errors properly Darrick J. Wong
2023-12-31 22:49 ` [PATCH 6/8] xfs_scrub: don't call FITRIM after runtime errors Darrick J. Wong
2023-12-31 22:50 ` [PATCH 7/8] xfs_scrub: don't trim the first agbno of each AG for better performance Darrick J. Wong
2023-12-31 22:50 ` [PATCH 8/8] xfs_scrub: improve progress meter for phase 8 fstrimming Darrick J. Wong
2023-12-31 19:48 ` [PATCHSET v29.0 33/40] xfs_scrub: use free space histograms to reduce fstrim runtime Darrick J. Wong
2023-12-31 22:50 ` [PATCH 1/7] libfrog: hoist free space histogram code Darrick J. Wong
2023-12-31 22:51 ` [PATCH 2/7] libfrog: print wider columns for free space histogram Darrick J. Wong
2023-12-31 22:51 ` [PATCH 3/7] libfrog: print cdf of free space buckets Darrick J. Wong
2023-12-31 22:51 ` [PATCH 4/7] xfs_scrub: don't close stdout when closing the progress bar Darrick J. Wong
2023-12-31 22:51 ` [PATCH 5/7] xfs_scrub: remove pointless spacemap.c arguments Darrick J. Wong
2023-12-31 22:52 ` [PATCH 6/7] xfs_scrub: collect free space histograms during phase 7 Darrick J. Wong
2023-12-31 22:52 ` [PATCH 7/7] xfs_scrub: tune fstrim minlen parameter based on free space histograms Darrick J. Wong
2023-12-31 19:48 ` [PATCHSET v29.0 34/40] xfs_scrub: fixes for systemd services Darrick J. Wong
2023-12-31 20:25 ` Neal Gompa
2024-01-03 1:23 ` Darrick J. Wong
2023-12-31 22:52 ` [PATCH 1/9] debian: install scrub services with dh_installsystemd Darrick J. Wong
2023-12-31 22:52 ` [PATCH 2/9] xfs_scrub_all: escape service names consistently Darrick J. Wong
2023-12-31 22:53 ` [PATCH 3/9] xfs_scrub: fix pathname escaping across all service definitions Darrick J. Wong
2023-12-31 22:53 ` [PATCH 4/9] xfs_scrub_fail: fix sendmail detection Darrick J. Wong
2023-12-31 22:53 ` [PATCH 5/9] xfs_scrub_fail: return the failure status of the mailer program Darrick J. Wong
2023-12-31 22:53 ` [PATCH 6/9] xfs_scrub_fail: add content type header to failure emails Darrick J. Wong
2024-01-05 5:09 ` Christoph Hellwig
2023-12-31 22:54 ` [PATCH 7/9] xfs_scrub_fail: advise recipients not to reply Darrick J. Wong
2024-01-05 5:10 ` Christoph Hellwig
2023-12-31 22:54 ` [PATCH 8/9] xfs_scrub_fail: move executable script to /usr/libexec Darrick J. Wong
2024-01-01 0:24 ` Neal Gompa
2024-01-03 1:26 ` Darrick J. Wong
2024-01-05 5:10 ` Christoph Hellwig
2023-12-31 22:54 ` [PATCH 9/9] xfs_scrub_all.cron: move to package data directory Darrick J. Wong
2024-01-03 2:01 ` Neal Gompa
2024-01-05 5:11 ` Christoph Hellwig
2024-01-02 10:48 ` [PATCHSET v29.0 34/40] xfs_scrub: fixes for systemd services Christoph Hellwig
2024-01-03 1:26 ` Darrick J. Wong
2023-12-31 19:48 ` [PATCHSET v29.0 35/40] xfs_scrub_all: " Darrick J. Wong
2023-12-31 22:54 ` [PATCH 1/4] xfs_scrub_all: fix argument passing when invoking xfs_scrub manually Darrick J. Wong
2023-12-31 22:55 ` [PATCH 2/4] xfs_scrub_all: survive systemd restarts when waiting for services Darrick J. Wong
2023-12-31 22:55 ` [PATCH 3/4] xfs_scrub_all: simplify cleanup of run_killable Darrick J. Wong
2023-12-31 22:55 ` [PATCH 4/4] xfs_scrub_all: fix termination signal handling Darrick J. Wong
2023-12-31 19:49 ` [PATCHSET v29.0 36/40] xfs_scrub: tighten security of systemd services Darrick J. Wong
2023-12-31 22:55 ` [PATCH 1/6] xfs_scrub: allow auxiliary pathnames for sandboxing Darrick J. Wong
2023-12-31 22:56 ` [PATCH 2/6] xfs_scrub.service: reduce CPU usage to 60% when possible Darrick J. Wong
2023-12-31 22:56 ` [PATCH 3/6] xfs_scrub: use dynamic users when running as a systemd service Darrick J. Wong
2023-12-31 22:56 ` [PATCH 4/6] xfs_scrub: tighten up the security on the background " Darrick J. Wong
2023-12-31 22:57 ` [PATCH 5/6] xfs_scrub_fail: " Darrick J. Wong
2023-12-31 22:57 ` [PATCH 6/6] xfs_scrub_all: " Darrick J. Wong
2023-12-31 19:49 ` [PATCHSET v29.0 37/40] xfs_scrub_all: automatic media scan service Darrick J. Wong
2023-12-31 22:57 ` [PATCH 1/6] xfs_scrub_all: only use the xfs_scrub@ systemd services in service mode Darrick J. Wong
2023-12-31 22:57 ` [PATCH 2/6] xfs_scrub_all: remove journalctl background process Darrick J. Wong
2023-12-31 22:58 ` [PATCH 3/6] xfs_scrub_all: support metadata+media scans of all filesystems Darrick J. Wong
2023-12-31 22:58 ` [PATCH 4/6] xfs_scrub_all: enable periodic file data scrubs automatically Darrick J. Wong
2023-12-31 22:58 ` [PATCH 5/6] xfs_scrub_all: trigger automatic media scans once per month Darrick J. Wong
2023-12-31 22:58 ` [PATCH 6/6] xfs_scrub_all: failure reporting for the xfs_scrub_all job Darrick J. Wong
2023-12-31 19:49 ` [PATCHSET v29.0 38/40] xfs_scrub_all: improve systemd handling Darrick J. Wong
2023-12-31 22:59 ` [PATCH 1/5] xfs_scrub_all: encapsulate all the subprocess code in an object Darrick J. Wong
2023-12-31 22:59 ` [PATCH 2/5] xfs_scrub_all: encapsulate all the systemctl " Darrick J. Wong
2023-12-31 22:59 ` [PATCH 3/5] xfs_scrub_all: add CLI option for easier debugging Darrick J. Wong
2023-12-31 22:59 ` [PATCH 4/5] xfs_scrub_all: convert systemctl calls to dbus Darrick J. Wong
2023-12-31 23:00 ` [PATCH 5/5] xfs_scrub_all: implement retry and backoff for dbus calls Darrick J. Wong
2023-12-31 19:49 ` [PATCHSET v29.0 39/40] xfs_scrub: automatic optimization by default Darrick J. Wong
2023-12-31 23:00 ` [PATCH 1/3] xfs_scrub: automatic downgrades to dry-run mode in service mode Darrick J. Wong
2023-12-31 23:00 ` [PATCH 2/3] xfs_scrub: add an optimization-only mode Darrick J. Wong
2023-12-31 23:00 ` [PATCH 3/3] debian: enable xfs_scrub systemd services by default Darrick J. Wong
2023-12-31 19:50 ` [PATCHSET 40/40] xfs_repair: add other v5 features to filesystems Darrick J. Wong
2023-12-31 23:01 ` [PATCH 1/4] xfs_repair: check free space requirements before allowing upgrades Darrick J. Wong
2023-12-31 23:01 ` [PATCH 2/4] xfs_repair: allow sysadmins to add free inode btree indexes Darrick J. Wong
2023-12-31 23:01 ` [PATCH 3/4] xfs_repair: allow sysadmins to add reflink Darrick J. Wong
2023-12-31 23:01 ` [PATCH 4/4] xfs_repair: allow sysadmins to add reverse mapping indexes Darrick J. Wong
2023-12-31 19:57 ` [PATCHSET 1/8] fstests: fuzz non-root dquots on xfs Darrick J. Wong
2023-12-27 13:42 ` [PATCH 1/3] fuzzy: mask off a few more inode fields from the fuzz tests Darrick J. Wong
2023-12-27 13:43 ` [PATCH 2/3] fuzzy: allow FUZZ_REWRITE_DURATION to control fsstress runtime when fuzzing Darrick J. Wong
2023-12-27 13:43 ` [PATCH 3/3] fuzzy: test other dquot ids Darrick J. Wong
2023-12-31 19:57 ` [PATCHSET 2/8] xfsprogs: scale shards on ssds Darrick J. Wong
2023-12-27 13:43 ` [PATCH 1/1] xfs: test scaling of the mkfs concurrency options Darrick J. Wong
2023-12-31 19:57 ` [PATCHSET v29.0 3/8] fstests: establish baseline for fuzz tests Darrick J. Wong
2023-12-27 13:43 ` [PATCH 1/4] xfs: online fuzz test known output Darrick J. Wong
2023-12-27 13:44 ` [PATCH 2/4] xfs: offline " Darrick J. Wong
2023-12-27 13:44 ` [PATCH 3/4] xfs: norepair " Darrick J. Wong
2023-12-27 13:44 ` [PATCH 4/4] xfs: bothrepair " Darrick J. Wong
2023-12-31 19:57 ` [PATCHSET v29.0 4/8] fstests: atomic file updates Darrick J. Wong
2023-12-27 13:44 ` [PATCH 1/1] swapext: make sure that we don't swap unwritten extents unless they're part of a rt extent(??) Darrick J. Wong
2023-12-31 19:58 ` [PATCHSET v29.0 5/8] fstests: detect deceptive filename extensions Darrick J. Wong
2023-12-27 13:45 ` [PATCH 1/2] generic/453: test confusable name detection with 32-bit unicode codepoints Darrick J. Wong
2023-12-27 13:45 ` [PATCH 2/2] generic/453: check xfs_scrub detection of confusing job offers Darrick J. Wong
2023-12-31 19:58 ` [PATCHSET v29.0 6/8] fstests: test systemd background services Darrick J. Wong
2023-12-27 13:45 ` [PATCH 1/1] xfs: test xfs_scrub services Darrick J. Wong
2023-12-31 19:58 ` [PATCHSET v29.0 7/8] fstests: use free space histograms to reduce fstrim runtime Darrick J. Wong
2023-12-27 13:45 ` [PATCH 1/1] xfs/004: fix column extraction code Darrick J. Wong
2023-12-31 19:58 ` [PATCHSET 8/8] fstests: test upgrading older features Darrick J. Wong
2023-12-27 13:46 ` [PATCH 1/1] xfs: test upgrading old features Darrick J. Wong
2023-12-31 20:02 ` [PATCHSET v29.0] xfs-documentation: atomic file updates Darrick J. Wong
2023-12-27 14:07 ` [PATCH 1/1] design: document atomic extent swap log intent structures Darrick J. Wong
-- strict thread matches above, loose matches on Subject: below --
2024-03-13 1:49 [PATCHSET v29.4 08/10] xfs_repair: rebuild inode fork mappings Darrick J. Wong
2024-03-13 2:14 ` [PATCH 3/3] xfs_repair: rebuild block mappings from rmapbt data Darrick J. Wong
2024-03-14 1:59 ` Christoph Hellwig
2024-03-14 23:56 ` Darrick J. Wong
2024-03-17 21:10 ` Christoph Hellwig
2024-03-14 17:13 ` Bill O'Donnell
2024-03-26 2:56 [PATCHSET v29.4 08/18] xfs_repair: rebuild inode fork mappings Darrick J. Wong
2024-03-26 3:25 ` [PATCH 3/3] xfs_repair: rebuild block mappings from rmapbt data Darrick J. Wong
2024-04-17 21:17 [PATCHSET v30.3 10/11] xfs_repair: rebuild inode fork mappings Darrick J. Wong
2024-04-17 21:44 ` [PATCH 3/3] xfs_repair: rebuild block mappings from rmapbt data Darrick J. Wong
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=170404990842.1793572.11558699389826458485.stgit@frogsfrogsfrogs \
--to=djwong@kernel.org \
--cc=cem@kernel.org \
--cc=linux-xfs@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.