2018-06-06 02:42:14 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2005-11-02 03:58:39 +00:00
|
|
|
* Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
|
|
|
|
|
* All Rights Reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
#ifndef __XFS_BUF_ITEM_H__
|
|
|
|
|
#define __XFS_BUF_ITEM_H__
|
|
|
|
|
|
2013-08-12 10:49:24 +00:00
|
|
|
/* kernel only definitions */
|
2012-06-22 08:50:07 +00:00
|
|
|
|
2022-04-21 00:46:40 +00:00
|
|
|
struct xfs_buf;
|
|
|
|
|
struct xfs_mount;
|
|
|
|
|
|
2013-08-12 10:49:24 +00:00
|
|
|
/* buf log item flags */
|
2022-04-21 00:46:40 +00:00
|
|
|
#define XFS_BLI_HOLD (1u << 0)
|
|
|
|
|
#define XFS_BLI_DIRTY (1u << 1)
|
|
|
|
|
#define XFS_BLI_STALE (1u << 2)
|
|
|
|
|
#define XFS_BLI_LOGGED (1u << 3)
|
|
|
|
|
#define XFS_BLI_INODE_ALLOC_BUF (1u << 4)
|
|
|
|
|
#define XFS_BLI_STALE_INODE (1u << 5)
|
|
|
|
|
#define XFS_BLI_INODE_BUF (1u << 6)
|
|
|
|
|
#define XFS_BLI_ORDERED (1u << 7)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-14 23:14:59 +00:00
|
|
|
#define XFS_BLI_FLAGS \
|
|
|
|
|
{ XFS_BLI_HOLD, "HOLD" }, \
|
|
|
|
|
{ XFS_BLI_DIRTY, "DIRTY" }, \
|
|
|
|
|
{ XFS_BLI_STALE, "STALE" }, \
|
|
|
|
|
{ XFS_BLI_LOGGED, "LOGGED" }, \
|
|
|
|
|
{ XFS_BLI_INODE_ALLOC_BUF, "INODE_ALLOC" }, \
|
2010-05-20 13:19:42 +00:00
|
|
|
{ XFS_BLI_STALE_INODE, "STALE_INODE" }, \
|
2013-06-27 06:04:52 +00:00
|
|
|
{ XFS_BLI_INODE_BUF, "INODE_BUF" }, \
|
|
|
|
|
{ XFS_BLI_ORDERED, "ORDERED" }
|
2009-12-14 23:14:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* This is the in core log item structure used to track information
|
|
|
|
|
* needed to log buffers. It tracks how many times the lock has been
|
|
|
|
|
* locked, and which 128 byte chunks of the buffer are dirty.
|
|
|
|
|
*/
|
2018-01-24 21:38:48 +00:00
|
|
|
struct xfs_buf_log_item {
|
2019-06-29 02:27:33 +00:00
|
|
|
struct xfs_log_item bli_item; /* common item structure */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct xfs_buf *bli_buf; /* real buffer pointer */
|
|
|
|
|
unsigned int bli_flags; /* misc flags */
|
|
|
|
|
unsigned int bli_recur; /* lock recursion count */
|
|
|
|
|
atomic_t bli_refcount; /* cnt of tp refs */
|
2012-06-22 08:50:12 +00:00
|
|
|
int bli_format_count; /* count of headers */
|
|
|
|
|
struct xfs_buf_log_format *bli_formats; /* array of in-log header ptrs */
|
2012-12-04 23:18:03 +00:00
|
|
|
struct xfs_buf_log_format __bli_format; /* embedded in-log header */
|
2018-01-24 21:38:48 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-08-25 00:05:13 +00:00
|
|
|
int xfs_buf_item_init(struct xfs_buf *, struct xfs_mount *);
|
2020-09-01 17:55:29 +00:00
|
|
|
void xfs_buf_item_done(struct xfs_buf *bp);
|
2005-04-16 22:20:36 +00:00
|
|
|
void xfs_buf_item_relse(struct xfs_buf *);
|
xfs: refactor xfs_buf_log_item reference count handling
The xfs_buf_log_item structure has a reference counter with slightly
tricky semantics. In the common case, a buffer is logged and
committed in a transaction, committed to the on-disk log (added to
the AIL) and then finally written back and removed from the AIL. The
bli refcount covers two potentially overlapping timeframes:
1. the bli is held in an active transaction
2. the bli is pinned by the log
The caveat to this approach is that the reference counter does not
purely dictate the lifetime of the bli. IOW, when a dirty buffer is
physically logged and unpinned, the bli refcount may go to zero as
the log item is inserted into the AIL. Only once the buffer is
written back can the bli finally be freed.
The above semantics means that it is not enough for the various
refcount decrementing contexts to release the bli on decrement to
zero. xfs_trans_brelse(), transaction commit (->iop_unlock()) and
unpin (->iop_unpin()) must all drop the associated reference and
make additional checks to determine if the current context is
responsible for freeing the item.
For example, if a transaction holds but does not dirty a particular
bli, the commit may drop the refcount to zero. If the bli itself is
clean, it is also not AIL resident and must be freed at this time.
The same is true for xfs_trans_brelse(). If the transaction dirties
a bli and then aborts or an unpin results in an abort due to a log
I/O error, the last reference count holder is expected to explicitly
remove the item from the AIL and release it (since an abort means
filesystem shutdown and metadata writeback will never occur).
This leads to fairly complex checks being replicated in a few
different places. Since ->iop_unlock() and xfs_trans_brelse() are
nearly identical, refactor the logic into a common helper that
implements and documents the semantics in one place. This patch does
not change behavior.
Signed-off-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2018-09-29 03:45:26 +00:00
|
|
|
bool xfs_buf_item_put(struct xfs_buf_log_item *);
|
2018-01-24 21:38:48 +00:00
|
|
|
void xfs_buf_item_log(struct xfs_buf_log_item *, uint, uint);
|
2017-08-29 17:08:37 +00:00
|
|
|
bool xfs_buf_item_dirty_format(struct xfs_buf_log_item *);
|
2020-06-29 21:48:46 +00:00
|
|
|
void xfs_buf_inode_iodone(struct xfs_buf *);
|
2020-09-01 17:55:29 +00:00
|
|
|
void xfs_buf_inode_io_fail(struct xfs_buf *bp);
|
|
|
|
|
#ifdef CONFIG_XFS_QUOTA
|
2020-06-29 21:48:46 +00:00
|
|
|
void xfs_buf_dquot_iodone(struct xfs_buf *);
|
2020-09-01 17:55:29 +00:00
|
|
|
void xfs_buf_dquot_io_fail(struct xfs_buf *bp);
|
|
|
|
|
#else
|
|
|
|
|
static inline void xfs_buf_dquot_iodone(struct xfs_buf *bp)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
static inline void xfs_buf_dquot_io_fail(struct xfs_buf *bp)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_XFS_QUOTA */
|
2020-06-29 21:48:47 +00:00
|
|
|
void xfs_buf_iodone(struct xfs_buf *);
|
2020-01-14 00:33:46 +00:00
|
|
|
bool xfs_buf_log_check_iovec(struct xfs_log_iovec *iovec);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-10-12 18:09:23 +00:00
|
|
|
extern struct kmem_cache *xfs_buf_item_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#endif /* __XFS_BUF_ITEM_H__ */
|
