From: Chandan Babu R <chandanrlinux@gmail.com>
To: "Darrick J. Wong" <darrick.wong@oracle.com>
Cc: linux-xfs@vger.kernel.org
Subject: Re: [PATCH 02/28] xfs: refactor log recovery item sorting into a generic dispatch structure
Date: Tue, 05 May 2020 09:41:08 +0530 [thread overview]
Message-ID: <93453827.lAAUMYVWGY@garuda> (raw)
In-Reply-To: <158864104502.182683.672673211897001126.stgit@magnolia>
On Tuesday 5 May 2020 6:40:45 AM IST Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@oracle.com>
>
> Create a generic dispatch structure to delegate recovery of different
> log item types into various code modules. This will enable us to move
> code specific to a particular log item type out of xfs_log_recover.c and
> into the log item source.
>
> The first operation we virtualize is the log item sorting.
>
The sorted list order is the maintained as it was done before.
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
> Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
> ---
> fs/xfs/Makefile | 3 +
> fs/xfs/libxfs/xfs_log_recover.h | 45 ++++++++++++++++++-
> fs/xfs/xfs_bmap_item.c | 9 ++++
> fs/xfs/xfs_buf_item_recover.c | 38 ++++++++++++++++
> fs/xfs/xfs_dquot_item_recover.c | 29 ++++++++++++
> fs/xfs/xfs_extfree_item.c | 9 ++++
> fs/xfs/xfs_icreate_item.c | 20 ++++++++
> fs/xfs/xfs_inode_item_recover.c | 26 +++++++++++
> fs/xfs/xfs_log_recover.c | 93 +++++++++++++++++++++++----------------
> fs/xfs/xfs_refcount_item.c | 9 ++++
> fs/xfs/xfs_rmap_item.c | 9 ++++
> 11 files changed, 251 insertions(+), 39 deletions(-)
> create mode 100644 fs/xfs/xfs_buf_item_recover.c
> create mode 100644 fs/xfs/xfs_dquot_item_recover.c
> create mode 100644 fs/xfs/xfs_inode_item_recover.c
>
>
> diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
> index ff94fb90a2ee..04611a1068b4 100644
> --- a/fs/xfs/Makefile
> +++ b/fs/xfs/Makefile
> @@ -99,9 +99,12 @@ xfs-y += xfs_log.o \
> xfs_log_cil.o \
> xfs_bmap_item.o \
> xfs_buf_item.o \
> + xfs_buf_item_recover.o \
> + xfs_dquot_item_recover.o \
> xfs_extfree_item.o \
> xfs_icreate_item.o \
> xfs_inode_item.o \
> + xfs_inode_item_recover.o \
> xfs_refcount_item.o \
> xfs_rmap_item.o \
> xfs_log_recover.o \
> diff --git a/fs/xfs/libxfs/xfs_log_recover.h b/fs/xfs/libxfs/xfs_log_recover.h
> index 148e0cb5d379..271b0741f1e1 100644
> --- a/fs/xfs/libxfs/xfs_log_recover.h
> +++ b/fs/xfs/libxfs/xfs_log_recover.h
> @@ -6,6 +6,47 @@
> #ifndef __XFS_LOG_RECOVER_H__
> #define __XFS_LOG_RECOVER_H__
>
> +/*
> + * Each log item type (XFS_LI_*) gets its own xlog_recover_item_ops to
> + * define how recovery should work for that type of log item.
> + */
> +struct xlog_recover_item;
> +
> +/* Sorting hat for log items as they're read in. */
> +enum xlog_recover_reorder {
> + XLOG_REORDER_BUFFER_LIST,
> + XLOG_REORDER_ITEM_LIST,
> + XLOG_REORDER_INODE_BUFFER_LIST,
> + XLOG_REORDER_CANCEL_LIST,
> +};
> +
> +struct xlog_recover_item_ops {
> + uint16_t item_type; /* XFS_LI_* type code. */
> +
> + /*
> + * Help sort recovered log items into the order required to replay them
> + * correctly. Log item types that always use XLOG_REORDER_ITEM_LIST do
> + * not have to supply a function here. See the comment preceding
> + * xlog_recover_reorder_trans for more details about what the return
> + * values mean.
> + */
> + enum xlog_recover_reorder (*reorder)(struct xlog_recover_item *item);
> +};
> +
> +extern const struct xlog_recover_item_ops xlog_icreate_item_ops;
> +extern const struct xlog_recover_item_ops xlog_buf_item_ops;
> +extern const struct xlog_recover_item_ops xlog_inode_item_ops;
> +extern const struct xlog_recover_item_ops xlog_dquot_item_ops;
> +extern const struct xlog_recover_item_ops xlog_quotaoff_item_ops;
> +extern const struct xlog_recover_item_ops xlog_bmap_intent_item_ops;
> +extern const struct xlog_recover_item_ops xlog_bmap_done_item_ops;
> +extern const struct xlog_recover_item_ops xlog_extfree_intent_item_ops;
> +extern const struct xlog_recover_item_ops xlog_extfree_done_item_ops;
> +extern const struct xlog_recover_item_ops xlog_rmap_intent_item_ops;
> +extern const struct xlog_recover_item_ops xlog_rmap_done_item_ops;
> +extern const struct xlog_recover_item_ops xlog_refcount_intent_item_ops;
> +extern const struct xlog_recover_item_ops xlog_refcount_done_item_ops;
> +
> /*
> * Macros, structures, prototypes for internal log manager use.
> */
> @@ -24,10 +65,10 @@
> */
> struct xlog_recover_item {
> struct list_head ri_list;
> - int ri_type;
> int ri_cnt; /* count of regions found */
> int ri_total; /* total regions */
> - xfs_log_iovec_t *ri_buf; /* ptr to regions buffer */
> + struct xfs_log_iovec *ri_buf; /* ptr to regions buffer */
> + const struct xlog_recover_item_ops *ri_ops;
> };
>
> struct xlog_recover {
> diff --git a/fs/xfs/xfs_bmap_item.c b/fs/xfs/xfs_bmap_item.c
> index 7768fb2b7135..42354403fec7 100644
> --- a/fs/xfs/xfs_bmap_item.c
> +++ b/fs/xfs/xfs_bmap_item.c
> @@ -22,6 +22,7 @@
> #include "xfs_bmap_btree.h"
> #include "xfs_trans_space.h"
> #include "xfs_error.h"
> +#include "xfs_log_recover.h"
>
> kmem_zone_t *xfs_bui_zone;
> kmem_zone_t *xfs_bud_zone;
> @@ -557,3 +558,11 @@ xfs_bui_recover(
> }
> return error;
> }
> +
> +const struct xlog_recover_item_ops xlog_bmap_intent_item_ops = {
> + .item_type = XFS_LI_BUI,
> +};
> +
> +const struct xlog_recover_item_ops xlog_bmap_done_item_ops = {
> + .item_type = XFS_LI_BUD,
> +};
> diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
> new file mode 100644
> index 000000000000..def19025512e
> --- /dev/null
> +++ b/fs/xfs/xfs_buf_item_recover.c
> @@ -0,0 +1,38 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2000-2006 Silicon Graphics, Inc.
> + * All Rights Reserved.
> + */
> +#include "xfs.h"
> +#include "xfs_fs.h"
> +#include "xfs_shared.h"
> +#include "xfs_format.h"
> +#include "xfs_log_format.h"
> +#include "xfs_trans_resv.h"
> +#include "xfs_bit.h"
> +#include "xfs_mount.h"
> +#include "xfs_trans.h"
> +#include "xfs_buf_item.h"
> +#include "xfs_trans_priv.h"
> +#include "xfs_trace.h"
> +#include "xfs_log.h"
> +#include "xfs_log_priv.h"
> +#include "xfs_log_recover.h"
> +
> +STATIC enum xlog_recover_reorder
> +xlog_recover_buf_reorder(
> + struct xlog_recover_item *item)
> +{
> + struct xfs_buf_log_format *buf_f = item->ri_buf[0].i_addr;
> +
> + if (buf_f->blf_flags & XFS_BLF_CANCEL)
> + return XLOG_REORDER_CANCEL_LIST;
> + if (buf_f->blf_flags & XFS_BLF_INODE_BUF)
> + return XLOG_REORDER_INODE_BUFFER_LIST;
> + return XLOG_REORDER_BUFFER_LIST;
> +}
> +
> +const struct xlog_recover_item_ops xlog_buf_item_ops = {
> + .item_type = XFS_LI_BUF,
> + .reorder = xlog_recover_buf_reorder,
> +};
> diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
> new file mode 100644
> index 000000000000..78fe644e9907
> --- /dev/null
> +++ b/fs/xfs/xfs_dquot_item_recover.c
> @@ -0,0 +1,29 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2000-2006 Silicon Graphics, Inc.
> + * All Rights Reserved.
> + */
> +#include "xfs.h"
> +#include "xfs_fs.h"
> +#include "xfs_shared.h"
> +#include "xfs_format.h"
> +#include "xfs_log_format.h"
> +#include "xfs_trans_resv.h"
> +#include "xfs_mount.h"
> +#include "xfs_inode.h"
> +#include "xfs_quota.h"
> +#include "xfs_trans.h"
> +#include "xfs_buf_item.h"
> +#include "xfs_trans_priv.h"
> +#include "xfs_qm.h"
> +#include "xfs_log.h"
> +#include "xfs_log_priv.h"
> +#include "xfs_log_recover.h"
> +
> +const struct xlog_recover_item_ops xlog_dquot_item_ops = {
> + .item_type = XFS_LI_DQUOT,
> +};
> +
> +const struct xlog_recover_item_ops xlog_quotaoff_item_ops = {
> + .item_type = XFS_LI_QUOTAOFF,
> +};
> diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
> index c8cde4122a0f..b43bb087aef3 100644
> --- a/fs/xfs/xfs_extfree_item.c
> +++ b/fs/xfs/xfs_extfree_item.c
> @@ -22,6 +22,7 @@
> #include "xfs_bmap.h"
> #include "xfs_trace.h"
> #include "xfs_error.h"
> +#include "xfs_log_recover.h"
>
> kmem_zone_t *xfs_efi_zone;
> kmem_zone_t *xfs_efd_zone;
> @@ -644,3 +645,11 @@ xfs_efi_recover(
> xfs_trans_cancel(tp);
> return error;
> }
> +
> +const struct xlog_recover_item_ops xlog_extfree_intent_item_ops = {
> + .item_type = XFS_LI_EFI,
> +};
> +
> +const struct xlog_recover_item_ops xlog_extfree_done_item_ops = {
> + .item_type = XFS_LI_EFD,
> +};
> diff --git a/fs/xfs/xfs_icreate_item.c b/fs/xfs/xfs_icreate_item.c
> index 490fee22b878..366c1e722a29 100644
> --- a/fs/xfs/xfs_icreate_item.c
> +++ b/fs/xfs/xfs_icreate_item.c
> @@ -11,6 +11,8 @@
> #include "xfs_trans_priv.h"
> #include "xfs_icreate_item.h"
> #include "xfs_log.h"
> +#include "xfs_log_priv.h"
> +#include "xfs_log_recover.h"
>
> kmem_zone_t *xfs_icreate_zone; /* inode create item zone */
>
> @@ -107,3 +109,21 @@ xfs_icreate_log(
> tp->t_flags |= XFS_TRANS_DIRTY;
> set_bit(XFS_LI_DIRTY, &icp->ic_item.li_flags);
> }
> +
> +static enum xlog_recover_reorder
> +xlog_recover_icreate_reorder(
> + struct xlog_recover_item *item)
> +{
> + /*
> + * Inode allocation buffers must be replayed before subsequent inode
> + * items try to modify those buffers. ICREATE items are the logical
> + * equivalent of logging a newly initialized inode buffer, so recover
> + * these at the same time that we recover logged buffers.
> + */
> + return XLOG_REORDER_BUFFER_LIST;
> +}
> +
> +const struct xlog_recover_item_ops xlog_icreate_item_ops = {
> + .item_type = XFS_LI_ICREATE,
> + .reorder = xlog_recover_icreate_reorder,
> +};
> diff --git a/fs/xfs/xfs_inode_item_recover.c b/fs/xfs/xfs_inode_item_recover.c
> new file mode 100644
> index 000000000000..b19a151efb10
> --- /dev/null
> +++ b/fs/xfs/xfs_inode_item_recover.c
> @@ -0,0 +1,26 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2000-2006 Silicon Graphics, Inc.
> + * All Rights Reserved.
> + */
> +#include "xfs.h"
> +#include "xfs_fs.h"
> +#include "xfs_shared.h"
> +#include "xfs_format.h"
> +#include "xfs_log_format.h"
> +#include "xfs_trans_resv.h"
> +#include "xfs_mount.h"
> +#include "xfs_inode.h"
> +#include "xfs_trans.h"
> +#include "xfs_inode_item.h"
> +#include "xfs_trace.h"
> +#include "xfs_trans_priv.h"
> +#include "xfs_buf_item.h"
> +#include "xfs_log.h"
> +#include "xfs_error.h"
> +#include "xfs_log_priv.h"
> +#include "xfs_log_recover.h"
> +
> +const struct xlog_recover_item_ops xlog_inode_item_ops = {
> + .item_type = XFS_LI_INODE,
> +};
> diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
> index c2c06f70fb8a..0ef0d81fd190 100644
> --- a/fs/xfs/xfs_log_recover.c
> +++ b/fs/xfs/xfs_log_recover.c
> @@ -1785,6 +1785,34 @@ xlog_clear_stale_blocks(
> *
> ******************************************************************************
> */
> +static const struct xlog_recover_item_ops *xlog_recover_item_ops[] = {
> + &xlog_buf_item_ops,
> + &xlog_inode_item_ops,
> + &xlog_dquot_item_ops,
> + &xlog_quotaoff_item_ops,
> + &xlog_icreate_item_ops,
> + &xlog_extfree_intent_item_ops,
> + &xlog_extfree_done_item_ops,
> + &xlog_rmap_intent_item_ops,
> + &xlog_rmap_done_item_ops,
> + &xlog_refcount_intent_item_ops,
> + &xlog_refcount_done_item_ops,
> + &xlog_bmap_intent_item_ops,
> + &xlog_bmap_done_item_ops,
> +};
> +
> +static const struct xlog_recover_item_ops *
> +xlog_find_item_ops(
> + struct xlog_recover_item *item)
> +{
> + unsigned int i;
> +
> + for (i = 0; i < ARRAY_SIZE(xlog_recover_item_ops); i++)
> + if (ITEM_TYPE(item) == xlog_recover_item_ops[i]->item_type)
> + return xlog_recover_item_ops[i];
> +
> + return NULL;
> +}
>
> /*
> * Sort the log items in the transaction.
> @@ -1851,41 +1879,10 @@ xlog_recover_reorder_trans(
>
> list_splice_init(&trans->r_itemq, &sort_list);
> list_for_each_entry_safe(item, n, &sort_list, ri_list) {
> - xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
> + enum xlog_recover_reorder fate = XLOG_REORDER_ITEM_LIST;
>
> - switch (ITEM_TYPE(item)) {
> - case XFS_LI_ICREATE:
> - list_move_tail(&item->ri_list, &buffer_list);
> - break;
> - case XFS_LI_BUF:
> - if (buf_f->blf_flags & XFS_BLF_CANCEL) {
> - trace_xfs_log_recover_item_reorder_head(log,
> - trans, item, pass);
> - list_move(&item->ri_list, &cancel_list);
> - break;
> - }
> - if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
> - list_move(&item->ri_list, &inode_buffer_list);
> - break;
> - }
> - list_move_tail(&item->ri_list, &buffer_list);
> - break;
> - case XFS_LI_INODE:
> - case XFS_LI_DQUOT:
> - case XFS_LI_QUOTAOFF:
> - case XFS_LI_EFD:
> - case XFS_LI_EFI:
> - case XFS_LI_RUI:
> - case XFS_LI_RUD:
> - case XFS_LI_CUI:
> - case XFS_LI_CUD:
> - case XFS_LI_BUI:
> - case XFS_LI_BUD:
> - trace_xfs_log_recover_item_reorder_tail(log,
> - trans, item, pass);
> - list_move_tail(&item->ri_list, &item_list);
> - break;
> - default:
> + item->ri_ops = xlog_find_item_ops(item);
> + if (!item->ri_ops) {
> xfs_warn(log->l_mp,
> "%s: unrecognized type of log operation (%d)",
> __func__, ITEM_TYPE(item));
> @@ -1896,11 +1893,33 @@ xlog_recover_reorder_trans(
> */
> if (!list_empty(&sort_list))
> list_splice_init(&sort_list, &trans->r_itemq);
> - error = -EIO;
> - goto out;
> + error = -EFSCORRUPTED;
> + break;
> + }
> +
> + if (item->ri_ops->reorder)
> + fate = item->ri_ops->reorder(item);
> +
> + switch (fate) {
> + case XLOG_REORDER_BUFFER_LIST:
> + list_move_tail(&item->ri_list, &buffer_list);
> + break;
> + case XLOG_REORDER_CANCEL_LIST:
> + trace_xfs_log_recover_item_reorder_head(log,
> + trans, item, pass);
> + list_move(&item->ri_list, &cancel_list);
> + break;
> + case XLOG_REORDER_INODE_BUFFER_LIST:
> + list_move(&item->ri_list, &inode_buffer_list);
> + break;
> + case XLOG_REORDER_ITEM_LIST:
> + trace_xfs_log_recover_item_reorder_tail(log,
> + trans, item, pass);
> + list_move_tail(&item->ri_list, &item_list);
> + break;
> }
> }
> -out:
> +
> ASSERT(list_empty(&sort_list));
> if (!list_empty(&buffer_list))
> list_splice(&buffer_list, &trans->r_itemq);
> diff --git a/fs/xfs/xfs_refcount_item.c b/fs/xfs/xfs_refcount_item.c
> index 0316eab2fc35..0e8e8bab4344 100644
> --- a/fs/xfs/xfs_refcount_item.c
> +++ b/fs/xfs/xfs_refcount_item.c
> @@ -18,6 +18,7 @@
> #include "xfs_log.h"
> #include "xfs_refcount.h"
> #include "xfs_error.h"
> +#include "xfs_log_recover.h"
>
> kmem_zone_t *xfs_cui_zone;
> kmem_zone_t *xfs_cud_zone;
> @@ -570,3 +571,11 @@ xfs_cui_recover(
> xfs_trans_cancel(tp);
> return error;
> }
> +
> +const struct xlog_recover_item_ops xlog_refcount_intent_item_ops = {
> + .item_type = XFS_LI_CUI,
> +};
> +
> +const struct xlog_recover_item_ops xlog_refcount_done_item_ops = {
> + .item_type = XFS_LI_CUD,
> +};
> diff --git a/fs/xfs/xfs_rmap_item.c b/fs/xfs/xfs_rmap_item.c
> index e3bba2aec868..3eb538674cb9 100644
> --- a/fs/xfs/xfs_rmap_item.c
> +++ b/fs/xfs/xfs_rmap_item.c
> @@ -18,6 +18,7 @@
> #include "xfs_log.h"
> #include "xfs_rmap.h"
> #include "xfs_error.h"
> +#include "xfs_log_recover.h"
>
> kmem_zone_t *xfs_rui_zone;
> kmem_zone_t *xfs_rud_zone;
> @@ -585,3 +586,11 @@ xfs_rui_recover(
> xfs_trans_cancel(tp);
> return error;
> }
> +
> +const struct xlog_recover_item_ops xlog_rmap_intent_item_ops = {
> + .item_type = XFS_LI_RUI,
> +};
> +
> +const struct xlog_recover_item_ops xlog_rmap_done_item_ops = {
> + .item_type = XFS_LI_RUD,
> +};
>
>
--
chandan
next prev parent reply other threads:[~2020-05-05 4:11 UTC|newest]
Thread overview: 94+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-05-05 1:10 [PATCH v3 00/28] xfs: refactor log recovery Darrick J. Wong
2020-05-05 1:10 ` [PATCH 01/28] xfs: convert xfs_log_recover_item_t to struct xfs_log_recover_item Darrick J. Wong
2020-05-05 3:33 ` Chandan Babu R
2020-05-06 14:59 ` Christoph Hellwig
2020-05-05 1:10 ` [PATCH 02/28] xfs: refactor log recovery item sorting into a generic dispatch structure Darrick J. Wong
2020-05-05 4:11 ` Chandan Babu R [this message]
2020-05-06 15:03 ` Christoph Hellwig
2020-05-06 18:36 ` Darrick J. Wong
2020-05-05 1:10 ` [PATCH 03/28] xfs: refactor log recovery item dispatch for pass2 readhead functions Darrick J. Wong
2020-05-05 4:32 ` Chandan Babu R
2020-05-06 15:04 ` Christoph Hellwig
2020-05-05 1:10 ` [PATCH 04/28] xfs: refactor log recovery item dispatch for pass1 commit functions Darrick J. Wong
2020-05-05 4:40 ` Chandan Babu R
2020-05-06 15:07 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 05/28] xfs: refactor log recovery buffer item dispatch for pass2 " Darrick J. Wong
2020-05-05 5:03 ` Chandan Babu R
2020-05-06 15:09 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 06/28] xfs: refactor log recovery inode " Darrick J. Wong
2020-05-05 5:09 ` Chandan Babu R
2020-05-06 15:10 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 07/28] xfs: refactor log recovery dquot " Darrick J. Wong
2020-05-05 5:13 ` Chandan Babu R
2020-05-06 15:11 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 08/28] xfs: refactor log recovery icreate " Darrick J. Wong
2020-05-05 6:10 ` Chandan Babu R
2020-05-06 15:11 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 09/28] xfs: refactor log recovery EFI " Darrick J. Wong
2020-05-05 6:46 ` Chandan Babu R
2020-05-06 15:12 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 10/28] xfs: refactor log recovery RUI " Darrick J. Wong
2020-05-05 7:02 ` Chandan Babu R
2020-05-06 15:12 ` Christoph Hellwig
2020-05-06 15:13 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 11/28] xfs: refactor log recovery CUI " Darrick J. Wong
2020-05-05 7:06 ` Chandan Babu R
2020-05-06 15:13 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 12/28] xfs: refactor log recovery BUI " Darrick J. Wong
2020-05-05 7:14 ` Chandan Babu R
2020-05-06 15:14 ` Christoph Hellwig
2020-05-05 1:11 ` [PATCH 13/28] xfs: remove log recovery quotaoff " Darrick J. Wong
2020-05-05 7:32 ` Chandan Babu R
2020-05-06 15:16 ` Christoph Hellwig
2020-05-06 16:48 ` Darrick J. Wong
2020-05-05 1:12 ` [PATCH 14/28] xfs: refactor recovered EFI log item playback Darrick J. Wong
2020-05-05 9:03 ` Chandan Babu R
2020-05-06 15:18 ` Christoph Hellwig
2020-05-06 18:59 ` Darrick J. Wong
2020-05-05 1:12 ` [PATCH 15/28] xfs: refactor recovered RUI " Darrick J. Wong
2020-05-05 9:10 ` Chandan Babu R
2020-05-06 15:18 ` Christoph Hellwig
2020-05-06 15:19 ` Christoph Hellwig
2020-05-05 1:12 ` [PATCH 16/28] xfs: refactor recovered CUI " Darrick J. Wong
2020-05-05 9:29 ` Chandan Babu R
2020-05-05 9:29 ` Chandan Babu R
2020-05-06 15:19 ` Christoph Hellwig
2020-05-05 1:12 ` [PATCH 17/28] xfs: refactor recovered BUI " Darrick J. Wong
2020-05-05 9:49 ` Chandan Babu R
2020-05-06 15:21 ` Christoph Hellwig
2020-05-05 1:12 ` [PATCH 18/28] xfs: refactor unlinked inode recovery Darrick J. Wong
2020-05-05 13:05 ` Chandan Babu R
2020-05-06 15:26 ` Christoph Hellwig
2020-05-06 16:51 ` Darrick J. Wong
2020-05-05 1:12 ` [PATCH 19/28] xfs: refactor xlog_recover_process_unlinked Darrick J. Wong
2020-05-05 13:19 ` Chandan Babu R
2020-05-05 13:30 ` Chandan Babu R
2020-05-06 19:11 ` Darrick J. Wong
2020-05-06 15:27 ` Christoph Hellwig
2020-05-05 1:12 ` [PATCH 20/28] xfs: report iunlink recovery failure upwards Darrick J. Wong
2020-05-05 13:43 ` Chandan Babu R
2020-05-06 15:27 ` Christoph Hellwig
2020-05-05 1:12 ` [PATCH 21/28] xfs: refactor releasing finished intents during log recovery Darrick J. Wong
2020-05-06 4:06 ` Chandan Babu R
2020-05-06 15:29 ` Christoph Hellwig
2020-05-05 1:12 ` [PATCH 22/28] xfs: refactor adding recovered intent items to the log Darrick J. Wong
2020-05-06 15:31 ` Christoph Hellwig
2020-05-06 19:28 ` Darrick J. Wong
2020-05-05 1:12 ` [PATCH 23/28] xfs: refactor intent item RECOVERED flag into the log item Darrick J. Wong
2020-05-06 4:45 ` Chandan Babu R
2020-05-06 15:32 ` Christoph Hellwig
2020-05-05 1:13 ` [PATCH 24/28] xfs: refactor intent item iop_recover calls Darrick J. Wong
2020-05-06 5:14 ` Chandan Babu R
2020-05-06 15:34 ` Christoph Hellwig
2020-05-05 1:13 ` [PATCH 25/28] xfs: hoist setting of XFS_LI_RECOVERED to caller Darrick J. Wong
2020-05-06 5:34 ` Chandan Babu R
2020-05-06 15:35 ` Christoph Hellwig
2020-05-05 1:13 ` [PATCH 26/28] xfs: move log recovery buffer cancellation code to xfs_buf_item_recover.c Darrick J. Wong
2020-05-06 6:42 ` Chandan Babu R
2020-05-06 15:35 ` Christoph Hellwig
2020-05-05 1:13 ` [PATCH 27/28] xfs: remove unnecessary includes from xfs_log_recover.c Darrick J. Wong
2020-05-06 7:21 ` Chandan Babu R
2020-05-05 1:13 ` [PATCH 28/28] xfs: use parallel processing to clear unlinked metadata Darrick J. Wong
2020-05-06 7:57 ` Chandan Babu R
2020-05-06 15:36 ` Christoph Hellwig
2020-05-06 16:54 ` 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=93453827.lAAUMYVWGY@garuda \
--to=chandanrlinux@gmail.com \
--cc=darrick.wong@oracle.com \
--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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox