2005-04-17 02:20:36 +04:00
|
|
|
/*
|
2005-11-02 06:58:39 +03:00
|
|
|
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
2005-11-02 06:58:39 +03: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-17 02:20:36 +04:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-02 06:58:39 +03: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-17 02:20:36 +04:00
|
|
|
*
|
2005-11-02 06:58:39 +03: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-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
#ifndef __XFS_LOG_PRIV_H__
|
|
|
|
#define __XFS_LOG_PRIV_H__
|
|
|
|
|
|
|
|
struct xfs_buf;
|
|
|
|
struct log;
|
2005-11-02 06:38:42 +03:00
|
|
|
struct xlog_ticket;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct xfs_buf_cancel;
|
|
|
|
struct xfs_mount;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Macros, structures, prototypes for internal log manager use.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define XLOG_MIN_ICLOGS 2
|
|
|
|
#define XLOG_MAX_ICLOGS 8
|
|
|
|
#define XLOG_HEADER_MAGIC_NUM 0xFEEDbabe /* Invalid cycle number */
|
|
|
|
#define XLOG_VERSION_1 1
|
|
|
|
#define XLOG_VERSION_2 2 /* Large IClogs, Log sunit */
|
|
|
|
#define XLOG_VERSION_OKBITS (XLOG_VERSION_1 | XLOG_VERSION_2)
|
2007-08-16 10:25:33 +04:00
|
|
|
#define XLOG_MIN_RECORD_BSIZE (16*1024) /* eventually 32k */
|
2005-04-17 02:20:36 +04:00
|
|
|
#define XLOG_BIG_RECORD_BSIZE (32*1024) /* 32k buffers */
|
|
|
|
#define XLOG_MAX_RECORD_BSIZE (256*1024)
|
|
|
|
#define XLOG_HEADER_CYCLE_SIZE (32*1024) /* cycle data in header */
|
2007-08-16 10:25:33 +04:00
|
|
|
#define XLOG_MIN_RECORD_BSHIFT 14 /* 16384 == 1 << 14 */
|
2005-04-17 02:20:36 +04:00
|
|
|
#define XLOG_BIG_RECORD_BSHIFT 15 /* 32k == 1 << 15 */
|
|
|
|
#define XLOG_MAX_RECORD_BSHIFT 18 /* 256k == 1 << 18 */
|
|
|
|
#define XLOG_BTOLSUNIT(log, b) (((b)+(log)->l_mp->m_sb.sb_logsunit-1) / \
|
|
|
|
(log)->l_mp->m_sb.sb_logsunit)
|
|
|
|
#define XLOG_LSUNITTOB(log, su) ((su) * (log)->l_mp->m_sb.sb_logsunit)
|
|
|
|
|
|
|
|
#define XLOG_HEADER_SIZE 512
|
|
|
|
|
|
|
|
#define XLOG_REC_SHIFT(log) \
|
2008-03-06 05:44:28 +03:00
|
|
|
BTOBB(1 << (xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? \
|
2005-04-17 02:20:36 +04:00
|
|
|
XLOG_MAX_RECORD_BSHIFT : XLOG_BIG_RECORD_BSHIFT))
|
|
|
|
#define XLOG_TOTAL_REC_SHIFT(log) \
|
2008-03-06 05:44:28 +03:00
|
|
|
BTOBB(XLOG_MAX_ICLOGS << (xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? \
|
2005-04-17 02:20:36 +04:00
|
|
|
XLOG_MAX_RECORD_BSHIFT : XLOG_BIG_RECORD_BSHIFT))
|
|
|
|
|
|
|
|
|
2007-10-12 04:58:05 +04:00
|
|
|
static inline xfs_lsn_t xlog_assign_lsn(uint cycle, uint block)
|
|
|
|
{
|
|
|
|
return ((xfs_lsn_t)cycle << 32) | block;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-10-12 04:58:05 +04:00
|
|
|
static inline uint xlog_get_cycle(char *ptr)
|
|
|
|
{
|
2007-10-12 04:59:34 +04:00
|
|
|
if (be32_to_cpu(*(__be32 *)ptr) == XLOG_HEADER_MAGIC_NUM)
|
|
|
|
return be32_to_cpu(*((__be32 *)ptr + 1));
|
2007-10-12 04:58:05 +04:00
|
|
|
else
|
2007-10-12 04:59:34 +04:00
|
|
|
return be32_to_cpu(*(__be32 *)ptr);
|
2007-10-12 04:58:05 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
#define BLK_AVG(blk1, blk2) ((blk1+blk2) >> 1)
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get client id from packed copy.
|
|
|
|
*
|
|
|
|
* this hack is here because the xlog_pack code copies four bytes
|
|
|
|
* of xlog_op_header containing the fields oh_clientid, oh_flags
|
|
|
|
* and oh_res2 into the packed copy.
|
|
|
|
*
|
|
|
|
* later on this four byte chunk is treated as an int and the
|
|
|
|
* client id is pulled out.
|
|
|
|
*
|
|
|
|
* this has endian issues, of course.
|
|
|
|
*/
|
2007-10-12 04:59:34 +04:00
|
|
|
static inline uint xlog_get_client_id(__be32 i)
|
2007-10-12 04:58:05 +04:00
|
|
|
{
|
2007-10-12 04:59:34 +04:00
|
|
|
return be32_to_cpu(i) >> 24;
|
2007-10-12 04:58:05 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
#define xlog_panic(args...) cmn_err(CE_PANIC, ## args)
|
|
|
|
#define xlog_exit(args...) cmn_err(CE_PANIC, ## args)
|
|
|
|
#define xlog_warn(args...) cmn_err(CE_WARN, ## args)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 */
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flags to log operation header
|
|
|
|
*
|
|
|
|
* The first write of a new transaction will be preceded with a start
|
|
|
|
* record, XLOG_START_TRANS. Once a transaction is committed, a commit
|
|
|
|
* record is written, XLOG_COMMIT_TRANS. If a single region can not fit into
|
|
|
|
* the remainder of the current active in-core log, it is split up into
|
|
|
|
* multiple regions. Each partial region will be marked with a
|
|
|
|
* XLOG_CONTINUE_TRANS until the last one, which gets marked with XLOG_END_TRANS.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#define XLOG_START_TRANS 0x01 /* Start a new transaction */
|
|
|
|
#define XLOG_COMMIT_TRANS 0x02 /* Commit this transaction */
|
|
|
|
#define XLOG_CONTINUE_TRANS 0x04 /* Cont this trans into new region */
|
|
|
|
#define XLOG_WAS_CONT_TRANS 0x08 /* Cont this trans into new region */
|
|
|
|
#define XLOG_END_TRANS 0x10 /* End a continued transaction */
|
|
|
|
#define XLOG_UNMOUNT_TRANS 0x20 /* Unmount a filesystem transaction */
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
/*
|
|
|
|
* Flags to log ticket
|
|
|
|
*/
|
|
|
|
#define XLOG_TIC_INITED 0x1 /* has been initialized */
|
|
|
|
#define XLOG_TIC_PERM_RESERV 0x2 /* permanent reservation */
|
|
|
|
#define XLOG_TIC_IN_Q 0x4
|
2009-12-15 02:14:59 +03:00
|
|
|
|
|
|
|
#define XLOG_TIC_FLAGS \
|
|
|
|
{ XLOG_TIC_INITED, "XLOG_TIC_INITED" }, \
|
|
|
|
{ XLOG_TIC_PERM_RESERV, "XLOG_TIC_PERM_RESERV" }, \
|
|
|
|
{ XLOG_TIC_IN_Q, "XLOG_TIC_IN_Q" }
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
|
|
|
#define XLOG_UNMOUNT_TYPE 0x556e /* Un for Unmount */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flags for log structure
|
|
|
|
*/
|
|
|
|
#define XLOG_CHKSUM_MISMATCH 0x1 /* used only during recovery */
|
|
|
|
#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 */
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
/*
|
|
|
|
* 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 10:42:05 +04: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 13:02:47 +03:00
|
|
|
uint r_len; /* region length :4 */
|
|
|
|
uint r_type; /* region's transaction type :4 */
|
2005-09-02 10:42:05 +04:00
|
|
|
} xlog_res_t;
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
typedef struct xlog_ticket {
|
2008-08-13 10:34:31 +04:00
|
|
|
sv_t t_wait; /* ticket wait queue : 20 */
|
2008-04-10 06:18:46 +04:00
|
|
|
struct xlog_ticket *t_next; /* :4|8 */
|
2005-09-02 10:42:05 +04:00
|
|
|
struct xlog_ticket *t_prev; /* :4|8 */
|
|
|
|
xlog_tid_t t_tid; /* transaction identifier : 4 */
|
2008-11-17 09:37:10 +03:00
|
|
|
atomic_t t_ref; /* ticket reference count : 4 */
|
2005-09-02 10:42:05 +04: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 13:02:47 +03:00
|
|
|
xlog_res_t t_res_arr[XLOG_TIC_LEN_MAX]; /* array of res : 8 * 15 */
|
2005-04-17 02:20:36 +04:00
|
|
|
} xlog_ticket_t;
|
2005-09-02 10:42:05 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct xlog_op_header {
|
2007-10-12 04:58:59 +04:00
|
|
|
__be32 oh_tid; /* transaction id of operation : 4 b */
|
|
|
|
__be32 oh_len; /* bytes in data region : 4 b */
|
|
|
|
__u8 oh_clientid; /* who sent me this : 1 b */
|
|
|
|
__u8 oh_flags; /* : 1 b */
|
|
|
|
__u16 oh_res2; /* 32 bit align : 2 b */
|
2005-04-17 02:20:36 +04:00
|
|
|
} xlog_op_header_t;
|
|
|
|
|
|
|
|
|
|
|
|
/* valid values for h_fmt */
|
|
|
|
#define XLOG_FMT_UNKNOWN 0
|
|
|
|
#define XLOG_FMT_LINUX_LE 1
|
|
|
|
#define XLOG_FMT_LINUX_BE 2
|
|
|
|
#define XLOG_FMT_IRIX_BE 3
|
|
|
|
|
|
|
|
/* our fmt */
|
2005-09-08 09:30:05 +04:00
|
|
|
#ifdef XFS_NATIVE_HOST
|
2005-04-17 02:20:36 +04:00
|
|
|
#define XLOG_FMT XLOG_FMT_LINUX_BE
|
|
|
|
#else
|
2005-09-08 09:30:05 +04:00
|
|
|
#define XLOG_FMT XLOG_FMT_LINUX_LE
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef struct xlog_rec_header {
|
2007-10-12 04:59:34 +04:00
|
|
|
__be32 h_magicno; /* log record (LR) identifier : 4 */
|
|
|
|
__be32 h_cycle; /* write cycle of log : 4 */
|
|
|
|
__be32 h_version; /* LR version : 4 */
|
|
|
|
__be32 h_len; /* len in bytes; should be 64-bit aligned: 4 */
|
|
|
|
__be64 h_lsn; /* lsn of this LR : 8 */
|
|
|
|
__be64 h_tail_lsn; /* lsn of 1st LR w/ buffers not committed: 8 */
|
|
|
|
__be32 h_chksum; /* may not be used; non-zero if used : 4 */
|
|
|
|
__be32 h_prev_block; /* block number to previous LR : 4 */
|
|
|
|
__be32 h_num_logops; /* number of log operations in this LR : 4 */
|
|
|
|
__be32 h_cycle_data[XLOG_HEADER_CYCLE_SIZE / BBSIZE];
|
2005-04-17 02:20:36 +04:00
|
|
|
/* new fields */
|
2007-10-12 04:59:34 +04:00
|
|
|
__be32 h_fmt; /* format of log record : 4 */
|
|
|
|
uuid_t h_fs_uuid; /* uuid of FS : 16 */
|
|
|
|
__be32 h_size; /* iclog size : 4 */
|
2005-04-17 02:20:36 +04:00
|
|
|
} xlog_rec_header_t;
|
|
|
|
|
|
|
|
typedef struct xlog_rec_ext_header {
|
2007-10-12 04:59:34 +04:00
|
|
|
__be32 xh_cycle; /* write cycle of log : 4 */
|
|
|
|
__be32 xh_cycle_data[XLOG_HEADER_CYCLE_SIZE / BBSIZE]; /* : 256 */
|
2005-04-17 02:20:36 +04:00
|
|
|
} xlog_rec_ext_header_t;
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
2008-11-28 06:23:38 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Quite misnamed, because this union lays out the actual on-disk log buffer.
|
|
|
|
*/
|
|
|
|
typedef union xlog_in_core2 {
|
|
|
|
xlog_rec_header_t hic_header;
|
|
|
|
xlog_rec_ext_header_t hic_xheader;
|
|
|
|
char hic_sector[XLOG_HEADER_SIZE];
|
|
|
|
} xlog_in_core_2_t;
|
|
|
|
|
2005-04-17 02:20:36 +04: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 10:34:31 +04:00
|
|
|
* - ic_forcewait is used to implement synchronous forcing of the iclog to disk.
|
2005-04-17 02:20:36 +04: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-10 06:18:39 +04: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-17 02:20:36 +04:00
|
|
|
*/
|
2008-11-28 06:23:38 +03:00
|
|
|
typedef struct xlog_in_core {
|
2008-08-13 10:34:31 +04:00
|
|
|
sv_t ic_force_wait;
|
|
|
|
sv_t ic_write_wait;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct xlog_in_core *ic_next;
|
|
|
|
struct xlog_in_core *ic_prev;
|
|
|
|
struct xfs_buf *ic_bp;
|
|
|
|
struct log *ic_log;
|
|
|
|
int ic_size;
|
|
|
|
int ic_offset;
|
|
|
|
int ic_bwritecnt;
|
2009-02-09 10:37:39 +03:00
|
|
|
unsigned short ic_state;
|
2005-04-17 02:20:36 +04:00
|
|
|
char *ic_datap; /* pointer to iclog data */
|
2008-04-10 06:18:39 +04:00
|
|
|
|
|
|
|
/* Callback structures need their own cacheline */
|
|
|
|
spinlock_t ic_callback_lock ____cacheline_aligned_in_smp;
|
|
|
|
xfs_log_callback_t *ic_callback;
|
|
|
|
xfs_log_callback_t **ic_callback_tail;
|
|
|
|
|
|
|
|
/* reference counts need their own cacheline */
|
|
|
|
atomic_t ic_refcnt ____cacheline_aligned_in_smp;
|
2008-11-28 06:23:38 +03:00
|
|
|
xlog_in_core_2_t *ic_data;
|
|
|
|
#define ic_header ic_data->hic_header
|
2005-04-17 02:20:36 +04:00
|
|
|
} xlog_in_core_t;
|
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 08:37:18 +04: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 */
|
|
|
|
xfs_log_callback_t log_cb; /* completion callback hook. */
|
|
|
|
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 {
|
|
|
|
struct log *xc_log;
|
|
|
|
struct list_head xc_cil;
|
|
|
|
spinlock_t xc_cil_lock;
|
|
|
|
struct xfs_cil_ctx *xc_ctx;
|
|
|
|
struct rw_semaphore xc_ctx_lock;
|
|
|
|
struct list_head xc_committing;
|
|
|
|
sv_t xc_commit_wait;
|
2010-08-24 05:40:03 +04:00
|
|
|
xfs_lsn_t 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-21 08:37:18 +04:00
|
|
|
};
|
|
|
|
|
2010-05-17 09:52:13 +04: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 12:13:44 +04:00
|
|
|
* The amount of log space we allow the CIL to aggregate is difficult to size.
|
|
|
|
* Whatever we choose, we have to make sure we can get a reservation for the
|
|
|
|
* log space effectively, that it is large enough to capture sufficient
|
|
|
|
* relogging to reduce log buffer IO significantly, but it is not too large for
|
|
|
|
* the log or induces too much latency when writing out through the iclogs. We
|
|
|
|
* track both space consumed and the number of vectors in the checkpoint
|
|
|
|
* context, so we need to decide which to use for limiting.
|
2010-05-17 09:52:13 +04: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 12:13:44 +04: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-17 09:52:13 +04: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 12:13:44 +04:00
|
|
|
#define XLOG_CIL_SPACE_LIMIT(log) (log->l_logsize >> 3)
|
|
|
|
#define XLOG_CIL_HARD_SPACE_LIMIT(log) (3 * (log->l_logsize >> 4))
|
2010-05-17 09:52:13 +04:00
|
|
|
|
2005-04-17 02:20:36 +04: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.
|
|
|
|
*/
|
|
|
|
typedef struct log {
|
2008-04-10 06:18:54 +04:00
|
|
|
/* The following fields don't need locking */
|
|
|
|
struct xfs_mount *l_mp; /* mount point */
|
2008-10-30 09:39:35 +03:00
|
|
|
struct xfs_ail *l_ailp; /* AIL log is working with */
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 08:37:18 +04:00
|
|
|
struct xfs_cil *l_cilp; /* CIL log is working with */
|
2008-04-10 06:18:54 +04:00
|
|
|
struct xfs_buf *l_xbuf; /* extra buffer for log
|
|
|
|
* wrapping */
|
|
|
|
struct xfs_buftarg *l_targ; /* buftarg of log */
|
|
|
|
uint l_flags;
|
|
|
|
uint l_quotaoffs_flag; /* XFS_DQ_*, for QUOTAOFFs */
|
|
|
|
struct xfs_buf_cancel **l_buf_cancel_table;
|
|
|
|
int l_iclog_hsize; /* size of iclog header */
|
|
|
|
int l_iclog_heads; /* # of iclog header sectors */
|
2010-04-20 11:10:21 +04:00
|
|
|
uint l_sectBBsize; /* sector size in BBs (2^n) */
|
2008-04-10 06:18:54 +04: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-17 02:20:36 +04:00
|
|
|
/* The following block of fields are changed while holding icloglock */
|
2008-05-19 10:34:27 +04:00
|
|
|
sv_t l_flush_wait ____cacheline_aligned_in_smp;
|
|
|
|
/* waiting for iclog flush */
|
2005-04-17 02:20:36 +04:00
|
|
|
int l_covered_state;/* state of "covering disk
|
|
|
|
* log entries" */
|
|
|
|
xlog_in_core_t *l_iclog; /* head log queue */
|
2007-10-11 11:37:10 +04:00
|
|
|
spinlock_t l_icloglock; /* grab to change iclog state */
|
2005-04-17 02:20:36 +04:00
|
|
|
xfs_lsn_t l_tail_lsn; /* lsn of 1st LR with unflushed
|
|
|
|
* buffers */
|
|
|
|
xfs_lsn_t l_last_sync_lsn;/* lsn of last LR on disk */
|
|
|
|
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 */
|
|
|
|
|
|
|
|
/* The following block of fields are changed while holding grant_lock */
|
2008-04-10 06:18:54 +04:00
|
|
|
spinlock_t l_grant_lock ____cacheline_aligned_in_smp;
|
2005-04-17 02:20:36 +04:00
|
|
|
xlog_ticket_t *l_reserve_headq;
|
|
|
|
xlog_ticket_t *l_write_headq;
|
|
|
|
int l_grant_reserve_cycle;
|
|
|
|
int l_grant_reserve_bytes;
|
|
|
|
int l_grant_write_cycle;
|
|
|
|
int l_grant_write_bytes;
|
|
|
|
|
2008-04-10 06:18:54 +04:00
|
|
|
/* The following field are used for debugging; need to hold icloglock */
|
|
|
|
#ifdef DEBUG
|
|
|
|
char *l_iclog_bak[XLOG_MAX_ICLOGS];
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
} xlog_t;
|
|
|
|
|
2005-11-02 07:12:04 +03:00
|
|
|
#define XLOG_FORCED_SHUTDOWN(log) ((log)->l_flags & XLOG_IO_ERROR)
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* common routines */
|
|
|
|
extern xfs_lsn_t xlog_assign_tail_lsn(struct xfs_mount *mp);
|
2006-01-11 07:34:19 +03:00
|
|
|
extern int xlog_recover(xlog_t *log);
|
2008-08-13 10:49:32 +04:00
|
|
|
extern int xlog_recover_finish(xlog_t *log);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void xlog_pack_data(xlog_t *log, xlog_in_core_t *iclog, int);
|
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 08:37:18 +04:00
|
|
|
extern kmem_zone_t *xfs_log_ticket_zone;
|
|
|
|
struct xlog_ticket *xlog_ticket_alloc(struct log *log, int unit_bytes,
|
|
|
|
int count, char client, uint xflags,
|
|
|
|
int alloc_flags);
|
|
|
|
|
2008-04-10 06:18:46 +04:00
|
|
|
|
2010-03-23 03:47:38 +03:00
|
|
|
static inline void
|
|
|
|
xlog_write_adv_cnt(void **ptr, int *len, int *off, size_t bytes)
|
|
|
|
{
|
|
|
|
*ptr += bytes;
|
|
|
|
*len -= bytes;
|
|
|
|
*off += bytes;
|
|
|
|
}
|
|
|
|
|
xfs: Introduce delayed logging core code
The delayed logging code only changes in-memory structures and as
such can be enabled and disabled with a mount option. Add the mount
option and emit a warning that this is an experimental feature that
should not be used in production yet.
We also need infrastructure to track committed items that have not
yet been written to the log. This is what the Committed Item List
(CIL) is for.
The log item also needs to be extended to track the current log
vector, the associated memory buffer and it's location in the Commit
Item List. Extend the log item and log vector structures to enable
this tracking.
To maintain the current log format for transactions with delayed
logging, we need to introduce a checkpoint transaction and a context
for tracking each checkpoint from initiation to transaction
completion. This includes adding a log ticket for tracking space
log required/used by the context checkpoint.
To track all the changes we need an io vector array per log item,
rather than a single array for the entire transaction. Using the new
log vector structure for this requires two passes - the first to
allocate the log vector structures and chain them together, and the
second to fill them out. This log vector chain can then be passed
to the CIL for formatting, pinning and insertion into the CIL.
Formatting of the log vector chain is relatively simple - it's just
a loop over the iovecs on each log vector, but it is made slightly
more complex because we re-write the iovec after the copy to point
back at the memory buffer we just copied into.
This code also needs to pin log items. If the log item is not
already tracked in this checkpoint context, then it needs to be
pinned. Otherwise it is already pinned and we don't need to pin it
again.
The only other complexity is calculating the amount of new log space
the formatting has consumed. This needs to be accounted to the
transaction in progress, and the accounting is made more complex
becase we need also to steal space from it for log metadata in the
checkpoint transaction. Calculate all this at insert time and update
all the tickets, counters, etc correctly.
Once we've formatted all the log items in the transaction, attach
the busy extents to the checkpoint context so the busy extents live
until checkpoint completion and can be processed at that point in
time. Transactions can then be freed at this point in time.
Now we need to issue checkpoints - we are tracking the amount of log space
used by the items in the CIL, so we can trigger background checkpoints when the
space usage gets to a certain threshold. Otherwise, checkpoints need ot be
triggered when a log synchronisation point is reached - a log force event.
Because the log write code already handles chained log vectors, writing the
transaction is trivial, too. Construct a transaction header, add it
to the head of the chain and write it into the log, then issue a
commit record write. Then we can release the checkpoint log ticket
and attach the context to the log buffer so it can be called during
Io completion to complete the checkpoint.
We also need to allow for synchronising multiple in-flight
checkpoints. This is needed for two things - the first is to ensure
that checkpoint commit records appear in the log in the correct
sequence order (so they are replayed in the correct order). The
second is so that xfs_log_force_lsn() operates correctly and only
flushes and/or waits for the specific sequence it was provided with.
To do this we need a wait variable and a list tracking the
checkpoint commits in progress. We can walk this list and wait for
the checkpoints to change state or complete easily, an this provides
the necessary synchronisation for correct operation in both cases.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-05-21 08:37:18 +04:00
|
|
|
void xlog_print_tic_res(struct xfs_mount *mp, struct xlog_ticket *ticket);
|
|
|
|
int xlog_write(struct log *log, struct xfs_log_vec *log_vector,
|
|
|
|
struct xlog_ticket *tic, xfs_lsn_t *start_lsn,
|
|
|
|
xlog_in_core_t **commit_iclog, uint flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Committed Item List interfaces
|
|
|
|
*/
|
|
|
|
int xlog_cil_init(struct log *log);
|
|
|
|
void xlog_cil_init_post_recovery(struct log *log);
|
|
|
|
void xlog_cil_destroy(struct log *log);
|
|
|
|
|
2010-08-24 05:40:03 +04:00
|
|
|
/*
|
|
|
|
* CIL force routines
|
|
|
|
*/
|
|
|
|
xfs_lsn_t xlog_cil_force_lsn(struct log *log, xfs_lsn_t sequence);
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
xlog_cil_force(struct log *log)
|
|
|
|
{
|
|
|
|
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-21 08:37:18 +04:00
|
|
|
|
2006-09-28 05:04:16 +04: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)
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
|
|
|
|
#endif /* __XFS_LOG_PRIV_H__ */
|