2018-06-06 02:42:14 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2005-11-02 03:58:39 +00:00
|
|
|
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#ifndef __XFS_LOG_PRIV_H__
|
|
|
|
#define __XFS_LOG_PRIV_H__
|
|
|
|
|
|
|
|
struct xfs_buf;
|
2012-06-14 14:22:15 +00:00
|
|
|
struct xlog;
|
2005-11-02 03:38:42 +00:00
|
|
|
struct xlog_ticket;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct xfs_mount;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get client id from packed copy.
|
|
|
|
*
|
|
|
|
* this hack is here because the xlog_pack code copies four bytes
|
|
|
|
* of xlog_op_header containing the fields oh_clientid, oh_flags
|
|
|
|
* and oh_res2 into the packed copy.
|
|
|
|
*
|
|
|
|
* later on this four byte chunk is treated as an int and the
|
|
|
|
* client id is pulled out.
|
|
|
|
*
|
|
|
|
* this has endian issues, of course.
|
|
|
|
*/
|
2007-10-12 00:59:34 +00:00
|
|
|
static inline uint xlog_get_client_id(__be32 i)
|
2007-10-12 00:58:05 +00:00
|
|
|
{
|
2007-10-12 00:59:34 +00:00
|
|
|
return be32_to_cpu(i) >> 24;
|
2007-10-12 00:58:05 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* In core log state
|
|
|
|
*/
|
2019-10-14 17:36:43 +00:00
|
|
|
enum xlog_iclog_state {
|
|
|
|
XLOG_STATE_ACTIVE, /* Current IC log being written to */
|
|
|
|
XLOG_STATE_WANT_SYNC, /* Want to sync this iclog; no more writes */
|
|
|
|
XLOG_STATE_SYNCING, /* This IC log is syncing */
|
|
|
|
XLOG_STATE_DONE_SYNC, /* Done syncing to disk */
|
|
|
|
XLOG_STATE_CALLBACK, /* Callback functions now */
|
|
|
|
XLOG_STATE_DIRTY, /* Dirty IC log, not ready for ACTIVE status */
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-06-18 18:57:05 +00:00
|
|
|
#define XLOG_STATE_STRINGS \
|
|
|
|
{ XLOG_STATE_ACTIVE, "XLOG_STATE_ACTIVE" }, \
|
|
|
|
{ XLOG_STATE_WANT_SYNC, "XLOG_STATE_WANT_SYNC" }, \
|
|
|
|
{ XLOG_STATE_SYNCING, "XLOG_STATE_SYNCING" }, \
|
|
|
|
{ XLOG_STATE_DONE_SYNC, "XLOG_STATE_DONE_SYNC" }, \
|
|
|
|
{ XLOG_STATE_CALLBACK, "XLOG_STATE_CALLBACK" }, \
|
2021-08-11 00:59:01 +00:00
|
|
|
{ XLOG_STATE_DIRTY, "XLOG_STATE_DIRTY" }
|
2021-06-18 18:57:05 +00:00
|
|
|
|
2021-07-27 23:23:50 +00:00
|
|
|
/*
|
|
|
|
* In core log flags
|
|
|
|
*/
|
|
|
|
#define XLOG_ICL_NEED_FLUSH (1 << 0) /* iclog needs REQ_PREFLUSH */
|
|
|
|
#define XLOG_ICL_NEED_FUA (1 << 1) /* iclog needs REQ_FUA */
|
|
|
|
|
|
|
|
#define XLOG_ICL_STRINGS \
|
|
|
|
{ XLOG_ICL_NEED_FLUSH, "XLOG_ICL_NEED_FLUSH" }, \
|
|
|
|
{ XLOG_ICL_NEED_FUA, "XLOG_ICL_NEED_FUA" }
|
|
|
|
|
2021-06-18 18:57:05 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2020-03-26 01:18:22 +00:00
|
|
|
* Log ticket flags
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-03-26 01:18:22 +00:00
|
|
|
#define XLOG_TIC_PERM_RESERV 0x1 /* permanent reservation */
|
2009-12-14 23:14:59 +00:00
|
|
|
|
|
|
|
#define XLOG_TIC_FLAGS \
|
2010-12-21 01:02:25 +00:00
|
|
|
{ XLOG_TIC_PERM_RESERV, "XLOG_TIC_PERM_RESERV" }
|
2009-12-14 23:14:59 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Below are states for covering allocation transactions.
|
|
|
|
* By covering, we mean changing the h_tail_lsn in the last on-disk
|
|
|
|
* log write such that no allocation transactions will be re-done during
|
|
|
|
* recovery after a system crash. Recovery starts at the last on-disk
|
|
|
|
* log write.
|
|
|
|
*
|
|
|
|
* These states are used to insert dummy log entries to cover
|
|
|
|
* space allocation transactions which can undo non-transactional changes
|
|
|
|
* after a crash. Writes to a file with space
|
|
|
|
* already allocated do not result in any transactions. Allocations
|
|
|
|
* might include space beyond the EOF. So if we just push the EOF a
|
|
|
|
* little, the last transaction for the file could contain the wrong
|
|
|
|
* size. If there is no file system activity, after an allocation
|
|
|
|
* transaction, and the system crashes, the allocation transaction
|
|
|
|
* will get replayed and the file will be truncated. This could
|
|
|
|
* be hours/days/... after the allocation occurred.
|
|
|
|
*
|
|
|
|
* The fix for this is to do two dummy transactions when the
|
|
|
|
* system is idle. We need two dummy transaction because the h_tail_lsn
|
|
|
|
* in the log record header needs to point beyond the last possible
|
|
|
|
* non-dummy transaction. The first dummy changes the h_tail_lsn to
|
|
|
|
* the first transaction before the dummy. The second dummy causes
|
|
|
|
* h_tail_lsn to point to the first dummy. Recovery starts at h_tail_lsn.
|
|
|
|
*
|
|
|
|
* These dummy transactions get committed when everything
|
|
|
|
* is idle (after there has been some activity).
|
|
|
|
*
|
|
|
|
* There are 5 states used to control this.
|
|
|
|
*
|
|
|
|
* IDLE -- no logging has been done on the file system or
|
|
|
|
* we are done covering previous transactions.
|
|
|
|
* NEED -- logging has occurred and we need a dummy transaction
|
|
|
|
* when the log becomes idle.
|
|
|
|
* DONE -- we were in the NEED state and have committed a dummy
|
|
|
|
* transaction.
|
|
|
|
* NEED2 -- we detected that a dummy transaction has gone to the
|
|
|
|
* on disk log with no other transactions.
|
|
|
|
* DONE2 -- we committed a dummy transaction when in the NEED2 state.
|
|
|
|
*
|
|
|
|
* There are two places where we switch states:
|
|
|
|
*
|
|
|
|
* 1.) In xfs_sync, when we detect an idle log and are in NEED or NEED2.
|
|
|
|
* We commit the dummy transaction and switch to DONE or DONE2,
|
|
|
|
* respectively. In all other states, we don't do anything.
|
|
|
|
*
|
|
|
|
* 2.) When we finish writing the on-disk log (xlog_state_clean_log).
|
|
|
|
*
|
|
|
|
* No matter what state we are in, if this isn't the dummy
|
|
|
|
* transaction going out, the next state is NEED.
|
|
|
|
* So, if we aren't in the DONE or DONE2 states, the next state
|
|
|
|
* is NEED. We can't be finishing a write of the dummy record
|
|
|
|
* unless it was committed and the state switched to DONE or DONE2.
|
|
|
|
*
|
|
|
|
* If we are in the DONE state and this was a write of the
|
|
|
|
* dummy transaction, we move to NEED2.
|
|
|
|
*
|
|
|
|
* If we are in the DONE2 state and this was a write of the
|
|
|
|
* dummy transaction, we move to IDLE.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Writing only one dummy transaction can get appended to
|
|
|
|
* one file space allocation. When this happens, the log recovery
|
|
|
|
* code replays the space allocation and a file could be truncated.
|
|
|
|
* This is why we have the NEED2 and DONE2 states before going idle.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define XLOG_STATE_COVER_IDLE 0
|
|
|
|
#define XLOG_STATE_COVER_NEED 1
|
|
|
|
#define XLOG_STATE_COVER_DONE 2
|
|
|
|
#define XLOG_STATE_COVER_NEED2 3
|
|
|
|
#define XLOG_STATE_COVER_DONE2 4
|
|
|
|
|
|
|
|
#define XLOG_COVER_OPS 5
|
|
|
|
|
2005-09-02 06:42:05 +00:00
|
|
|
/* Ticket reservation region accounting */
|
|
|
|
#define XLOG_TIC_LEN_MAX 15
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reservation region
|
|
|
|
* As would be stored in xfs_log_iovec but without the i_addr which
|
|
|
|
* we don't care about.
|
|
|
|
*/
|
|
|
|
typedef struct xlog_res {
|
2006-01-11 10:02:47 +00:00
|
|
|
uint r_len; /* region length :4 */
|
|
|
|
uint r_type; /* region's transaction type :4 */
|
2005-09-02 06:42:05 +00:00
|
|
|
} xlog_res_t;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
typedef struct xlog_ticket {
|
2010-12-21 01:02:25 +00:00
|
|
|
struct list_head t_queue; /* reserve/write queue */
|
2012-02-20 02:31:24 +00:00
|
|
|
struct task_struct *t_task; /* task that owns this ticket */
|
2005-09-02 06:42:05 +00:00
|
|
|
xlog_tid_t t_tid; /* transaction identifier : 4 */
|
2008-11-17 06:37:10 +00:00
|
|
|
atomic_t t_ref; /* ticket reference count : 4 */
|
2005-09-02 06:42:05 +00:00
|
|
|
int t_curr_res; /* current reservation in bytes : 4 */
|
|
|
|
int t_unit_res; /* unit reservation in bytes : 4 */
|
|
|
|
char t_ocnt; /* original count : 1 */
|
|
|
|
char t_cnt; /* current count : 1 */
|
|
|
|
char t_clientid; /* who does this belong to; : 1 */
|
|
|
|
char t_flags; /* properties of reservation : 1 */
|
|
|
|
|
|
|
|
/* reservation array fields */
|
|
|
|
uint t_res_num; /* num in array : 4 */
|
|
|
|
uint t_res_num_ophdrs; /* num op hdrs : 4 */
|
|
|
|
uint t_res_arr_sum; /* array sum : 4 */
|
|
|
|
uint t_res_o_flow; /* sum overflow : 4 */
|
2006-01-11 10:02:47 +00:00
|
|
|
xlog_res_t t_res_arr[XLOG_TIC_LEN_MAX]; /* array of res : 8 * 15 */
|
2005-04-16 22:20:36 +00:00
|
|
|
} xlog_ticket_t;
|
2005-09-02 06:42:05 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* - A log record header is 512 bytes. There is plenty of room to grow the
|
|
|
|
* xlog_rec_header_t into the reserved space.
|
|
|
|
* - ic_data follows, so a write to disk can start at the beginning of
|
|
|
|
* the iclog.
|
2008-08-13 06:34:31 +00:00
|
|
|
* - ic_forcewait is used to implement synchronous forcing of the iclog to disk.
|
2005-04-16 22:20:36 +00:00
|
|
|
* - ic_next is the pointer to the next iclog in the ring.
|
|
|
|
* - ic_log is a pointer back to the global log structure.
|
2019-06-29 02:27:25 +00:00
|
|
|
* - ic_size is the full size of the log buffer, minus the cycle headers.
|
2005-04-16 22:20:36 +00:00
|
|
|
* - ic_offset is the current number of bytes written to in this iclog.
|
|
|
|
* - ic_refcnt is bumped when someone is writing to the log.
|
|
|
|
* - ic_state is the state of the iclog.
|
2008-04-10 02:18:39 +00:00
|
|
|
*
|
|
|
|
* Because of cacheline contention on large machines, we need to separate
|
|
|
|
* various resources onto different cachelines. To start with, make the
|
|
|
|
* structure cacheline aligned. The following fields can be contended on
|
|
|
|
* by independent processes:
|
|
|
|
*
|
2019-06-29 02:27:34 +00:00
|
|
|
* - ic_callbacks
|
2008-04-10 02:18:39 +00:00
|
|
|
* - ic_refcnt
|
|
|
|
* - fields protected by the global l_icloglock
|
|
|
|
*
|
|
|
|
* so we need to ensure that these fields are located in separate cachelines.
|
|
|
|
* We'll put all the read-only and l_icloglock fields in the first cacheline,
|
|
|
|
* and move everything else out to subsequent cachelines.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-11-28 03:23:38 +00:00
|
|
|
typedef struct xlog_in_core {
|
2010-12-21 01:09:01 +00:00
|
|
|
wait_queue_head_t ic_force_wait;
|
|
|
|
wait_queue_head_t ic_write_wait;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct xlog_in_core *ic_next;
|
|
|
|
struct xlog_in_core *ic_prev;
|
2012-06-14 14:22:15 +00:00
|
|
|
struct xlog *ic_log;
|
2019-06-29 02:27:25 +00:00
|
|
|
u32 ic_size;
|
|
|
|
u32 ic_offset;
|
2019-10-14 17:36:43 +00:00
|
|
|
enum xlog_iclog_state ic_state;
|
xfs: journal IO cache flush reductions
Currently every journal IO is issued as REQ_PREFLUSH | REQ_FUA to
guarantee the ordering requirements the journal has w.r.t. metadata
writeback. THe two ordering constraints are:
1. we cannot overwrite metadata in the journal until we guarantee
that the dirty metadata has been written back in place and is
stable.
2. we cannot write back dirty metadata until it has been written to
the journal and guaranteed to be stable (and hence recoverable) in
the journal.
The ordering guarantees of #1 are provided by REQ_PREFLUSH. This
causes the journal IO to issue a cache flush and wait for it to
complete before issuing the write IO to the journal. Hence all
completed metadata IO is guaranteed to be stable before the journal
overwrites the old metadata.
The ordering guarantees of #2 are provided by the REQ_FUA, which
ensures the journal writes do not complete until they are on stable
storage. Hence by the time the last journal IO in a checkpoint
completes, we know that the entire checkpoint is on stable storage
and we can unpin the dirty metadata and allow it to be written back.
This is the mechanism by which ordering was first implemented in XFS
way back in 2002 by commit 95d97c36e5155075ba2eb22b17562cfcc53fcf96
("Add support for drive write cache flushing") in the xfs-archive
tree.
A lot has changed since then, most notably we now use delayed
logging to checkpoint the filesystem to the journal rather than
write each individual transaction to the journal. Cache flushes on
journal IO are necessary when individual transactions are wholly
contained within a single iclog. However, CIL checkpoints are single
transactions that typically span hundreds to thousands of individual
journal writes, and so the requirements for device cache flushing
have changed.
That is, the ordering rules I state above apply to ordering of
atomic transactions recorded in the journal, not to the journal IO
itself. Hence we need to ensure metadata is stable before we start
writing a new transaction to the journal (guarantee #1), and we need
to ensure the entire transaction is stable in the journal before we
start metadata writeback (guarantee #2).
Hence we only need a REQ_PREFLUSH on the journal IO that starts a
new journal transaction to provide #1, and it is not on any other
journal IO done within the context of that journal transaction.
The CIL checkpoint already issues a cache flush before it starts
writing to the log, so we no longer need the iclog IO to issue a
REQ_REFLUSH for us. Hence if XLOG_START_TRANS is passed
to xlog_write(), we no longer need to mark the first iclog in
the log write with REQ_PREFLUSH for this case. As an added bonus,
this ordering mechanism works for both internal and external logs,
meaning we can remove the explicit data device cache flushes from
the iclog write code when using external logs.
Given the new ordering semantics of commit records for the CIL, we
need iclogs containing commit records to issue a REQ_PREFLUSH. We
also require unmount records to do this. Hence for both
XLOG_COMMIT_TRANS and XLOG_UNMOUNT_TRANS xlog_write() calls we need
to mark the first iclog being written with REQ_PREFLUSH.
For both commit records and unmount records, we also want them
immediately on stable storage, so we want to also mark the iclogs
that contain these records to be marked REQ_FUA. That means if a
record is split across multiple iclogs, they are all marked REQ_FUA
and not just the last one so that when the transaction is completed
all the parts of the record are on stable storage.
And for external logs, unmount records need a pre-write data device
cache flush similar to the CIL checkpoint cache pre-flush as the
internal iclog write code does not do this implicitly anymore.
As an optimisation, when the commit record lands in the same iclog
as the journal transaction starts, we don't need to wait for
anything and can simply use REQ_FUA to provide guarantee #2. This
means that for fsync() heavy workloads, the cache flush behaviour is
completely unchanged and there is no degradation in performance as a
result of optimise the multi-IO transaction case.
The most notable sign that there is less IO latency on my test
machine (nvme SSDs) is that the "noiclogs" rate has dropped
substantially. This metric indicates that the CIL push is blocking
in xlog_get_iclog_space() waiting for iclog IO completion to occur.
With 8 iclogs of 256kB, the rate is appoximately 1 noiclog event to
every 4 iclog writes. IOWs, every 4th call to xlog_get_iclog_space()
is blocking waiting for log IO. With the changes in this patch, this
drops to 1 noiclog event for every 100 iclog writes. Hence it is
clear that log IO is completing much faster than it was previously,
but it is also clear that for large iclog sizes, this isn't the
performance limiting factor on this hardware.
With smaller iclogs (32kB), however, there is a substantial
difference. With the cache flush modifications, the journal is now
running at over 4000 write IOPS, and the journal throughput is
largely identical to the 256kB iclogs and the noiclog event rate
stays low at about 1:50 iclog writes. The existing code tops out at
about 2500 IOPS as the number of cache flushes dominate performance
and latency. The noiclog event rate is about 1:4, and the
performance variance is quite large as the journal throughput can
fall to less than half the peak sustained rate when the cache flush
rate prevents metadata writeback from keeping up and the log runs
out of space and throttles reservations.
As a result:
logbsize fsmark create rate rm -rf
before 32kb 152851+/-5.3e+04 5m28s
patched 32kb 221533+/-1.1e+04 5m24s
before 256kb 220239+/-6.2e+03 4m58s
patched 256kb 228286+/-9.2e+03 5m06s
The rm -rf times are included because I ran them, but the
differences are largely noise. This workload is largely metadata
read IO latency bound and the changes to the journal cache flushing
doesn't really make any noticable difference to behaviour apart from
a reduction in noiclog events from background CIL pushing.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.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-06-18 15:21:51 +00:00
|
|
|
unsigned int ic_flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
char *ic_datap; /* pointer to iclog data */
|
2019-06-29 02:27:34 +00:00
|
|
|
struct list_head ic_callbacks;
|
2008-04-10 02:18:39 +00:00
|
|
|
|
|
|
|
/* reference counts need their own cacheline */
|
|
|
|
atomic_t ic_refcnt ____cacheline_aligned_in_smp;
|
2008-11-28 03:23:38 +00:00
|
|
|
xlog_in_core_2_t *ic_data;
|
|
|
|
#define ic_header ic_data->hic_header
|
2019-06-29 02:27:21 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
bool ic_fail_crc : 1;
|
|
|
|
#endif
|
2019-06-29 02:27:25 +00:00
|
|
|
struct semaphore ic_sema;
|
|
|
|
struct work_struct ic_end_io_work;
|
|
|
|
struct bio ic_bio;
|
|
|
|
struct bio_vec ic_bvec[];
|
2005-04-16 22:20:36 +00:00
|
|
|
} xlog_in_core_t;
|
|
|
|
|
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 04:37:18 +00:00
|
|
|
/*
|
|
|
|
* The CIL context is used to aggregate per-transaction details as well be
|
|
|
|
* passed to the iclog for checkpoint post-commit processing. After being
|
|
|
|
* passed to the iclog, another context needs to be allocated for tracking the
|
|
|
|
* next set of transactions to be aggregated into a checkpoint.
|
|
|
|
*/
|
|
|
|
struct xfs_cil;
|
|
|
|
|
|
|
|
struct xfs_cil_ctx {
|
|
|
|
struct xfs_cil *cil;
|
2021-06-18 15:21:52 +00:00
|
|
|
xfs_csn_t sequence; /* chkpt sequence # */
|
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 04:37:18 +00:00
|
|
|
xfs_lsn_t start_lsn; /* first LSN of chkpt commit */
|
|
|
|
xfs_lsn_t commit_lsn; /* chkpt commit record lsn */
|
2021-08-11 01:00:43 +00:00
|
|
|
struct xlog_in_core *commit_iclog;
|
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 04:37:18 +00:00
|
|
|
struct xlog_ticket *ticket; /* chkpt ticket */
|
|
|
|
int nvecs; /* number of regions */
|
|
|
|
int space_used; /* aggregate size of regions */
|
|
|
|
struct list_head busy_extents; /* busy extents in chkpt */
|
|
|
|
struct xfs_log_vec *lv_chain; /* logvecs being pushed */
|
2019-06-29 02:27:34 +00:00
|
|
|
struct list_head iclog_entry;
|
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 04:37:18 +00:00
|
|
|
struct list_head committing; /* ctx committing list */
|
2017-02-07 22:07:58 +00:00
|
|
|
struct work_struct discard_endio_work;
|
xfs: CIL work is serialised, not pipelined
Because we use a single work structure attached to the CIL rather
than the CIL context, we can only queue a single work item at a
time. This results in the CIL being single threaded and limits
performance when it becomes CPU bound.
The design of the CIL is that it is pipelined and multiple commits
can be running concurrently, but the way the work is currently
implemented means that it is not pipelining as it was intended. The
critical work to switch the CIL context can take a few milliseconds
to run, but the rest of the CIL context flush can take hundreds of
milliseconds to complete. The context switching is the serialisation
point of the CIL, once the context has been switched the rest of the
context push can run asynchrnously with all other context pushes.
Hence we can move the work to the CIL context so that we can run
multiple CIL pushes at the same time and spread the majority of
the work out over multiple CPUs. We can keep the per-cpu CIL commit
state on the CIL rather than the context, because the context is
pinned to the CIL until the switch is done and we aggregate and
drain the per-cpu state held on the CIL during the context switch.
However, because we no longer serialise the CIL work, we can have
effectively unlimited CIL pushes in progress. We don't want to do
this - not only does it create contention on the iclogs and the
state machine locks, we can run the log right out of space with
outstanding pushes. Instead, limit the work concurrency to 4
concurrent works being processed at a time. This is enough
concurrency to remove the CIL from being a CPU bound bottleneck but
not enough to create new contention points or unbound concurrency
issues.
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>
2021-08-11 01:00:45 +00:00
|
|
|
struct work_struct push_work;
|
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 04:37:18 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Committed Item List structure
|
|
|
|
*
|
|
|
|
* This structure is used to track log items that have been committed but not
|
|
|
|
* yet written into the log. It is used only when the delayed logging mount
|
|
|
|
* option is enabled.
|
|
|
|
*
|
|
|
|
* This structure tracks the list of committing checkpoint contexts so
|
|
|
|
* we can avoid the problem of having to hold out new transactions during a
|
|
|
|
* flush until we have a the commit record LSN of the checkpoint. We can
|
|
|
|
* traverse the list of committing contexts in xlog_cil_push_lsn() to find a
|
|
|
|
* sequence match and extract the commit LSN directly from there. If the
|
|
|
|
* checkpoint is still in the process of committing, we can block waiting for
|
|
|
|
* the commit LSN to be determined as well. This should make synchronous
|
|
|
|
* operations almost as efficient as the old logging methods.
|
|
|
|
*/
|
|
|
|
struct xfs_cil {
|
2012-06-14 14:22:15 +00:00
|
|
|
struct xlog *xc_log;
|
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 04:37:18 +00:00
|
|
|
struct list_head xc_cil;
|
|
|
|
spinlock_t xc_cil_lock;
|
2021-08-11 01:00:45 +00:00
|
|
|
struct workqueue_struct *xc_push_wq;
|
2013-08-12 10:50:08 +00:00
|
|
|
|
|
|
|
struct rw_semaphore xc_ctx_lock ____cacheline_aligned_in_smp;
|
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 04:37:18 +00:00
|
|
|
struct xfs_cil_ctx *xc_ctx;
|
2013-08-12 10:50:08 +00:00
|
|
|
|
|
|
|
spinlock_t xc_push_lock ____cacheline_aligned_in_smp;
|
2021-06-18 15:21:52 +00:00
|
|
|
xfs_csn_t xc_push_seq;
|
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 01:00:44 +00:00
|
|
|
bool xc_push_commit_stable;
|
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 04:37:18 +00:00
|
|
|
struct list_head xc_committing;
|
2010-12-21 01:09:01 +00:00
|
|
|
wait_queue_head_t xc_commit_wait;
|
2021-08-11 01:00:44 +00:00
|
|
|
wait_queue_head_t xc_start_wait;
|
2021-06-18 15:21:52 +00:00
|
|
|
xfs_csn_t xc_current_sequence;
|
2020-06-16 15:57:43 +00:00
|
|
|
wait_queue_head_t xc_push_wait; /* background push throttle */
|
2013-08-12 10:50:08 +00:00
|
|
|
} ____cacheline_aligned_in_smp;
|
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 04:37:18 +00:00
|
|
|
|
2010-05-17 05:52:13 +00:00
|
|
|
/*
|
xfs: force background CIL push under sustained load
I have been seeing occasional pauses in transaction throughput up to
30s long under heavy parallel workloads. The only notable thing was
that the xfsaild was trying to be active during the pauses, but
making no progress. It was running exactly 20 times a second (on the
50ms no-progress backoff), and the number of pushbuf events was
constant across this time as well. IOWs, the xfsaild appeared to be
stuck on buffers that it could not push out.
Further investigation indicated that it was trying to push out inode
buffers that were pinned and/or locked. The xfsbufd was also getting
woken at the same frequency (by the xfsaild, no doubt) to push out
delayed write buffers. The xfsbufd was not making any progress
because all the buffers in the delwri queue were pinned. This scan-
and-make-no-progress dance went one in the trace for some seconds,
before the xfssyncd came along an issued a log force, and then
things started going again.
However, I noticed something strange about the log force - there
were way too many IO's issued. 516 log buffers were written, to be
exact. That added up to 129MB of log IO, which got me very
interested because it's almost exactly 25% of the size of the log.
He delayed logging code is suppose to aggregate the minimum of 25%
of the log or 8MB worth of changes before flushing. That's what
really puzzled me - why did a log force write 129MB instead of only
8MB?
Essentially what has happened is that no CIL pushes had occurred
since the previous tail push which cleared out 25% of the log space.
That caused all the new transactions to block because there wasn't
log space for them, but they kick the xfsaild to push the tail.
However, the xfsaild was not making progress because there were
buffers it could not lock and flush, and the xfsbufd could not flush
them because they were pinned. As a result, both the xfsaild and the
xfsbufd could not move the tail of the log forward without the CIL
first committing.
The cause of the problem was that the background CIL push, which
should happen when 8MB of aggregated changes have been committed, is
being held off by the concurrent transaction commit load. The
background push does a down_write_trylock() which will fail if there
is a concurrent transaction commit holding the push lock in read
mode. With 8 CPUs all doing transactions as fast as they can, there
was enough concurrent transaction commits to hold off the background
push until tail-pushing could no longer free log space, and the halt
would occur.
It should be noted that there is no reason why it would halt at 25%
of log space used by a single CIL checkpoint. This bug could
definitely violate the "no transaction should be larger than half
the log" requirement and hence result in corruption if the system
crashed under heavy load. This sort of bug is exactly the reason why
delayed logging was tagged as experimental....
The fix is to start blocking background pushes once the threshold
has been exceeded. Rework the threshold calculations to keep the
amount of log space a CIL checkpoint can use to below that of the
AIL push threshold to avoid the problem completely.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Alex Elder <aelder@sgi.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-09-24 08:13:44 +00:00
|
|
|
* The amount of log space we allow the CIL to aggregate is difficult to size.
|
|
|
|
* Whatever we choose, we have to make sure we can get a reservation for the
|
|
|
|
* log space effectively, that it is large enough to capture sufficient
|
|
|
|
* relogging to reduce log buffer IO significantly, but it is not too large for
|
|
|
|
* the log or induces too much latency when writing out through the iclogs. We
|
|
|
|
* track both space consumed and the number of vectors in the checkpoint
|
|
|
|
* context, so we need to decide which to use for limiting.
|
2010-05-17 05:52:13 +00:00
|
|
|
*
|
|
|
|
* Every log buffer we write out during a push needs a header reserved, which
|
|
|
|
* is at least one sector and more for v2 logs. Hence we need a reservation of
|
|
|
|
* at least 512 bytes per 32k of log space just for the LR headers. That means
|
|
|
|
* 16KB of reservation per megabyte of delayed logging space we will consume,
|
|
|
|
* plus various headers. The number of headers will vary based on the num of
|
|
|
|
* io vectors, so limiting on a specific number of vectors is going to result
|
|
|
|
* in transactions of varying size. IOWs, it is more consistent to track and
|
|
|
|
* limit space consumed in the log rather than by the number of objects being
|
|
|
|
* logged in order to prevent checkpoint ticket overruns.
|
|
|
|
*
|
|
|
|
* Further, use of static reservations through the log grant mechanism is
|
|
|
|
* problematic. It introduces a lot of complexity (e.g. reserve grant vs write
|
|
|
|
* grant) and a significant deadlock potential because regranting write space
|
|
|
|
* can block on log pushes. Hence if we have to regrant log space during a log
|
|
|
|
* push, we can deadlock.
|
|
|
|
*
|
|
|
|
* However, we can avoid this by use of a dynamic "reservation stealing"
|
|
|
|
* technique during transaction commit whereby unused reservation space in the
|
|
|
|
* transaction ticket is transferred to the CIL ctx commit ticket to cover the
|
|
|
|
* space needed by the checkpoint transaction. This means that we never need to
|
|
|
|
* specifically reserve space for the CIL checkpoint transaction, nor do we
|
|
|
|
* need to regrant space once the checkpoint completes. This also means the
|
|
|
|
* checkpoint transaction ticket is specific to the checkpoint context, rather
|
|
|
|
* than the CIL itself.
|
|
|
|
*
|
xfs: force background CIL push under sustained load
I have been seeing occasional pauses in transaction throughput up to
30s long under heavy parallel workloads. The only notable thing was
that the xfsaild was trying to be active during the pauses, but
making no progress. It was running exactly 20 times a second (on the
50ms no-progress backoff), and the number of pushbuf events was
constant across this time as well. IOWs, the xfsaild appeared to be
stuck on buffers that it could not push out.
Further investigation indicated that it was trying to push out inode
buffers that were pinned and/or locked. The xfsbufd was also getting
woken at the same frequency (by the xfsaild, no doubt) to push out
delayed write buffers. The xfsbufd was not making any progress
because all the buffers in the delwri queue were pinned. This scan-
and-make-no-progress dance went one in the trace for some seconds,
before the xfssyncd came along an issued a log force, and then
things started going again.
However, I noticed something strange about the log force - there
were way too many IO's issued. 516 log buffers were written, to be
exact. That added up to 129MB of log IO, which got me very
interested because it's almost exactly 25% of the size of the log.
He delayed logging code is suppose to aggregate the minimum of 25%
of the log or 8MB worth of changes before flushing. That's what
really puzzled me - why did a log force write 129MB instead of only
8MB?
Essentially what has happened is that no CIL pushes had occurred
since the previous tail push which cleared out 25% of the log space.
That caused all the new transactions to block because there wasn't
log space for them, but they kick the xfsaild to push the tail.
However, the xfsaild was not making progress because there were
buffers it could not lock and flush, and the xfsbufd could not flush
them because they were pinned. As a result, both the xfsaild and the
xfsbufd could not move the tail of the log forward without the CIL
first committing.
The cause of the problem was that the background CIL push, which
should happen when 8MB of aggregated changes have been committed, is
being held off by the concurrent transaction commit load. The
background push does a down_write_trylock() which will fail if there
is a concurrent transaction commit holding the push lock in read
mode. With 8 CPUs all doing transactions as fast as they can, there
was enough concurrent transaction commits to hold off the background
push until tail-pushing could no longer free log space, and the halt
would occur.
It should be noted that there is no reason why it would halt at 25%
of log space used by a single CIL checkpoint. This bug could
definitely violate the "no transaction should be larger than half
the log" requirement and hence result in corruption if the system
crashed under heavy load. This sort of bug is exactly the reason why
delayed logging was tagged as experimental....
The fix is to start blocking background pushes once the threshold
has been exceeded. Rework the threshold calculations to keep the
amount of log space a CIL checkpoint can use to below that of the
AIL push threshold to avoid the problem completely.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Alex Elder <aelder@sgi.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
2010-09-24 08:13:44 +00:00
|
|
|
* With dynamic reservations, we can effectively make up arbitrary limits for
|
|
|
|
* the checkpoint size so long as they don't violate any other size rules.
|
|
|
|
* Recovery imposes a rule that no transaction exceed half the log, so we are
|
|
|
|
* limited by that. Furthermore, the log transaction reservation subsystem
|
|
|
|
* tries to keep 25% of the log free, so we need to keep below that limit or we
|
|
|
|
* risk running out of free log space to start any new transactions.
|
|
|
|
*
|
2020-03-25 03:10:26 +00:00
|
|
|
* In order to keep background CIL push efficient, we only need to ensure the
|
|
|
|
* CIL is large enough to maintain sufficient in-memory relogging to avoid
|
|
|
|
* repeated physical writes of frequently modified metadata. If we allow the CIL
|
|
|
|
* to grow to a substantial fraction of the log, then we may be pinning hundreds
|
|
|
|
* of megabytes of metadata in memory until the CIL flushes. This can cause
|
|
|
|
* issues when we are running low on memory - pinned memory cannot be reclaimed,
|
|
|
|
* and the CIL consumes a lot of memory. Hence we need to set an upper physical
|
|
|
|
* size limit for the CIL that limits the maximum amount of memory pinned by the
|
|
|
|
* CIL but does not limit performance by reducing relogging efficiency
|
|
|
|
* significantly.
|
|
|
|
*
|
|
|
|
* As such, the CIL push threshold ends up being the smaller of two thresholds:
|
|
|
|
* - a threshold large enough that it allows CIL to be pushed and progress to be
|
|
|
|
* made without excessive blocking of incoming transaction commits. This is
|
|
|
|
* defined to be 12.5% of the log space - half the 25% push threshold of the
|
|
|
|
* AIL.
|
|
|
|
* - small enough that it doesn't pin excessive amounts of memory but maintains
|
|
|
|
* close to peak relogging efficiency. This is defined to be 16x the iclog
|
|
|
|
* buffer window (32MB) as measurements have shown this to be roughly the
|
|
|
|
* point of diminishing performance increases under highly concurrent
|
|
|
|
* modification workloads.
|
2020-03-25 03:10:27 +00:00
|
|
|
*
|
|
|
|
* To prevent the CIL from overflowing upper commit size bounds, we introduce a
|
|
|
|
* new threshold at which we block committing transactions until the background
|
|
|
|
* CIL commit commences and switches to a new context. While this is not a hard
|
|
|
|
* limit, it forces the process committing a transaction to the CIL to block and
|
|
|
|
* yeild the CPU, giving the CIL push work a chance to be scheduled and start
|
|
|
|
* work. This prevents a process running lots of transactions from overfilling
|
|
|
|
* the CIL because it is not yielding the CPU. We set the blocking limit at
|
|
|
|
* twice the background push space threshold so we keep in line with the AIL
|
|
|
|
* push thresholds.
|
|
|
|
*
|
|
|
|
* Note: this is not a -hard- limit as blocking is applied after the transaction
|
|
|
|
* is inserted into the CIL and the push has been triggered. It is largely a
|
|
|
|
* throttling mechanism that allows the CIL push to be scheduled and run. A hard
|
|
|
|
* limit will be difficult to implement without introducing global serialisation
|
|
|
|
* in the CIL commit fast path, and it's not at all clear that we actually need
|
|
|
|
* such hard limits given the ~7 years we've run without a hard limit before
|
|
|
|
* finding the first situation where a checkpoint size overflow actually
|
|
|
|
* occurred. Hence the simple throttle, and an ASSERT check to tell us that
|
|
|
|
* we've overrun the max size.
|
2010-05-17 05:52:13 +00:00
|
|
|
*/
|
2020-03-25 03:10:26 +00:00
|
|
|
#define XLOG_CIL_SPACE_LIMIT(log) \
|
|
|
|
min_t(int, (log)->l_logsize >> 3, BBTOB(XLOG_TOTAL_REC_SHIFT(log)) << 4)
|
2010-05-17 05:52:13 +00:00
|
|
|
|
2020-03-25 03:10:27 +00:00
|
|
|
#define XLOG_CIL_BLOCKING_SPACE_LIMIT(log) \
|
|
|
|
(XLOG_CIL_SPACE_LIMIT(log) * 2)
|
|
|
|
|
2012-02-20 02:31:25 +00:00
|
|
|
/*
|
|
|
|
* ticket grant locks, queues and accounting have their own cachlines
|
|
|
|
* as these are quite hot and can be operated on concurrently.
|
|
|
|
*/
|
|
|
|
struct xlog_grant_head {
|
|
|
|
spinlock_t lock ____cacheline_aligned_in_smp;
|
|
|
|
struct list_head waiters;
|
|
|
|
atomic64_t grant;
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The reservation head lsn is not made up of a cycle number and block number.
|
|
|
|
* Instead, it uses a cycle number and byte number. Logs don't expect to
|
|
|
|
* overflow 31 bits worth of byte offset, so using a byte number will mean
|
|
|
|
* that round off problems won't occur when releasing partial reservations.
|
|
|
|
*/
|
2012-06-14 14:22:16 +00:00
|
|
|
struct xlog {
|
2008-04-10 02:18:54 +00:00
|
|
|
/* The following fields don't need locking */
|
|
|
|
struct xfs_mount *l_mp; /* mount point */
|
2008-10-30 06:39:35 +00:00
|
|
|
struct xfs_ail *l_ailp; /* AIL log is working with */
|
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 04:37:18 +00:00
|
|
|
struct xfs_cil *l_cilp; /* CIL log is working with */
|
2008-04-10 02:18:54 +00:00
|
|
|
struct xfs_buftarg *l_targ; /* buftarg of log */
|
2019-06-29 02:27:25 +00:00
|
|
|
struct workqueue_struct *l_ioend_workqueue; /* for I/O completions */
|
2012-10-08 10:56:02 +00:00
|
|
|
struct delayed_work l_work; /* background flush work */
|
2021-08-11 00:59:02 +00:00
|
|
|
long l_opstate; /* operational state */
|
2008-04-10 02:18:54 +00:00
|
|
|
uint l_quotaoffs_flag; /* XFS_DQ_*, for QUOTAOFFs */
|
2010-12-01 22:06:22 +00:00
|
|
|
struct list_head *l_buf_cancel_table;
|
2008-04-10 02:18:54 +00:00
|
|
|
int l_iclog_hsize; /* size of iclog header */
|
|
|
|
int l_iclog_heads; /* # of iclog header sectors */
|
2010-04-20 07:10:21 +00:00
|
|
|
uint l_sectBBsize; /* sector size in BBs (2^n) */
|
2008-04-10 02:18:54 +00:00
|
|
|
int l_iclog_size; /* size of log in bytes */
|
|
|
|
int l_iclog_bufs; /* number of iclog buffers */
|
|
|
|
xfs_daddr_t l_logBBstart; /* start block of log */
|
|
|
|
int l_logsize; /* size of log in bytes */
|
|
|
|
int l_logBBsize; /* size of log in BB chunks */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* The following block of fields are changed while holding icloglock */
|
2010-12-21 01:09:01 +00:00
|
|
|
wait_queue_head_t l_flush_wait ____cacheline_aligned_in_smp;
|
2008-05-19 06:34:27 +00:00
|
|
|
/* waiting for iclog flush */
|
2005-04-16 22:20:36 +00:00
|
|
|
int l_covered_state;/* state of "covering disk
|
|
|
|
* log entries" */
|
|
|
|
xlog_in_core_t *l_iclog; /* head log queue */
|
2007-10-11 07:37:10 +00:00
|
|
|
spinlock_t l_icloglock; /* grab to change iclog state */
|
2005-04-16 22:20:36 +00:00
|
|
|
int l_curr_cycle; /* Cycle number of log writes */
|
|
|
|
int l_prev_cycle; /* Cycle number before last
|
|
|
|
* block increment */
|
|
|
|
int l_curr_block; /* current logical log block */
|
|
|
|
int l_prev_block; /* previous logical log block */
|
|
|
|
|
2010-12-03 11:11:29 +00:00
|
|
|
/*
|
2010-12-21 01:28:39 +00:00
|
|
|
* l_last_sync_lsn and l_tail_lsn are atomics so they can be set and
|
|
|
|
* read without needing to hold specific locks. To avoid operations
|
|
|
|
* contending with other hot objects, place each of them on a separate
|
|
|
|
* cacheline.
|
2010-12-03 11:11:29 +00:00
|
|
|
*/
|
|
|
|
/* lsn of last LR on disk */
|
|
|
|
atomic64_t l_last_sync_lsn ____cacheline_aligned_in_smp;
|
2010-12-21 01:28:39 +00:00
|
|
|
/* lsn of 1st LR with unflushed * buffers */
|
|
|
|
atomic64_t l_tail_lsn ____cacheline_aligned_in_smp;
|
2010-12-03 11:11:29 +00:00
|
|
|
|
2012-02-20 02:31:25 +00:00
|
|
|
struct xlog_grant_head l_reserve_head;
|
|
|
|
struct xlog_grant_head l_write_head;
|
2010-12-21 01:29:01 +00:00
|
|
|
|
2014-07-14 22:07:29 +00:00
|
|
|
struct xfs_kobj l_kobj;
|
|
|
|
|
2008-04-10 02:18:54 +00:00
|
|
|
/* The following field are used for debugging; need to hold icloglock */
|
|
|
|
#ifdef DEBUG
|
2015-06-21 23:44:47 +00:00
|
|
|
void *l_iclog_bak[XLOG_MAX_ICLOGS];
|
2008-04-10 02:18:54 +00:00
|
|
|
#endif
|
2016-09-25 22:22:16 +00:00
|
|
|
/* log recovery lsn tracking (for buffer submission */
|
|
|
|
xfs_lsn_t l_recovery_lsn;
|
2021-06-18 15:21:48 +00:00
|
|
|
|
|
|
|
uint32_t l_iclog_roundoff;/* padding roundoff */
|
2021-08-08 15:27:12 +00:00
|
|
|
|
|
|
|
/* Users of log incompat features should take a read lock. */
|
|
|
|
struct rw_semaphore l_incompat_users;
|
2012-06-14 14:22:16 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-12-01 22:06:22 +00:00
|
|
|
#define XLOG_BUF_CANCEL_BUCKET(log, blkno) \
|
2017-06-16 18:00:05 +00:00
|
|
|
((log)->l_buf_cancel_table + ((uint64_t)blkno % XLOG_BC_TABLE_SIZE))
|
2010-12-01 22:06:22 +00:00
|
|
|
|
2021-08-11 00:59:02 +00:00
|
|
|
/*
|
|
|
|
* Bits for operational state
|
|
|
|
*/
|
|
|
|
#define XLOG_ACTIVE_RECOVERY 0 /* in the middle of recovery */
|
|
|
|
#define XLOG_RECOVERY_NEEDED 1 /* log was recovered */
|
|
|
|
#define XLOG_IO_ERROR 2 /* log hit an I/O error, and being
|
|
|
|
shutdown */
|
|
|
|
#define XLOG_TAIL_WARN 3 /* log tail verify warning issued */
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
xlog_recovery_needed(struct xlog *log)
|
|
|
|
{
|
|
|
|
return test_bit(XLOG_RECOVERY_NEEDED, &log->l_opstate);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
xlog_in_recovery(struct xlog *log)
|
|
|
|
{
|
|
|
|
return test_bit(XLOG_ACTIVE_RECOVERY, &log->l_opstate);
|
|
|
|
}
|
|
|
|
|
2021-08-11 00:59:01 +00:00
|
|
|
static inline bool
|
|
|
|
xlog_is_shutdown(struct xlog *log)
|
|
|
|
{
|
2021-08-11 00:59:02 +00:00
|
|
|
return test_bit(XLOG_IO_ERROR, &log->l_opstate);
|
2021-08-11 00:59:01 +00:00
|
|
|
}
|
2005-11-02 04:12:04 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* common routines */
|
2012-06-14 14:22:16 +00:00
|
|
|
extern int
|
|
|
|
xlog_recover(
|
|
|
|
struct xlog *log);
|
|
|
|
extern int
|
|
|
|
xlog_recover_finish(
|
|
|
|
struct xlog *log);
|
2019-07-03 14:34:18 +00:00
|
|
|
extern void
|
2015-08-18 23:58:36 +00:00
|
|
|
xlog_recover_cancel(struct xlog *);
|
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 11:54:24 +00:00
|
|
|
|
2012-11-28 02:01:03 +00:00
|
|
|
extern __le32 xlog_cksum(struct xlog *log, struct xlog_rec_header *rhead,
|
xfs: add CRC checks to the log
Implement CRCs for the log buffers. We re-use a field in
struct xlog_rec_header that was used for a weak checksum of the
log buffer payload in debug builds before.
The new checksumming uses the crc32c checksum we will use elsewhere
in XFS, and also protects the record header and addition cycle data.
Due to this there are some interesting changes in xlog_sync, as we
need to do the cycle wrapping for the split buffer case much earlier,
as we would touch the buffer after generating the checksum otherwise.
The CRC calculation is always enabled, even for non-CRC filesystems,
as adding this CRC does not change the log format. On non-CRC
filesystems, only issue an alert if a CRC mismatch is found and
allow recovery to continue - this will act as an indicator that
log recovery problems are a result of log corruption. On CRC enabled
filesystems, however, log recovery will fail.
Note that existing debug kernels will write a simple checksum value
to the log, so the first time this is run on a filesystem taht was
last used on a debug kernel it will through CRC mismatch warning
errors. These can be ignored.
Initially based on a patch from Dave Chinner, then modified
significantly by Christoph Hellwig. Modified again by Dave Chinner
to get to this version.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-11-12 11:54:24 +00:00
|
|
|
char *dp, int size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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 04:37:18 +00:00
|
|
|
extern kmem_zone_t *xfs_log_ticket_zone;
|
2012-06-14 14:22:15 +00:00
|
|
|
struct xlog_ticket *
|
|
|
|
xlog_ticket_alloc(
|
|
|
|
struct xlog *log,
|
|
|
|
int unit_bytes,
|
|
|
|
int count,
|
|
|
|
char client,
|
2020-07-22 16:23:17 +00:00
|
|
|
bool permanent);
|
2008-04-10 02:18:46 +00:00
|
|
|
|
2010-03-23 00:47:38 +00:00
|
|
|
static inline void
|
|
|
|
xlog_write_adv_cnt(void **ptr, int *len, int *off, size_t bytes)
|
|
|
|
{
|
|
|
|
*ptr += bytes;
|
|
|
|
*len -= bytes;
|
|
|
|
*off += bytes;
|
|
|
|
}
|
|
|
|
|
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 04:37:18 +00:00
|
|
|
void xlog_print_tic_res(struct xfs_mount *mp, struct xlog_ticket *ticket);
|
2017-06-15 04:29:50 +00:00
|
|
|
void xlog_print_trans(struct xfs_trans *);
|
2021-08-11 01:00:42 +00:00
|
|
|
int xlog_write(struct xlog *log, struct xfs_cil_ctx *ctx,
|
|
|
|
struct xfs_log_vec *log_vector, struct xlog_ticket *tic,
|
2021-08-11 01:00:43 +00:00
|
|
|
uint optype);
|
2020-03-26 01:18:23 +00:00
|
|
|
void xfs_log_ticket_ungrant(struct xlog *log, struct xlog_ticket *ticket);
|
|
|
|
void xfs_log_ticket_regrant(struct xlog *log, struct xlog_ticket *ticket);
|
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 04:37:18 +00:00
|
|
|
|
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 01:00:44 +00:00
|
|
|
void xlog_state_switch_iclogs(struct xlog *log, struct xlog_in_core *iclog,
|
|
|
|
int eventual_size);
|
xfs: fix ordering violation between cache flushes and tail updates
There is a race between the new CIL async data device metadata IO
completion cache flush and the log tail in the iclog the flush
covers being updated. This can be seen by repeating generic/482 in a
loop and eventually log recovery fails with a failures such as this:
XFS (dm-3): Starting recovery (logdev: internal)
XFS (dm-3): bad inode magic/vsn daddr 228352 #0 (magic=0)
XFS (dm-3): Metadata corruption detected at xfs_inode_buf_verify+0x180/0x190, xfs_inode block 0x37c00 xfs_inode_buf_verify
XFS (dm-3): Unmount and run xfs_repair
XFS (dm-3): First 128 bytes of corrupted metadata buffer:
00000000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000040: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
00000070: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
XFS (dm-3): metadata I/O error in "xlog_recover_items_pass2+0x55/0xc0" at daddr 0x37c00 len 32 error 117
Analysis of the logwrite replay shows that there were no writes to
the data device between the FUA @ write 124 and the FUA at write @
125, but log recovery @ 125 failed. The difference was the one log
write @ 125 moved the tail of the log forwards from (1,8) to (1,32)
and so the inode create intent in (1,8) was not replayed and so the
inode cluster was zero on disk when replay of the first inode item
in (1,32) was attempted.
What this meant was that the journal write that occurred at @ 125
did not ensure that metadata completed before the iclog was written
was correctly on stable storage. The tail of the log moved forward,
so IO must have been completed between the two iclog writes. This
means that there is a race condition between the unconditional async
cache flush in the CIL push work and the tail LSN that is written to
the iclog. This happens like so:
CIL push work AIL push work
------------- -------------
Add to committing list
start async data dev cache flush
.....
<flush completes>
<all writes to old tail lsn are stable>
xlog_write
.... push inode create buffer
<start IO>
.....
xlog_write(commit record)
.... <IO completes>
log tail moves
xlog_assign_tail_lsn()
start_lsn == commit_lsn
<no iclog preflush!>
xlog_state_release_iclog
__xlog_state_release_iclog()
<writes *new* tail_lsn into iclog>
xlog_sync()
....
submit_bio()
<tail in log moves forward without flushing written metadata>
Essentially, this can only occur if the commit iclog is issued
without a cache flush. If the iclog bio is submitted with
REQ_PREFLUSH, then it will guarantee that all the completed IO is
one stable storage before the iclog bio with the new tail LSN in it
is written to the log.
IOWs, the tail lsn that is written to the iclog needs to be sampled
*before* we issue the cache flush that guarantees all IO up to that
LSN has been completed.
To fix this without giving up the performance advantage of the
flush/FUA optimisations (e.g. g/482 runtime halves with 5.14-rc1
compared to 5.13), we need to ensure that we always issue a cache
flush if the tail LSN changes between the initial async flush and
the commit record being written. THis requires sampling the tail_lsn
before we start the flush, and then passing the sampled tail LSN to
xlog_state_release_iclog() so it can determine if the the tail LSN
has changed while writing the checkpoint. If the tail LSN has
changed, then it needs to set the NEED_FLUSH flag on the iclog and
we'll issue another cache flush before writing the iclog.
Fixes: eef983ffeae7 ("xfs: journal IO cache flush reductions")
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
2021-07-27 23:23:48 +00:00
|
|
|
int xlog_state_release_iclog(struct xlog *log, struct xlog_in_core *iclog,
|
|
|
|
xfs_lsn_t log_tail_lsn);
|
xfs: journal IO cache flush reductions
Currently every journal IO is issued as REQ_PREFLUSH | REQ_FUA to
guarantee the ordering requirements the journal has w.r.t. metadata
writeback. THe two ordering constraints are:
1. we cannot overwrite metadata in the journal until we guarantee
that the dirty metadata has been written back in place and is
stable.
2. we cannot write back dirty metadata until it has been written to
the journal and guaranteed to be stable (and hence recoverable) in
the journal.
The ordering guarantees of #1 are provided by REQ_PREFLUSH. This
causes the journal IO to issue a cache flush and wait for it to
complete before issuing the write IO to the journal. Hence all
completed metadata IO is guaranteed to be stable before the journal
overwrites the old metadata.
The ordering guarantees of #2 are provided by the REQ_FUA, which
ensures the journal writes do not complete until they are on stable
storage. Hence by the time the last journal IO in a checkpoint
completes, we know that the entire checkpoint is on stable storage
and we can unpin the dirty metadata and allow it to be written back.
This is the mechanism by which ordering was first implemented in XFS
way back in 2002 by commit 95d97c36e5155075ba2eb22b17562cfcc53fcf96
("Add support for drive write cache flushing") in the xfs-archive
tree.
A lot has changed since then, most notably we now use delayed
logging to checkpoint the filesystem to the journal rather than
write each individual transaction to the journal. Cache flushes on
journal IO are necessary when individual transactions are wholly
contained within a single iclog. However, CIL checkpoints are single
transactions that typically span hundreds to thousands of individual
journal writes, and so the requirements for device cache flushing
have changed.
That is, the ordering rules I state above apply to ordering of
atomic transactions recorded in the journal, not to the journal IO
itself. Hence we need to ensure metadata is stable before we start
writing a new transaction to the journal (guarantee #1), and we need
to ensure the entire transaction is stable in the journal before we
start metadata writeback (guarantee #2).
Hence we only need a REQ_PREFLUSH on the journal IO that starts a
new journal transaction to provide #1, and it is not on any other
journal IO done within the context of that journal transaction.
The CIL checkpoint already issues a cache flush before it starts
writing to the log, so we no longer need the iclog IO to issue a
REQ_REFLUSH for us. Hence if XLOG_START_TRANS is passed
to xlog_write(), we no longer need to mark the first iclog in
the log write with REQ_PREFLUSH for this case. As an added bonus,
this ordering mechanism works for both internal and external logs,
meaning we can remove the explicit data device cache flushes from
the iclog write code when using external logs.
Given the new ordering semantics of commit records for the CIL, we
need iclogs containing commit records to issue a REQ_PREFLUSH. We
also require unmount records to do this. Hence for both
XLOG_COMMIT_TRANS and XLOG_UNMOUNT_TRANS xlog_write() calls we need
to mark the first iclog being written with REQ_PREFLUSH.
For both commit records and unmount records, we also want them
immediately on stable storage, so we want to also mark the iclogs
that contain these records to be marked REQ_FUA. That means if a
record is split across multiple iclogs, they are all marked REQ_FUA
and not just the last one so that when the transaction is completed
all the parts of the record are on stable storage.
And for external logs, unmount records need a pre-write data device
cache flush similar to the CIL checkpoint cache pre-flush as the
internal iclog write code does not do this implicitly anymore.
As an optimisation, when the commit record lands in the same iclog
as the journal transaction starts, we don't need to wait for
anything and can simply use REQ_FUA to provide guarantee #2. This
means that for fsync() heavy workloads, the cache flush behaviour is
completely unchanged and there is no degradation in performance as a
result of optimise the multi-IO transaction case.
The most notable sign that there is less IO latency on my test
machine (nvme SSDs) is that the "noiclogs" rate has dropped
substantially. This metric indicates that the CIL push is blocking
in xlog_get_iclog_space() waiting for iclog IO completion to occur.
With 8 iclogs of 256kB, the rate is appoximately 1 noiclog event to
every 4 iclog writes. IOWs, every 4th call to xlog_get_iclog_space()
is blocking waiting for log IO. With the changes in this patch, this
drops to 1 noiclog event for every 100 iclog writes. Hence it is
clear that log IO is completing much faster than it was previously,
but it is also clear that for large iclog sizes, this isn't the
performance limiting factor on this hardware.
With smaller iclogs (32kB), however, there is a substantial
difference. With the cache flush modifications, the journal is now
running at over 4000 write IOPS, and the journal throughput is
largely identical to the 256kB iclogs and the noiclog event rate
stays low at about 1:50 iclog writes. The existing code tops out at
about 2500 IOPS as the number of cache flushes dominate performance
and latency. The noiclog event rate is about 1:4, and the
performance variance is quite large as the journal throughput can
fall to less than half the peak sustained rate when the cache flush
rate prevents metadata writeback from keeping up and the log runs
out of space and throttles reservations.
As a result:
logbsize fsmark create rate rm -rf
before 32kb 152851+/-5.3e+04 5m28s
patched 32kb 221533+/-1.1e+04 5m24s
before 256kb 220239+/-6.2e+03 4m58s
patched 256kb 228286+/-9.2e+03 5m06s
The rm -rf times are included because I ran them, but the
differences are largely noise. This workload is largely metadata
read IO latency bound and the changes to the journal cache flushing
doesn't really make any noticable difference to behaviour apart from
a reduction in noiclog events from background CIL pushing.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.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-06-18 15:21:51 +00:00
|
|
|
|
2010-12-21 01:28:39 +00:00
|
|
|
/*
|
|
|
|
* When we crack an atomic LSN, we sample it first so that the value will not
|
|
|
|
* change while we are cracking it into the component values. This means we
|
|
|
|
* will always get consistent component values to work from. This should always
|
2011-03-31 01:57:33 +00:00
|
|
|
* be used to sample and crack LSNs that are stored and updated in atomic
|
2010-12-21 01:28:39 +00:00
|
|
|
* variables.
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
xlog_crack_atomic_lsn(atomic64_t *lsn, uint *cycle, uint *block)
|
|
|
|
{
|
|
|
|
xfs_lsn_t val = atomic64_read(lsn);
|
|
|
|
|
|
|
|
*cycle = CYCLE_LSN(val);
|
|
|
|
*block = BLOCK_LSN(val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate and assign a value to an atomic LSN variable from component pieces.
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
xlog_assign_atomic_lsn(atomic64_t *lsn, uint cycle, uint block)
|
|
|
|
{
|
|
|
|
atomic64_set(lsn, xlog_assign_lsn(cycle, block));
|
|
|
|
}
|
|
|
|
|
2010-12-21 01:08:20 +00:00
|
|
|
/*
|
2010-12-21 01:29:14 +00:00
|
|
|
* When we crack the grant head, we sample it first so that the value will not
|
2010-12-21 01:08:20 +00:00
|
|
|
* change while we are cracking it into the component values. This means we
|
|
|
|
* will always get consistent component values to work from.
|
|
|
|
*/
|
|
|
|
static inline void
|
2010-12-21 01:29:14 +00:00
|
|
|
xlog_crack_grant_head_val(int64_t val, int *cycle, int *space)
|
2010-12-21 01:08:20 +00:00
|
|
|
{
|
|
|
|
*cycle = val >> 32;
|
|
|
|
*space = val & 0xffffffff;
|
|
|
|
}
|
|
|
|
|
2010-12-21 01:29:14 +00:00
|
|
|
static inline void
|
|
|
|
xlog_crack_grant_head(atomic64_t *head, int *cycle, int *space)
|
|
|
|
{
|
|
|
|
xlog_crack_grant_head_val(atomic64_read(head), cycle, space);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int64_t
|
|
|
|
xlog_assign_grant_head_val(int cycle, int space)
|
|
|
|
{
|
|
|
|
return ((int64_t)cycle << 32) | space;
|
|
|
|
}
|
|
|
|
|
2010-12-21 01:08:20 +00:00
|
|
|
static inline void
|
2010-12-03 13:02:40 +00:00
|
|
|
xlog_assign_grant_head(atomic64_t *head, int cycle, int space)
|
2010-12-21 01:08:20 +00:00
|
|
|
{
|
2010-12-21 01:29:14 +00:00
|
|
|
atomic64_set(head, xlog_assign_grant_head_val(cycle, space));
|
2010-12-21 01:08:20 +00:00
|
|
|
}
|
|
|
|
|
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 04:37:18 +00:00
|
|
|
/*
|
|
|
|
* Committed Item List interfaces
|
|
|
|
*/
|
xfs: prevent deadlock trying to cover an active log
Recent analysis of a deadlocked XFS filesystem from a kernel
crash dump indicated that the filesystem was stuck waiting for log
space. The short story of the hang on the RHEL6 kernel is this:
- the tail of the log is pinned by an inode
- the inode has been pushed by the xfsaild
- the inode has been flushed to it's backing buffer and is
currently flush locked and hence waiting for backing
buffer IO to complete and remove it from the AIL
- the backing buffer is marked for write - it is on the
delayed write queue
- the inode buffer has been modified directly and logged
recently due to unlinked inode list modification
- the backing buffer is pinned in memory as it is in the
active CIL context.
- the xfsbufd won't start buffer writeback because it is
pinned
- xfssyncd won't force the log because it sees the log as
needing to be covered and hence wants to issue a dummy
transaction to move the log covering state machine along.
Hence there is no trigger to force the CIL to the log and hence
unpin the inode buffer and therefore complete the inode IO, remove
it from the AIL and hence move the tail of the log along, allowing
transactions to start again.
Mainline kernels also have the same deadlock, though the signature
is slightly different - the inode buffer never reaches the delayed
write lists because xfs_buf_item_push() sees that it is pinned and
hence never adds it to the delayed write list that the xfsaild
flushes.
There are two possible solutions here. The first is to simply force
the log before trying to cover the log and so ensure that the CIL is
emptied before we try to reserve space for the dummy transaction in
the xfs_log_worker(). While this might work most of the time, it is
still racy and is no guarantee that we don't get stuck in
xfs_trans_reserve waiting for log space to come free. Hence it's not
the best way to solve the problem.
The second solution is to modify xfs_log_need_covered() to be aware
of the CIL. We only should be attempting to cover the log if there
is no current activity in the log - covering the log is the process
of ensuring that the head and tail in the log on disk are identical
(i.e. the log is clean and at idle). Hence, by definition, if there
are items in the CIL then the log is not at idle and so we don't
need to attempt to cover it.
When we don't need to cover the log because it is active or idle, we
issue a log force from xfs_log_worker() - if the log is idle, then
this does nothing. However, if the log is active due to there being
items in the CIL, it will force the items in the CIL to the log and
unpin them.
In the case of the above deadlock scenario, instead of
xfs_log_worker() getting stuck in xfs_trans_reserve() attempting to
cover the log, it will instead force the log, thereby unpinning the
inode buffer, allowing IO to be issued and complete and hence
removing the inode that was pinning the tail of the log from the
AIL. At that point, everything will start moving along again. i.e.
the xfs_log_worker turns back into a watchdog that can alleviate
deadlocks based around pinned items that prevent the tail of the log
from being moved...
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2013-10-14 22:17:49 +00:00
|
|
|
int xlog_cil_init(struct xlog *log);
|
|
|
|
void xlog_cil_init_post_recovery(struct xlog *log);
|
|
|
|
void xlog_cil_destroy(struct xlog *log);
|
|
|
|
bool xlog_cil_empty(struct xlog *log);
|
2021-06-18 15:21:52 +00:00
|
|
|
void xlog_cil_commit(struct xlog *log, struct xfs_trans *tp,
|
|
|
|
xfs_csn_t *commit_seq, bool regrant);
|
2021-08-11 01:00:42 +00:00
|
|
|
void xlog_cil_set_ctx_write_state(struct xfs_cil_ctx *ctx,
|
|
|
|
struct xlog_in_core *iclog);
|
|
|
|
|
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 04:37:18 +00:00
|
|
|
|
2010-08-24 01:40:03 +00:00
|
|
|
/*
|
|
|
|
* CIL force routines
|
|
|
|
*/
|
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 01:00:44 +00:00
|
|
|
void xlog_cil_flush(struct xlog *log);
|
2021-06-18 15:21:52 +00:00
|
|
|
xfs_lsn_t xlog_cil_force_seq(struct xlog *log, xfs_csn_t sequence);
|
2010-08-24 01:40:03 +00:00
|
|
|
|
|
|
|
static inline void
|
2012-06-14 14:22:15 +00:00
|
|
|
xlog_cil_force(struct xlog *log)
|
2010-08-24 01:40:03 +00:00
|
|
|
{
|
2021-06-18 15:21:52 +00:00
|
|
|
xlog_cil_force_seq(log, log->l_cilp->xc_current_sequence);
|
2010-08-24 01:40:03 +00:00
|
|
|
}
|
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 04:37:18 +00:00
|
|
|
|
2010-12-21 01:09:01 +00:00
|
|
|
/*
|
|
|
|
* Wrapper function for waiting on a wait queue serialised against wakeups
|
|
|
|
* by a spinlock. This matches the semantics of all the wait queues used in the
|
|
|
|
* log code.
|
|
|
|
*/
|
2019-11-06 16:41:20 +00:00
|
|
|
static inline void
|
|
|
|
xlog_wait(
|
|
|
|
struct wait_queue_head *wq,
|
|
|
|
struct spinlock *lock)
|
|
|
|
__releases(lock)
|
2010-12-21 01:09:01 +00:00
|
|
|
{
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
|
|
|
|
add_wait_queue_exclusive(wq, &wait);
|
|
|
|
__set_current_state(TASK_UNINTERRUPTIBLE);
|
|
|
|
spin_unlock(lock);
|
|
|
|
schedule();
|
|
|
|
remove_wait_queue(wq, &wait);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-06-18 15:21:48 +00:00
|
|
|
int xlog_wait_on_iclog(struct xlog_in_core *iclog);
|
|
|
|
|
2015-10-12 04:59:25 +00:00
|
|
|
/*
|
|
|
|
* The LSN is valid so long as it is behind the current LSN. If it isn't, this
|
|
|
|
* means that the next log record that includes this metadata could have a
|
|
|
|
* smaller LSN. In turn, this means that the modification in the log would not
|
|
|
|
* replay.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
xlog_valid_lsn(
|
|
|
|
struct xlog *log,
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
{
|
|
|
|
int cur_cycle;
|
|
|
|
int cur_block;
|
|
|
|
bool valid = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First, sample the current lsn without locking to avoid added
|
|
|
|
* contention from metadata I/O. The current cycle and block are updated
|
|
|
|
* (in xlog_state_switch_iclogs()) and read here in a particular order
|
|
|
|
* to avoid false negatives (e.g., thinking the metadata LSN is valid
|
|
|
|
* when it is not).
|
|
|
|
*
|
|
|
|
* The current block is always rewound before the cycle is bumped in
|
|
|
|
* xlog_state_switch_iclogs() to ensure the current LSN is never seen in
|
|
|
|
* a transiently forward state. Instead, we can see the LSN in a
|
|
|
|
* transiently behind state if we happen to race with a cycle wrap.
|
|
|
|
*/
|
locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
Please do not apply this to mainline directly, instead please re-run the
coccinelle script shown below and apply its output.
For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
preference to ACCESS_ONCE(), and new code is expected to use one of the
former. So far, there's been no reason to change most existing uses of
ACCESS_ONCE(), as these aren't harmful, and changing them results in
churn.
However, for some features, the read/write distinction is critical to
correct operation. To distinguish these cases, separate read/write
accessors must be used. This patch migrates (most) remaining
ACCESS_ONCE() instances to {READ,WRITE}_ONCE(), using the following
coccinelle script:
----
// Convert trivial ACCESS_ONCE() uses to equivalent READ_ONCE() and
// WRITE_ONCE()
// $ make coccicheck COCCI=/home/mark/once.cocci SPFLAGS="--include-headers" MODE=patch
virtual patch
@ depends on patch @
expression E1, E2;
@@
- ACCESS_ONCE(E1) = E2
+ WRITE_ONCE(E1, E2)
@ depends on patch @
expression E;
@@
- ACCESS_ONCE(E)
+ READ_ONCE(E)
----
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: davem@davemloft.net
Cc: linux-arch@vger.kernel.org
Cc: mpe@ellerman.id.au
Cc: shuah@kernel.org
Cc: snitzer@redhat.com
Cc: thor.thayer@linux.intel.com
Cc: tj@kernel.org
Cc: viro@zeniv.linux.org.uk
Cc: will.deacon@arm.com
Link: http://lkml.kernel.org/r/1508792849-3115-19-git-send-email-paulmck@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-10-23 21:07:29 +00:00
|
|
|
cur_cycle = READ_ONCE(log->l_curr_cycle);
|
2015-10-12 04:59:25 +00:00
|
|
|
smp_rmb();
|
locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
Please do not apply this to mainline directly, instead please re-run the
coccinelle script shown below and apply its output.
For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
preference to ACCESS_ONCE(), and new code is expected to use one of the
former. So far, there's been no reason to change most existing uses of
ACCESS_ONCE(), as these aren't harmful, and changing them results in
churn.
However, for some features, the read/write distinction is critical to
correct operation. To distinguish these cases, separate read/write
accessors must be used. This patch migrates (most) remaining
ACCESS_ONCE() instances to {READ,WRITE}_ONCE(), using the following
coccinelle script:
----
// Convert trivial ACCESS_ONCE() uses to equivalent READ_ONCE() and
// WRITE_ONCE()
// $ make coccicheck COCCI=/home/mark/once.cocci SPFLAGS="--include-headers" MODE=patch
virtual patch
@ depends on patch @
expression E1, E2;
@@
- ACCESS_ONCE(E1) = E2
+ WRITE_ONCE(E1, E2)
@ depends on patch @
expression E;
@@
- ACCESS_ONCE(E)
+ READ_ONCE(E)
----
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: davem@davemloft.net
Cc: linux-arch@vger.kernel.org
Cc: mpe@ellerman.id.au
Cc: shuah@kernel.org
Cc: snitzer@redhat.com
Cc: thor.thayer@linux.intel.com
Cc: tj@kernel.org
Cc: viro@zeniv.linux.org.uk
Cc: will.deacon@arm.com
Link: http://lkml.kernel.org/r/1508792849-3115-19-git-send-email-paulmck@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-10-23 21:07:29 +00:00
|
|
|
cur_block = READ_ONCE(log->l_curr_block);
|
2015-10-12 04:59:25 +00:00
|
|
|
|
|
|
|
if ((CYCLE_LSN(lsn) > cur_cycle) ||
|
|
|
|
(CYCLE_LSN(lsn) == cur_cycle && BLOCK_LSN(lsn) > cur_block)) {
|
|
|
|
/*
|
|
|
|
* If the metadata LSN appears invalid, it's possible the check
|
|
|
|
* above raced with a wrap to the next log cycle. Grab the lock
|
|
|
|
* to check for sure.
|
|
|
|
*/
|
|
|
|
spin_lock(&log->l_icloglock);
|
|
|
|
cur_cycle = log->l_curr_cycle;
|
|
|
|
cur_block = log->l_curr_block;
|
|
|
|
spin_unlock(&log->l_icloglock);
|
|
|
|
|
|
|
|
if ((CYCLE_LSN(lsn) > cur_cycle) ||
|
|
|
|
(CYCLE_LSN(lsn) == cur_cycle && BLOCK_LSN(lsn) > cur_block))
|
|
|
|
valid = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return valid;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* __XFS_LOG_PRIV_H__ */
|