2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 20:58:39 -07:00
|
|
|
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 16:20:36 -06:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#ifndef __XFS_LOG_PRIV_H__
|
|
|
|
#define __XFS_LOG_PRIV_H__
|
|
|
|
|
|
|
|
struct xfs_buf;
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog;
|
2005-11-01 20:38:42 -07:00
|
|
|
struct xlog_ticket;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct xfs_mount;
|
2013-10-22 17:50:10 -06:00
|
|
|
struct xfs_log_callback;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2013-08-12 04:49:22 -06:00
|
|
|
* Flags for log structure
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2013-08-12 04:49:22 -06:00
|
|
|
#define XLOG_ACTIVE_RECOVERY 0x2 /* in the middle of recovery */
|
|
|
|
#define XLOG_RECOVERY_NEEDED 0x4 /* log was recovered */
|
|
|
|
#define XLOG_IO_ERROR 0x8 /* log hit an I/O error, and being
|
|
|
|
shutdown */
|
|
|
|
#define XLOG_TAIL_WARN 0x10 /* log tail verify warning issued */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-11 18:59:34 -06:00
|
|
|
static inline uint xlog_get_client_id(__be32 i)
|
2007-10-11 18:58:05 -06:00
|
|
|
{
|
2007-10-11 18:59:34 -06:00
|
|
|
return be32_to_cpu(i) >> 24;
|
2007-10-11 18:58:05 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* In core log state
|
|
|
|
*/
|
|
|
|
#define XLOG_STATE_ACTIVE 0x0001 /* Current IC log being written to */
|
|
|
|
#define XLOG_STATE_WANT_SYNC 0x0002 /* Want to sync this iclog; no more writes */
|
|
|
|
#define XLOG_STATE_SYNCING 0x0004 /* This IC log is syncing */
|
|
|
|
#define XLOG_STATE_DONE_SYNC 0x0008 /* Done syncing to disk */
|
|
|
|
#define XLOG_STATE_DO_CALLBACK \
|
|
|
|
0x0010 /* Process callback functions */
|
|
|
|
#define XLOG_STATE_CALLBACK 0x0020 /* Callback functions now */
|
|
|
|
#define XLOG_STATE_DIRTY 0x0040 /* Dirty IC log, not ready for ACTIVE status*/
|
|
|
|
#define XLOG_STATE_IOERROR 0x0080 /* IO error happened in sync'ing log */
|
|
|
|
#define XLOG_STATE_ALL 0x7FFF /* All possible valid flags */
|
|
|
|
#define XLOG_STATE_NOTUSED 0x8000 /* This IC log not being used */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flags to log ticket
|
|
|
|
*/
|
|
|
|
#define XLOG_TIC_INITED 0x1 /* has been initialized */
|
|
|
|
#define XLOG_TIC_PERM_RESERV 0x2 /* permanent reservation */
|
2009-12-14 16:14:59 -07:00
|
|
|
|
|
|
|
#define XLOG_TIC_FLAGS \
|
|
|
|
{ XLOG_TIC_INITED, "XLOG_TIC_INITED" }, \
|
2010-12-20 18:02:25 -07:00
|
|
|
{ XLOG_TIC_PERM_RESERV, "XLOG_TIC_PERM_RESERV" }
|
2009-12-14 16:14:59 -07:00
|
|
|
|
2005-04-16 16:20:36 -06: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 00:42:05 -06: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 03:02:47 -07:00
|
|
|
uint r_len; /* region length :4 */
|
|
|
|
uint r_type; /* region's transaction type :4 */
|
2005-09-02 00:42:05 -06:00
|
|
|
} xlog_res_t;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
typedef struct xlog_ticket {
|
2010-12-20 18:02:25 -07:00
|
|
|
struct list_head t_queue; /* reserve/write queue */
|
2012-02-19 19:31:24 -07:00
|
|
|
struct task_struct *t_task; /* task that owns this ticket */
|
2005-09-02 00:42:05 -06:00
|
|
|
xlog_tid_t t_tid; /* transaction identifier : 4 */
|
2008-11-16 23:37:10 -07:00
|
|
|
atomic_t t_ref; /* ticket reference count : 4 */
|
2005-09-02 00:42:05 -06: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 */
|
|
|
|
uint t_trans_type; /* transaction type : 4 */
|
|
|
|
|
|
|
|
/* 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 03:02:47 -07:00
|
|
|
xlog_res_t t_res_arr[XLOG_TIC_LEN_MAX]; /* array of res : 8 * 15 */
|
2005-04-16 16:20:36 -06:00
|
|
|
} xlog_ticket_t;
|
2005-09-02 00:42:05 -06:00
|
|
|
|
2005-04-16 16:20:36 -06: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 00:34:31 -06:00
|
|
|
* - ic_forcewait is used to implement synchronous forcing of the iclog to disk.
|
2005-04-16 16:20:36 -06:00
|
|
|
* - ic_next is the pointer to the next iclog in the ring.
|
|
|
|
* - ic_bp is a pointer to the buffer used to write this incore log to disk.
|
|
|
|
* - ic_log is a pointer back to the global log structure.
|
|
|
|
* - ic_callback is a linked list of callback function/argument pairs to be
|
|
|
|
* called after an iclog finishes writing.
|
|
|
|
* - ic_size is the full size of the header plus data.
|
|
|
|
* - 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-09 20:18:39 -06: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:
|
|
|
|
*
|
|
|
|
* - ic_callback_*
|
|
|
|
* - 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 16:20:36 -06:00
|
|
|
*/
|
2008-11-27 20:23:38 -07:00
|
|
|
typedef struct xlog_in_core {
|
2010-12-20 18:09:01 -07:00
|
|
|
wait_queue_head_t ic_force_wait;
|
|
|
|
wait_queue_head_t ic_write_wait;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct xlog_in_core *ic_next;
|
|
|
|
struct xlog_in_core *ic_prev;
|
|
|
|
struct xfs_buf *ic_bp;
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *ic_log;
|
2005-04-16 16:20:36 -06:00
|
|
|
int ic_size;
|
|
|
|
int ic_offset;
|
|
|
|
int ic_bwritecnt;
|
2009-02-09 00:37:39 -07:00
|
|
|
unsigned short ic_state;
|
2005-04-16 16:20:36 -06:00
|
|
|
char *ic_datap; /* pointer to iclog data */
|
2008-04-09 20:18:39 -06:00
|
|
|
|
|
|
|
/* Callback structures need their own cacheline */
|
|
|
|
spinlock_t ic_callback_lock ____cacheline_aligned_in_smp;
|
2013-10-22 17:50:10 -06:00
|
|
|
struct xfs_log_callback *ic_callback;
|
|
|
|
struct xfs_log_callback **ic_callback_tail;
|
2008-04-09 20:18:39 -06:00
|
|
|
|
|
|
|
/* reference counts need their own cacheline */
|
|
|
|
atomic_t ic_refcnt ____cacheline_aligned_in_smp;
|
2008-11-27 20:23:38 -07:00
|
|
|
xlog_in_core_2_t *ic_data;
|
|
|
|
#define ic_header ic_data->hic_header
|
2005-04-16 16:20:36 -06: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-20 22:37:18 -06: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;
|
|
|
|
xfs_lsn_t sequence; /* chkpt sequence # */
|
|
|
|
xfs_lsn_t start_lsn; /* first LSN of chkpt commit */
|
|
|
|
xfs_lsn_t commit_lsn; /* chkpt commit record lsn */
|
|
|
|
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 */
|
2013-10-22 17:50:10 -06:00
|
|
|
struct xfs_log_callback log_cb; /* completion callback hook. */
|
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-20 22:37:18 -06:00
|
|
|
struct list_head committing; /* ctx committing list */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 08:22:15 -06: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-20 22:37:18 -06:00
|
|
|
struct list_head xc_cil;
|
|
|
|
spinlock_t xc_cil_lock;
|
2013-08-12 04:50:08 -06: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-20 22:37:18 -06:00
|
|
|
struct xfs_cil_ctx *xc_ctx;
|
2013-08-12 04:50:08 -06:00
|
|
|
|
|
|
|
spinlock_t xc_push_lock ____cacheline_aligned_in_smp;
|
|
|
|
xfs_lsn_t xc_push_seq;
|
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-20 22:37:18 -06:00
|
|
|
struct list_head xc_committing;
|
2010-12-20 18:09:01 -07:00
|
|
|
wait_queue_head_t xc_commit_wait;
|
2010-08-23 19:40:03 -06:00
|
|
|
xfs_lsn_t xc_current_sequence;
|
2012-04-23 01:54:32 -06:00
|
|
|
struct work_struct xc_push_work;
|
2013-08-12 04:50:08 -06: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-20 22:37:18 -06:00
|
|
|
|
2010-05-16 23:52:13 -06: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 02:13:44 -06: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-16 23:52:13 -06: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 02:13:44 -06: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.
|
|
|
|
*
|
|
|
|
* In order to keep background CIL push efficient, we will set a lower
|
|
|
|
* threshold at which background pushing is attempted without blocking current
|
|
|
|
* transaction commits. A separate, higher bound defines when CIL pushes are
|
|
|
|
* enforced to ensure we stay within our maximum checkpoint size bounds.
|
|
|
|
* threshold, yet give us plenty of space for aggregation on large logs.
|
2010-05-16 23:52:13 -06: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 02:13:44 -06:00
|
|
|
#define XLOG_CIL_SPACE_LIMIT(log) (log->l_logsize >> 3)
|
2010-05-16 23:52:13 -06:00
|
|
|
|
2012-02-19 19:31:25 -07: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 16:20:36 -06: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 08:22:16 -06:00
|
|
|
struct xlog {
|
2008-04-09 20:18:54 -06:00
|
|
|
/* The following fields don't need locking */
|
|
|
|
struct xfs_mount *l_mp; /* mount point */
|
2008-10-30 00:39:35 -06: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-20 22:37:18 -06:00
|
|
|
struct xfs_cil *l_cilp; /* CIL log is working with */
|
2008-04-09 20:18:54 -06:00
|
|
|
struct xfs_buf *l_xbuf; /* extra buffer for log
|
|
|
|
* wrapping */
|
|
|
|
struct xfs_buftarg *l_targ; /* buftarg of log */
|
2012-10-08 04:56:02 -06:00
|
|
|
struct delayed_work l_work; /* background flush work */
|
2008-04-09 20:18:54 -06:00
|
|
|
uint l_flags;
|
|
|
|
uint l_quotaoffs_flag; /* XFS_DQ_*, for QUOTAOFFs */
|
2010-12-01 15:06:22 -07:00
|
|
|
struct list_head *l_buf_cancel_table;
|
2008-04-09 20:18:54 -06:00
|
|
|
int l_iclog_hsize; /* size of iclog header */
|
|
|
|
int l_iclog_heads; /* # of iclog header sectors */
|
2010-04-20 01:10:21 -06:00
|
|
|
uint l_sectBBsize; /* sector size in BBs (2^n) */
|
2008-04-09 20:18:54 -06:00
|
|
|
int l_iclog_size; /* size of log in bytes */
|
|
|
|
int l_iclog_size_log; /* log power size of log */
|
|
|
|
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 16:20:36 -06:00
|
|
|
/* The following block of fields are changed while holding icloglock */
|
2010-12-20 18:09:01 -07:00
|
|
|
wait_queue_head_t l_flush_wait ____cacheline_aligned_in_smp;
|
2008-05-19 00:34:27 -06:00
|
|
|
/* waiting for iclog flush */
|
2005-04-16 16:20:36 -06:00
|
|
|
int l_covered_state;/* state of "covering disk
|
|
|
|
* log entries" */
|
|
|
|
xlog_in_core_t *l_iclog; /* head log queue */
|
2007-10-11 01:37:10 -06:00
|
|
|
spinlock_t l_icloglock; /* grab to change iclog state */
|
2005-04-16 16:20:36 -06: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 04:11:29 -07:00
|
|
|
/*
|
2010-12-20 18:28:39 -07: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 04:11:29 -07:00
|
|
|
*/
|
|
|
|
/* lsn of last LR on disk */
|
|
|
|
atomic64_t l_last_sync_lsn ____cacheline_aligned_in_smp;
|
2010-12-20 18:28:39 -07:00
|
|
|
/* lsn of 1st LR with unflushed * buffers */
|
|
|
|
atomic64_t l_tail_lsn ____cacheline_aligned_in_smp;
|
2010-12-03 04:11:29 -07:00
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
struct xlog_grant_head l_reserve_head;
|
|
|
|
struct xlog_grant_head l_write_head;
|
2010-12-20 18:29:01 -07:00
|
|
|
|
2014-07-14 16:07:29 -06:00
|
|
|
struct xfs_kobj l_kobj;
|
|
|
|
|
2008-04-09 20:18:54 -06:00
|
|
|
/* The following field are used for debugging; need to hold icloglock */
|
|
|
|
#ifdef DEBUG
|
|
|
|
char *l_iclog_bak[XLOG_MAX_ICLOGS];
|
|
|
|
#endif
|
|
|
|
|
2012-06-14 08:22:16 -06:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-01 15:06:22 -07:00
|
|
|
#define XLOG_BUF_CANCEL_BUCKET(log, blkno) \
|
|
|
|
((log)->l_buf_cancel_table + ((__uint64_t)blkno % XLOG_BC_TABLE_SIZE))
|
|
|
|
|
2005-11-01 21:12:04 -07:00
|
|
|
#define XLOG_FORCED_SHUTDOWN(log) ((log)->l_flags & XLOG_IO_ERROR)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* common routines */
|
2012-06-14 08:22:16 -06:00
|
|
|
extern int
|
|
|
|
xlog_recover(
|
|
|
|
struct xlog *log);
|
|
|
|
extern int
|
|
|
|
xlog_recover_finish(
|
|
|
|
struct xlog *log);
|
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 04:54:24 -07:00
|
|
|
|
2012-11-27 19:01:03 -07: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 04:54:24 -07:00
|
|
|
char *dp, int size);
|
2005-04-16 16:20:36 -06: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-20 22:37:18 -06:00
|
|
|
extern kmem_zone_t *xfs_log_ticket_zone;
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog_ticket *
|
|
|
|
xlog_ticket_alloc(
|
|
|
|
struct xlog *log,
|
|
|
|
int unit_bytes,
|
|
|
|
int count,
|
|
|
|
char client,
|
|
|
|
bool permanent,
|
|
|
|
xfs_km_flags_t alloc_flags);
|
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-20 22:37:18 -06:00
|
|
|
|
2008-04-09 20:18:46 -06:00
|
|
|
|
2010-03-22 18:47:38 -06: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-20 22:37:18 -06:00
|
|
|
void xlog_print_tic_res(struct xfs_mount *mp, struct xlog_ticket *ticket);
|
2012-06-14 08:22:15 -06:00
|
|
|
int
|
|
|
|
xlog_write(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xfs_log_vec *log_vector,
|
|
|
|
struct xlog_ticket *tic,
|
|
|
|
xfs_lsn_t *start_lsn,
|
|
|
|
struct xlog_in_core **commit_iclog,
|
|
|
|
uint flags);
|
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-20 22:37:18 -06:00
|
|
|
|
2010-12-20 18:28:39 -07: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-30 19:57:33 -06:00
|
|
|
* be used to sample and crack LSNs that are stored and updated in atomic
|
2010-12-20 18:28:39 -07: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-20 18:08:20 -07:00
|
|
|
/*
|
2010-12-20 18:29:14 -07:00
|
|
|
* When we crack the grant head, we sample it first so that the value will not
|
2010-12-20 18:08:20 -07: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-20 18:29:14 -07:00
|
|
|
xlog_crack_grant_head_val(int64_t val, int *cycle, int *space)
|
2010-12-20 18:08:20 -07:00
|
|
|
{
|
|
|
|
*cycle = val >> 32;
|
|
|
|
*space = val & 0xffffffff;
|
|
|
|
}
|
|
|
|
|
2010-12-20 18:29:14 -07: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-20 18:08:20 -07:00
|
|
|
static inline void
|
2010-12-03 06:02:40 -07:00
|
|
|
xlog_assign_grant_head(atomic64_t *head, int cycle, int space)
|
2010-12-20 18:08:20 -07:00
|
|
|
{
|
2010-12-20 18:29:14 -07:00
|
|
|
atomic64_set(head, xlog_assign_grant_head_val(cycle, space));
|
2010-12-20 18:08:20 -07: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-20 22:37:18 -06: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 16:17:49 -06: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);
|
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-20 22:37:18 -06:00
|
|
|
|
2010-08-23 19:40:03 -06:00
|
|
|
/*
|
|
|
|
* CIL force routines
|
|
|
|
*/
|
2012-06-14 08:22:15 -06:00
|
|
|
xfs_lsn_t
|
|
|
|
xlog_cil_force_lsn(
|
|
|
|
struct xlog *log,
|
|
|
|
xfs_lsn_t sequence);
|
2010-08-23 19:40:03 -06:00
|
|
|
|
|
|
|
static inline void
|
2012-06-14 08:22:15 -06:00
|
|
|
xlog_cil_force(struct xlog *log)
|
2010-08-23 19:40:03 -06:00
|
|
|
{
|
|
|
|
xlog_cil_force_lsn(log, log->l_cilp->xc_current_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-20 22:37:18 -06:00
|
|
|
|
2006-09-27 19:04:16 -06:00
|
|
|
/*
|
|
|
|
* Unmount record type is used as a pseudo transaction type for the ticket.
|
|
|
|
* It's value must be outside the range of XFS_TRANS_* values.
|
|
|
|
*/
|
|
|
|
#define XLOG_UNMOUNT_REC_TYPE (-1U)
|
|
|
|
|
2010-12-20 18:09:01 -07: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.
|
|
|
|
*/
|
|
|
|
static inline void xlog_wait(wait_queue_head_t *wq, spinlock_t *lock)
|
|
|
|
{
|
|
|
|
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 16:20:36 -06:00
|
|
|
|
|
|
|
#endif /* __XFS_LOG_PRIV_H__ */
|