2018-06-06 10:42:14 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-11-02 11:58:39 +08:00
|
|
|
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
|
2010-06-23 16:11:15 +08:00
|
|
|
* Copyright (C) 2010 Red Hat, Inc.
|
2005-11-02 11:58:39 +08:00
|
|
|
* All Rights Reserved.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2005-11-02 11:38:42 +08:00
|
|
|
#include "xfs_fs.h"
|
2013-10-23 07:36:05 +08:00
|
|
|
#include "xfs_shared.h"
|
2013-10-23 07:50:10 +08:00
|
|
|
#include "xfs_format.h"
|
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
#include "xfs_mount.h"
|
2012-04-29 18:39:43 +08:00
|
|
|
#include "xfs_extent_busy.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
#include "xfs_quota.h"
|
2013-10-23 07:50:10 +08:00
|
|
|
#include "xfs_trans.h"
|
2005-11-02 11:38:42 +08:00
|
|
|
#include "xfs_trans_priv.h"
|
2013-10-23 07:50:10 +08:00
|
|
|
#include "xfs_log.h"
|
xfs: AIL needs asynchronous CIL forcing
The AIL pushing is stalling on log forces when it comes across
pinned items. This is happening on removal workloads where the AIL
is dominated by stale items that are removed from AIL when the
checkpoint that marks the items stale is committed to the journal.
This results is relatively few items in the AIL, but those that are
are often pinned as directories items are being removed from are
still being logged.
As a result, many push cycles through the CIL will first issue a
blocking log force to unpin the items. This can take some time to
complete, with tracing regularly showing push delays of half a
second and sometimes up into the range of several seconds. Sequences
like this aren't uncommon:
....
399.829437: xfsaild: last lsn 0x11002dd000 count 101 stuck 101 flushing 0 tout 20
<wanted 20ms, got 270ms delay>
400.099622: xfsaild: target 0x11002f3600, prev 0x11002f3600, last lsn 0x0
400.099623: xfsaild: first lsn 0x11002f3600
400.099679: xfsaild: last lsn 0x1100305000 count 16 stuck 11 flushing 0 tout 50
<wanted 50ms, got 500ms delay>
400.589348: xfsaild: target 0x110032e600, prev 0x11002f3600, last lsn 0x0
400.589349: xfsaild: first lsn 0x1100305000
400.589595: xfsaild: last lsn 0x110032e600 count 156 stuck 101 flushing 30 tout 50
<wanted 50ms, got 460ms delay>
400.950341: xfsaild: target 0x1100353000, prev 0x110032e600, last lsn 0x0
400.950343: xfsaild: first lsn 0x1100317c00
400.950436: xfsaild: last lsn 0x110033d200 count 105 stuck 101 flushing 0 tout 20
<wanted 20ms, got 200ms delay>
401.142333: xfsaild: target 0x1100361600, prev 0x1100353000, last lsn 0x0
401.142334: xfsaild: first lsn 0x110032e600
401.142535: xfsaild: last lsn 0x1100353000 count 122 stuck 101 flushing 8 tout 10
<wanted 10ms, got 10ms delay>
401.154323: xfsaild: target 0x1100361600, prev 0x1100361600, last lsn 0x1100353000
401.154328: xfsaild: first lsn 0x1100353000
401.154389: xfsaild: last lsn 0x1100353000 count 101 stuck 101 flushing 0 tout 20
<wanted 20ms, got 300ms delay>
401.451525: xfsaild: target 0x1100361600, prev 0x1100361600, last lsn 0x0
401.451526: xfsaild: first lsn 0x1100353000
401.451804: xfsaild: last lsn 0x1100377200 count 170 stuck 22 flushing 122 tout 50
<wanted 50ms, got 500ms delay>
401.933581: xfsaild: target 0x1100361600, prev 0x1100361600, last lsn 0x0
....
In each of these cases, every AIL pass saw 101 log items stuck on
the AIL (pinned) with very few other items being found. Each pass, a
log force was issued, and delay between last/first is the sleep time
+ the sync log force time.
Some of these 101 items pinned the tail of the log. The tail of the
log does slowly creep forward (first lsn), but the problem is that
the log is actually out of reservation space because it's been
running so many transactions that stale items that never reach the
AIL but consume log space. Hence we have a largely empty AIL, with
long term pins on items that pin the tail of the log that don't get
pushed frequently enough to keep log space available.
The problem is the hundreds of milliseconds that we block in the log
force pushing the CIL out to disk. The AIL should not be stalled
like this - it needs to run and flush items that are at the tail of
the log with minimal latency. What we really need to do is trigger a
log flush, but then not wait for it at all - we've already done our
waiting for stuff to complete when we backed off prior to the log
force being issued.
Even if we remove the XFS_LOG_SYNC from the xfs_log_force() call, we
still do a blocking flush of the CIL and that is what is causing the
issue. Hence we need a new interface for the CIL to trigger an
immediate background push of the CIL to get it moving faster but not
to wait on that to occur. While the CIL is pushing, the AIL can also
be pushing.
We already have an internal interface to do this -
xlog_cil_push_now() - but we need a wrapper for it to be used
externally. xlog_cil_force_seq() can easily be extended to do what
we need as it already implements the synchronous CIL push via
xlog_cil_push_now(). Add the necessary flags and "push current
sequence" semantics to xlog_cil_force_seq() and convert the AIL
pushing to use it.
One of the complexities here is that the CIL push does not guarantee
that the commit record for the CIL checkpoint is written to disk.
The current log force ensures this by submitting the current ACTIVE
iclog that the commit record was written to. We need the CIL to
actually write this commit record to disk for an async push to
ensure that the checkpoint actually makes it to disk and unpins the
pinned items in the checkpoint on completion. Hence we need to pass
down to the CIL push that we are doing an async flush so that it can
switch out the commit_iclog if necessary to get written to disk when
the commit iclog is finally released.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Allison Henderson <allison.henderson@oracle.com>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2021-08-11 09:00:44 +08:00
|
|
|
#include "xfs_log_priv.h"
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 10:07:08 +08:00
|
|
|
#include "xfs_trace.h"
|
2013-10-23 07:51:50 +08:00
|
|
|
#include "xfs_error.h"
|
2018-05-08 08:38:47 +08:00
|
|
|
#include "xfs_defer.h"
|
2021-01-27 08:33:29 +08:00
|
|
|
#include "xfs_inode.h"
|
2021-01-28 04:07:57 +08:00
|
|
|
#include "xfs_dquot_item.h"
|
|
|
|
#include "xfs_dquot.h"
|
2021-01-23 08:48:37 +08:00
|
|
|
#include "xfs_icache.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2021-10-13 02:09:23 +08:00
|
|
|
struct kmem_cache *xfs_trans_cache;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-01-09 02:51:26 +08:00
|
|
|
#if defined(CONFIG_TRACEPOINTS)
|
|
|
|
static void
|
|
|
|
xfs_trans_trace_reservations(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
struct xfs_trans_res *res;
|
|
|
|
struct xfs_trans_res *end_res;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
res = (struct xfs_trans_res *)M_RES(mp);
|
|
|
|
end_res = (struct xfs_trans_res *)(M_RES(mp) + 1);
|
|
|
|
for (i = 0; res < end_res; i++, res++)
|
|
|
|
trace_xfs_trans_resv_calc(mp, i, res);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define xfs_trans_trace_reservations(mp)
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Initialize the precomputed transaction reservation values
|
|
|
|
* in the mount structure.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_init(
|
2010-05-04 21:53:48 +08:00
|
|
|
struct xfs_mount *mp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-08-12 18:49:59 +08:00
|
|
|
xfs_trans_resv_calc(mp, M_RES(mp));
|
2018-01-09 02:51:26 +08:00
|
|
|
xfs_trans_trace_reservations(mp);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-03-23 07:11:05 +08:00
|
|
|
/*
|
|
|
|
* Free the transaction structure. If there is more clean up
|
|
|
|
* to do when the structure is freed, add it here.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_free(
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 10:07:08 +08:00
|
|
|
struct xfs_trans *tp)
|
2010-03-23 07:11:05 +08:00
|
|
|
{
|
2012-04-29 18:41:10 +08:00
|
|
|
xfs_extent_busy_sort(&tp->t_busy);
|
|
|
|
xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false);
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 10:07:08 +08:00
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_free(tp, _RET_IP_);
|
2021-02-24 02:26:06 +08:00
|
|
|
xfs_trans_clear_context(tp);
|
2016-04-06 07:19:55 +08:00
|
|
|
if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT))
|
2012-06-12 22:20:39 +08:00
|
|
|
sb_end_intwrite(tp->t_mountp->m_super);
|
2010-03-23 07:11:05 +08:00
|
|
|
xfs_trans_free_dqinfo(tp);
|
2021-10-13 02:09:23 +08:00
|
|
|
kmem_cache_free(xfs_trans_cache, tp);
|
2010-03-23 07:11:05 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* This is called to create a new transaction which will share the
|
|
|
|
* permanent log reservation of the given transaction. The remaining
|
|
|
|
* unused block and rt extent reservations are also inherited. This
|
|
|
|
* implies that the original transaction is no longer allowed to allocate
|
|
|
|
* blocks. Locks and log items, however, are no inherited. They must
|
|
|
|
* be added to the new transaction explicitly.
|
|
|
|
*/
|
2018-05-08 08:38:47 +08:00
|
|
|
STATIC struct xfs_trans *
|
2005-04-17 06:20:36 +08:00
|
|
|
xfs_trans_dup(
|
2018-05-08 08:38:47 +08:00
|
|
|
struct xfs_trans *tp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2018-05-08 08:38:47 +08:00
|
|
|
struct xfs_trans *ntp;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_dup(tp, _RET_IP_);
|
|
|
|
|
2021-10-13 02:09:23 +08:00
|
|
|
ntp = kmem_cache_zalloc(xfs_trans_cache, GFP_KERNEL | __GFP_NOFAIL);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the new transaction structure.
|
|
|
|
*/
|
2013-08-12 18:49:28 +08:00
|
|
|
ntp->t_magic = XFS_TRANS_HEADER_MAGIC;
|
2005-04-17 06:20:36 +08:00
|
|
|
ntp->t_mountp = tp->t_mountp;
|
2010-06-23 16:11:15 +08:00
|
|
|
INIT_LIST_HEAD(&ntp->t_items);
|
xfs: Improve scalability of busy extent tracking
When we free a metadata extent, we record it in the per-AG busy
extent array so that it is not re-used before the freeing
transaction hits the disk. This array is fixed size, so when it
overflows we make further allocation transactions synchronous
because we cannot track more freed extents until those transactions
hit the disk and are completed. Under heavy mixed allocation and
freeing workloads with large log buffers, we can overflow this array
quite easily.
Further, the array is sparsely populated, which means that inserts
need to search for a free slot, and array searches often have to
search many more slots that are actually used to check all the
busy extents. Quite inefficient, really.
To enable this aspect of extent freeing to scale better, we need
a structure that can grow dynamically. While in other areas of
XFS we have used radix trees, the extents being freed are at random
locations on disk so are better suited to being indexed by an rbtree.
So, use a per-AG rbtree indexed by block number to track busy
extents. This incures a memory allocation when marking an extent
busy, but should not occur too often in low memory situations. This
should scale to an arbitrary number of extents so should not be a
limitation for features such as in-memory aggregation of
transactions.
However, there are still situations where we can't avoid allocating
busy extents (such as allocation from the AGFL). To minimise the
overhead of such occurences, we need to avoid doing a synchronous
log force while holding the AGF locked to ensure that the previous
transactions are safely on disk before we use the extent. We can do
this by marking the transaction doing the allocation as synchronous
rather issuing a log force.
Because of the locking involved and the ordering of transactions,
the synchronous transaction provides the same guarantees as a
synchronous log force because it ensures that all the prior
transactions are already on disk when the synchronous transaction
hits the disk. i.e. it preserves the free->allocate order of the
extent correctly in recovery.
By doing this, we avoid holding the AGF locked while log writes are
in progress, hence reducing the length of time the lock is held and
therefore we increase the rate at which we can allocate and free
from the allocation group, thereby increasing overall throughput.
The only problem with this approach is that when a metadata buffer is
marked stale (e.g. a directory block is removed), then buffer remains
pinned and locked until the log goes to disk. The issue here is that
if that stale buffer is reallocated in a subsequent transaction, the
attempt to lock that buffer in the transaction will hang waiting
the log to go to disk to unlock and unpin the buffer. Hence if
someone tries to lock a pinned, stale, locked buffer we need to
push on the log to get it unlocked ASAP. Effectively we are trading
off a guaranteed log force for a much less common trigger for log
force to occur.
Ideally we should not reallocate busy extents. That is a much more
complex fix to the problem as it involves direct intervention in the
allocation btree searches in many places. This is left to a future
set of modifications.
Finally, now that we track busy extents in allocated memory, we
don't need the descriptors in the transaction structure to point to
them. We can replace the complex busy chunk infrastructure with a
simple linked list of busy extents. This allows us to remove a large
chunk of code, making the overall change a net reduction in code
size.
Signed-off-by: Dave Chinner <david@fromorbit.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 10:07:08 +08:00
|
|
|
INIT_LIST_HEAD(&ntp->t_busy);
|
2018-08-01 22:20:35 +08:00
|
|
|
INIT_LIST_HEAD(&ntp->t_dfops);
|
2018-07-12 13:26:20 +08:00
|
|
|
ntp->t_firstblock = NULLFSBLOCK;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
|
|
|
|
ASSERT(tp->t_ticket != NULL);
|
2005-11-02 12:12:04 +08:00
|
|
|
|
2012-06-12 22:20:39 +08:00
|
|
|
ntp->t_flags = XFS_TRANS_PERM_LOG_RES |
|
|
|
|
(tp->t_flags & XFS_TRANS_RESERVE) |
|
2020-06-30 05:44:36 +08:00
|
|
|
(tp->t_flags & XFS_TRANS_NO_WRITECOUNT) |
|
|
|
|
(tp->t_flags & XFS_TRANS_RES_FDBLKS);
|
2012-06-12 22:20:39 +08:00
|
|
|
/* We gave our writer reference to the new transaction */
|
2016-04-06 07:19:55 +08:00
|
|
|
tp->t_flags |= XFS_TRANS_NO_WRITECOUNT;
|
2008-11-17 14:37:10 +08:00
|
|
|
ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket);
|
2018-03-10 06:01:58 +08:00
|
|
|
|
|
|
|
ASSERT(tp->t_blk_res >= tp->t_blk_res_used);
|
2005-04-17 06:20:36 +08:00
|
|
|
ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used;
|
|
|
|
tp->t_blk_res = tp->t_blk_res_used;
|
2018-03-10 06:01:58 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
|
|
|
|
tp->t_rtx_res = tp->t_rtx_res_used;
|
2021-02-24 02:26:06 +08:00
|
|
|
|
|
|
|
xfs_trans_switch_context(tp, ntp);
|
2018-07-25 04:43:11 +08:00
|
|
|
|
2018-08-01 22:20:35 +08:00
|
|
|
/* move deferred ops over to the new tp */
|
|
|
|
xfs_defer_move(ntp, tp);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-06-08 21:33:32 +08:00
|
|
|
xfs_trans_dup_dqinfo(tp, ntp);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ntp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called to reserve free disk blocks and log space for the
|
|
|
|
* given transaction. This must be done before allocating any resources
|
|
|
|
* within the transaction.
|
|
|
|
*
|
|
|
|
* This will return ENOSPC if there are not enough blocks available.
|
|
|
|
* It will sleep waiting for available log space.
|
|
|
|
* The only valid value for the flags parameter is XFS_RES_LOG_PERM, which
|
|
|
|
* is used by long running transactions. If any one of the reservations
|
|
|
|
* fails then they will all be backed out.
|
|
|
|
*
|
|
|
|
* This does not do quota reservations. That typically is done by the
|
|
|
|
* caller afterwards.
|
|
|
|
*/
|
2016-04-06 07:19:55 +08:00
|
|
|
static int
|
2005-04-17 06:20:36 +08:00
|
|
|
xfs_trans_reserve(
|
2013-08-12 18:49:59 +08:00
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_trans_res *resp,
|
|
|
|
uint blocks,
|
|
|
|
uint rtextents)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2020-03-26 09:18:21 +08:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
int error = 0;
|
|
|
|
bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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) {
|
2020-03-26 09:18:21 +08:00
|
|
|
error = xfs_mod_fdblocks(mp, -((int64_t)blocks), rsvd);
|
2021-02-24 02:26:06 +08:00
|
|
|
if (error != 0)
|
2014-06-25 12:58:08 +08:00
|
|
|
return -ENOSPC;
|
2005-04-17 06:20:36 +08:00
|
|
|
tp->t_blk_res += blocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reserve the log space needed for this transaction.
|
|
|
|
*/
|
2013-08-12 18:49:59 +08:00
|
|
|
if (resp->tr_logres > 0) {
|
2012-02-20 10:31:31 +08:00
|
|
|
bool permanent = false;
|
|
|
|
|
2013-08-12 18:49:59 +08:00
|
|
|
ASSERT(tp->t_log_res == 0 ||
|
|
|
|
tp->t_log_res == resp->tr_logres);
|
|
|
|
ASSERT(tp->t_log_count == 0 ||
|
|
|
|
tp->t_log_count == resp->tr_logcount);
|
2012-02-20 10:31:31 +08:00
|
|
|
|
2013-08-12 18:49:59 +08:00
|
|
|
if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) {
|
2005-04-17 06:20:36 +08:00
|
|
|
tp->t_flags |= XFS_TRANS_PERM_LOG_RES;
|
2012-02-20 10:31:31 +08:00
|
|
|
permanent = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
ASSERT(tp->t_ticket == NULL);
|
|
|
|
ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
|
|
|
|
}
|
|
|
|
|
2012-02-20 10:31:31 +08:00
|
|
|
if (tp->t_ticket != NULL) {
|
2013-08-12 18:49:59 +08:00
|
|
|
ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES);
|
2020-03-26 09:18:21 +08:00
|
|
|
error = xfs_log_regrant(mp, tp->t_ticket);
|
2012-02-20 10:31:31 +08:00
|
|
|
} else {
|
2022-04-21 08:34:33 +08:00
|
|
|
error = xfs_log_reserve(mp, resp->tr_logres,
|
2013-08-12 18:49:59 +08:00
|
|
|
resp->tr_logcount,
|
2022-04-21 08:34:33 +08:00
|
|
|
&tp->t_ticket, permanent);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-02-20 10:31:31 +08:00
|
|
|
|
|
|
|
if (error)
|
|
|
|
goto undo_blocks;
|
|
|
|
|
2013-08-12 18:49:59 +08:00
|
|
|
tp->t_log_res = resp->tr_logres;
|
|
|
|
tp->t_log_count = resp->tr_logcount;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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) {
|
2020-03-26 09:18:21 +08:00
|
|
|
error = xfs_mod_frextents(mp, -((int64_t)rtextents));
|
2005-04-17 06:20:36 +08:00
|
|
|
if (error) {
|
2014-06-25 12:58:08 +08:00
|
|
|
error = -ENOSPC;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto undo_log;
|
|
|
|
}
|
|
|
|
tp->t_rtx_res += rtextents;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Error cases jump to one of these labels to undo any
|
|
|
|
* reservations which have already been performed.
|
|
|
|
*/
|
|
|
|
undo_log:
|
2013-08-12 18:49:59 +08:00
|
|
|
if (resp->tr_logres > 0) {
|
2020-03-26 09:18:23 +08:00
|
|
|
xfs_log_ticket_ungrant(mp->m_log, tp->t_ticket);
|
2005-04-17 06:20:36 +08:00
|
|
|
tp->t_ticket = NULL;
|
|
|
|
tp->t_log_res = 0;
|
|
|
|
tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES;
|
|
|
|
}
|
|
|
|
|
|
|
|
undo_blocks:
|
|
|
|
if (blocks > 0) {
|
2020-03-26 09:18:21 +08:00
|
|
|
xfs_mod_fdblocks(mp, (int64_t)blocks, rsvd);
|
2005-04-17 06:20:36 +08:00
|
|
|
tp->t_blk_res = 0;
|
|
|
|
}
|
2006-06-09 12:59:13 +08:00
|
|
|
return error;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2016-04-06 07:19:55 +08:00
|
|
|
int
|
|
|
|
xfs_trans_alloc(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans_res *resp,
|
|
|
|
uint blocks,
|
|
|
|
uint rtextents,
|
|
|
|
uint flags,
|
|
|
|
struct xfs_trans **tpp)
|
|
|
|
{
|
|
|
|
struct xfs_trans *tp;
|
2021-02-20 01:18:06 +08:00
|
|
|
bool want_retry = true;
|
2016-04-06 07:19:55 +08:00
|
|
|
int error;
|
|
|
|
|
2018-09-29 11:46:21 +08:00
|
|
|
/*
|
|
|
|
* Allocate the handle before we do our freeze accounting and setting up
|
|
|
|
* GFP_NOFS allocation context so that we avoid lockdep false positives
|
|
|
|
* by doing GFP_KERNEL allocations inside sb_start_intwrite().
|
|
|
|
*/
|
2021-02-20 01:18:06 +08:00
|
|
|
retry:
|
2021-10-13 02:09:23 +08:00
|
|
|
tp = kmem_cache_zalloc(xfs_trans_cache, GFP_KERNEL | __GFP_NOFAIL);
|
2016-04-06 07:19:55 +08:00
|
|
|
if (!(flags & XFS_TRANS_NO_WRITECOUNT))
|
|
|
|
sb_start_intwrite(mp->m_super);
|
2021-02-24 02:26:06 +08:00
|
|
|
xfs_trans_set_context(tp);
|
2016-04-06 07:19:55 +08:00
|
|
|
|
2018-06-22 14:26:55 +08:00
|
|
|
/*
|
|
|
|
* Zero-reservation ("empty") transactions can't modify anything, so
|
|
|
|
* they're allowed to run while we're frozen.
|
|
|
|
*/
|
|
|
|
WARN_ON(resp->tr_logres > 0 &&
|
|
|
|
mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE);
|
2020-06-30 05:44:36 +08:00
|
|
|
ASSERT(!(flags & XFS_TRANS_RES_FDBLKS) ||
|
2021-08-19 09:46:37 +08:00
|
|
|
xfs_has_lazysbcount(mp));
|
2016-04-06 07:19:55 +08:00
|
|
|
|
|
|
|
tp->t_magic = XFS_TRANS_HEADER_MAGIC;
|
|
|
|
tp->t_flags = flags;
|
|
|
|
tp->t_mountp = mp;
|
|
|
|
INIT_LIST_HEAD(&tp->t_items);
|
|
|
|
INIT_LIST_HEAD(&tp->t_busy);
|
2018-08-01 22:20:35 +08:00
|
|
|
INIT_LIST_HEAD(&tp->t_dfops);
|
2018-07-12 13:26:20 +08:00
|
|
|
tp->t_firstblock = NULLFSBLOCK;
|
2016-04-06 07:19:55 +08:00
|
|
|
|
|
|
|
error = xfs_trans_reserve(tp, resp, blocks, rtextents);
|
2021-02-20 01:18:06 +08:00
|
|
|
if (error == -ENOSPC && want_retry) {
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
|
2021-01-23 08:48:39 +08:00
|
|
|
/*
|
|
|
|
* We weren't able to reserve enough space for the transaction.
|
|
|
|
* Flush the other speculative space allocations to free space.
|
|
|
|
* Do not perform a synchronous scan because callers can hold
|
|
|
|
* other locks.
|
|
|
|
*/
|
2021-08-07 02:05:42 +08:00
|
|
|
xfs_blockgc_flush_all(mp);
|
2021-02-20 01:18:06 +08:00
|
|
|
want_retry = false;
|
|
|
|
goto retry;
|
2021-01-23 08:48:39 +08:00
|
|
|
}
|
2016-04-06 07:19:55 +08:00
|
|
|
if (error) {
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_alloc(tp, _RET_IP_);
|
|
|
|
|
2016-04-06 07:19:55 +08:00
|
|
|
*tpp = tp;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-29 05:56:37 +08:00
|
|
|
/*
|
|
|
|
* Create an empty transaction with no reservation. This is a defensive
|
2020-05-21 04:17:11 +08:00
|
|
|
* mechanism for routines that query metadata without actually modifying them --
|
|
|
|
* if the metadata being queried is somehow cross-linked (think a btree block
|
|
|
|
* pointer that points higher in the tree), we risk deadlock. However, blocks
|
|
|
|
* grabbed as part of a transaction can be re-grabbed. The verifiers will
|
|
|
|
* notice the corrupt block and the operation will fail back to userspace
|
|
|
|
* without deadlocking.
|
2017-03-29 05:56:37 +08:00
|
|
|
*
|
2020-05-21 04:17:11 +08:00
|
|
|
* Note the zero-length reservation; this transaction MUST be cancelled without
|
|
|
|
* any dirty data.
|
2020-03-25 14:03:24 +08:00
|
|
|
*
|
2020-05-21 04:17:11 +08:00
|
|
|
* Callers should obtain freeze protection to avoid a conflict with fs freezing
|
|
|
|
* where we can be grabbing buffers at the same time that freeze is trying to
|
|
|
|
* drain the buffer LRU list.
|
2017-03-29 05:56:37 +08:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_trans_alloc_empty(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans **tpp)
|
|
|
|
{
|
|
|
|
struct xfs_trans_res resv = {0};
|
|
|
|
|
|
|
|
return xfs_trans_alloc(mp, &resv, 0, 0, XFS_TRANS_NO_WRITECOUNT, tpp);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Record the indicated change to the given field for application
|
|
|
|
* to the file system's superblock when the transaction commits.
|
|
|
|
* For now, just store the change in the transaction structure.
|
|
|
|
*
|
|
|
|
* Mark the transaction structure to indicate that the superblock
|
|
|
|
* needs to be updated before committing.
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 13:26:31 +08:00
|
|
|
*
|
|
|
|
* Because we may not be keeping track of allocated/free inodes and
|
|
|
|
* used filesystem blocks in the superblock, we do not mark the
|
|
|
|
* superblock dirty in this transaction if we modify these fields.
|
|
|
|
* We still need to update the transaction deltas so that they get
|
|
|
|
* applied to the incore superblock, but we don't want them to
|
|
|
|
* cause the superblock to get locked and logged if these are the
|
|
|
|
* only fields in the superblock that the transaction modifies.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_mod_sb(
|
|
|
|
xfs_trans_t *tp,
|
|
|
|
uint field,
|
2007-02-10 15:36:10 +08:00
|
|
|
int64_t delta)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 13:26:31 +08:00
|
|
|
uint32_t flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
|
|
|
|
xfs_mount_t *mp = tp->t_mountp;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
switch (field) {
|
|
|
|
case XFS_TRANS_SB_ICOUNT:
|
|
|
|
tp->t_icount_delta += delta;
|
2021-08-19 09:46:37 +08:00
|
|
|
if (xfs_has_lazysbcount(mp))
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 13:26:31 +08:00
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_IFREE:
|
|
|
|
tp->t_ifree_delta += delta;
|
2021-08-19 09:46:37 +08:00
|
|
|
if (xfs_has_lazysbcount(mp))
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 13:26:31 +08:00
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_FDBLOCKS:
|
|
|
|
/*
|
2018-03-10 06:01:58 +08:00
|
|
|
* Track the number of blocks allocated in the transaction.
|
|
|
|
* Make sure it does not exceed the number reserved. If so,
|
|
|
|
* shutdown as this can lead to accounting inconsistency.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
if (delta < 0) {
|
|
|
|
tp->t_blk_res_used += (uint)-delta;
|
2018-03-10 06:01:58 +08:00
|
|
|
if (tp->t_blk_res_used > tp->t_blk_res)
|
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
|
2020-06-30 05:44:36 +08:00
|
|
|
} else if (delta > 0 && (tp->t_flags & XFS_TRANS_RES_FDBLKS)) {
|
|
|
|
int64_t blkres_delta;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return freed blocks directly to the reservation
|
|
|
|
* instead of the global pool, being careful not to
|
|
|
|
* overflow the trans counter. This is used to preserve
|
|
|
|
* reservation across chains of transaction rolls that
|
|
|
|
* repeatedly free and allocate blocks.
|
|
|
|
*/
|
|
|
|
blkres_delta = min_t(int64_t, delta,
|
|
|
|
UINT_MAX - tp->t_blk_res);
|
|
|
|
tp->t_blk_res += blkres_delta;
|
|
|
|
delta -= blkres_delta;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
tp->t_fdblocks_delta += delta;
|
2021-08-19 09:46:37 +08:00
|
|
|
if (xfs_has_lazysbcount(mp))
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 13:26:31 +08:00
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RES_FDBLOCKS:
|
|
|
|
/*
|
|
|
|
* The allocation has already been applied to the
|
|
|
|
* in-core superblock's counter. This should only
|
|
|
|
* be applied to the on-disk superblock.
|
|
|
|
*/
|
|
|
|
tp->t_res_fdblocks_delta += delta;
|
2021-08-19 09:46:37 +08:00
|
|
|
if (xfs_has_lazysbcount(mp))
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 13:26:31 +08:00
|
|
|
flags &= ~XFS_TRANS_SB_DIRTY;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_FREXTENTS:
|
|
|
|
/*
|
|
|
|
* Track the number of blocks allocated in the
|
|
|
|
* transaction. Make sure it does not exceed the
|
|
|
|
* number reserved.
|
|
|
|
*/
|
|
|
|
if (delta < 0) {
|
|
|
|
tp->t_rtx_res_used += (uint)-delta;
|
|
|
|
ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res);
|
|
|
|
}
|
|
|
|
tp->t_frextents_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RES_FREXTENTS:
|
|
|
|
/*
|
|
|
|
* The allocation has already been applied to the
|
2006-03-29 06:55:14 +08:00
|
|
|
* in-core superblock's counter. This should only
|
2005-04-17 06:20:36 +08:00
|
|
|
* be applied to the on-disk superblock.
|
|
|
|
*/
|
|
|
|
ASSERT(delta < 0);
|
|
|
|
tp->t_res_frextents_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_DBLOCKS:
|
|
|
|
tp->t_dblocks_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_AGCOUNT:
|
|
|
|
ASSERT(delta > 0);
|
|
|
|
tp->t_agcount_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_IMAXPCT:
|
|
|
|
tp->t_imaxpct_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_REXTSIZE:
|
|
|
|
tp->t_rextsize_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RBMBLOCKS:
|
|
|
|
tp->t_rbmblocks_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_RBLOCKS:
|
|
|
|
tp->t_rblocks_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_REXTENTS:
|
|
|
|
tp->t_rextents_delta += delta;
|
|
|
|
break;
|
|
|
|
case XFS_TRANS_SB_REXTSLOG:
|
|
|
|
tp->t_rextslog_delta += delta;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ASSERT(0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-05-24 13:26:51 +08:00
|
|
|
tp->t_flags |= flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* xfs_trans_apply_sb_deltas() is called from the commit code
|
|
|
|
* to bring the superblock buffer into the current transaction
|
|
|
|
* and modify it as requested by earlier calls to xfs_trans_mod_sb().
|
|
|
|
*
|
|
|
|
* For now we just look at each field allowed to change and change
|
|
|
|
* it if necessary.
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xfs_trans_apply_sb_deltas(
|
|
|
|
xfs_trans_t *tp)
|
|
|
|
{
|
2021-10-12 07:11:45 +08:00
|
|
|
struct xfs_dsb *sbp;
|
2020-12-17 08:07:34 +08:00
|
|
|
struct xfs_buf *bp;
|
2005-04-17 06:20:36 +08:00
|
|
|
int whole = 0;
|
|
|
|
|
2020-09-02 01:55:47 +08:00
|
|
|
bp = xfs_trans_getsb(tp);
|
2020-03-10 23:57:30 +08:00
|
|
|
sbp = bp->b_addr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
[XFS] Lazy Superblock Counters
When we have a couple of hundred transactions on the fly at once, they all
typically modify the on disk superblock in some way.
create/unclink/mkdir/rmdir modify inode counts, allocation/freeing modify
free block counts.
When these counts are modified in a transaction, they must eventually lock
the superblock buffer and apply the mods. The buffer then remains locked
until the transaction is committed into the incore log buffer. The result
of this is that with enough transactions on the fly the incore superblock
buffer becomes a bottleneck.
The result of contention on the incore superblock buffer is that
transaction rates fall - the more pressure that is put on the superblock
buffer, the slower things go.
The key to removing the contention is to not require the superblock fields
in question to be locked. We do that by not marking the superblock dirty
in the transaction. IOWs, we modify the incore superblock but do not
modify the cached superblock buffer. In short, we do not log superblock
modifications to critical fields in the superblock on every transaction.
In fact we only do it just before we write the superblock to disk every
sync period or just before unmount.
This creates an interesting problem - if we don't log or write out the
fields in every transaction, then how do the values get recovered after a
crash? the answer is simple - we keep enough duplicate, logged information
in other structures that we can reconstruct the correct count after log
recovery has been performed.
It is the AGF and AGI structures that contain the duplicate information;
after recovery, we walk every AGI and AGF and sum their individual
counters to get the correct value, and we do a transaction into the log to
correct them. An optimisation of this is that if we have a clean unmount
record, we know the value in the superblock is correct, so we can avoid
the summation walk under normal conditions and so mount/recovery times do
not change under normal operation.
One wrinkle that was discovered during development was that the blocks
used in the freespace btrees are never accounted for in the AGF counters.
This was once a valid optimisation to make; when the filesystem is full,
the free space btrees are empty and consume no space. Hence when it
matters, the "accounting" is correct. But that means the when we do the
AGF summations, we would not have a correct count and xfs_check would
complain. Hence a new counter was added to track the number of blocks used
by the free space btrees. This is an *on-disk format change*.
As a result of this, lazy superblock counters are a mkfs option and at the
moment on linux there is no way to convert an old filesystem. This is
possible - xfs_db can be used to twiddle the right bits and then
xfs_repair will do the format conversion for you. Similarly, you can
convert backwards as well. At some point we'll add functionality to
xfs_admin to do the bit twiddling easily....
SGI-PV: 964999
SGI-Modid: xfs-linux-melb:xfs-kern:28652a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-24 13:26:31 +08:00
|
|
|
/*
|
|
|
|
* Only update the superblock counters if we are logging them
|
|
|
|
*/
|
2021-08-19 09:46:37 +08:00
|
|
|
if (!xfs_has_lazysbcount((tp->t_mountp))) {
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_icount_delta)
|
2008-02-14 07:03:29 +08:00
|
|
|
be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta);
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_ifree_delta)
|
2008-02-14 07:03:29 +08:00
|
|
|
be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta);
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_fdblocks_delta)
|
2008-02-14 07:03:29 +08:00
|
|
|
be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_res_fdblocks_delta)
|
2008-02-14 07:03:29 +08:00
|
|
|
be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2022-04-12 04:49:42 +08:00
|
|
|
/*
|
|
|
|
* Updating frextents requires careful handling because it does not
|
|
|
|
* behave like the lazysb counters because we cannot rely on log
|
|
|
|
* recovery in older kenels to recompute the value from the rtbitmap.
|
|
|
|
* This means that the ondisk frextents must be consistent with the
|
|
|
|
* rtbitmap.
|
|
|
|
*
|
|
|
|
* Therefore, log the frextents change to the ondisk superblock and
|
|
|
|
* update the incore superblock so that future calls to xfs_log_sb
|
|
|
|
* write the correct value ondisk.
|
|
|
|
*
|
|
|
|
* Don't touch m_frextents because it includes incore reservations,
|
|
|
|
* and those are handled by the unreserve function.
|
|
|
|
*/
|
|
|
|
if (tp->t_frextents_delta || tp->t_res_frextents_delta) {
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
int64_t rtxdelta;
|
|
|
|
|
|
|
|
rtxdelta = tp->t_frextents_delta + tp->t_res_frextents_delta;
|
|
|
|
|
|
|
|
spin_lock(&mp->m_sb_lock);
|
|
|
|
be64_add_cpu(&sbp->sb_frextents, rtxdelta);
|
|
|
|
mp->m_sb.sb_frextents += rtxdelta;
|
|
|
|
spin_unlock(&mp->m_sb_lock);
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
|
|
|
|
if (tp->t_dblocks_delta) {
|
2008-02-14 07:03:29 +08:00
|
|
|
be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta);
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_agcount_delta) {
|
2008-02-14 07:03:29 +08:00
|
|
|
be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta);
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_imaxpct_delta) {
|
|
|
|
sbp->sb_imax_pct += tp->t_imaxpct_delta;
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_rextsize_delta) {
|
2008-02-14 07:03:29 +08:00
|
|
|
be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta);
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_rbmblocks_delta) {
|
2008-02-14 07:03:29 +08:00
|
|
|
be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_rblocks_delta) {
|
2008-02-14 07:03:29 +08:00
|
|
|
be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta);
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_rextents_delta) {
|
2008-02-14 07:03:29 +08:00
|
|
|
be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta);
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
2007-08-28 11:58:06 +08:00
|
|
|
if (tp->t_rextslog_delta) {
|
|
|
|
sbp->sb_rextslog += tp->t_rextslog_delta;
|
2005-04-17 06:20:36 +08:00
|
|
|
whole = 1;
|
|
|
|
}
|
|
|
|
|
2015-01-22 06:30:23 +08:00
|
|
|
xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (whole)
|
|
|
|
/*
|
2006-03-29 06:55:14 +08:00
|
|
|
* Log the whole thing, the fields are noncontiguous.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2021-10-12 07:11:45 +08:00
|
|
|
xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsb) - 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
|
|
|
/*
|
|
|
|
* Since all the modifiable fields are contiguous, we
|
|
|
|
* can get away with this.
|
|
|
|
*/
|
2021-10-12 07:11:45 +08:00
|
|
|
xfs_trans_log_buf(tp, bp, offsetof(struct xfs_dsb, sb_icount),
|
|
|
|
offsetof(struct xfs_dsb, sb_frextents) +
|
2005-04-17 06:20:36 +08:00
|
|
|
sizeof(sbp->sb_frextents) - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-05-21 04:17:10 +08:00
|
|
|
* xfs_trans_unreserve_and_mod_sb() is called to release unused reservations and
|
|
|
|
* apply superblock counter changes to the in-core superblock. The
|
2007-06-18 14:49:44 +08:00
|
|
|
* t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
|
|
|
|
* applied to the in-core superblock. The idea is that that has already been
|
|
|
|
* done.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2007-06-18 14:49:44 +08:00
|
|
|
* If we are not logging superblock counters, then the inode allocated/free and
|
|
|
|
* used block counts are not updated in the on disk superblock. In this case,
|
|
|
|
* XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
|
|
|
|
* still need to update the incore superblock with the changes.
|
2020-05-21 04:17:11 +08:00
|
|
|
*
|
|
|
|
* Deltas for the inode count are +/-64, hence we use a large batch size of 128
|
|
|
|
* so we don't need to take the counter lock on every update.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2020-05-21 04:17:11 +08:00
|
|
|
#define XFS_ICOUNT_BATCH 128
|
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 12:37:18 +08:00
|
|
|
void
|
2005-04-17 06:20:36 +08:00
|
|
|
xfs_trans_unreserve_and_mod_sb(
|
2015-02-23 18:24:11 +08:00
|
|
|
struct xfs_trans *tp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2015-02-23 18:24:11 +08:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
|
|
|
|
int64_t blkdelta = 0;
|
|
|
|
int64_t rtxdelta = 0;
|
|
|
|
int64_t idelta = 0;
|
|
|
|
int64_t ifreedelta = 0;
|
|
|
|
int error;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-09-30 10:25:56 +08:00
|
|
|
/* calculate deltas */
|
2007-06-18 14:49:44 +08:00
|
|
|
if (tp->t_blk_res > 0)
|
|
|
|
blkdelta = tp->t_blk_res;
|
|
|
|
if ((tp->t_fdblocks_delta != 0) &&
|
2021-08-19 09:46:37 +08:00
|
|
|
(xfs_has_lazysbcount(mp) ||
|
2007-06-18 14:49:44 +08:00
|
|
|
(tp->t_flags & XFS_TRANS_SB_DIRTY)))
|
|
|
|
blkdelta += tp->t_fdblocks_delta;
|
|
|
|
|
|
|
|
if (tp->t_rtx_res > 0)
|
|
|
|
rtxdelta = tp->t_rtx_res;
|
|
|
|
if ((tp->t_frextents_delta != 0) &&
|
|
|
|
(tp->t_flags & XFS_TRANS_SB_DIRTY))
|
|
|
|
rtxdelta += tp->t_frextents_delta;
|
|
|
|
|
2021-08-19 09:46:37 +08:00
|
|
|
if (xfs_has_lazysbcount(mp) ||
|
2010-09-30 10:25:56 +08:00
|
|
|
(tp->t_flags & XFS_TRANS_SB_DIRTY)) {
|
|
|
|
idelta = tp->t_icount_delta;
|
|
|
|
ifreedelta = tp->t_ifree_delta;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* apply the per-cpu counters */
|
|
|
|
if (blkdelta) {
|
2015-02-23 18:22:03 +08:00
|
|
|
error = xfs_mod_fdblocks(mp, blkdelta, rsvd);
|
2020-05-21 04:17:10 +08:00
|
|
|
ASSERT(!error);
|
2010-09-30 10:25:56 +08:00
|
|
|
}
|
|
|
|
|
2021-03-23 00:52:06 +08:00
|
|
|
if (idelta)
|
2020-05-21 04:17:11 +08:00
|
|
|
percpu_counter_add_batch(&mp->m_icount, idelta,
|
|
|
|
XFS_ICOUNT_BATCH);
|
2010-09-30 10:25:56 +08:00
|
|
|
|
2021-03-23 00:52:06 +08:00
|
|
|
if (ifreedelta)
|
2020-05-21 04:17:11 +08:00
|
|
|
percpu_counter_add(&mp->m_ifree, ifreedelta);
|
2010-09-30 10:25:56 +08:00
|
|
|
|
2022-04-12 04:49:42 +08:00
|
|
|
if (rtxdelta) {
|
|
|
|
error = xfs_mod_frextents(mp, rtxdelta);
|
|
|
|
ASSERT(!error);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(tp->t_flags & XFS_TRANS_SB_DIRTY))
|
2015-02-23 18:24:11 +08:00
|
|
|
return;
|
|
|
|
|
2010-09-30 10:25:56 +08:00
|
|
|
/* apply remaining deltas */
|
2015-02-23 18:24:11 +08:00
|
|
|
spin_lock(&mp->m_sb_lock);
|
2021-04-27 09:28:31 +08:00
|
|
|
mp->m_sb.sb_fdblocks += tp->t_fdblocks_delta + tp->t_res_fdblocks_delta;
|
|
|
|
mp->m_sb.sb_icount += idelta;
|
|
|
|
mp->m_sb.sb_ifree += ifreedelta;
|
2022-04-12 04:49:42 +08:00
|
|
|
/*
|
|
|
|
* Do not touch sb_frextents here because we are dealing with incore
|
|
|
|
* reservation. sb_frextents is not part of the lazy sb counters so it
|
|
|
|
* must be consistent with the ondisk rtbitmap and must never include
|
|
|
|
* incore reservations.
|
|
|
|
*/
|
2020-05-21 04:17:10 +08:00
|
|
|
mp->m_sb.sb_dblocks += tp->t_dblocks_delta;
|
|
|
|
mp->m_sb.sb_agcount += tp->t_agcount_delta;
|
|
|
|
mp->m_sb.sb_imax_pct += tp->t_imaxpct_delta;
|
|
|
|
mp->m_sb.sb_rextsize += tp->t_rextsize_delta;
|
|
|
|
mp->m_sb.sb_rbmblocks += tp->t_rbmblocks_delta;
|
|
|
|
mp->m_sb.sb_rblocks += tp->t_rblocks_delta;
|
|
|
|
mp->m_sb.sb_rextents += tp->t_rextents_delta;
|
|
|
|
mp->m_sb.sb_rextslog += tp->t_rextslog_delta;
|
2015-02-23 18:24:11 +08:00
|
|
|
spin_unlock(&mp->m_sb_lock);
|
2010-09-30 10:25:56 +08:00
|
|
|
|
2020-05-21 04:17:10 +08:00
|
|
|
/*
|
|
|
|
* Debug checks outside of the spinlock so they don't lock up the
|
|
|
|
* machine if they fail.
|
|
|
|
*/
|
|
|
|
ASSERT(mp->m_sb.sb_imax_pct >= 0);
|
|
|
|
ASSERT(mp->m_sb.sb_rextslog >= 0);
|
2010-09-30 10:25:56 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 22:49:37 +08:00
|
|
|
/* Add the given log item to the transaction's list of log items. */
|
2010-06-23 16:11:15 +08:00
|
|
|
void
|
|
|
|
xfs_trans_add_item(
|
|
|
|
struct xfs_trans *tp,
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
2022-03-18 00:09:12 +08:00
|
|
|
ASSERT(lip->li_log == tp->t_mountp->m_log);
|
2012-02-14 04:51:05 +08:00
|
|
|
ASSERT(lip->li_ailp == tp->t_mountp->m_ail);
|
2018-05-09 22:49:37 +08:00
|
|
|
ASSERT(list_empty(&lip->li_trans));
|
|
|
|
ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags));
|
2010-06-23 16:11:15 +08:00
|
|
|
|
2018-05-09 22:49:37 +08:00
|
|
|
list_add_tail(&lip->li_trans, &tp->t_items);
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_add_item(tp, _RET_IP_);
|
2010-06-23 16:11:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2018-05-09 22:49:37 +08:00
|
|
|
* Unlink the log item from the transaction. the log item is no longer
|
|
|
|
* considered dirty in this transaction, as the linked transaction has
|
|
|
|
* finished, either by abort or commit completion.
|
2010-06-23 16:11:15 +08:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_del_item(
|
|
|
|
struct xfs_log_item *lip)
|
|
|
|
{
|
2018-05-09 22:49:37 +08:00
|
|
|
clear_bit(XFS_LI_DIRTY, &lip->li_flags);
|
|
|
|
list_del_init(&lip->li_trans);
|
2010-06-23 16:11:15 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 22:49:37 +08:00
|
|
|
/* Detach and unlock all of the items in a transaction */
|
2019-06-29 10:27:31 +08:00
|
|
|
static void
|
2010-06-23 16:11:15 +08:00
|
|
|
xfs_trans_free_items(
|
|
|
|
struct xfs_trans *tp,
|
2015-06-04 11:47:43 +08:00
|
|
|
bool abort)
|
2010-06-23 16:11:15 +08:00
|
|
|
{
|
2018-05-09 22:49:37 +08:00
|
|
|
struct xfs_log_item *lip, *next;
|
2010-06-23 16:11:15 +08:00
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_free_items(tp, _RET_IP_);
|
|
|
|
|
2018-05-09 22:49:37 +08:00
|
|
|
list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) {
|
|
|
|
xfs_trans_del_item(lip);
|
2015-06-04 11:47:43 +08:00
|
|
|
if (abort)
|
2018-05-09 22:47:34 +08:00
|
|
|
set_bit(XFS_LI_ABORTED, &lip->li_flags);
|
2019-06-29 10:27:32 +08:00
|
|
|
if (lip->li_ops->iop_release)
|
|
|
|
lip->li_ops->iop_release(lip);
|
2010-06-23 16:11:15 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-20 09:02:19 +08:00
|
|
|
static inline void
|
|
|
|
xfs_log_item_batch_insert(
|
|
|
|
struct xfs_ail *ailp,
|
2011-07-18 11:40:16 +08:00
|
|
|
struct xfs_ail_cursor *cur,
|
2010-12-20 09:02:19 +08:00
|
|
|
struct xfs_log_item **log_items,
|
|
|
|
int nr_items,
|
|
|
|
xfs_lsn_t commit_lsn)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2018-03-08 06:59:39 +08:00
|
|
|
spin_lock(&ailp->ail_lock);
|
|
|
|
/* xfs_trans_ail_update_bulk drops ailp->ail_lock */
|
2011-07-18 11:40:16 +08:00
|
|
|
xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
|
2010-12-20 09:02:19 +08:00
|
|
|
|
2013-08-28 19:12:03 +08:00
|
|
|
for (i = 0; i < nr_items; i++) {
|
|
|
|
struct xfs_log_item *lip = log_items[i];
|
|
|
|
|
2019-06-29 10:27:30 +08:00
|
|
|
if (lip->li_ops->iop_unpin)
|
|
|
|
lip->li_ops->iop_unpin(lip, 0);
|
2013-08-28 19:12:03 +08:00
|
|
|
}
|
2010-12-20 09:02:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bulk operation version of xfs_trans_committed that takes a log vector of
|
|
|
|
* items to insert into the AIL. This uses bulk AIL insertion techniques to
|
|
|
|
* minimise lock traffic.
|
2011-01-27 09:13:35 +08:00
|
|
|
*
|
|
|
|
* If we are called with the aborted flag set, it is because a log write during
|
|
|
|
* a CIL checkpoint commit has failed. In this case, all the items in the
|
2019-06-29 10:27:32 +08:00
|
|
|
* checkpoint have already gone through iop_committed and iop_committing, which
|
2011-01-27 09:13:35 +08:00
|
|
|
* means that checkpoint commit abort handling is treated exactly the same
|
|
|
|
* as an iclog write error even though we haven't started any IO yet. Hence in
|
2013-08-28 19:12:03 +08:00
|
|
|
* this case all we need to do is iop_committed processing, followed by an
|
|
|
|
* iop_unpin(aborted) call.
|
2011-07-18 11:40:16 +08:00
|
|
|
*
|
|
|
|
* The AIL cursor is used to optimise the insert process. If commit_lsn is not
|
|
|
|
* at the end of the AIL, the insert cursor avoids the need to walk
|
|
|
|
* the AIL to find the insertion point on every xfs_log_item_batch_insert()
|
|
|
|
* call. This saves a lot of needless list walking and is a net win, even
|
|
|
|
* though it slightly increases that amount of AIL lock traffic to set it up
|
|
|
|
* and tear it down.
|
2010-12-20 09:02:19 +08:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_committed_bulk(
|
|
|
|
struct xfs_ail *ailp,
|
2022-07-07 16:55:59 +08:00
|
|
|
struct list_head *lv_chain,
|
2010-12-20 09:02:19 +08:00
|
|
|
xfs_lsn_t commit_lsn,
|
2019-06-29 10:27:30 +08:00
|
|
|
bool aborted)
|
2010-12-20 09:02:19 +08:00
|
|
|
{
|
|
|
|
#define LOG_ITEM_BATCH_SIZE 32
|
|
|
|
struct xfs_log_item *log_items[LOG_ITEM_BATCH_SIZE];
|
|
|
|
struct xfs_log_vec *lv;
|
2011-07-18 11:40:16 +08:00
|
|
|
struct xfs_ail_cursor cur;
|
2010-12-20 09:02:19 +08:00
|
|
|
int i = 0;
|
|
|
|
|
2018-03-08 06:59:39 +08:00
|
|
|
spin_lock(&ailp->ail_lock);
|
2011-07-18 11:40:16 +08:00
|
|
|
xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
|
2018-03-08 06:59:39 +08:00
|
|
|
spin_unlock(&ailp->ail_lock);
|
2011-07-18 11:40:16 +08:00
|
|
|
|
2010-12-20 09:02:19 +08:00
|
|
|
/* unpin all the log items */
|
2022-07-07 16:55:59 +08:00
|
|
|
list_for_each_entry(lv, lv_chain, lv_list) {
|
2010-12-20 09:02:19 +08:00
|
|
|
struct xfs_log_item *lip = lv->lv_item;
|
|
|
|
xfs_lsn_t item_lsn;
|
|
|
|
|
|
|
|
if (aborted)
|
2018-05-09 22:47:34 +08:00
|
|
|
set_bit(XFS_LI_ABORTED, &lip->li_flags);
|
2019-06-29 10:27:32 +08:00
|
|
|
|
|
|
|
if (lip->li_ops->flags & XFS_ITEM_RELEASE_WHEN_COMMITTED) {
|
|
|
|
lip->li_ops->iop_release(lip);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-06-29 10:27:30 +08:00
|
|
|
if (lip->li_ops->iop_committed)
|
|
|
|
item_lsn = lip->li_ops->iop_committed(lip, commit_lsn);
|
|
|
|
else
|
|
|
|
item_lsn = commit_lsn;
|
2010-12-20 09:02:19 +08:00
|
|
|
|
xfs: unpin stale inodes directly in IOP_COMMITTED
When inodes are marked stale in a transaction, they are treated
specially when the inode log item is being inserted into the AIL.
It tries to avoid moving the log item forward in the AIL due to a
race condition with the writing the underlying buffer back to disk.
The was "fixed" in commit de25c18 ("xfs: avoid moving stale inodes
in the AIL").
To avoid moving the item forward, we return a LSN smaller than the
commit_lsn of the completing transaction, thereby trying to trick
the commit code into not moving the inode forward at all. I'm not
sure this ever worked as intended - it assumes the inode is already
in the AIL, but I don't think the returned LSN would have been small
enough to prevent moving the inode. It appears that the reason it
worked is that the lower LSN of the inodes meant they were inserted
into the AIL and flushed before the inode buffer (which was moved to
the commit_lsn of the transaction).
The big problem is that with delayed logging, the returning of the
different LSN means insertion takes the slow, non-bulk path. Worse
yet is that insertion is to a position -before- the commit_lsn so it
is doing a AIL traversal on every insertion, and has to walk over
all the items that have already been inserted into the AIL. It's
expensive.
To compound the matter further, with delayed logging inodes are
likely to go from clean to stale in a single checkpoint, which means
they aren't even in the AIL at all when we come across them at AIL
insertion time. Hence these were all getting inserted into the AIL
when they simply do not need to be as inodes marked XFS_ISTALE are
never written back.
Transactional/recovery integrity is maintained in this case by the
other items in the unlink transaction that were modified (e.g. the
AGI btree blocks) and committed in the same checkpoint.
So to fix this, simply unpin the stale inodes directly in
xfs_inode_item_committed() and return -1 to indicate that the AIL
insertion code does not need to do any further processing of these
inodes.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-07-04 13:27:36 +08:00
|
|
|
/* item_lsn of -1 means the item needs no further processing */
|
2010-12-20 09:02:19 +08:00
|
|
|
if (XFS_LSN_CMP(item_lsn, (xfs_lsn_t)-1) == 0)
|
|
|
|
continue;
|
|
|
|
|
2011-01-27 09:13:35 +08:00
|
|
|
/*
|
|
|
|
* if we are aborting the operation, no point in inserting the
|
|
|
|
* object into the AIL as we are in a shutdown situation.
|
|
|
|
*/
|
|
|
|
if (aborted) {
|
2022-03-18 00:09:12 +08:00
|
|
|
ASSERT(xlog_is_shutdown(ailp->ail_log));
|
2019-06-29 10:27:30 +08:00
|
|
|
if (lip->li_ops->iop_unpin)
|
|
|
|
lip->li_ops->iop_unpin(lip, 1);
|
2011-01-27 09:13:35 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-12-20 09:02:19 +08:00
|
|
|
if (item_lsn != commit_lsn) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not a bulk update option due to unusual item_lsn.
|
|
|
|
* Push into AIL immediately, rechecking the lsn once
|
2011-07-18 11:40:16 +08:00
|
|
|
* we have the ail lock. Then unpin the item. This does
|
|
|
|
* not affect the AIL cursor the bulk insert path is
|
|
|
|
* using.
|
2010-12-20 09:02:19 +08:00
|
|
|
*/
|
2018-03-08 06:59:39 +08:00
|
|
|
spin_lock(&ailp->ail_lock);
|
2010-12-20 09:02:19 +08:00
|
|
|
if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
|
|
|
|
xfs_trans_ail_update(ailp, lip, item_lsn);
|
|
|
|
else
|
2018-03-08 06:59:39 +08:00
|
|
|
spin_unlock(&ailp->ail_lock);
|
2019-06-29 10:27:30 +08:00
|
|
|
if (lip->li_ops->iop_unpin)
|
|
|
|
lip->li_ops->iop_unpin(lip, 0);
|
2010-12-20 09:02:19 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Item is a candidate for bulk AIL insert. */
|
|
|
|
log_items[i++] = lv->lv_item;
|
|
|
|
if (i >= LOG_ITEM_BATCH_SIZE) {
|
2011-07-18 11:40:16 +08:00
|
|
|
xfs_log_item_batch_insert(ailp, &cur, log_items,
|
2010-12-20 09:02:19 +08:00
|
|
|
LOG_ITEM_BATCH_SIZE, commit_lsn);
|
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure we insert the remainder! */
|
|
|
|
if (i)
|
2011-07-18 11:40:16 +08:00
|
|
|
xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
|
|
|
|
|
2018-03-08 06:59:39 +08:00
|
|
|
spin_lock(&ailp->ail_lock);
|
2014-04-14 17:06:05 +08:00
|
|
|
xfs_trans_ail_cursor_done(&cur);
|
2018-03-08 06:59:39 +08:00
|
|
|
spin_unlock(&ailp->ail_lock);
|
2010-12-20 09:02:19 +08:00
|
|
|
}
|
|
|
|
|
xfs: add log item precommit operation
For inodes that are dirty, we have an attached cluster buffer that
we want to use to track the dirty inode through the AIL.
Unfortunately, locking the cluster buffer and adding it to the
transaction when the inode is first logged in a transaction leads to
buffer lock ordering inversions.
The specific problem is ordering against the AGI buffer. When
modifying unlinked lists, the buffer lock order is AGI -> inode
cluster buffer as the AGI buffer lock serialises all access to the
unlinked lists. Unfortunately, functionality like xfs_droplink()
logs the inode before calling xfs_iunlink(), as do various directory
manipulation functions. The inode can be logged way down in the
stack as far as the bmapi routines and hence, without a major
rewrite of lots of APIs there's no way we can avoid the inode being
logged by something until after the AGI has been logged.
As we are going to be using ordered buffers for inode AIL tracking,
there isn't a need to actually lock that buffer against modification
as all the modifications are captured by logging the inode item
itself. Hence we don't actually need to join the cluster buffer into
the transaction until just before it is committed. This means we do
not perturb any of the existing buffer lock orders in transactions,
and the inode cluster buffer is always locked last in a transaction
that doesn't otherwise touch inode cluster buffers.
We do this by introducing a precommit log item method. This commit
just introduces the mechanism; the inode item implementation is in
followup commits.
The precommit items need to be sorted into consistent order as we
may be locking multiple items here. Hence if we have two dirty
inodes in cluster buffers A and B, and some other transaction has
two separate dirty inodes in the same cluster buffers, locking them
in different orders opens us up to ABBA deadlocks. Hence we sort the
items on the transaction based on the presence of a sort log item
method.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2022-07-14 09:47:26 +08:00
|
|
|
/*
|
|
|
|
* Sort transaction items prior to running precommit operations. This will
|
|
|
|
* attempt to order the items such that they will always be locked in the same
|
|
|
|
* order. Items that have no sort function are moved to the end of the list
|
|
|
|
* and so are locked last.
|
|
|
|
*
|
|
|
|
* This may need refinement as different types of objects add sort functions.
|
|
|
|
*
|
|
|
|
* Function is more complex than it needs to be because we are comparing 64 bit
|
|
|
|
* values and the function only returns 32 bit values.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_trans_precommit_sort(
|
|
|
|
void *unused_arg,
|
|
|
|
const struct list_head *a,
|
|
|
|
const struct list_head *b)
|
|
|
|
{
|
|
|
|
struct xfs_log_item *lia = container_of(a,
|
|
|
|
struct xfs_log_item, li_trans);
|
|
|
|
struct xfs_log_item *lib = container_of(b,
|
|
|
|
struct xfs_log_item, li_trans);
|
|
|
|
int64_t diff;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If both items are non-sortable, leave them alone. If only one is
|
|
|
|
* sortable, move the non-sortable item towards the end of the list.
|
|
|
|
*/
|
|
|
|
if (!lia->li_ops->iop_sort && !lib->li_ops->iop_sort)
|
|
|
|
return 0;
|
|
|
|
if (!lia->li_ops->iop_sort)
|
|
|
|
return 1;
|
|
|
|
if (!lib->li_ops->iop_sort)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
diff = lia->li_ops->iop_sort(lia) - lib->li_ops->iop_sort(lib);
|
|
|
|
if (diff < 0)
|
|
|
|
return -1;
|
|
|
|
if (diff > 0)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Run transaction precommit functions.
|
|
|
|
*
|
|
|
|
* If there is an error in any of the callouts, then stop immediately and
|
|
|
|
* trigger a shutdown to abort the transaction. There is no recovery possible
|
|
|
|
* from errors at this point as the transaction is dirty....
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xfs_trans_run_precommits(
|
|
|
|
struct xfs_trans *tp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
struct xfs_log_item *lip, *n;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sort the item list to avoid ABBA deadlocks with other transactions
|
|
|
|
* running precommit operations that lock multiple shared items such as
|
|
|
|
* inode cluster buffers.
|
|
|
|
*/
|
|
|
|
list_sort(NULL, &tp->t_items, xfs_trans_precommit_sort);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Precommit operations can remove the log item from the transaction
|
|
|
|
* if the log item exists purely to delay modifications until they
|
|
|
|
* can be ordered against other operations. Hence we have to use
|
|
|
|
* list_for_each_entry_safe() here.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_safe(lip, n, &tp->t_items, li_trans) {
|
|
|
|
if (!test_bit(XFS_LI_DIRTY, &lip->li_flags))
|
|
|
|
continue;
|
|
|
|
if (lip->li_ops->iop_precommit) {
|
|
|
|
error = lip->li_ops->iop_precommit(tp, lip);
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-03-08 08:28:28 +08:00
|
|
|
/*
|
2011-09-19 22:55:51 +08:00
|
|
|
* Commit the given transaction to the log.
|
2010-03-08 08:28:28 +08:00
|
|
|
*
|
|
|
|
* XFS disk error handling mechanism is not based on a typical
|
|
|
|
* transaction abort mechanism. Logically after the filesystem
|
|
|
|
* gets marked 'SHUTDOWN', we can't let any new transactions
|
|
|
|
* be durable - ie. committed to disk - because some metadata might
|
|
|
|
* be inconsistent. In such cases, this returns an error, and the
|
|
|
|
* caller may assume that all locked objects joined to the transaction
|
|
|
|
* have already been unlocked as if the commit had succeeded.
|
|
|
|
* Do not reference the transaction structure after this call.
|
|
|
|
*/
|
2015-06-04 11:48:08 +08:00
|
|
|
static int
|
|
|
|
__xfs_trans_commit(
|
2010-03-15 09:52:49 +08:00
|
|
|
struct xfs_trans *tp,
|
2015-06-04 11:48:08 +08:00
|
|
|
bool regrant)
|
2010-03-08 08:28:28 +08:00
|
|
|
{
|
2010-03-15 09:52:49 +08:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
struct xlog *log = mp->m_log;
|
2021-06-18 23:21:52 +08:00
|
|
|
xfs_csn_t commit_seq = 0;
|
2010-03-15 09:52:49 +08:00
|
|
|
int error = 0;
|
2010-03-08 08:28:28 +08:00
|
|
|
int sync = tp->t_flags & XFS_TRANS_SYNC;
|
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_commit(tp, _RET_IP_);
|
|
|
|
|
xfs: add log item precommit operation
For inodes that are dirty, we have an attached cluster buffer that
we want to use to track the dirty inode through the AIL.
Unfortunately, locking the cluster buffer and adding it to the
transaction when the inode is first logged in a transaction leads to
buffer lock ordering inversions.
The specific problem is ordering against the AGI buffer. When
modifying unlinked lists, the buffer lock order is AGI -> inode
cluster buffer as the AGI buffer lock serialises all access to the
unlinked lists. Unfortunately, functionality like xfs_droplink()
logs the inode before calling xfs_iunlink(), as do various directory
manipulation functions. The inode can be logged way down in the
stack as far as the bmapi routines and hence, without a major
rewrite of lots of APIs there's no way we can avoid the inode being
logged by something until after the AGI has been logged.
As we are going to be using ordered buffers for inode AIL tracking,
there isn't a need to actually lock that buffer against modification
as all the modifications are captured by logging the inode item
itself. Hence we don't actually need to join the cluster buffer into
the transaction until just before it is committed. This means we do
not perturb any of the existing buffer lock orders in transactions,
and the inode cluster buffer is always locked last in a transaction
that doesn't otherwise touch inode cluster buffers.
We do this by introducing a precommit log item method. This commit
just introduces the mechanism; the inode item implementation is in
followup commits.
The precommit items need to be sorted into consistent order as we
may be locking multiple items here. Hence if we have two dirty
inodes in cluster buffers A and B, and some other transaction has
two separate dirty inodes in the same cluster buffers, locking them
in different orders opens us up to ABBA deadlocks. Hence we sort the
items on the transaction based on the presence of a sort log item
method.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2022-07-14 09:47:26 +08:00
|
|
|
error = xfs_trans_run_precommits(tp);
|
|
|
|
if (error) {
|
|
|
|
if (tp->t_flags & XFS_TRANS_PERM_LOG_RES)
|
|
|
|
xfs_defer_cancel(tp);
|
|
|
|
goto out_unreserve;
|
|
|
|
}
|
|
|
|
|
2018-08-01 22:20:29 +08:00
|
|
|
/*
|
|
|
|
* Finish deferred items on final commit. Only permanent transactions
|
|
|
|
* should ever have deferred ops.
|
|
|
|
*/
|
2018-08-01 22:20:35 +08:00
|
|
|
WARN_ON_ONCE(!list_empty(&tp->t_dfops) &&
|
2018-08-01 22:20:29 +08:00
|
|
|
!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
|
|
|
|
if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {
|
2018-07-25 04:43:15 +08:00
|
|
|
error = xfs_defer_finish_noroll(&tp);
|
2018-08-01 22:20:33 +08:00
|
|
|
if (error)
|
2018-07-25 04:43:11 +08:00
|
|
|
goto out_unreserve;
|
|
|
|
}
|
|
|
|
|
2010-03-08 08:28:28 +08:00
|
|
|
/*
|
|
|
|
* If there is nothing to be logged by the transaction,
|
|
|
|
* then unlock all of the items associated with the
|
|
|
|
* transaction and free the transaction structure.
|
|
|
|
* Also make sure to return any reserved blocks to
|
|
|
|
* the free pool.
|
|
|
|
*/
|
2010-03-15 09:52:49 +08:00
|
|
|
if (!(tp->t_flags & XFS_TRANS_DIRTY))
|
|
|
|
goto out_unreserve;
|
|
|
|
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
/*
|
|
|
|
* We must check against log shutdown here because we cannot abort log
|
|
|
|
* items and leave them dirty, inconsistent and unpinned in memory while
|
|
|
|
* the log is active. This leaves them open to being written back to
|
|
|
|
* disk, and that will lead to on-disk corruption.
|
|
|
|
*/
|
|
|
|
if (xlog_is_shutdown(log)) {
|
2014-06-25 12:58:08 +08:00
|
|
|
error = -EIO;
|
2010-03-15 09:52:49 +08:00
|
|
|
goto out_unreserve;
|
2010-03-08 08:28:28 +08:00
|
|
|
}
|
2010-03-15 09:52:49 +08:00
|
|
|
|
2010-03-08 08:28:28 +08:00
|
|
|
ASSERT(tp->t_ticket != NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we need to update the superblock, then do it now.
|
|
|
|
*/
|
|
|
|
if (tp->t_flags & XFS_TRANS_SB_DIRTY)
|
|
|
|
xfs_trans_apply_sb_deltas(tp);
|
|
|
|
xfs_trans_apply_dquot_deltas(tp);
|
|
|
|
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
xlog_cil_commit(log, tp, &commit_seq, regrant);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-12-07 05:58:08 +08:00
|
|
|
xfs_trans_free(tp);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* If the transaction needs to be synchronous, then force the
|
|
|
|
* log out now and wait for it.
|
|
|
|
*/
|
|
|
|
if (sync) {
|
2021-06-18 23:21:52 +08:00
|
|
|
error = xfs_log_force_seq(mp, commit_seq, XFS_LOG_SYNC, NULL);
|
2015-10-12 15:21:22 +08:00
|
|
|
XFS_STATS_INC(mp, xs_trans_sync);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
2015-10-12 15:21:22 +08:00
|
|
|
XFS_STATS_INC(mp, xs_trans_async);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-03-15 09:52:49 +08:00
|
|
|
return error;
|
|
|
|
|
|
|
|
out_unreserve:
|
|
|
|
xfs_trans_unreserve_and_mod_sb(tp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It is indeed possible for the transaction to be not dirty but
|
|
|
|
* the dqinfo portion to be. All that means is that we have some
|
|
|
|
* (non-persistent) quota reservations that need to be unreserved.
|
|
|
|
*/
|
|
|
|
xfs_trans_unreserve_and_mod_dquots(tp);
|
|
|
|
if (tp->t_ticket) {
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
if (regrant && !xlog_is_shutdown(log))
|
|
|
|
xfs_log_ticket_regrant(log, tp->t_ticket);
|
2020-03-26 09:18:23 +08:00
|
|
|
else
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
xfs_log_ticket_ungrant(log, tp->t_ticket);
|
2018-05-09 22:47:57 +08:00
|
|
|
tp->t_ticket = NULL;
|
2010-03-15 09:52:49 +08:00
|
|
|
}
|
2019-06-29 10:27:31 +08:00
|
|
|
xfs_trans_free_items(tp, !!error);
|
2010-03-15 09:52:49 +08:00
|
|
|
xfs_trans_free(tp);
|
|
|
|
|
2015-10-12 15:21:22 +08:00
|
|
|
XFS_STATS_INC(mp, xs_trans_empty);
|
2010-03-15 09:52:49 +08:00
|
|
|
return error;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-06-04 11:48:08 +08:00
|
|
|
int
|
|
|
|
xfs_trans_commit(
|
|
|
|
struct xfs_trans *tp)
|
|
|
|
{
|
|
|
|
return __xfs_trans_commit(tp, false);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
* Unlock all of the transaction's items and free the transaction. If the
|
|
|
|
* transaction is dirty, we must shut down the filesystem because there is no
|
|
|
|
* way to restore them to their previous state.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
* If the transaction has made a log reservation, make sure to release it as
|
|
|
|
* well.
|
|
|
|
*
|
|
|
|
* This is a high level function (equivalent to xfs_trans_commit()) and so can
|
|
|
|
* be called after the transaction has effectively been aborted due to the mount
|
|
|
|
* being shut down. However, if the mount has not been shut down and the
|
|
|
|
* transaction is dirty we will shut the mount down and, in doing so, that
|
|
|
|
* guarantees that the log is shut down, too. Hence we don't need to be as
|
|
|
|
* careful with shutdown state and dirty items here as we need to be in
|
|
|
|
* xfs_trans_commit().
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_trans_cancel(
|
2015-06-04 11:47:56 +08:00
|
|
|
struct xfs_trans *tp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2015-06-04 11:47:56 +08:00
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
struct xlog *log = mp->m_log;
|
2015-06-04 11:47:56 +08:00
|
|
|
bool dirty = (tp->t_flags & XFS_TRANS_DIRTY);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_cancel(tp, _RET_IP_);
|
|
|
|
|
2021-12-16 03:53:14 +08:00
|
|
|
/*
|
|
|
|
* It's never valid to cancel a transaction with deferred ops attached,
|
|
|
|
* because the transaction is effectively dirty. Complain about this
|
|
|
|
* loudly before freeing the in-memory defer items.
|
|
|
|
*/
|
|
|
|
if (!list_empty(&tp->t_dfops)) {
|
|
|
|
ASSERT(xfs_is_shutdown(mp) || list_empty(&tp->t_dfops));
|
|
|
|
ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES);
|
|
|
|
dirty = true;
|
2018-07-25 04:43:15 +08:00
|
|
|
xfs_defer_cancel(tp);
|
2021-12-16 03:53:14 +08:00
|
|
|
}
|
2018-07-25 04:43:11 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
* See if the caller is relying on us to shut down the filesystem. We
|
|
|
|
* only want an error report if there isn't already a shutdown in
|
|
|
|
* progress, so we only need to check against the mount shutdown state
|
|
|
|
* here.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2021-08-19 09:46:53 +08:00
|
|
|
if (dirty && !xfs_is_shutdown(mp)) {
|
2006-01-11 12:36:44 +08:00
|
|
|
XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
|
2006-06-09 12:58:38 +08:00
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
|
2006-01-11 12:37:00 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef DEBUG
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
/* Log items need to be consistent until the log is shut down. */
|
|
|
|
if (!dirty && !xlog_is_shutdown(log)) {
|
2018-05-09 22:49:37 +08:00
|
|
|
struct xfs_log_item *lip;
|
2010-06-23 16:11:15 +08:00
|
|
|
|
2018-05-09 22:49:37 +08:00
|
|
|
list_for_each_entry(lip, &tp->t_items, li_trans)
|
2020-09-24 00:13:28 +08:00
|
|
|
ASSERT(!xlog_item_is_intent_done(lip));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
xfs_trans_unreserve_and_mod_sb(tp);
|
2009-06-08 21:33:32 +08:00
|
|
|
xfs_trans_unreserve_and_mod_dquots(tp);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
if (tp->t_ticket) {
|
xfs: xfs_trans_commit() path must check for log shutdown
If a shut races with xfs_trans_commit() and we have shut down the
filesystem but not the log, we will still cancel the transaction.
This can result in aborting dirty log items instead of committing and
pinning them whilst the log is still running. Hence we can end up
with dirty, unlogged metadata that isn't in the AIL in memory that
can be flushed to disk via writeback clustering.
This was discovered from a g/388 trace where an inode log item was
having IO completed on it and it wasn't in the AIL, hence tripping
asserts xfs_ail_check(). Inode cluster writeback started long after
the filesystem shutdown started, and long after the transaction
containing the dirty inode was aborted and the log item marked
XFS_LI_ABORTED. The inode was seen as dirty and unpinned, so it
was flushed. IO completion tried to remove the inode from the AIL,
at which point stuff went bad:
XFS (pmem1): Log I/O Error (0x6) detected at xfs_fs_goingdown+0xa3/0xf0 (fs/xfs/xfs_fsops.c:500). Shutting down filesystem.
XFS: Assertion failed: in_ail, file: fs/xfs/xfs_trans_ail.c, line: 67
XFS (pmem1): Please unmount the filesystem and rectify the problem(s)
Workqueue: xfs-buf/pmem1 xfs_buf_ioend_work
RIP: 0010:assfail+0x27/0x2d
Call Trace:
<TASK>
xfs_ail_check+0xa8/0x180
xfs_ail_delete_one+0x3b/0xf0
xfs_buf_inode_iodone+0x329/0x3f0
xfs_buf_ioend+0x1f8/0x530
xfs_buf_ioend_work+0x15/0x20
process_one_work+0x1ac/0x390
worker_thread+0x56/0x3c0
kthread+0xf6/0x120
ret_from_fork+0x1f/0x30
</TASK>
xfs_trans_commit() needs to check log state for shutdown, not mount
state. It cannot abort dirty log items while the log is still
running as dirty items must remained pinned in memory until they are
either committed to the journal or the log has shut down and they
can be safely tossed away. Hence if the log has not shut down, the
xfs_trans_commit() path must allow completed transactions to commit
to the CIL and pin the dirty items even if a mount shutdown has
started.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2022-03-30 09:22:01 +08:00
|
|
|
xfs_log_ticket_ungrant(log, tp->t_ticket);
|
2018-05-09 22:47:57 +08:00
|
|
|
tp->t_ticket = NULL;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-06-29 10:27:31 +08:00
|
|
|
xfs_trans_free_items(tp, dirty);
|
2005-04-17 06:20:36 +08:00
|
|
|
xfs_trans_free(tp);
|
|
|
|
}
|
|
|
|
|
2008-08-13 14:05:49 +08:00
|
|
|
/*
|
|
|
|
* Roll from one trans in the sequence of PERMANENT transactions to
|
|
|
|
* the next: permanent transactions are only flushed out when
|
2015-06-04 11:48:08 +08:00
|
|
|
* committed with xfs_trans_commit(), but we still want as soon
|
2008-08-13 14:05:49 +08:00
|
|
|
* as possible to let chunks of it go to the log. So we commit the
|
|
|
|
* chunk we've been working on and get a new transaction to continue.
|
|
|
|
*/
|
|
|
|
int
|
2017-04-07 07:00:11 +08:00
|
|
|
xfs_trans_roll(
|
2017-08-29 01:21:03 +08:00
|
|
|
struct xfs_trans **tpp)
|
2008-08-13 14:05:49 +08:00
|
|
|
{
|
2017-08-29 01:21:03 +08:00
|
|
|
struct xfs_trans *trans = *tpp;
|
2013-08-12 18:49:59 +08:00
|
|
|
struct xfs_trans_res tres;
|
2008-08-13 14:05:49 +08:00
|
|
|
int error;
|
|
|
|
|
2018-05-09 22:47:57 +08:00
|
|
|
trace_xfs_trans_roll(trans, _RET_IP_);
|
|
|
|
|
2008-08-13 14:05:49 +08:00
|
|
|
/*
|
|
|
|
* Copy the critical parameters from one trans to the next.
|
|
|
|
*/
|
2013-08-12 18:49:59 +08:00
|
|
|
tres.tr_logres = trans->t_log_res;
|
|
|
|
tres.tr_logcount = trans->t_log_count;
|
2017-08-29 01:21:03 +08:00
|
|
|
|
2008-08-13 14:05:49 +08:00
|
|
|
*tpp = xfs_trans_dup(trans);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit the current transaction.
|
|
|
|
* If this commit failed, then it'd just unlock those items that
|
|
|
|
* are not marked ihold. That also means that a filesystem shutdown
|
|
|
|
* is in progress. The caller takes the responsibility to cancel
|
|
|
|
* the duplicate transaction that gets returned.
|
|
|
|
*/
|
2015-06-04 11:48:08 +08:00
|
|
|
error = __xfs_trans_commit(trans, true);
|
2008-08-13 14:05:49 +08:00
|
|
|
if (error)
|
2014-06-22 13:03:54 +08:00
|
|
|
return error;
|
2008-08-13 14:05:49 +08:00
|
|
|
|
|
|
|
/*
|
2017-08-29 01:21:03 +08:00
|
|
|
* Reserve space in the log for the next transaction.
|
2008-08-13 14:05:49 +08:00
|
|
|
* This also pushes items in the "AIL", the list of logged items,
|
|
|
|
* out to disk if they are taking up space at the tail of the log
|
|
|
|
* that we want to use. This requires that either nothing be locked
|
|
|
|
* across this call, or that anything that is locked be logged in
|
|
|
|
* the prior and the next transactions.
|
|
|
|
*/
|
2013-08-12 18:49:59 +08:00
|
|
|
tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;
|
2017-08-29 01:21:03 +08:00
|
|
|
return xfs_trans_reserve(*tpp, &tres, 0, 0);
|
2008-08-13 14:05:49 +08:00
|
|
|
}
|
2021-01-27 08:33:29 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate an transaction, lock and join the inode to it, and reserve quota.
|
|
|
|
*
|
|
|
|
* The caller must ensure that the on-disk dquots attached to this inode have
|
|
|
|
* already been allocated and initialized. The caller is responsible for
|
|
|
|
* releasing ILOCK_EXCL if a new transaction is returned.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_trans_alloc_inode(
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
struct xfs_trans_res *resv,
|
|
|
|
unsigned int dblocks,
|
2021-01-27 08:44:07 +08:00
|
|
|
unsigned int rblocks,
|
2021-01-27 08:33:29 +08:00
|
|
|
bool force,
|
|
|
|
struct xfs_trans **tpp)
|
|
|
|
{
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2021-01-23 08:48:37 +08:00
|
|
|
bool retried = false;
|
2021-01-27 08:33:29 +08:00
|
|
|
int error;
|
|
|
|
|
2021-01-23 08:48:37 +08:00
|
|
|
retry:
|
2021-01-27 08:44:07 +08:00
|
|
|
error = xfs_trans_alloc(mp, resv, dblocks,
|
|
|
|
rblocks / mp->m_sb.sb_rextsize,
|
2021-01-27 08:33:29 +08:00
|
|
|
force ? XFS_TRANS_RESERVE : 0, &tp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
|
|
|
|
|
|
|
error = xfs_qm_dqattach_locked(ip, false);
|
|
|
|
if (error) {
|
|
|
|
/* Caller should have allocated the dquots! */
|
|
|
|
ASSERT(error != -ENOENT);
|
|
|
|
goto out_cancel;
|
|
|
|
}
|
|
|
|
|
2021-01-27 08:44:07 +08:00
|
|
|
error = xfs_trans_reserve_quota_nblks(tp, ip, dblocks, rblocks, force);
|
2021-01-23 08:48:37 +08:00
|
|
|
if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_blockgc_free_quota(ip, 0);
|
|
|
|
retried = true;
|
|
|
|
goto retry;
|
|
|
|
}
|
2021-01-27 08:33:29 +08:00
|
|
|
if (error)
|
|
|
|
goto out_cancel;
|
|
|
|
|
|
|
|
*tpp = tp;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_cancel:
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return error;
|
|
|
|
}
|
2021-01-28 04:07:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate an transaction in preparation for inode creation by reserving quota
|
|
|
|
* against the given dquots. Callers are not required to hold any inode locks.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_trans_alloc_icreate(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_trans_res *resv,
|
|
|
|
struct xfs_dquot *udqp,
|
|
|
|
struct xfs_dquot *gdqp,
|
|
|
|
struct xfs_dquot *pdqp,
|
|
|
|
unsigned int dblocks,
|
|
|
|
struct xfs_trans **tpp)
|
|
|
|
{
|
|
|
|
struct xfs_trans *tp;
|
2021-01-23 08:48:37 +08:00
|
|
|
bool retried = false;
|
2021-01-28 04:07:57 +08:00
|
|
|
int error;
|
|
|
|
|
2021-01-23 08:48:37 +08:00
|
|
|
retry:
|
2021-01-28 04:07:57 +08:00
|
|
|
error = xfs_trans_alloc(mp, resv, dblocks, 0, 0, &tp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = xfs_trans_reserve_quota_icreate(tp, udqp, gdqp, pdqp, dblocks);
|
2021-01-23 08:48:37 +08:00
|
|
|
if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
xfs_blockgc_free_dquots(mp, udqp, gdqp, pdqp, 0);
|
|
|
|
retried = true;
|
|
|
|
goto retry;
|
|
|
|
}
|
2021-01-28 04:07:57 +08:00
|
|
|
if (error) {
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
*tpp = tp;
|
|
|
|
return 0;
|
|
|
|
}
|
2021-01-30 03:32:09 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate an transaction, lock and join the inode to it, and reserve quota
|
|
|
|
* in preparation for inode attribute changes that include uid, gid, or prid
|
|
|
|
* changes.
|
|
|
|
*
|
|
|
|
* The caller must ensure that the on-disk dquots attached to this inode have
|
|
|
|
* already been allocated and initialized. The ILOCK will be dropped when the
|
|
|
|
* transaction is committed or cancelled.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_trans_alloc_ichange(
|
|
|
|
struct xfs_inode *ip,
|
2021-01-23 08:48:38 +08:00
|
|
|
struct xfs_dquot *new_udqp,
|
|
|
|
struct xfs_dquot *new_gdqp,
|
|
|
|
struct xfs_dquot *new_pdqp,
|
2021-01-30 03:32:09 +08:00
|
|
|
bool force,
|
|
|
|
struct xfs_trans **tpp)
|
|
|
|
{
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
2021-01-23 08:48:38 +08:00
|
|
|
struct xfs_dquot *udqp;
|
|
|
|
struct xfs_dquot *gdqp;
|
|
|
|
struct xfs_dquot *pdqp;
|
|
|
|
bool retried = false;
|
2021-01-30 03:32:09 +08:00
|
|
|
int error;
|
|
|
|
|
2021-01-23 08:48:38 +08:00
|
|
|
retry:
|
2021-01-30 03:32:09 +08:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
error = xfs_qm_dqattach_locked(ip, false);
|
|
|
|
if (error) {
|
|
|
|
/* Caller should have allocated the dquots! */
|
|
|
|
ASSERT(error != -ENOENT);
|
|
|
|
goto out_cancel;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For each quota type, skip quota reservations if the inode's dquots
|
|
|
|
* now match the ones that came from the caller, or the caller didn't
|
2021-01-23 08:48:38 +08:00
|
|
|
* pass one in. The inode's dquots can change if we drop the ILOCK to
|
|
|
|
* perform a blockgc scan, so we must preserve the caller's arguments.
|
2021-01-30 03:32:09 +08:00
|
|
|
*/
|
2021-01-23 08:48:38 +08:00
|
|
|
udqp = (new_udqp != ip->i_udquot) ? new_udqp : NULL;
|
|
|
|
gdqp = (new_gdqp != ip->i_gdquot) ? new_gdqp : NULL;
|
|
|
|
pdqp = (new_pdqp != ip->i_pdquot) ? new_pdqp : NULL;
|
2021-01-30 03:32:09 +08:00
|
|
|
if (udqp || gdqp || pdqp) {
|
2021-02-02 02:38:51 +08:00
|
|
|
unsigned int qflags = XFS_QMOPT_RES_REGBLKS;
|
|
|
|
|
|
|
|
if (force)
|
|
|
|
qflags |= XFS_QMOPT_FORCE_RES;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reserve enough quota to handle blocks on disk and reserved
|
|
|
|
* for a delayed allocation. We'll actually transfer the
|
|
|
|
* delalloc reservation between dquots at chown time, even
|
|
|
|
* though that part is only semi-transactional.
|
|
|
|
*/
|
|
|
|
error = xfs_trans_reserve_quota_bydquots(tp, mp, udqp, gdqp,
|
2021-03-30 02:11:40 +08:00
|
|
|
pdqp, ip->i_nblocks + ip->i_delayed_blks,
|
2021-02-02 02:38:51 +08:00
|
|
|
1, qflags);
|
2021-01-23 08:48:38 +08:00
|
|
|
if ((error == -EDQUOT || error == -ENOSPC) && !retried) {
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
xfs_blockgc_free_dquots(mp, udqp, gdqp, pdqp, 0);
|
|
|
|
retried = true;
|
|
|
|
goto retry;
|
|
|
|
}
|
2021-01-30 03:32:09 +08:00
|
|
|
if (error)
|
|
|
|
goto out_cancel;
|
|
|
|
}
|
|
|
|
|
|
|
|
*tpp = tp;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_cancel:
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
return error;
|
|
|
|
}
|
2022-02-26 08:18:41 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate an transaction, lock and join the directory and child inodes to it,
|
|
|
|
* and reserve quota for a directory update. If there isn't sufficient space,
|
|
|
|
* @dblocks will be set to zero for a reservationless directory update and
|
|
|
|
* @nospace_error will be set to a negative errno describing the space
|
|
|
|
* constraint we hit.
|
|
|
|
*
|
|
|
|
* The caller must ensure that the on-disk dquots attached to this inode have
|
|
|
|
* already been allocated and initialized. The ILOCKs will be dropped when the
|
|
|
|
* transaction is committed or cancelled.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_trans_alloc_dir(
|
|
|
|
struct xfs_inode *dp,
|
|
|
|
struct xfs_trans_res *resv,
|
|
|
|
struct xfs_inode *ip,
|
|
|
|
unsigned int *dblocks,
|
|
|
|
struct xfs_trans **tpp,
|
|
|
|
int *nospace_error)
|
|
|
|
{
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
struct xfs_mount *mp = ip->i_mount;
|
|
|
|
unsigned int resblks;
|
|
|
|
bool retried = false;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
retry:
|
|
|
|
*nospace_error = 0;
|
|
|
|
resblks = *dblocks;
|
|
|
|
error = xfs_trans_alloc(mp, resv, resblks, 0, 0, &tp);
|
|
|
|
if (error == -ENOSPC) {
|
|
|
|
*nospace_error = error;
|
|
|
|
resblks = 0;
|
|
|
|
error = xfs_trans_alloc(mp, resv, resblks, 0, 0, &tp);
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_lock_two_inodes(dp, XFS_ILOCK_EXCL, ip, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
error = xfs_qm_dqattach_locked(dp, false);
|
|
|
|
if (error) {
|
|
|
|
/* Caller should have allocated the dquots! */
|
|
|
|
ASSERT(error != -ENOENT);
|
|
|
|
goto out_cancel;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = xfs_qm_dqattach_locked(ip, false);
|
|
|
|
if (error) {
|
|
|
|
/* Caller should have allocated the dquots! */
|
|
|
|
ASSERT(error != -ENOENT);
|
|
|
|
goto out_cancel;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (resblks == 0)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
error = xfs_trans_reserve_quota_nblks(tp, dp, resblks, 0, false);
|
|
|
|
if (error == -EDQUOT || error == -ENOSPC) {
|
|
|
|
if (!retried) {
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
xfs_blockgc_free_quota(dp, 0);
|
|
|
|
retried = true;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
*nospace_error = error;
|
|
|
|
resblks = 0;
|
|
|
|
error = 0;
|
|
|
|
}
|
|
|
|
if (error)
|
|
|
|
goto out_cancel;
|
|
|
|
|
|
|
|
done:
|
|
|
|
*tpp = tp;
|
|
|
|
*dblocks = resblks;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_cancel:
|
|
|
|
xfs_trans_cancel(tp);
|
|
|
|
return error;
|
|
|
|
}
|