2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 20:58:39 -07:00
|
|
|
* Copyright (c) 2000-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
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_fs.h"
|
2013-10-22 17:36:05 -06:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 17:51:50 -06:00
|
|
|
#include "xfs_format.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_mount.h"
|
2017-10-31 13:04:49 -06:00
|
|
|
#include "xfs_errortag.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_error.h"
|
2013-10-22 17:50:10 -06:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_trans_priv.h"
|
|
|
|
#include "xfs_log.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "xfs_log_priv.h"
|
|
|
|
#include "xfs_log_recover.h"
|
2005-11-01 20:38:42 -07:00
|
|
|
#include "xfs_inode.h"
|
2009-12-14 16:14:59 -07:00
|
|
|
#include "xfs_trace.h"
|
2012-10-08 04:56:02 -06:00
|
|
|
#include "xfs_fsops.h"
|
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
|
|
|
#include "xfs_cksum.h"
|
2014-07-14 16:07:29 -06:00
|
|
|
#include "xfs_sysfs.h"
|
2015-01-21 15:10:31 -07:00
|
|
|
#include "xfs_sb.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-09 20:18:46 -06:00
|
|
|
kmem_zone_t *xfs_log_ticket_zone;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Local miscellaneous function prototypes */
|
2012-06-14 08:22:15 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_commit_record(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
struct xlog_in_core **iclog,
|
|
|
|
xfs_lsn_t *commitlsnp);
|
|
|
|
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC struct xlog *
|
|
|
|
xlog_alloc_log(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_buftarg *log_target,
|
|
|
|
xfs_daddr_t blk_offset,
|
|
|
|
int num_bblks);
|
2012-06-14 08:22:15 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_space_left(
|
|
|
|
struct xlog *log,
|
|
|
|
atomic64_t *head);
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_sync(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog);
|
|
|
|
STATIC void
|
|
|
|
xlog_dealloc_log(
|
|
|
|
struct xlog *log);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* local state machine functions */
|
|
|
|
STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int);
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_state_do_callback(
|
|
|
|
struct xlog *log,
|
|
|
|
int aborted,
|
|
|
|
struct xlog_in_core *iclog);
|
|
|
|
STATIC int
|
|
|
|
xlog_state_get_iclog_space(
|
|
|
|
struct xlog *log,
|
|
|
|
int len,
|
|
|
|
struct xlog_in_core **iclog,
|
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
int *continued_write,
|
|
|
|
int *logoffsetp);
|
|
|
|
STATIC int
|
|
|
|
xlog_state_release_iclog(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog);
|
|
|
|
STATIC void
|
|
|
|
xlog_state_switch_iclogs(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
int eventual_size);
|
|
|
|
STATIC void
|
|
|
|
xlog_state_want_sync(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-14 08:22:15 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_grant_push_ail(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
int need_bytes);
|
|
|
|
STATIC void
|
|
|
|
xlog_regrant_reserve_log_space(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_ticket *ticket);
|
|
|
|
STATIC void
|
|
|
|
xlog_ungrant_log_space(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_ticket *ticket);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-01 21:12:04 -07:00
|
|
|
#if defined(DEBUG)
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_verify_dest_ptr(
|
|
|
|
struct xlog *log,
|
2015-06-21 17:44:47 -06:00
|
|
|
void *ptr);
|
2012-06-14 08:22:15 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_verify_grant_tail(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log);
|
|
|
|
STATIC void
|
|
|
|
xlog_verify_iclog(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
int count,
|
2012-11-12 16:32:59 -07:00
|
|
|
bool syncing);
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC void
|
|
|
|
xlog_verify_tail_lsn(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
xfs_lsn_t tail_lsn);
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
|
|
|
#define xlog_verify_dest_ptr(a,b)
|
2010-12-20 18:02:52 -07:00
|
|
|
#define xlog_verify_grant_tail(a)
|
2005-04-16 16:20:36 -06:00
|
|
|
#define xlog_verify_iclog(a,b,c,d)
|
|
|
|
#define xlog_verify_tail_lsn(a,b,c)
|
|
|
|
#endif
|
|
|
|
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC int
|
|
|
|
xlog_iclogs_empty(
|
|
|
|
struct xlog *log);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-10 21:34:50 -07:00
|
|
|
static void
|
2010-12-20 18:06:05 -07:00
|
|
|
xlog_grant_sub_space(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
|
|
|
atomic64_t *head,
|
|
|
|
int bytes)
|
2006-01-10 21:34:50 -07:00
|
|
|
{
|
2010-12-20 18:29:14 -07:00
|
|
|
int64_t head_val = atomic64_read(head);
|
|
|
|
int64_t new, old;
|
2010-12-20 18:08:20 -07:00
|
|
|
|
2010-12-20 18:29:14 -07:00
|
|
|
do {
|
|
|
|
int cycle, space;
|
2010-12-20 18:08:20 -07:00
|
|
|
|
2010-12-20 18:29:14 -07:00
|
|
|
xlog_crack_grant_head_val(head_val, &cycle, &space);
|
2010-12-20 18:08:20 -07:00
|
|
|
|
2010-12-20 18:29:14 -07:00
|
|
|
space -= bytes;
|
|
|
|
if (space < 0) {
|
|
|
|
space += log->l_logsize;
|
|
|
|
cycle--;
|
|
|
|
}
|
|
|
|
|
|
|
|
old = head_val;
|
|
|
|
new = xlog_assign_grant_head_val(cycle, space);
|
|
|
|
head_val = atomic64_cmpxchg(head, old, new);
|
|
|
|
} while (head_val != old);
|
2006-01-10 21:34:50 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-12-20 18:06:05 -07:00
|
|
|
xlog_grant_add_space(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
|
|
|
atomic64_t *head,
|
|
|
|
int bytes)
|
2006-01-10 21:34:50 -07:00
|
|
|
{
|
2010-12-20 18:29:14 -07:00
|
|
|
int64_t head_val = atomic64_read(head);
|
|
|
|
int64_t new, old;
|
2010-12-20 18:08:20 -07:00
|
|
|
|
2010-12-20 18:29:14 -07:00
|
|
|
do {
|
|
|
|
int tmp;
|
|
|
|
int cycle, space;
|
2010-12-20 18:08:20 -07:00
|
|
|
|
2010-12-20 18:29:14 -07:00
|
|
|
xlog_crack_grant_head_val(head_val, &cycle, &space);
|
2010-12-20 18:08:20 -07:00
|
|
|
|
2010-12-20 18:29:14 -07:00
|
|
|
tmp = log->l_logsize - space;
|
|
|
|
if (tmp > bytes)
|
|
|
|
space += bytes;
|
|
|
|
else {
|
|
|
|
space = bytes - tmp;
|
|
|
|
cycle++;
|
|
|
|
}
|
|
|
|
|
|
|
|
old = head_val;
|
|
|
|
new = xlog_assign_grant_head_val(cycle, space);
|
|
|
|
head_val = atomic64_cmpxchg(head, old, new);
|
|
|
|
} while (head_val != old);
|
2006-01-10 21:34:50 -07:00
|
|
|
}
|
2010-12-20 18:08:20 -07:00
|
|
|
|
2012-02-19 19:31:26 -07:00
|
|
|
STATIC void
|
|
|
|
xlog_grant_head_init(
|
|
|
|
struct xlog_grant_head *head)
|
|
|
|
{
|
|
|
|
xlog_assign_grant_head(&head->grant, 1, 0);
|
|
|
|
INIT_LIST_HEAD(&head->waiters);
|
|
|
|
spin_lock_init(&head->lock);
|
|
|
|
}
|
|
|
|
|
2012-02-19 19:31:27 -07:00
|
|
|
STATIC void
|
|
|
|
xlog_grant_head_wake_all(
|
|
|
|
struct xlog_grant_head *head)
|
|
|
|
{
|
|
|
|
struct xlog_ticket *tic;
|
|
|
|
|
|
|
|
spin_lock(&head->lock);
|
|
|
|
list_for_each_entry(tic, &head->waiters, t_queue)
|
|
|
|
wake_up_process(tic->t_task);
|
|
|
|
spin_unlock(&head->lock);
|
|
|
|
}
|
|
|
|
|
2012-02-19 19:31:29 -07:00
|
|
|
static inline int
|
|
|
|
xlog_ticket_reservation(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2012-02-19 19:31:29 -07:00
|
|
|
struct xlog_grant_head *head,
|
|
|
|
struct xlog_ticket *tic)
|
2011-11-28 01:17:36 -07:00
|
|
|
{
|
2012-02-19 19:31:29 -07:00
|
|
|
if (head == &log->l_write_head) {
|
|
|
|
ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV);
|
|
|
|
return tic->t_unit_res;
|
|
|
|
} else {
|
2011-11-28 01:17:36 -07:00
|
|
|
if (tic->t_flags & XLOG_TIC_PERM_RESERV)
|
2012-02-19 19:31:29 -07:00
|
|
|
return tic->t_unit_res * tic->t_cnt;
|
2011-11-28 01:17:36 -07:00
|
|
|
else
|
2012-02-19 19:31:29 -07:00
|
|
|
return tic->t_unit_res;
|
2011-11-28 01:17:36 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC bool
|
2012-02-19 19:31:29 -07:00
|
|
|
xlog_grant_head_wake(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2012-02-19 19:31:29 -07:00
|
|
|
struct xlog_grant_head *head,
|
2011-11-28 01:17:36 -07:00
|
|
|
int *free_bytes)
|
|
|
|
{
|
|
|
|
struct xlog_ticket *tic;
|
|
|
|
int need_bytes;
|
|
|
|
|
2012-02-19 19:31:29 -07:00
|
|
|
list_for_each_entry(tic, &head->waiters, t_queue) {
|
|
|
|
need_bytes = xlog_ticket_reservation(log, head, tic);
|
2011-11-28 01:17:36 -07:00
|
|
|
if (*free_bytes < need_bytes)
|
|
|
|
return false;
|
|
|
|
|
2012-02-19 19:31:29 -07:00
|
|
|
*free_bytes -= need_bytes;
|
|
|
|
trace_xfs_log_grant_wake_up(log, tic);
|
2012-02-19 19:31:24 -07:00
|
|
|
wake_up_process(tic->t_task);
|
2011-11-28 01:17:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC int
|
2012-02-19 19:31:28 -07:00
|
|
|
xlog_grant_head_wait(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2012-02-19 19:31:28 -07:00
|
|
|
struct xlog_grant_head *head,
|
2011-11-28 01:17:36 -07:00
|
|
|
struct xlog_ticket *tic,
|
2013-09-02 04:49:36 -06:00
|
|
|
int need_bytes) __releases(&head->lock)
|
|
|
|
__acquires(&head->lock)
|
2011-11-28 01:17:36 -07:00
|
|
|
{
|
2012-02-19 19:31:28 -07:00
|
|
|
list_add_tail(&tic->t_queue, &head->waiters);
|
2011-11-28 01:17:36 -07:00
|
|
|
|
|
|
|
do {
|
|
|
|
if (XLOG_FORCED_SHUTDOWN(log))
|
|
|
|
goto shutdown;
|
|
|
|
xlog_grant_push_ail(log, need_bytes);
|
|
|
|
|
2012-02-19 19:31:24 -07:00
|
|
|
__set_current_state(TASK_UNINTERRUPTIBLE);
|
2012-02-19 19:31:28 -07:00
|
|
|
spin_unlock(&head->lock);
|
2012-02-19 19:31:24 -07:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(log->l_mp, xs_sleep_logspace);
|
2011-11-28 01:17:36 -07:00
|
|
|
|
2012-02-19 19:31:24 -07:00
|
|
|
trace_xfs_log_grant_sleep(log, tic);
|
|
|
|
schedule();
|
2011-11-28 01:17:36 -07:00
|
|
|
trace_xfs_log_grant_wake(log, tic);
|
|
|
|
|
2012-02-19 19:31:28 -07:00
|
|
|
spin_lock(&head->lock);
|
2011-11-28 01:17:36 -07:00
|
|
|
if (XLOG_FORCED_SHUTDOWN(log))
|
|
|
|
goto shutdown;
|
2012-02-19 19:31:28 -07:00
|
|
|
} while (xlog_space_left(log, &head->grant) < need_bytes);
|
2011-11-28 01:17:36 -07:00
|
|
|
|
|
|
|
list_del_init(&tic->t_queue);
|
|
|
|
return 0;
|
|
|
|
shutdown:
|
|
|
|
list_del_init(&tic->t_queue);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2011-11-28 01:17:36 -07:00
|
|
|
}
|
|
|
|
|
2012-02-19 19:31:30 -07:00
|
|
|
/*
|
|
|
|
* Atomically get the log space required for a log ticket.
|
|
|
|
*
|
|
|
|
* Once a ticket gets put onto head->waiters, it will only return after the
|
|
|
|
* needed reservation is satisfied.
|
|
|
|
*
|
|
|
|
* This function is structured so that it has a lock free fast path. This is
|
|
|
|
* necessary because every new transaction reservation will come through this
|
|
|
|
* path. Hence any lock will be globally hot if we take it unconditionally on
|
|
|
|
* every pass.
|
|
|
|
*
|
|
|
|
* As tickets are only ever moved on and off head->waiters under head->lock, we
|
|
|
|
* only need to take that lock if we are going to add the ticket to the queue
|
|
|
|
* and sleep. We can avoid taking the lock if the ticket was never added to
|
|
|
|
* head->waiters because the t_queue list head will be empty and we hold the
|
|
|
|
* only reference to it so it can safely be checked unlocked.
|
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_grant_head_check(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2012-02-19 19:31:30 -07:00
|
|
|
struct xlog_grant_head *head,
|
|
|
|
struct xlog_ticket *tic,
|
|
|
|
int *need_bytes)
|
|
|
|
{
|
|
|
|
int free_bytes;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are other waiters on the queue then give them a chance at
|
|
|
|
* logspace before us. Wake up the first waiters, if we do not wake
|
|
|
|
* up all the waiters then go to sleep waiting for more free space,
|
|
|
|
* otherwise try to get some space for this transaction.
|
|
|
|
*/
|
|
|
|
*need_bytes = xlog_ticket_reservation(log, head, tic);
|
|
|
|
free_bytes = xlog_space_left(log, &head->grant);
|
|
|
|
if (!list_empty_careful(&head->waiters)) {
|
|
|
|
spin_lock(&head->lock);
|
|
|
|
if (!xlog_grant_head_wake(log, head, &free_bytes) ||
|
|
|
|
free_bytes < *need_bytes) {
|
|
|
|
error = xlog_grant_head_wait(log, head, tic,
|
|
|
|
*need_bytes);
|
|
|
|
}
|
|
|
|
spin_unlock(&head->lock);
|
|
|
|
} else if (free_bytes < *need_bytes) {
|
|
|
|
spin_lock(&head->lock);
|
|
|
|
error = xlog_grant_head_wait(log, head, tic, *need_bytes);
|
|
|
|
spin_unlock(&head->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-08-30 01:21:46 -06:00
|
|
|
static void
|
|
|
|
xlog_tic_reset_res(xlog_ticket_t *tic)
|
|
|
|
{
|
|
|
|
tic->t_res_num = 0;
|
|
|
|
tic->t_res_arr_sum = 0;
|
|
|
|
tic->t_res_num_ophdrs = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type)
|
|
|
|
{
|
|
|
|
if (tic->t_res_num == XLOG_TIC_LEN_MAX) {
|
|
|
|
/* add to overflow and start again */
|
|
|
|
tic->t_res_o_flow += tic->t_res_arr_sum;
|
|
|
|
tic->t_res_num = 0;
|
|
|
|
tic->t_res_arr_sum = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
tic->t_res_arr[tic->t_res_num].r_len = len;
|
|
|
|
tic->t_res_arr[tic->t_res_num].r_type = type;
|
|
|
|
tic->t_res_arr_sum += len;
|
|
|
|
tic->t_res_num++;
|
|
|
|
}
|
2006-01-10 21:34:50 -07:00
|
|
|
|
2012-02-19 19:31:31 -07:00
|
|
|
/*
|
|
|
|
* Replenish the byte reservation required by moving the grant write head.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_log_regrant(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xlog_ticket *tic)
|
|
|
|
{
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2012-02-19 19:31:31 -07:00
|
|
|
int need_bytes;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (XLOG_FORCED_SHUTDOWN(log))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2012-02-19 19:31:31 -07:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_try_logspace);
|
2012-02-19 19:31:31 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a new transaction on the ticket, so we need to change the
|
|
|
|
* transaction ID so that the next transaction has a different TID in
|
|
|
|
* the log. Just add one to the existing tid so that we can see chains
|
|
|
|
* of rolling transactions in the log easily.
|
|
|
|
*/
|
|
|
|
tic->t_tid++;
|
|
|
|
|
|
|
|
xlog_grant_push_ail(log, tic->t_unit_res);
|
|
|
|
|
|
|
|
tic->t_curr_res = tic->t_unit_res;
|
|
|
|
xlog_tic_reset_res(tic);
|
|
|
|
|
|
|
|
if (tic->t_cnt > 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
trace_xfs_log_regrant(log, tic);
|
|
|
|
|
|
|
|
error = xlog_grant_head_check(log, &log->l_write_head, tic,
|
|
|
|
&need_bytes);
|
|
|
|
if (error)
|
|
|
|
goto out_error;
|
|
|
|
|
|
|
|
xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);
|
|
|
|
trace_xfs_log_regrant_exit(log, tic);
|
|
|
|
xlog_verify_grant_tail(log);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_error:
|
|
|
|
/*
|
|
|
|
* If we are failing, make sure the ticket doesn't have any current
|
|
|
|
* reservations. We don't want to add this back when the ticket/
|
|
|
|
* transaction gets cancelled.
|
|
|
|
*/
|
|
|
|
tic->t_curr_res = 0;
|
|
|
|
tic->t_cnt = 0; /* ungrant will give back unit_res * t_cnt. */
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reserve log space and return a ticket corresponding the reservation.
|
|
|
|
*
|
|
|
|
* Each reservation is going to reserve extra space for a log record header.
|
|
|
|
* When writes happen to the on-disk log, we don't subtract the length of the
|
|
|
|
* log record header from any reservation. By wasting space in each
|
|
|
|
* reservation, we prevent over allocation problems.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_log_reserve(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int unit_bytes,
|
|
|
|
int cnt,
|
|
|
|
struct xlog_ticket **ticp,
|
2017-06-16 12:00:05 -06:00
|
|
|
uint8_t client,
|
2016-04-05 17:20:36 -06:00
|
|
|
bool permanent)
|
2012-02-19 19:31:31 -07:00
|
|
|
{
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2012-02-19 19:31:31 -07:00
|
|
|
struct xlog_ticket *tic;
|
|
|
|
int need_bytes;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
|
|
|
|
|
|
|
|
if (XLOG_FORCED_SHUTDOWN(log))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2012-02-19 19:31:31 -07:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_try_logspace);
|
2012-02-19 19:31:31 -07:00
|
|
|
|
|
|
|
ASSERT(*ticp == NULL);
|
|
|
|
tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,
|
|
|
|
KM_SLEEP | KM_MAYFAIL);
|
|
|
|
if (!tic)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -ENOMEM;
|
2012-02-19 19:31:31 -07:00
|
|
|
|
|
|
|
*ticp = tic;
|
|
|
|
|
2012-11-27 19:01:00 -07:00
|
|
|
xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt
|
|
|
|
: tic->t_unit_res);
|
2012-02-19 19:31:31 -07:00
|
|
|
|
|
|
|
trace_xfs_log_reserve(log, tic);
|
|
|
|
|
|
|
|
error = xlog_grant_head_check(log, &log->l_reserve_head, tic,
|
|
|
|
&need_bytes);
|
|
|
|
if (error)
|
|
|
|
goto out_error;
|
|
|
|
|
|
|
|
xlog_grant_add_space(log, &log->l_reserve_head.grant, need_bytes);
|
|
|
|
xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);
|
|
|
|
trace_xfs_log_reserve_exit(log, tic);
|
|
|
|
xlog_verify_grant_tail(log);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_error:
|
|
|
|
/*
|
|
|
|
* If we are failing, make sure the ticket doesn't have any current
|
|
|
|
* reservations. We don't want to add this back when the ticket/
|
|
|
|
* transaction gets cancelled.
|
|
|
|
*/
|
|
|
|
tic->t_curr_res = 0;
|
|
|
|
tic->t_cnt = 0; /* ungrant will give back unit_res * t_cnt. */
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* NOTES:
|
|
|
|
*
|
|
|
|
* 1. currblock field gets updated at startup and after in-core logs
|
|
|
|
* marked as with WANT_SYNC.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called when a user of a log manager ticket is done with
|
|
|
|
* the reservation. If the ticket was ever used, then a commit record for
|
|
|
|
* the associated transaction is written out as a log operation header with
|
|
|
|
* no data. The flag XLOG_TIC_INITED is set when the first write occurs with
|
|
|
|
* a given ticket. If the ticket was one with a permanent reservation, then
|
|
|
|
* a few operations are done differently. Permanent reservation tickets by
|
|
|
|
* default don't release the reservation. They just commit the current
|
|
|
|
* transaction with the belief that the reservation is still needed. A flag
|
|
|
|
* must be passed in before permanent reservations are actually released.
|
|
|
|
* When these type of tickets are not released, they need to be set into
|
|
|
|
* the inited state again. By doing this, a start record will be written
|
|
|
|
* out when the next write occurs.
|
|
|
|
*/
|
|
|
|
xfs_lsn_t
|
2010-02-15 16:34:54 -07:00
|
|
|
xfs_log_done(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
struct xlog_in_core **iclog,
|
2015-06-03 21:48:20 -06:00
|
|
|
bool regrant)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2010-02-15 16:34:54 -07:00
|
|
|
xfs_lsn_t lsn = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (XLOG_FORCED_SHUTDOWN(log) ||
|
|
|
|
/*
|
|
|
|
* If nothing was ever written, don't write out commit record.
|
|
|
|
* If we get an error, just continue and give back the log ticket.
|
|
|
|
*/
|
|
|
|
(((ticket->t_flags & XLOG_TIC_INITED) == 0) &&
|
2010-03-22 18:43:17 -06:00
|
|
|
(xlog_commit_record(log, ticket, iclog, &lsn)))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
lsn = (xfs_lsn_t) -1;
|
2015-06-03 21:48:20 -06:00
|
|
|
regrant = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-06-03 21:48:20 -06:00
|
|
|
if (!regrant) {
|
2009-12-14 16:14:59 -07:00
|
|
|
trace_xfs_log_done_nonperm(log, ticket);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-03-28 15:55:14 -07:00
|
|
|
* Release ticket if not permanent reservation or a specific
|
2005-04-16 16:20:36 -06:00
|
|
|
* request has been made to release a permanent reservation.
|
|
|
|
*/
|
|
|
|
xlog_ungrant_log_space(log, ticket);
|
|
|
|
} else {
|
2009-12-14 16:14:59 -07:00
|
|
|
trace_xfs_log_done_perm(log, ticket);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_regrant_reserve_log_space(log, ticket);
|
2008-08-13 00:52:50 -06:00
|
|
|
/* If this ticket was a permanent reservation and we aren't
|
|
|
|
* trying to release it, reset the inited flags; so next time
|
|
|
|
* we write, a start record will be written out.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
ticket->t_flags |= XLOG_TIC_INITED;
|
2008-08-13 00:52:50 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-06-03 21:48:20 -06:00
|
|
|
xfs_log_ticket_put(ticket);
|
2005-04-16 16:20:36 -06:00
|
|
|
return lsn;
|
2010-02-15 16:34:54 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Attaches a new iclog I/O completion callback routine during
|
|
|
|
* transaction commit. If the log is in error state, a non-zero
|
|
|
|
* return code is handed back and the caller is responsible for
|
|
|
|
* executing the callback at an appropriate time.
|
|
|
|
*/
|
|
|
|
int
|
2010-02-15 16:34:54 -07:00
|
|
|
xfs_log_notify(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
xfs_log_callback_t *cb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-10-11 01:37:10 -06:00
|
|
|
int abortflg;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-09 20:18:39 -06:00
|
|
|
spin_lock(&iclog->ic_callback_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
abortflg = (iclog->ic_state & XLOG_STATE_IOERROR);
|
|
|
|
if (!abortflg) {
|
|
|
|
ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) ||
|
|
|
|
(iclog->ic_state == XLOG_STATE_WANT_SYNC));
|
|
|
|
cb->cb_next = NULL;
|
|
|
|
*(iclog->ic_callback_tail) = cb;
|
|
|
|
iclog->ic_callback_tail = &(cb->cb_next);
|
|
|
|
}
|
2008-04-09 20:18:39 -06:00
|
|
|
spin_unlock(&iclog->ic_callback_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return abortflg;
|
2010-02-15 16:34:54 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
int
|
2010-02-15 16:34:54 -07:00
|
|
|
xfs_log_release_iclog(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xlog_in_core *iclog)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-02-15 16:34:54 -07:00
|
|
|
if (xlog_state_release_iclog(mp->m_log, iclog)) {
|
2006-06-08 22:58:38 -06:00
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mount a log filesystem
|
|
|
|
*
|
|
|
|
* mp - ubiquitous xfs mount point structure
|
|
|
|
* log_target - buftarg of on-disk log device
|
|
|
|
* blk_offset - Start block # where block size is 512 bytes (BBSIZE)
|
|
|
|
* num_bblocks - Number of BBSIZE blocks in on-disk log
|
|
|
|
*
|
|
|
|
* Return error or zero.
|
|
|
|
*/
|
|
|
|
int
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
xfs_log_mount(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
xfs_buftarg_t *log_target,
|
|
|
|
xfs_daddr_t blk_offset,
|
|
|
|
int num_bblks)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2017-10-25 17:59:43 -06:00
|
|
|
bool fatal = xfs_sb_version_hascrc(&mp->m_sb);
|
2013-08-12 04:50:03 -06:00
|
|
|
int error = 0;
|
|
|
|
int min_logfsbs;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
|
2014-05-05 00:18:37 -06:00
|
|
|
if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
|
|
|
|
xfs_notice(mp, "Mounting V%d Filesystem",
|
|
|
|
XFS_SB_VERSION_NUM(&mp->m_sb));
|
|
|
|
} else {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_notice(mp,
|
2014-05-05 00:18:37 -06:00
|
|
|
"Mounting V%d filesystem in no-recovery mode. Filesystem will be inconsistent.",
|
|
|
|
XFS_SB_VERSION_NUM(&mp->m_sb));
|
2007-08-30 01:21:12 -06:00
|
|
|
ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
|
2009-04-06 10:39:27 -06:00
|
|
|
if (IS_ERR(mp->m_log)) {
|
2014-06-24 22:58:08 -06:00
|
|
|
error = PTR_ERR(mp->m_log);
|
2008-11-09 22:50:24 -07:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-12 04:50:03 -06:00
|
|
|
/*
|
|
|
|
* Validate the given log space and drop a critical message via syslog
|
|
|
|
* if the log size is too small that would lead to some unexpected
|
|
|
|
* situations in transaction log space reservation stage.
|
|
|
|
*
|
|
|
|
* Note: we can't just reject the mount if the validation fails. This
|
|
|
|
* would mean that people would have to downgrade their kernel just to
|
|
|
|
* remedy the situation as there is no way to grow the log (short of
|
|
|
|
* black magic surgery with xfs_db).
|
|
|
|
*
|
|
|
|
* We can, however, reject mounts for CRC format filesystems, as the
|
|
|
|
* mkfs binary being used to make the filesystem should never create a
|
|
|
|
* filesystem with a log that is too small.
|
|
|
|
*/
|
|
|
|
min_logfsbs = xfs_log_calc_minimum_size(mp);
|
|
|
|
|
|
|
|
if (mp->m_sb.sb_logblocks < min_logfsbs) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"Log size %d blocks too small, minimum size is %d blocks",
|
|
|
|
mp->m_sb.sb_logblocks, min_logfsbs);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EINVAL;
|
2013-08-12 04:50:03 -06:00
|
|
|
} else if (mp->m_sb.sb_logblocks > XFS_MAX_LOG_BLOCKS) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"Log size %d blocks too large, maximum size is %lld blocks",
|
|
|
|
mp->m_sb.sb_logblocks, XFS_MAX_LOG_BLOCKS);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EINVAL;
|
2013-08-12 04:50:03 -06:00
|
|
|
} else if (XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks) > XFS_MAX_LOG_BYTES) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"log size %lld bytes too large, maximum size is %lld bytes",
|
|
|
|
XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks),
|
|
|
|
XFS_MAX_LOG_BYTES);
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EINVAL;
|
2017-10-25 17:59:43 -06:00
|
|
|
} else if (mp->m_sb.sb_logsunit > 1 &&
|
|
|
|
mp->m_sb.sb_logsunit % mp->m_sb.sb_blocksize) {
|
|
|
|
xfs_warn(mp,
|
|
|
|
"log stripe unit %u bytes must be a multiple of block size",
|
|
|
|
mp->m_sb.sb_logsunit);
|
|
|
|
error = -EINVAL;
|
|
|
|
fatal = true;
|
2013-08-12 04:50:03 -06:00
|
|
|
}
|
|
|
|
if (error) {
|
2017-10-25 17:59:43 -06:00
|
|
|
/*
|
|
|
|
* Log check errors are always fatal on v5; or whenever bad
|
|
|
|
* metadata leads to a crash.
|
|
|
|
*/
|
|
|
|
if (fatal) {
|
2013-08-12 04:50:03 -06:00
|
|
|
xfs_crit(mp, "AAIEEE! Log failed size checks. Abort!");
|
|
|
|
ASSERT(0);
|
|
|
|
goto out_free_log;
|
|
|
|
}
|
2015-07-28 19:52:04 -06:00
|
|
|
xfs_crit(mp, "Log size out of supported range.");
|
2013-08-12 04:50:03 -06:00
|
|
|
xfs_crit(mp,
|
2015-07-28 19:52:04 -06:00
|
|
|
"Continuing onwards, but if log hangs are experienced then please report this message in the bug report.");
|
2013-08-12 04:50:03 -06:00
|
|
|
}
|
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
/*
|
|
|
|
* Initialize the AIL now we have a log.
|
|
|
|
*/
|
|
|
|
error = xfs_trans_ail_init(mp);
|
|
|
|
if (error) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "AIL initialisation failed: error %d", error);
|
2009-02-12 11:55:48 -07:00
|
|
|
goto out_free_log;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
}
|
2008-10-30 00:39:35 -06:00
|
|
|
mp->m_log->l_ailp = mp->m_ail;
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* skip log recovery on a norecovery mount. pretend it all
|
|
|
|
* just worked.
|
|
|
|
*/
|
|
|
|
if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
int readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (readonly)
|
2007-08-30 01:21:12 -06:00
|
|
|
mp->m_flags &= ~XFS_MOUNT_RDONLY;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-10 21:34:19 -07:00
|
|
|
error = xlog_recover(mp->m_log);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (readonly)
|
2007-08-30 01:21:12 -06:00
|
|
|
mp->m_flags |= XFS_MOUNT_RDONLY;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "log mount/recovery failed: error %d",
|
|
|
|
error);
|
2015-08-18 17:58:36 -06:00
|
|
|
xlog_recover_cancel(mp->m_log);
|
2009-02-12 11:55:48 -07:00
|
|
|
goto out_destroy_ail;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-14 16:07:29 -06:00
|
|
|
error = xfs_sysfs_init(&mp->m_log->l_kobj, &xfs_log_ktype, &mp->m_kobj,
|
|
|
|
"log");
|
|
|
|
if (error)
|
|
|
|
goto out_destroy_ail;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Normal transactions can now occur */
|
|
|
|
mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
* Now the log has been fully initialised and we know were our
|
|
|
|
* space grant counters are, we can initialise the permanent ticket
|
|
|
|
* needed for delayed logging to work.
|
|
|
|
*/
|
|
|
|
xlog_cil_init_post_recovery(mp->m_log);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2009-02-12 11:55:48 -07:00
|
|
|
|
|
|
|
out_destroy_ail:
|
|
|
|
xfs_trans_ail_destroy(mp);
|
|
|
|
out_free_log:
|
|
|
|
xlog_dealloc_log(mp->m_log);
|
2008-11-09 22:50:24 -07:00
|
|
|
out:
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
return error;
|
2009-02-12 11:55:48 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2012-10-08 04:56:02 -06:00
|
|
|
* Finish the recovery of the file system. This is separate from the
|
|
|
|
* xfs_log_mount() call, because it depends on the code in xfs_mountfs() to read
|
|
|
|
* in the root and real-time bitmap inodes between calling xfs_log_mount() and
|
|
|
|
* here.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2012-10-08 04:56:02 -06:00
|
|
|
* If we finish recovery successfully, start the background log work. If we are
|
|
|
|
* not doing recovery, then we have a RO filesystem and we don't need to start
|
|
|
|
* it.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
2015-08-18 17:58:36 -06:00
|
|
|
xfs_log_mount_finish(
|
|
|
|
struct xfs_mount *mp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-10-08 04:56:02 -06:00
|
|
|
int error = 0;
|
2017-08-08 19:21:49 -06:00
|
|
|
bool readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
|
2017-10-26 10:31:16 -06:00
|
|
|
bool recovered = mp->m_log->l_flags & XLOG_RECOVERY_NEEDED;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-08-18 17:58:36 -06:00
|
|
|
if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
|
2007-08-30 01:21:12 -06:00
|
|
|
ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
|
2015-08-18 17:58:36 -06:00
|
|
|
return 0;
|
2017-08-08 19:21:49 -06:00
|
|
|
} else if (readonly) {
|
|
|
|
/* Allow unlinked processing to proceed */
|
|
|
|
mp->m_flags &= ~XFS_MOUNT_RDONLY;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2017-08-10 15:20:28 -06:00
|
|
|
/*
|
|
|
|
* During the second phase of log recovery, we need iget and
|
|
|
|
* iput to behave like they do for an active filesystem.
|
|
|
|
* xfs_fs_drop_inode needs to be able to prevent the deletion
|
|
|
|
* of inodes before we're done replaying log items on those
|
|
|
|
* inodes. Turn it off immediately after recovery finishes
|
|
|
|
* so that we don't leak the quota inodes if subsequent mount
|
|
|
|
* activities fail.
|
2017-08-18 19:08:25 -06:00
|
|
|
*
|
|
|
|
* We let all inodes involved in redo item processing end up on
|
|
|
|
* the LRU instead of being evicted immediately so that if we do
|
|
|
|
* something to an unlinked inode, the irele won't cause
|
|
|
|
* premature truncation and freeing of the inode, which results
|
|
|
|
* in log recovery failure. We have to evict the unreferenced
|
2017-11-27 14:05:09 -07:00
|
|
|
* lru inodes after clearing SB_ACTIVE because we don't
|
2017-08-18 19:08:25 -06:00
|
|
|
* otherwise clean up the lru if there's a subsequent failure in
|
|
|
|
* xfs_mountfs, which leads to us leaking the inodes if nothing
|
|
|
|
* else (e.g. quotacheck) references the inodes before the
|
|
|
|
* mount failure occurs.
|
2017-08-10 15:20:28 -06:00
|
|
|
*/
|
2017-11-27 14:05:09 -07:00
|
|
|
mp->m_super->s_flags |= SB_ACTIVE;
|
2015-08-18 17:58:36 -06:00
|
|
|
error = xlog_recover_finish(mp->m_log);
|
|
|
|
if (!error)
|
|
|
|
xfs_log_work_queue(mp);
|
2017-11-27 14:05:09 -07:00
|
|
|
mp->m_super->s_flags &= ~SB_ACTIVE;
|
2017-08-18 19:08:25 -06:00
|
|
|
evict_inodes(mp->m_super);
|
2015-08-18 17:58:36 -06:00
|
|
|
|
2017-10-26 10:31:16 -06:00
|
|
|
/*
|
|
|
|
* Drain the buffer LRU after log recovery. This is required for v4
|
|
|
|
* filesystems to avoid leaving around buffers with NULL verifier ops,
|
|
|
|
* but we do it unconditionally to make sure we're always in a clean
|
|
|
|
* cache state after mount.
|
|
|
|
*
|
|
|
|
* Don't push in the error case because the AIL may have pending intents
|
|
|
|
* that aren't removed until recovery is cancelled.
|
|
|
|
*/
|
|
|
|
if (!error && recovered) {
|
|
|
|
xfs_log_force(mp, XFS_LOG_SYNC);
|
|
|
|
xfs_ail_push_all_sync(mp->m_ail);
|
|
|
|
}
|
|
|
|
xfs_wait_buftarg(mp->m_ddev_targp);
|
|
|
|
|
2017-08-08 19:21:49 -06:00
|
|
|
if (readonly)
|
|
|
|
mp->m_flags |= XFS_MOUNT_RDONLY;
|
|
|
|
|
2015-08-18 17:58:36 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The mount has failed. Cancel the recovery if it hasn't completed and destroy
|
|
|
|
* the log.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_log_mount_cancel(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = xlog_recover_cancel(mp->m_log);
|
|
|
|
xfs_log_unmount(mp);
|
2012-10-08 04:56:02 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Final log writes as part of unmount.
|
|
|
|
*
|
|
|
|
* Mark the filesystem clean as unmount happens. Note that during relocation
|
|
|
|
* this routine needs to be executed as part of source-bag while the
|
|
|
|
* deallocation must not be done until source-end.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unmount record used to have a string "Unmount filesystem--" in the
|
|
|
|
* data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE).
|
|
|
|
* We just write the magic number now since that particular field isn't
|
2013-08-11 21:15:00 -06:00
|
|
|
* currently architecture converted and "Unmount" is a bit foo.
|
2005-04-16 16:20:36 -06:00
|
|
|
* As far as I know, there weren't any dependencies on the old behaviour.
|
|
|
|
*/
|
|
|
|
|
2016-06-01 01:38:15 -06:00
|
|
|
static int
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_log_unmount_write(xfs_mount_t *mp)
|
|
|
|
{
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_in_core_t *iclog;
|
|
|
|
#ifdef DEBUG
|
|
|
|
xlog_in_core_t *first_iclog;
|
|
|
|
#endif
|
2010-02-15 16:34:54 -07:00
|
|
|
xlog_ticket_t *tic = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_lsn_t lsn;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
2017-08-08 19:19:47 -06:00
|
|
|
* Don't write out unmount record on norecovery mounts or ro devices.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Or, if we are doing a forced umount (typically because of IO errors).
|
|
|
|
*/
|
2017-08-08 19:19:47 -06:00
|
|
|
if (mp->m_flags & XFS_MOUNT_NORECOVERY ||
|
|
|
|
xfs_readonly_buftarg(log->l_mp->m_logdev_targp)) {
|
|
|
|
ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2017-08-08 19:19:47 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-19 02:56:46 -07:00
|
|
|
error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
|
2008-04-09 20:24:30 -06:00
|
|
|
ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log)));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
first_iclog = iclog = log->l_iclog;
|
|
|
|
do {
|
|
|
|
if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
|
|
|
|
ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE);
|
|
|
|
ASSERT(iclog->ic_offset == 0);
|
|
|
|
}
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
} while (iclog != first_iclog);
|
|
|
|
#endif
|
|
|
|
if (! (XLOG_FORCED_SHUTDOWN(log))) {
|
2016-04-05 17:20:36 -06:00
|
|
|
error = xfs_log_reserve(mp, 600, 1, &tic, XFS_LOG, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!error) {
|
2010-03-22 18:43:17 -06:00
|
|
|
/* the data section must be 32 bit size aligned */
|
|
|
|
struct {
|
2017-06-16 12:00:05 -06:00
|
|
|
uint16_t magic;
|
|
|
|
uint16_t pad1;
|
|
|
|
uint32_t pad2; /* may as well make it 64 bits */
|
2010-03-22 18:43:17 -06:00
|
|
|
} magic = {
|
|
|
|
.magic = XLOG_UNMOUNT_TYPE,
|
|
|
|
};
|
|
|
|
struct xfs_log_iovec reg = {
|
2010-06-23 02:11:15 -06:00
|
|
|
.i_addr = &magic,
|
2010-03-22 18:43:17 -06:00
|
|
|
.i_len = sizeof(magic),
|
|
|
|
.i_type = XLOG_REG_TYPE_UNMOUNT,
|
|
|
|
};
|
|
|
|
struct xfs_log_vec vec = {
|
|
|
|
.lv_niovecs = 1,
|
|
|
|
.lv_iovecp = ®,
|
|
|
|
};
|
|
|
|
|
2012-03-21 23:15:11 -06:00
|
|
|
/* remove inited flag, and account for space used */
|
2010-03-22 18:43:17 -06:00
|
|
|
tic->t_flags = 0;
|
2012-03-21 23:15:11 -06:00
|
|
|
tic->t_curr_res -= sizeof(magic);
|
2010-03-22 18:43:17 -06:00
|
|
|
error = xlog_write(log, &vec, tic, &lsn,
|
2005-04-16 16:20:36 -06:00
|
|
|
NULL, XLOG_UNMOUNT_TRANS);
|
|
|
|
/*
|
|
|
|
* At this point, we're umounting anyway,
|
|
|
|
* so there's no point in transitioning log state
|
|
|
|
* to IOERROR. Just continue...
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2011-03-06 16:01:35 -07:00
|
|
|
if (error)
|
|
|
|
xfs_alert(mp, "%s: unmount record failed", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = log->l_iclog;
|
2008-03-05 19:44:14 -07:00
|
|
|
atomic_inc(&iclog->ic_refcnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_state_want_sync(log, iclog);
|
2008-12-03 04:20:28 -07:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2008-04-09 20:24:38 -06:00
|
|
|
error = xlog_state_release_iclog(log, iclog);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!(iclog->ic_state == XLOG_STATE_ACTIVE ||
|
|
|
|
iclog->ic_state == XLOG_STATE_DIRTY)) {
|
|
|
|
if (!XLOG_FORCED_SHUTDOWN(log)) {
|
2010-12-20 18:09:01 -07:00
|
|
|
xlog_wait(&iclog->ic_force_wait,
|
|
|
|
&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} else {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-09-27 19:04:16 -06:00
|
|
|
if (tic) {
|
2009-12-14 16:14:59 -07:00
|
|
|
trace_xfs_log_umount_write(log, tic);
|
2006-09-27 19:04:16 -06:00
|
|
|
xlog_ungrant_log_space(log, tic);
|
2008-11-16 23:37:10 -07:00
|
|
|
xfs_log_ticket_put(tic);
|
2006-09-27 19:04:16 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We're already in forced_shutdown mode, couldn't
|
|
|
|
* even attempt to write out the unmount transaction.
|
|
|
|
*
|
|
|
|
* Go through the motions of sync'ing and releasing
|
|
|
|
* the iclog, even though no I/O will actually happen,
|
2006-03-28 15:55:14 -07:00
|
|
|
* we need to wait for other log I/Os that may already
|
2005-04-16 16:20:36 -06:00
|
|
|
* be in progress. Do this as a separate section of
|
|
|
|
* code so we'll know if we ever get stuck here that
|
|
|
|
* we're in this odd situation of trying to unmount
|
|
|
|
* a file system that went into forced_shutdown as
|
|
|
|
* the result of an unmount..
|
|
|
|
*/
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = log->l_iclog;
|
2008-03-05 19:44:14 -07:00
|
|
|
atomic_inc(&iclog->ic_refcnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
xlog_state_want_sync(log, iclog);
|
2008-12-03 04:20:28 -07:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2008-04-09 20:24:38 -06:00
|
|
|
error = xlog_state_release_iclog(log, iclog);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if ( ! ( iclog->ic_state == XLOG_STATE_ACTIVE
|
|
|
|
|| iclog->ic_state == XLOG_STATE_DIRTY
|
|
|
|
|| iclog->ic_state == XLOG_STATE_IOERROR) ) {
|
|
|
|
|
2010-12-20 18:09:01 -07:00
|
|
|
xlog_wait(&iclog->ic_force_wait,
|
|
|
|
&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-09 20:24:38 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* xfs_log_unmount_write */
|
|
|
|
|
|
|
|
/*
|
2012-10-08 04:56:08 -06:00
|
|
|
* Empty the log for unmount/freeze.
|
2012-10-08 04:56:03 -06:00
|
|
|
*
|
|
|
|
* To do this, we first need to shut down the background log work so it is not
|
|
|
|
* trying to cover the log as we clean up. We then need to unpin all objects in
|
|
|
|
* the log so we can then flush them out. Once they have completed their IO and
|
|
|
|
* run the callbacks removing themselves from the AIL, we can write the unmount
|
2012-10-08 04:56:08 -06:00
|
|
|
* record.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
void
|
2012-10-08 04:56:08 -06:00
|
|
|
xfs_log_quiesce(
|
|
|
|
struct xfs_mount *mp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-10-08 04:56:02 -06:00
|
|
|
cancel_delayed_work_sync(&mp->m_log->l_work);
|
2012-10-08 04:56:03 -06:00
|
|
|
xfs_log_force(mp, XFS_LOG_SYNC);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The superblock buffer is uncached and while xfs_ail_push_all_sync()
|
|
|
|
* will push it, xfs_wait_buftarg() will not wait for it. Further,
|
|
|
|
* xfs_buf_iowait() cannot be used because it was pushed with the
|
|
|
|
* XBF_ASYNC flag set, so we need to use a lock/unlock pair to wait for
|
|
|
|
* the IO to complete.
|
|
|
|
*/
|
|
|
|
xfs_ail_push_all_sync(mp->m_ail);
|
|
|
|
xfs_wait_buftarg(mp->m_ddev_targp);
|
|
|
|
xfs_buf_lock(mp->m_sb_bp);
|
|
|
|
xfs_buf_unlock(mp->m_sb_bp);
|
|
|
|
|
|
|
|
xfs_log_unmount_write(mp);
|
2012-10-08 04:56:08 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shut down and release the AIL and Log.
|
|
|
|
*
|
|
|
|
* During unmount, we need to ensure we flush all the dirty metadata objects
|
|
|
|
* from the AIL so that the log is empty before we write the unmount record to
|
|
|
|
* the log. Once this is done, we can tear down the AIL and the log.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_log_unmount(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
xfs_log_quiesce(mp);
|
2012-10-08 04:56:03 -06:00
|
|
|
|
[XFS] Move AIL pushing into it's own thread
When many hundreds to thousands of threads all try to do simultaneous
transactions and the log is in a tail-pushing situation (i.e. full), we
can get multiple threads walking the AIL list and contending on the AIL
lock.
The AIL push is, in effect, a simple I/O dispatch algorithm complicated by
the ordering constraints placed on it by the transaction subsystem. It
really does not need multiple threads to push on it - even when only a
single CPU is pushing the AIL, it can push the I/O out far faster that
pretty much any disk subsystem can handle.
So, to avoid contention problems stemming from multiple list walkers, move
the list walk off into another thread and simply provide a "target" to
push to. When a thread requires a push, it sets the target and wakes the
push thread, then goes to sleep waiting for the required amount of space
to become available in the log.
This mechanism should also be a lot fairer under heavy load as the waiters
will queue in arrival order, rather than queuing in "who completed a push
first" order.
Also, by moving the pushing to a separate thread we can do more
effectively overload detection and prevention as we can keep context from
loop iteration to loop iteration. That is, we can push only part of the
list each loop and not have to loop back to the start of the list every
time we run. This should also help by reducing the number of items we try
to lock and/or push items that we cannot move.
Note that this patch is not intended to solve the inefficiencies in the
AIL structure and the associated issues with extremely large list
contents. That needs to be addresses separately; parallel access would
cause problems to any new structure as well, so I'm only aiming to isolate
the structure from unbounded parallelism here.
SGI-PV: 972759
SGI-Modid: xfs-linux-melb:xfs-kern:30371a
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
2008-02-04 18:13:32 -07:00
|
|
|
xfs_trans_ail_destroy(mp);
|
2014-07-14 16:07:29 -06:00
|
|
|
|
|
|
|
xfs_sysfs_del(&mp->m_log->l_kobj);
|
|
|
|
|
2006-03-28 15:55:14 -07:00
|
|
|
xlog_dealloc_log(mp->m_log);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-03-22 17:10:00 -06:00
|
|
|
void
|
|
|
|
xfs_log_item_init(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_log_item *item,
|
|
|
|
int type,
|
2011-10-28 03:54:24 -06:00
|
|
|
const struct xfs_item_ops *ops)
|
2010-03-22 17:10:00 -06:00
|
|
|
{
|
|
|
|
item->li_mountp = mp;
|
|
|
|
item->li_ailp = mp->m_ail;
|
|
|
|
item->li_type = type;
|
|
|
|
item->li_ops = ops;
|
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
|
|
|
item->li_lv = NULL;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&item->li_ail);
|
|
|
|
INIT_LIST_HEAD(&item->li_cil);
|
2018-01-24 14:38:49 -07:00
|
|
|
INIT_LIST_HEAD(&item->li_bio_list);
|
2010-03-22 17:10:00 -06:00
|
|
|
}
|
|
|
|
|
2012-02-19 19:31:20 -07:00
|
|
|
/*
|
|
|
|
* Wake up processes waiting for log space after we have moved the log tail.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
void
|
2012-02-19 19:31:20 -07:00
|
|
|
xfs_log_space_wake(
|
2012-02-19 19:31:23 -07:00
|
|
|
struct xfs_mount *mp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2012-02-19 19:31:23 -07:00
|
|
|
int free_bytes;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (XLOG_FORCED_SHUTDOWN(log))
|
|
|
|
return;
|
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
if (!list_empty_careful(&log->l_write_head.waiters)) {
|
2012-02-19 19:31:20 -07:00
|
|
|
ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
|
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
spin_lock(&log->l_write_head.lock);
|
|
|
|
free_bytes = xlog_space_left(log, &log->l_write_head.grant);
|
2012-02-19 19:31:29 -07:00
|
|
|
xlog_grant_head_wake(log, &log->l_write_head, &free_bytes);
|
2012-02-19 19:31:25 -07:00
|
|
|
spin_unlock(&log->l_write_head.lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-12-20 18:02:25 -07:00
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
if (!list_empty_careful(&log->l_reserve_head.waiters)) {
|
2012-02-19 19:31:20 -07:00
|
|
|
ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));
|
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
spin_lock(&log->l_reserve_head.lock);
|
|
|
|
free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
|
2012-02-19 19:31:29 -07:00
|
|
|
xlog_grant_head_wake(log, &log->l_reserve_head, &free_bytes);
|
2012-02-19 19:31:25 -07:00
|
|
|
spin_unlock(&log->l_reserve_head.lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-12-20 18:29:01 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
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
|
|
|
* Determine if we have a transaction that has gone to disk that needs to be
|
|
|
|
* covered. To begin the transition to the idle state firstly the log needs to
|
|
|
|
* be idle. That means the CIL, the AIL and the iclogs needs to be empty before
|
|
|
|
* we start attempting to cover the log.
|
xfs: ensure that sync updates the log tail correctly
Updates to the VFS layer removed an extra ->sync_fs call into the
filesystem during the sync process (from the quota code).
Unfortunately the sync code was unknowingly relying on this call to
make sure metadata buffers were flushed via a xfs_buftarg_flush()
call to move the tail of the log forward in memory before the final
transactions of the sync process were issued.
As a result, the old code would write a very recent log tail value
to the log by the end of the sync process, and so a subsequent crash
would leave nothing for log recovery to do. Hence in qa test 182,
log recovery only replayed a small handle for inode fsync
transactions in this case.
However, with the removal of the extra ->sync_fs call, the log tail
was now not moved forward with the inode fsync transactions near the
end of the sync procese the first (and only) buftarg flush occurred
after these transactions went to disk. The result is that log
recovery now sees a large number of transactions for metadata that
is already on disk.
This usually isn't a problem, but when the transactions include
inode chunk allocation, the inode create transactions and all
subsequent changes are replayed as we cannt rely on what is on disk
is valid. As a result, if the inode was written and contains
unlogged changes, the unlogged changes are lost, thereby violating
sync semantics.
The fix is to always issue a transaction after the buftarg flush
occurs is the log iѕ not idle or covered. This results in a dummy
transaction being written that contains the up-to-date log tail
value, which will be very recent. Indeed, it will be at least as
recent as the old code would have left on disk, so log recovery
will behave exactly as it used to in this situation.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-04-12 23:06:44 -06:00
|
|
|
*
|
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
|
|
|
* Only if we are then in a state where covering is needed, the caller is
|
|
|
|
* informed that dummy transactions are required to move the log into the idle
|
|
|
|
* state.
|
|
|
|
*
|
|
|
|
* If there are any items in the AIl or CIL, then we do not want to attempt to
|
|
|
|
* cover the log as we may be in a situation where there isn't log space
|
|
|
|
* available to run a dummy transaction and this can lead to deadlocks when the
|
|
|
|
* tail of the log is pinned by an item that is modified in the CIL. Hence
|
|
|
|
* there's no point in running a dummy transaction at this point because we
|
|
|
|
* can't start trying to idle the log until both the CIL and AIL are empty.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2016-06-01 01:38:15 -06:00
|
|
|
static int
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_log_need_covered(xfs_mount_t *mp)
|
|
|
|
{
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
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 needed = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-27 20:02:59 -07:00
|
|
|
if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
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
|
|
|
if (!xlog_cil_empty(log))
|
|
|
|
return 0;
|
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
xfs: ensure that sync updates the log tail correctly
Updates to the VFS layer removed an extra ->sync_fs call into the
filesystem during the sync process (from the quota code).
Unfortunately the sync code was unknowingly relying on this call to
make sure metadata buffers were flushed via a xfs_buftarg_flush()
call to move the tail of the log forward in memory before the final
transactions of the sync process were issued.
As a result, the old code would write a very recent log tail value
to the log by the end of the sync process, and so a subsequent crash
would leave nothing for log recovery to do. Hence in qa test 182,
log recovery only replayed a small handle for inode fsync
transactions in this case.
However, with the removal of the extra ->sync_fs call, the log tail
was now not moved forward with the inode fsync transactions near the
end of the sync procese the first (and only) buftarg flush occurred
after these transactions went to disk. The result is that log
recovery now sees a large number of transactions for metadata that
is already on disk.
This usually isn't a problem, but when the transactions include
inode chunk allocation, the inode create transactions and all
subsequent changes are replayed as we cannt rely on what is on disk
is valid. As a result, if the inode was written and contains
unlogged changes, the unlogged changes are lost, thereby violating
sync semantics.
The fix is to always issue a transaction after the buftarg flush
occurs is the log iѕ not idle or covered. This results in a dummy
transaction being written that contains the up-to-date log tail
value, which will be very recent. Indeed, it will be at least as
recent as the old code would have left on disk, so log recovery
will behave exactly as it used to in this situation.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-04-12 23:06:44 -06:00
|
|
|
switch (log->l_covered_state) {
|
|
|
|
case XLOG_STATE_COVER_DONE:
|
|
|
|
case XLOG_STATE_COVER_DONE2:
|
|
|
|
case XLOG_STATE_COVER_IDLE:
|
|
|
|
break;
|
|
|
|
case XLOG_STATE_COVER_NEED:
|
|
|
|
case XLOG_STATE_COVER_NEED2:
|
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
|
|
|
if (xfs_ail_min_lsn(log->l_ailp))
|
|
|
|
break;
|
|
|
|
if (!xlog_iclogs_empty(log))
|
|
|
|
break;
|
|
|
|
|
|
|
|
needed = 1;
|
|
|
|
if (log->l_covered_state == XLOG_STATE_COVER_NEED)
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_DONE;
|
|
|
|
else
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_DONE2;
|
|
|
|
break;
|
xfs: ensure that sync updates the log tail correctly
Updates to the VFS layer removed an extra ->sync_fs call into the
filesystem during the sync process (from the quota code).
Unfortunately the sync code was unknowingly relying on this call to
make sure metadata buffers were flushed via a xfs_buftarg_flush()
call to move the tail of the log forward in memory before the final
transactions of the sync process were issued.
As a result, the old code would write a very recent log tail value
to the log by the end of the sync process, and so a subsequent crash
would leave nothing for log recovery to do. Hence in qa test 182,
log recovery only replayed a small handle for inode fsync
transactions in this case.
However, with the removal of the extra ->sync_fs call, the log tail
was now not moved forward with the inode fsync transactions near the
end of the sync procese the first (and only) buftarg flush occurred
after these transactions went to disk. The result is that log
recovery now sees a large number of transactions for metadata that
is already on disk.
This usually isn't a problem, but when the transactions include
inode chunk allocation, the inode create transactions and all
subsequent changes are replayed as we cannt rely on what is on disk
is valid. As a result, if the inode was written and contains
unlogged changes, the unlogged changes are lost, thereby violating
sync semantics.
The fix is to always issue a transaction after the buftarg flush
occurs is the log iѕ not idle or covered. This results in a dummy
transaction being written that contains the up-to-date log tail
value, which will be very recent. Indeed, it will be at least as
recent as the old code would have left on disk, so log recovery
will behave exactly as it used to in this situation.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-04-12 23:06:44 -06:00
|
|
|
default:
|
2005-04-16 16:20:36 -06:00
|
|
|
needed = 1;
|
xfs: ensure that sync updates the log tail correctly
Updates to the VFS layer removed an extra ->sync_fs call into the
filesystem during the sync process (from the quota code).
Unfortunately the sync code was unknowingly relying on this call to
make sure metadata buffers were flushed via a xfs_buftarg_flush()
call to move the tail of the log forward in memory before the final
transactions of the sync process were issued.
As a result, the old code would write a very recent log tail value
to the log by the end of the sync process, and so a subsequent crash
would leave nothing for log recovery to do. Hence in qa test 182,
log recovery only replayed a small handle for inode fsync
transactions in this case.
However, with the removal of the extra ->sync_fs call, the log tail
was now not moved forward with the inode fsync transactions near the
end of the sync procese the first (and only) buftarg flush occurred
after these transactions went to disk. The result is that log
recovery now sees a large number of transactions for metadata that
is already on disk.
This usually isn't a problem, but when the transactions include
inode chunk allocation, the inode create transactions and all
subsequent changes are replayed as we cannt rely on what is on disk
is valid. As a result, if the inode was written and contains
unlogged changes, the unlogged changes are lost, thereby violating
sync semantics.
The fix is to always issue a transaction after the buftarg flush
occurs is the log iѕ not idle or covered. This results in a dummy
transaction being written that contains the up-to-date log tail
value, which will be very recent. Indeed, it will be at least as
recent as the old code would have left on disk, so log recovery
will behave exactly as it used to in this situation.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
2010-04-12 23:06:44 -06:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2006-01-14 18:37:08 -07:00
|
|
|
return needed;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-02-19 19:31:20 -07:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
* We may be holding the log iclog lock upon entering this routine.
|
|
|
|
*/
|
|
|
|
xfs_lsn_t
|
2012-04-22 23:58:33 -06:00
|
|
|
xlog_assign_tail_lsn_locked(
|
2010-12-20 18:28:39 -07:00
|
|
|
struct xfs_mount *mp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2012-04-22 23:58:33 -06:00
|
|
|
struct xfs_log_item *lip;
|
|
|
|
xfs_lsn_t tail_lsn;
|
|
|
|
|
|
|
|
assert_spin_locked(&mp->m_ail->xa_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-19 19:31:20 -07:00
|
|
|
/*
|
|
|
|
* To make sure we always have a valid LSN for the log tail we keep
|
|
|
|
* track of the last LSN which was committed in log->l_last_sync_lsn,
|
2012-04-22 23:58:33 -06:00
|
|
|
* and use that when the AIL was empty.
|
2012-02-19 19:31:20 -07:00
|
|
|
*/
|
2012-04-22 23:58:33 -06:00
|
|
|
lip = xfs_ail_min(mp->m_ail);
|
|
|
|
if (lip)
|
|
|
|
tail_lsn = lip->li_lsn;
|
|
|
|
else
|
2010-12-03 04:11:29 -07:00
|
|
|
tail_lsn = atomic64_read(&log->l_last_sync_lsn);
|
2013-10-31 22:27:18 -06:00
|
|
|
trace_xfs_log_assign_tail_lsn(log, tail_lsn);
|
2010-12-20 18:28:39 -07:00
|
|
|
atomic64_set(&log->l_tail_lsn, tail_lsn);
|
2005-04-16 16:20:36 -06:00
|
|
|
return tail_lsn;
|
2010-12-20 18:28:39 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-04-22 23:58:33 -06:00
|
|
|
xfs_lsn_t
|
|
|
|
xlog_assign_tail_lsn(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
|
|
|
xfs_lsn_t tail_lsn;
|
|
|
|
|
|
|
|
spin_lock(&mp->m_ail->xa_lock);
|
|
|
|
tail_lsn = xlog_assign_tail_lsn_locked(mp);
|
|
|
|
spin_unlock(&mp->m_ail->xa_lock);
|
|
|
|
|
|
|
|
return tail_lsn;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Return the space in the log between the tail and the head. The head
|
|
|
|
* is passed in the cycle/bytes formal parms. In the special case where
|
|
|
|
* the reserve head has wrapped passed the tail, this calculation is no
|
|
|
|
* longer valid. In this case, just return 0 which means there is no space
|
|
|
|
* in the log. This works for all places where this function is called
|
|
|
|
* with the reserve head. Of course, if the write head were to ever
|
|
|
|
* wrap the tail, we should blow up. Rather than catch this case here,
|
|
|
|
* we depend on other ASSERTions in other parts of the code. XXXmiken
|
|
|
|
*
|
|
|
|
* This code also handles the case where the reservation head is behind
|
|
|
|
* the tail. The details of this case are described below, but the end
|
|
|
|
* result is that we return the size of the log as the amount of space left.
|
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC int
|
2010-12-20 18:08:20 -07:00
|
|
|
xlog_space_left(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2010-12-03 06:02:40 -07:00
|
|
|
atomic64_t *head)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-20 18:08:20 -07:00
|
|
|
int free_bytes;
|
|
|
|
int tail_bytes;
|
|
|
|
int tail_cycle;
|
|
|
|
int head_cycle;
|
|
|
|
int head_bytes;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-20 18:08:20 -07:00
|
|
|
xlog_crack_grant_head(head, &head_cycle, &head_bytes);
|
2010-12-20 18:28:39 -07:00
|
|
|
xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);
|
|
|
|
tail_bytes = BBTOB(tail_bytes);
|
2010-12-20 18:08:20 -07:00
|
|
|
if (tail_cycle == head_cycle && head_bytes >= tail_bytes)
|
|
|
|
free_bytes = log->l_logsize - (head_bytes - tail_bytes);
|
|
|
|
else if (tail_cycle + 1 < head_cycle)
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2010-12-20 18:08:20 -07:00
|
|
|
else if (tail_cycle < head_cycle) {
|
|
|
|
ASSERT(tail_cycle == (head_cycle - 1));
|
|
|
|
free_bytes = tail_bytes - head_bytes;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The reservation head is behind the tail.
|
|
|
|
* In this case we just want to return the size of the
|
|
|
|
* log as the amount of space left.
|
|
|
|
*/
|
2015-07-28 19:52:04 -06:00
|
|
|
xfs_alert(log->l_mp, "xlog_space_left: head behind tail");
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_alert(log->l_mp,
|
2015-07-28 19:52:04 -06:00
|
|
|
" tail_cycle = %d, tail_bytes = %d",
|
|
|
|
tail_cycle, tail_bytes);
|
|
|
|
xfs_alert(log->l_mp,
|
|
|
|
" GH cycle = %d, GH bytes = %d",
|
|
|
|
head_cycle, head_bytes);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(0);
|
|
|
|
free_bytes = log->l_logsize;
|
|
|
|
}
|
|
|
|
return free_bytes;
|
2010-12-20 18:08:20 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Log function which is called when an io completes.
|
|
|
|
*
|
|
|
|
* The log manager needs its own routine, in order to control what
|
|
|
|
* happens with the buffer after the write completes.
|
|
|
|
*/
|
2016-06-01 01:38:15 -06:00
|
|
|
static void
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_iodone(xfs_buf_t *bp)
|
|
|
|
{
|
2018-01-24 14:38:48 -07:00
|
|
|
struct xlog_in_core *iclog = bp->b_log_item;
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *l = iclog->ic_log;
|
|
|
|
int aborted = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2016-01-04 13:41:16 -07:00
|
|
|
* Race to shutdown the filesystem if we see an error or the iclog is in
|
|
|
|
* IOABORT state. The IOABORT state is only set in DEBUG mode to inject
|
|
|
|
* CRC errors into log recovery.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2017-06-20 18:54:47 -06:00
|
|
|
if (XFS_TEST_ERROR(bp->b_error, l->l_mp, XFS_ERRTAG_IODONE_IOERR) ||
|
2016-01-04 13:41:16 -07:00
|
|
|
iclog->ic_state & XLOG_STATE_IOABORT) {
|
|
|
|
if (iclog->ic_state & XLOG_STATE_IOABORT)
|
|
|
|
iclog->ic_state &= ~XLOG_STATE_IOABORT;
|
|
|
|
|
2011-10-10 10:52:49 -06:00
|
|
|
xfs_buf_ioerror_alert(bp, __func__);
|
2011-10-10 10:52:46 -06:00
|
|
|
xfs_buf_stale(bp);
|
2006-06-08 22:58:38 -06:00
|
|
|
xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This flag will be propagated to the trans-committed
|
|
|
|
* callback routines to let them know that the log-commit
|
|
|
|
* didn't succeed.
|
|
|
|
*/
|
|
|
|
aborted = XFS_LI_ABORTED;
|
|
|
|
} else if (iclog->ic_state & XLOG_STATE_IOERROR) {
|
|
|
|
aborted = XFS_LI_ABORTED;
|
|
|
|
}
|
2007-05-14 02:24:16 -06:00
|
|
|
|
|
|
|
/* log I/O is always issued ASYNC */
|
2016-02-09 21:01:11 -07:00
|
|
|
ASSERT(bp->b_flags & XBF_ASYNC);
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_state_done_syncing(iclog, aborted);
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
|
2007-05-14 02:24:16 -06:00
|
|
|
/*
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
* drop the buffer lock now that we are done. Nothing references
|
|
|
|
* the buffer after this, so an unmount waiting on this lock can now
|
|
|
|
* tear it down safely. As such, it is unsafe to reference the buffer
|
|
|
|
* (bp) after the unlock as we could race with it being freed.
|
2007-05-14 02:24:16 -06:00
|
|
|
*/
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
xfs_buf_unlock(bp);
|
2012-11-12 04:54:01 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Return size of each in-core log record buffer.
|
|
|
|
*
|
2009-03-29 01:55:42 -06:00
|
|
|
* All machines get 8 x 32kB buffers by default, unless tuned otherwise.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* If the filesystem blocksize is too large, we may need to choose a
|
|
|
|
* larger size since the directory code currently logs entire blocks.
|
|
|
|
*/
|
|
|
|
|
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_get_iclog_buffer_size(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int size;
|
|
|
|
int xhdrs;
|
|
|
|
|
2007-08-16 00:24:43 -06:00
|
|
|
if (mp->m_logbufs <= 0)
|
|
|
|
log->l_iclog_bufs = XLOG_MAX_ICLOGS;
|
|
|
|
else
|
2005-11-01 21:12:04 -07:00
|
|
|
log->l_iclog_bufs = mp->m_logbufs;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Buffer size passed in from mount system call.
|
|
|
|
*/
|
2005-11-01 21:12:04 -07:00
|
|
|
if (mp->m_logbsize > 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
size = log->l_iclog_size = mp->m_logbsize;
|
|
|
|
log->l_iclog_size_log = 0;
|
|
|
|
while (size != 1) {
|
|
|
|
log->l_iclog_size_log++;
|
|
|
|
size >>= 1;
|
|
|
|
}
|
|
|
|
|
2008-03-05 19:44:28 -07:00
|
|
|
if (xfs_sb_version_haslogv2(&mp->m_sb)) {
|
2009-03-29 01:55:42 -06:00
|
|
|
/* # headers = size / 32k
|
|
|
|
* one header holds cycles from 32k of data
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE;
|
|
|
|
if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE)
|
|
|
|
xhdrs++;
|
|
|
|
log->l_iclog_hsize = xhdrs << BBSHIFT;
|
|
|
|
log->l_iclog_heads = xhdrs;
|
|
|
|
} else {
|
|
|
|
ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE);
|
|
|
|
log->l_iclog_hsize = BBSIZE;
|
|
|
|
log->l_iclog_heads = 1;
|
|
|
|
}
|
2005-11-01 21:12:04 -07:00
|
|
|
goto done;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-03-29 01:55:42 -06:00
|
|
|
/* All machines use 32kB buffers by default. */
|
2007-08-16 00:24:43 -06:00
|
|
|
log->l_iclog_size = XLOG_BIG_RECORD_BSIZE;
|
|
|
|
log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* the default log size is 16k or 32k which is one header sector */
|
|
|
|
log->l_iclog_hsize = BBSIZE;
|
|
|
|
log->l_iclog_heads = 1;
|
|
|
|
|
2009-02-09 00:36:46 -07:00
|
|
|
done:
|
|
|
|
/* are we being asked to make the sizes selected above visible? */
|
2005-11-01 21:12:04 -07:00
|
|
|
if (mp->m_logbufs == 0)
|
|
|
|
mp->m_logbufs = log->l_iclog_bufs;
|
|
|
|
if (mp->m_logbsize == 0)
|
|
|
|
mp->m_logbsize = log->l_iclog_size;
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* xlog_get_iclog_buffer_size */
|
|
|
|
|
|
|
|
|
2012-10-08 04:56:02 -06:00
|
|
|
void
|
|
|
|
xfs_log_work_queue(
|
|
|
|
struct xfs_mount *mp)
|
|
|
|
{
|
2017-03-28 15:51:44 -06:00
|
|
|
queue_delayed_work(mp->m_sync_workqueue, &mp->m_log->l_work,
|
2012-10-08 04:56:02 -06:00
|
|
|
msecs_to_jiffies(xfs_syncd_centisecs * 10));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Every sync period we need to unpin all items in the AIL and push them to
|
|
|
|
* disk. If there is nothing dirty, then we might need to cover the log to
|
|
|
|
* indicate that the filesystem is idle.
|
|
|
|
*/
|
2016-06-01 01:38:15 -06:00
|
|
|
static void
|
2012-10-08 04:56:02 -06:00
|
|
|
xfs_log_worker(
|
|
|
|
struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct xlog *log = container_of(to_delayed_work(work),
|
|
|
|
struct xlog, l_work);
|
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
|
|
|
|
/* dgc: errors ignored - not fatal and nowhere to report them */
|
2015-01-21 15:10:31 -07:00
|
|
|
if (xfs_log_need_covered(mp)) {
|
|
|
|
/*
|
|
|
|
* Dump a transaction into the log that contains no real change.
|
|
|
|
* This is needed to stamp the current tail LSN into the log
|
|
|
|
* during the covering operation.
|
|
|
|
*
|
|
|
|
* We cannot use an inode here for this - that will push dirty
|
|
|
|
* state back up into the VFS and then periodic inode flushing
|
|
|
|
* will prevent log covering from making progress. Hence we
|
|
|
|
* synchronously log the superblock instead to ensure the
|
|
|
|
* superblock is immediately unpinned and can be written back.
|
|
|
|
*/
|
|
|
|
xfs_sync_sb(mp, true);
|
|
|
|
} else
|
2012-10-08 04:56:02 -06:00
|
|
|
xfs_log_force(mp, 0);
|
|
|
|
|
|
|
|
/* start pushing all the metadata that is currently dirty */
|
|
|
|
xfs_ail_push_all(mp->m_ail);
|
|
|
|
|
|
|
|
/* queue us up again */
|
|
|
|
xfs_log_work_queue(mp);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This routine initializes some of the log structure for a given mount point.
|
|
|
|
* Its primary purpose is to fill in enough, so recovery can occur. However,
|
|
|
|
* some other stuff may be filled in too.
|
|
|
|
*/
|
2012-06-14 08:22:16 -06:00
|
|
|
STATIC struct xlog *
|
|
|
|
xlog_alloc_log(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_buftarg *log_target,
|
|
|
|
xfs_daddr_t blk_offset,
|
|
|
|
int num_bblks)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log;
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_rec_header_t *head;
|
|
|
|
xlog_in_core_t **iclogp;
|
|
|
|
xlog_in_core_t *iclog, *prev_iclog=NULL;
|
|
|
|
xfs_buf_t *bp;
|
|
|
|
int i;
|
2014-06-24 22:58:08 -06:00
|
|
|
int error = -ENOMEM;
|
2010-04-20 01:09:59 -06:00
|
|
|
uint log2_size = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-14 08:22:16 -06:00
|
|
|
log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);
|
2009-04-06 10:39:27 -06:00
|
|
|
if (!log) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "Log allocation failed: No memory!");
|
2009-04-06 10:39:27 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
log->l_mp = mp;
|
|
|
|
log->l_targ = log_target;
|
|
|
|
log->l_logsize = BBTOB(num_bblks);
|
|
|
|
log->l_logBBstart = blk_offset;
|
|
|
|
log->l_logBBsize = num_bblks;
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_IDLE;
|
|
|
|
log->l_flags |= XLOG_ACTIVE_RECOVERY;
|
2012-10-08 04:56:02 -06:00
|
|
|
INIT_DELAYED_WORK(&log->l_work, xfs_log_worker);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
log->l_prev_block = -1;
|
|
|
|
/* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */
|
2010-12-20 18:28:39 -07:00
|
|
|
xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0);
|
|
|
|
xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_curr_cycle = 1; /* 0 is bad since this is initial value */
|
2012-02-19 19:31:26 -07:00
|
|
|
|
|
|
|
xlog_grant_head_init(&log->l_reserve_head);
|
|
|
|
xlog_grant_head_init(&log->l_write_head);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -EFSCORRUPTED;
|
2008-03-05 19:44:28 -07:00
|
|
|
if (xfs_sb_version_hassector(&mp->m_sb)) {
|
2010-04-20 01:09:59 -06:00
|
|
|
log2_size = mp->m_sb.sb_logsectlog;
|
|
|
|
if (log2_size < BBSHIFT) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)",
|
|
|
|
log2_size, BBSHIFT);
|
2009-04-06 10:39:27 -06:00
|
|
|
goto out_free_log;
|
|
|
|
}
|
|
|
|
|
2010-04-20 01:09:59 -06:00
|
|
|
log2_size -= BBSHIFT;
|
|
|
|
if (log2_size > mp->m_sectbb_log) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)",
|
|
|
|
log2_size, mp->m_sectbb_log);
|
2009-04-06 10:39:27 -06:00
|
|
|
goto out_free_log;
|
|
|
|
}
|
2010-04-20 01:09:59 -06:00
|
|
|
|
|
|
|
/* for larger sector sizes, must have v2 or external log */
|
|
|
|
if (log2_size && log->l_logBBstart > 0 &&
|
|
|
|
!xfs_sb_version_haslogv2(&mp->m_sb)) {
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(mp,
|
|
|
|
"log sector size (0x%x) invalid for configuration.",
|
|
|
|
log2_size);
|
2009-04-06 10:39:27 -06:00
|
|
|
goto out_free_log;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-04-20 01:09:59 -06:00
|
|
|
log->l_sectBBsize = 1 << log2_size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
xlog_get_iclog_buffer_size(mp, log);
|
|
|
|
|
2014-08-03 20:42:40 -06:00
|
|
|
/*
|
|
|
|
* Use a NULL block for the extra log buffer used during splits so that
|
|
|
|
* it will trigger errors if we ever try to do IO on it without first
|
|
|
|
* having set it up properly.
|
|
|
|
*/
|
2014-06-24 22:58:08 -06:00
|
|
|
error = -ENOMEM;
|
2014-08-03 20:42:40 -06:00
|
|
|
bp = xfs_buf_alloc(mp->m_logdev_targp, XFS_BUF_DADDR_NULL,
|
2016-07-19 19:13:43 -06:00
|
|
|
BTOBB(log->l_iclog_size), XBF_NO_IOACCT);
|
2008-11-09 22:50:24 -07:00
|
|
|
if (!bp)
|
|
|
|
goto out_free_log;
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The iclogbuf buffer locks are held over IO but we are not going to do
|
|
|
|
* IO yet. Hence unlock the buffer so that the log IO path can grab it
|
|
|
|
* when appropriately.
|
|
|
|
*/
|
2011-07-08 06:36:19 -06:00
|
|
|
ASSERT(xfs_buf_islocked(bp));
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
xfs_buf_unlock(bp);
|
|
|
|
|
2014-12-23 15:46:23 -07:00
|
|
|
/* use high priority wq for log I/O completion */
|
|
|
|
bp->b_ioend_wq = mp->m_log_workqueue;
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
bp->b_iodone = xlog_iodone;
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_xbuf = bp;
|
|
|
|
|
2007-10-11 01:43:56 -06:00
|
|
|
spin_lock_init(&log->l_icloglock);
|
2010-12-20 18:09:01 -07:00
|
|
|
init_waitqueue_head(&log->l_flush_wait);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iclogp = &log->l_iclog;
|
|
|
|
/*
|
|
|
|
* The amount of memory to allocate for the iclog structure is
|
|
|
|
* rather funky due to the way the structure is defined. It is
|
|
|
|
* done this way so that we can use different sizes for machines
|
|
|
|
* with different amounts of memory. See the definition of
|
|
|
|
* xlog_in_core_t in xfs_log_priv.h for details.
|
|
|
|
*/
|
|
|
|
ASSERT(log->l_iclog_size >= 4096);
|
|
|
|
for (i=0; i < log->l_iclog_bufs; i++) {
|
2008-11-09 22:50:24 -07:00
|
|
|
*iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL);
|
|
|
|
if (!*iclogp)
|
|
|
|
goto out_free_iclog;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = *iclogp;
|
|
|
|
iclog->ic_prev = prev_iclog;
|
|
|
|
prev_iclog = iclog;
|
2007-05-14 02:23:50 -06:00
|
|
|
|
2010-09-24 04:07:47 -06:00
|
|
|
bp = xfs_buf_get_uncached(mp->m_logdev_targp,
|
2016-07-19 19:13:43 -06:00
|
|
|
BTOBB(log->l_iclog_size),
|
|
|
|
XBF_NO_IOACCT);
|
2008-11-09 22:50:24 -07:00
|
|
|
if (!bp)
|
|
|
|
goto out_free_iclog;
|
2011-07-08 06:36:25 -06:00
|
|
|
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
ASSERT(xfs_buf_islocked(bp));
|
|
|
|
xfs_buf_unlock(bp);
|
|
|
|
|
2014-12-23 15:46:23 -07:00
|
|
|
/* use high priority wq for log I/O completion */
|
|
|
|
bp->b_ioend_wq = mp->m_log_workqueue;
|
2011-07-13 05:43:49 -06:00
|
|
|
bp->b_iodone = xlog_iodone;
|
2007-05-14 02:23:50 -06:00
|
|
|
iclog->ic_bp = bp;
|
2008-11-27 20:23:38 -07:00
|
|
|
iclog->ic_data = bp->b_addr;
|
2008-04-09 20:18:54 -06:00
|
|
|
#ifdef DEBUG
|
2015-06-21 17:44:47 -06:00
|
|
|
log->l_iclog_bak[i] = &iclog->ic_header;
|
2008-04-09 20:18:54 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
head = &iclog->ic_header;
|
|
|
|
memset(head, 0, sizeof(xlog_rec_header_t));
|
2007-10-11 18:59:34 -06:00
|
|
|
head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
|
|
|
|
head->h_version = cpu_to_be32(
|
2008-03-05 19:44:28 -07:00
|
|
|
xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
|
2007-10-11 18:59:34 -06:00
|
|
|
head->h_size = cpu_to_be32(log->l_iclog_size);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* new fields */
|
2007-10-11 18:59:34 -06:00
|
|
|
head->h_fmt = cpu_to_be32(XLOG_FMT);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));
|
|
|
|
|
2012-04-22 23:58:51 -06:00
|
|
|
iclog->ic_size = BBTOB(bp->b_length) - log->l_iclog_hsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog->ic_state = XLOG_STATE_ACTIVE;
|
|
|
|
iclog->ic_log = log;
|
2008-04-09 20:18:39 -06:00
|
|
|
atomic_set(&iclog->ic_refcnt, 0);
|
|
|
|
spin_lock_init(&iclog->ic_callback_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog->ic_callback_tail = &(iclog->ic_callback);
|
2008-11-27 20:23:38 -07:00
|
|
|
iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-20 18:09:01 -07:00
|
|
|
init_waitqueue_head(&iclog->ic_force_wait);
|
|
|
|
init_waitqueue_head(&iclog->ic_write_wait);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iclogp = &iclog->ic_next;
|
|
|
|
}
|
|
|
|
*iclogp = log->l_iclog; /* complete ring */
|
|
|
|
log->l_iclog->ic_prev = prev_iclog; /* re-write 1st prev ptr */
|
|
|
|
|
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
|
|
|
error = xlog_cil_init(log);
|
|
|
|
if (error)
|
|
|
|
goto out_free_iclog;
|
2005-04-16 16:20:36 -06:00
|
|
|
return log;
|
2008-11-09 22:50:24 -07:00
|
|
|
|
|
|
|
out_free_iclog:
|
|
|
|
for (iclog = log->l_iclog; iclog; iclog = prev_iclog) {
|
|
|
|
prev_iclog = iclog->ic_next;
|
2010-12-20 18:09:01 -07:00
|
|
|
if (iclog->ic_bp)
|
2008-11-09 22:50:24 -07:00
|
|
|
xfs_buf_free(iclog->ic_bp);
|
|
|
|
kmem_free(iclog);
|
|
|
|
}
|
|
|
|
spinlock_destroy(&log->l_icloglock);
|
|
|
|
xfs_buf_free(log->l_xbuf);
|
|
|
|
out_free_log:
|
|
|
|
kmem_free(log);
|
2009-04-06 10:39:27 -06:00
|
|
|
out:
|
2014-06-24 22:58:08 -06:00
|
|
|
return ERR_PTR(error);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* xlog_alloc_log */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write out the commit record of a transaction associated with the given
|
|
|
|
* ticket. Return the lsn of the commit record.
|
|
|
|
*/
|
|
|
|
STATIC int
|
2010-03-22 18:43:17 -06:00
|
|
|
xlog_commit_record(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2010-03-22 18:43:17 -06:00
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
struct xlog_in_core **iclog,
|
|
|
|
xfs_lsn_t *commitlsnp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-03-22 18:43:17 -06:00
|
|
|
struct xfs_mount *mp = log->l_mp;
|
|
|
|
int error;
|
|
|
|
struct xfs_log_iovec reg = {
|
|
|
|
.i_addr = NULL,
|
|
|
|
.i_len = 0,
|
|
|
|
.i_type = XLOG_REG_TYPE_COMMIT,
|
|
|
|
};
|
|
|
|
struct xfs_log_vec vec = {
|
|
|
|
.lv_niovecs = 1,
|
|
|
|
.lv_iovecp = ®,
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT_ALWAYS(iclog);
|
2010-03-22 18:43:17 -06:00
|
|
|
error = xlog_write(log, &vec, ticket, commitlsnp, iclog,
|
|
|
|
XLOG_COMMIT_TRANS);
|
|
|
|
if (error)
|
2006-06-08 22:58:38 -06:00
|
|
|
xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
|
2006-01-14 18:37:08 -07:00
|
|
|
return error;
|
2010-03-22 18:43:17 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Push on the buffer cache code if we ever use more than 75% of the on-disk
|
|
|
|
* log space. This code pushes on the lsn which would supposedly free up
|
|
|
|
* the 25% which we want to leave free. We may need to adopt a policy which
|
|
|
|
* pushes on an lsn which is further along in the log once we reach the high
|
|
|
|
* water mark. In this manner, we would be creating a low water mark.
|
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC void
|
2010-12-20 18:09:20 -07:00
|
|
|
xlog_grant_push_ail(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2010-12-20 18:09:20 -07:00
|
|
|
int need_bytes)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-20 18:09:20 -07:00
|
|
|
xfs_lsn_t threshold_lsn = 0;
|
2010-12-03 04:11:29 -07:00
|
|
|
xfs_lsn_t last_sync_lsn;
|
2010-12-20 18:09:20 -07:00
|
|
|
int free_blocks;
|
|
|
|
int free_bytes;
|
|
|
|
int threshold_block;
|
|
|
|
int threshold_cycle;
|
|
|
|
int free_threshold;
|
|
|
|
|
|
|
|
ASSERT(BTOBB(need_bytes) < log->l_logBBsize);
|
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
|
2010-12-20 18:09:20 -07:00
|
|
|
free_blocks = BTOBBT(free_bytes);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the threshold for the minimum number of free blocks in the
|
|
|
|
* log to the maximum of what the caller needs, one quarter of the
|
|
|
|
* log, and 256 blocks.
|
|
|
|
*/
|
|
|
|
free_threshold = BTOBB(need_bytes);
|
|
|
|
free_threshold = MAX(free_threshold, (log->l_logBBsize >> 2));
|
|
|
|
free_threshold = MAX(free_threshold, 256);
|
|
|
|
if (free_blocks >= free_threshold)
|
|
|
|
return;
|
|
|
|
|
2010-12-20 18:28:39 -07:00
|
|
|
xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle,
|
|
|
|
&threshold_block);
|
|
|
|
threshold_block += free_threshold;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (threshold_block >= log->l_logBBsize) {
|
2010-12-20 18:09:20 -07:00
|
|
|
threshold_block -= log->l_logBBsize;
|
|
|
|
threshold_cycle += 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-12-20 18:09:20 -07:00
|
|
|
threshold_lsn = xlog_assign_lsn(threshold_cycle,
|
|
|
|
threshold_block);
|
|
|
|
/*
|
|
|
|
* Don't pass in an lsn greater than the lsn of the last
|
2010-12-03 04:11:29 -07:00
|
|
|
* log record known to be on disk. Use a snapshot of the last sync lsn
|
|
|
|
* so that it doesn't change between the compare and the set.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-12-03 04:11:29 -07:00
|
|
|
last_sync_lsn = atomic64_read(&log->l_last_sync_lsn);
|
|
|
|
if (XFS_LSN_CMP(threshold_lsn, last_sync_lsn) > 0)
|
|
|
|
threshold_lsn = last_sync_lsn;
|
2010-12-20 18:09:20 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the transaction layer to kick the dirty buffers out to
|
|
|
|
* disk asynchronously. No point in trying to do this if
|
|
|
|
* the filesystem is shutting down.
|
|
|
|
*/
|
|
|
|
if (!XLOG_FORCED_SHUTDOWN(log))
|
2011-04-07 20:45:07 -06:00
|
|
|
xfs_ail_push(log->l_ailp, threshold_lsn);
|
2010-12-20 18:09:20 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
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
|
|
|
/*
|
|
|
|
* Stamp cycle number in every block
|
|
|
|
*/
|
|
|
|
STATIC void
|
|
|
|
xlog_pack_data(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
int roundoff)
|
|
|
|
{
|
|
|
|
int i, j, k;
|
|
|
|
int size = iclog->ic_offset + roundoff;
|
|
|
|
__be32 cycle_lsn;
|
2015-06-21 17:45:10 -06:00
|
|
|
char *dp;
|
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
|
|
|
|
|
|
|
cycle_lsn = CYCLE_LSN_DISK(iclog->ic_header.h_lsn);
|
|
|
|
|
|
|
|
dp = iclog->ic_datap;
|
|
|
|
for (i = 0; i < BTOBB(size); i++) {
|
|
|
|
if (i >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE))
|
|
|
|
break;
|
|
|
|
iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp;
|
|
|
|
*(__be32 *)dp = cycle_lsn;
|
|
|
|
dp += BBSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
|
|
|
|
xlog_in_core_2_t *xhdr = iclog->ic_data;
|
|
|
|
|
|
|
|
for ( ; i < BTOBB(size); i++) {
|
|
|
|
j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
|
|
|
k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
|
|
|
xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp;
|
|
|
|
*(__be32 *)dp = cycle_lsn;
|
|
|
|
dp += BBSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 1; i < log->l_iclog_heads; i++)
|
|
|
|
xhdr[i].hic_xheader.xh_cycle = cycle_lsn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the checksum for a log buffer.
|
|
|
|
*
|
|
|
|
* This is a little more complicated than it should be because the various
|
|
|
|
* headers and the actual data are non-contiguous.
|
|
|
|
*/
|
2012-11-27 19:01:03 -07:00
|
|
|
__le32
|
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
|
|
|
xlog_cksum(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_rec_header *rhead,
|
|
|
|
char *dp,
|
|
|
|
int size)
|
|
|
|
{
|
2017-06-16 12:00:05 -06:00
|
|
|
uint32_t crc;
|
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
|
|
|
|
|
|
|
/* first generate the crc for the record header ... */
|
2016-12-04 20:40:32 -07:00
|
|
|
crc = xfs_start_cksum_update((char *)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
|
|
|
sizeof(struct xlog_rec_header),
|
|
|
|
offsetof(struct xlog_rec_header, h_crc));
|
|
|
|
|
|
|
|
/* ... then for additional cycle data for v2 logs ... */
|
|
|
|
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
|
|
|
|
union xlog_in_core2 *xhdr = (union xlog_in_core2 *)rhead;
|
|
|
|
int i;
|
2015-08-18 17:59:50 -06:00
|
|
|
int xheads;
|
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
|
|
|
|
2015-08-18 17:59:50 -06:00
|
|
|
xheads = size / XLOG_HEADER_CYCLE_SIZE;
|
|
|
|
if (size % XLOG_HEADER_CYCLE_SIZE)
|
|
|
|
xheads++;
|
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
|
|
|
|
2015-08-18 17:59:50 -06:00
|
|
|
for (i = 1; i < xheads; i++) {
|
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
|
|
|
crc = crc32c(crc, &xhdr[i].hic_xheader,
|
|
|
|
sizeof(struct xlog_rec_ext_header));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ... and finally for the payload */
|
|
|
|
crc = crc32c(crc, dp, size);
|
|
|
|
|
|
|
|
return xfs_end_cksum(crc);
|
|
|
|
}
|
|
|
|
|
2010-01-13 15:17:57 -07:00
|
|
|
/*
|
|
|
|
* The bdstrat callback function for log bufs. This gives us a central
|
|
|
|
* place to trap bufs in case we get hit by a log I/O error and need to
|
|
|
|
* shutdown. Actually, in practice, even when we didn't get a log error,
|
|
|
|
* we transition the iclogs to IOERROR state *after* flushing all existing
|
|
|
|
* iclogs to disk. This is because we don't want anymore new transactions to be
|
|
|
|
* started or completed afterwards.
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
*
|
|
|
|
* We lock the iclogbufs here so that we can serialise against IO completion
|
|
|
|
* during unmount. We might be processing a shutdown triggered during unmount,
|
|
|
|
* and that can occur asynchronously to the unmount thread, and hence we need to
|
|
|
|
* ensure that completes before tearing down the iclogbufs. Hence we need to
|
|
|
|
* hold the buffer lock across the log IO to acheive that.
|
2010-01-13 15:17:57 -07:00
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_bdstrat(
|
|
|
|
struct xfs_buf *bp)
|
|
|
|
{
|
2018-01-24 14:38:48 -07:00
|
|
|
struct xlog_in_core *iclog = bp->b_log_item;
|
2010-01-13 15:17:57 -07:00
|
|
|
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
xfs_buf_lock(bp);
|
2010-01-13 15:17:57 -07:00
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR) {
|
2014-06-24 22:58:08 -06:00
|
|
|
xfs_buf_ioerror(bp, -EIO);
|
2011-10-10 10:52:46 -06:00
|
|
|
xfs_buf_stale(bp);
|
2014-10-01 17:04:22 -06:00
|
|
|
xfs_buf_ioend(bp);
|
2010-01-13 15:17:57 -07:00
|
|
|
/*
|
|
|
|
* It would seem logical to return EIO here, but we rely on
|
|
|
|
* the log state machine to propagate I/O errors instead of
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
* doing it here. Similarly, IO completion will unlock the
|
|
|
|
* buffer, so we don't do it here.
|
2010-01-13 15:17:57 -07:00
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-01 17:05:14 -06:00
|
|
|
xfs_buf_submit(bp);
|
2010-01-13 15:17:57 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush out the in-core log (iclog) to the on-disk log in an asynchronous
|
|
|
|
* fashion. Previously, we should have moved the current iclog
|
|
|
|
* ptr in the log to point to the next available iclog. This allows further
|
|
|
|
* write to continue while this code syncs out an iclog ready to go.
|
|
|
|
* Before an in-core log can be written out, the data section must be scanned
|
|
|
|
* to save away the 1st word of each BBSIZE block into the header. We replace
|
|
|
|
* it with the current cycle count. Each BBSIZE block is tagged with the
|
|
|
|
* cycle count because there in an implicit assumption that drives will
|
|
|
|
* guarantee that entire 512 byte blocks get written at once. In other words,
|
|
|
|
* we can't have part of a 512 byte block written and part not written. By
|
|
|
|
* tagging each block, we will know which blocks are valid when recovering
|
|
|
|
* after an unclean shutdown.
|
|
|
|
*
|
|
|
|
* This routine is single threaded on the iclog. No other thread can be in
|
|
|
|
* this routine with the same iclog. Changing contents of iclog can there-
|
|
|
|
* fore be done without grabbing the state machine lock. Updating the global
|
|
|
|
* log will require grabbing the lock though.
|
|
|
|
*
|
|
|
|
* The entire log manager uses a logical block numbering scheme. Only
|
|
|
|
* log_sync (and then only bwrite()) know about the fact that the log may
|
|
|
|
* not start with block zero on a given device. The log block start offset
|
|
|
|
* is added immediately before calling bwrite().
|
|
|
|
*/
|
|
|
|
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC int
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_sync(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xfs_buf_t *bp;
|
2007-10-11 18:59:34 -06:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
uint count; /* byte count of bwrite */
|
|
|
|
uint count_init; /* initial count before roundup */
|
|
|
|
int roundoff; /* roundoff to BB or stripe */
|
|
|
|
int split = 0; /* split write into two regions */
|
|
|
|
int error;
|
2008-03-05 19:44:28 -07:00
|
|
|
int v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb);
|
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
|
|
|
int size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(log->l_mp, xs_log_writes);
|
2008-03-05 19:44:14 -07:00
|
|
|
ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Add for LR header */
|
|
|
|
count_init = log->l_iclog_hsize + iclog->ic_offset;
|
|
|
|
|
|
|
|
/* Round out the log write size */
|
|
|
|
if (v2 && log->l_mp->m_sb.sb_logsunit > 1) {
|
|
|
|
/* we have a v2 stripe unit to use */
|
|
|
|
count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init));
|
|
|
|
} else {
|
|
|
|
count = BBTOB(BTOBB(count_init));
|
|
|
|
}
|
|
|
|
roundoff = count - count_init;
|
|
|
|
ASSERT(roundoff >= 0);
|
|
|
|
ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 &&
|
|
|
|
roundoff < log->l_mp->m_sb.sb_logsunit)
|
|
|
|
||
|
|
|
|
(log->l_mp->m_sb.sb_logsunit <= 1 &&
|
|
|
|
roundoff < BBTOB(1)));
|
|
|
|
|
|
|
|
/* move grant heads by roundoff in sync */
|
2012-02-19 19:31:25 -07:00
|
|
|
xlog_grant_add_space(log, &log->l_reserve_head.grant, roundoff);
|
|
|
|
xlog_grant_add_space(log, &log->l_write_head.grant, roundoff);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* put cycle number in every block */
|
|
|
|
xlog_pack_data(log, iclog, roundoff);
|
|
|
|
|
|
|
|
/* real byte length */
|
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
|
|
|
size = iclog->ic_offset;
|
|
|
|
if (v2)
|
|
|
|
size += roundoff;
|
|
|
|
iclog->ic_header.h_len = cpu_to_be32(size);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-07-28 01:04:44 -06:00
|
|
|
bp = iclog->ic_bp;
|
2007-10-11 18:59:34 -06:00
|
|
|
XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_ADD(log->l_mp, xs_log_blocks, BTOBB(count));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Do we need to split this write into 2 parts? */
|
|
|
|
if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) {
|
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 *dptr;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)));
|
|
|
|
count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp));
|
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
|
|
|
iclog->ic_bwritecnt = 2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bump the cycle numbers at the start of each block in the
|
|
|
|
* part of the iclog that ends up in the buffer that gets
|
|
|
|
* written to the start of the log.
|
|
|
|
*
|
|
|
|
* Watch out for the header magic number case, though.
|
|
|
|
*/
|
|
|
|
dptr = (char *)&iclog->ic_header + count;
|
|
|
|
for (i = 0; i < split; i += BBSIZE) {
|
2017-06-16 12:00:05 -06:00
|
|
|
uint32_t cycle = be32_to_cpu(*(__be32 *)dptr);
|
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
|
|
|
if (++cycle == XLOG_HEADER_MAGIC_NUM)
|
|
|
|
cycle++;
|
|
|
|
*(__be32 *)dptr = cpu_to_be32(cycle);
|
|
|
|
|
|
|
|
dptr += BBSIZE;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
iclog->ic_bwritecnt = 1;
|
|
|
|
}
|
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
|
|
|
|
|
|
|
/* calculcate the checksum */
|
|
|
|
iclog->ic_header.h_crc = xlog_cksum(log, &iclog->ic_header,
|
|
|
|
iclog->ic_datap, size);
|
2016-01-04 13:41:16 -07:00
|
|
|
/*
|
|
|
|
* Intentionally corrupt the log record CRC based on the error injection
|
|
|
|
* frequency, if defined. This facilitates testing log recovery in the
|
|
|
|
* event of torn writes. Hence, set the IOABORT state to abort the log
|
|
|
|
* write on I/O completion and shutdown the fs. The subsequent mount
|
|
|
|
* detects the bad CRC and attempts to recover.
|
|
|
|
*/
|
2017-06-27 10:52:32 -06:00
|
|
|
if (XFS_TEST_ERROR(false, log->l_mp, XFS_ERRTAG_LOG_BAD_CRC)) {
|
2017-04-21 12:24:40 -06:00
|
|
|
iclog->ic_header.h_crc &= cpu_to_le32(0xAAAAAAAA);
|
2016-01-04 13:41:16 -07:00
|
|
|
iclog->ic_state |= XLOG_STATE_IOABORT;
|
|
|
|
xfs_warn(log->l_mp,
|
|
|
|
"Intentionally corrupted log record at LSN 0x%llx. Shutdown imminent.",
|
|
|
|
be64_to_cpu(iclog->ic_header.h_lsn));
|
|
|
|
}
|
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-04-22 23:58:52 -06:00
|
|
|
bp->b_io_length = BTOBB(count);
|
2018-01-24 14:38:48 -07:00
|
|
|
bp->b_log_item = iclog;
|
2016-12-08 22:49:54 -07:00
|
|
|
bp->b_flags &= ~XBF_FLUSH;
|
|
|
|
bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
|
2010-06-28 08:34:34 -06:00
|
|
|
|
2016-12-08 22:49:54 -07:00
|
|
|
/*
|
|
|
|
* Flush the data device before flushing the log to make sure all meta
|
|
|
|
* data written back from the AIL actually made it to disk before
|
|
|
|
* stamping the new log tail LSN into the log buffer. For an external
|
|
|
|
* log we need to issue the flush explicitly, and unfortunately
|
|
|
|
* synchronously here; for an internal log we can simply use the block
|
|
|
|
* layer state machine for preflushes.
|
|
|
|
*/
|
|
|
|
if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
|
|
|
|
xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
|
|
|
|
else
|
|
|
|
bp->b_flags |= XBF_FLUSH;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
|
|
|
|
ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
|
|
|
|
|
2013-01-18 13:17:46 -07:00
|
|
|
xlog_verify_iclog(log, iclog, count, true);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* account for log which doesn't start at block #0 */
|
|
|
|
XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
|
2016-02-09 21:01:11 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Don't call xfs_bwrite here. We do log-syncs even when the filesystem
|
|
|
|
* is shutting down.
|
|
|
|
*/
|
2011-10-10 10:52:49 -06:00
|
|
|
error = xlog_bdstrat(bp);
|
|
|
|
if (error) {
|
|
|
|
xfs_buf_ioerror_alert(bp, "xlog_sync");
|
2006-01-14 18:37:08 -07:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (split) {
|
2006-07-28 01:04:44 -06:00
|
|
|
bp = iclog->ic_log->l_xbuf;
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_BUF_SET_ADDR(bp, 0); /* logical 0 */
|
2011-07-22 17:40:22 -06:00
|
|
|
xfs_buf_associate_memory(bp,
|
|
|
|
(char *)&iclog->ic_header + count, split);
|
2018-01-24 14:38:48 -07:00
|
|
|
bp->b_log_item = iclog;
|
2016-12-08 22:49:54 -07:00
|
|
|
bp->b_flags &= ~XBF_FLUSH;
|
|
|
|
bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE | XBF_FUA);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
|
|
|
|
ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
|
|
|
|
|
2006-03-28 15:55:14 -07:00
|
|
|
/* account for internal log which doesn't start at block #0 */
|
2005-04-16 16:20:36 -06:00
|
|
|
XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
|
2011-10-10 10:52:49 -06:00
|
|
|
error = xlog_bdstrat(bp);
|
|
|
|
if (error) {
|
|
|
|
xfs_buf_ioerror_alert(bp, "xlog_sync (split)");
|
2006-01-14 18:37:08 -07:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2006-01-14 18:37:08 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* xlog_sync */
|
|
|
|
|
|
|
|
/*
|
2006-03-28 15:55:14 -07:00
|
|
|
* Deallocate a log structure
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_dealloc_log(
|
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_in_core_t *iclog, *next_iclog;
|
|
|
|
int i;
|
|
|
|
|
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
|
|
|
xlog_cil_destroy(log);
|
|
|
|
|
2011-04-21 03:34:27 -06:00
|
|
|
/*
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
* Cycle all the iclogbuf locks to make sure all log IO completion
|
|
|
|
* is done before we tear down these buffers.
|
|
|
|
*/
|
|
|
|
iclog = log->l_iclog;
|
|
|
|
for (i = 0; i < log->l_iclog_bufs; i++) {
|
|
|
|
xfs_buf_lock(iclog->ic_bp);
|
|
|
|
xfs_buf_unlock(iclog->ic_bp);
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Always need to ensure that the extra buffer does not point to memory
|
|
|
|
* owned by another log buffer before we free it. Also, cycle the lock
|
|
|
|
* first to ensure we've completed IO on it.
|
2011-04-21 03:34:27 -06:00
|
|
|
*/
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
xfs_buf_lock(log->l_xbuf);
|
|
|
|
xfs_buf_unlock(log->l_xbuf);
|
2012-04-22 23:58:49 -06:00
|
|
|
xfs_buf_set_empty(log->l_xbuf, BTOBB(log->l_iclog_size));
|
2011-04-21 03:34:27 -06:00
|
|
|
xfs_buf_free(log->l_xbuf);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = log->l_iclog;
|
xfs: unmount does not wait for shutdown during unmount
And interesting situation can occur if a log IO error occurs during
the unmount of a filesystem. The cases reported have the same
signature - the update of the superblock counters fails due to a log
write IO error:
XFS (dm-16): xfs_do_force_shutdown(0x2) called from line 1170 of file fs/xfs/xfs_log.c. Return address = 0xffffffffa08a44a1
XFS (dm-16): Log I/O Error Detected. Shutting down filesystem
XFS (dm-16): Unable to update superblock counters. Freespace may not be correct on next mount.
XFS (dm-16): xfs_log_force: error 5 returned.
XFS (¿-¿¿¿): Please umount the filesystem and rectify the problem(s)
It can be seen that the last line of output contains a corrupt
device name - this is because the log and xfs_mount structures have
already been freed by the time this message is printed. A kernel
oops closely follows.
The issue is that the shutdown is occurring in a separate IO
completion thread to the unmount. Once the shutdown processing has
started and all the iclogs are marked with XLOG_STATE_IOERROR, the
log shutdown code wakes anyone waiting on a log force so they can
process the shutdown error. This wakes up the unmount code that
is doing a synchronous transaction to update the superblock
counters.
The unmount path now sees all the iclogs are marked with
XLOG_STATE_IOERROR and so never waits on them again, knowing that if
it does, there will not be a wakeup trigger for it and we will hang
the unmount if we do. Hence the unmount runs through all the
remaining code and frees all the filesystem structures while the
xlog_iodone() is still processing the shutdown. When the log
shutdown processing completes, xfs_do_force_shutdown() emits the
"Please umount the filesystem and rectify the problem(s)" message,
and xlog_iodone() then aborts all the objects attached to the iclog.
An iclog that has already been freed....
The real issue here is that there is no serialisation point between
the log IO and the unmount. We have serialisations points for log
writes, log forces, reservations, etc, but we don't actually have
any code that wakes for log IO to fully complete. We do that for all
other types of object, so why not iclogbufs?
Well, it turns out that we can easily do this. We've got xfs_buf
handles, and that's what everyone else uses for IO serialisation.
i.e. bp->b_sema. So, lets hold iclogbufs locked over IO, and only
release the lock in xlog_iodone() when we are finished with the
buffer. That way before we tear down the iclog, we can lock and
unlock the buffer to ensure IO completion has finished completely
before we tear it down.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Tested-by: Bob Mastors <bob.mastors@solidfire.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2014-04-16 16:15:26 -06:00
|
|
|
for (i = 0; i < log->l_iclog_bufs; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
xfs_buf_free(iclog->ic_bp);
|
|
|
|
next_iclog = iclog->ic_next;
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(iclog);
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = next_iclog;
|
|
|
|
}
|
|
|
|
spinlock_destroy(&log->l_icloglock);
|
|
|
|
|
|
|
|
log->l_mp->m_log = NULL;
|
2008-05-19 00:31:57 -06:00
|
|
|
kmem_free(log);
|
2006-03-28 15:55:14 -07:00
|
|
|
} /* xlog_dealloc_log */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Update counters atomically now that memcpy is done.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
|
|
|
static inline void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_state_finish_copy(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
int record_cnt,
|
|
|
|
int copy_bytes)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-13 16:03:29 -07:00
|
|
|
be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog->ic_offset += copy_bytes;
|
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* xlog_state_finish_copy */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-09-02 00:42:05 -06:00
|
|
|
/*
|
|
|
|
* print out info relating to regions written which consume
|
|
|
|
* the reservation
|
|
|
|
*/
|
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)
|
2005-09-02 00:42:05 -06:00
|
|
|
{
|
|
|
|
uint i;
|
|
|
|
uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t);
|
|
|
|
|
|
|
|
/* match with XLOG_REG_TYPE_* in xfs_log.h */
|
2016-03-06 14:40:03 -07:00
|
|
|
#define REG_TYPE_STR(type, str) [XLOG_REG_TYPE_##type] = str
|
|
|
|
static char *res_type_str[XLOG_REG_TYPE_MAX + 1] = {
|
|
|
|
REG_TYPE_STR(BFORMAT, "bformat"),
|
|
|
|
REG_TYPE_STR(BCHUNK, "bchunk"),
|
|
|
|
REG_TYPE_STR(EFI_FORMAT, "efi_format"),
|
|
|
|
REG_TYPE_STR(EFD_FORMAT, "efd_format"),
|
|
|
|
REG_TYPE_STR(IFORMAT, "iformat"),
|
|
|
|
REG_TYPE_STR(ICORE, "icore"),
|
|
|
|
REG_TYPE_STR(IEXT, "iext"),
|
|
|
|
REG_TYPE_STR(IBROOT, "ibroot"),
|
|
|
|
REG_TYPE_STR(ILOCAL, "ilocal"),
|
|
|
|
REG_TYPE_STR(IATTR_EXT, "iattr_ext"),
|
|
|
|
REG_TYPE_STR(IATTR_BROOT, "iattr_broot"),
|
|
|
|
REG_TYPE_STR(IATTR_LOCAL, "iattr_local"),
|
|
|
|
REG_TYPE_STR(QFORMAT, "qformat"),
|
|
|
|
REG_TYPE_STR(DQUOT, "dquot"),
|
|
|
|
REG_TYPE_STR(QUOTAOFF, "quotaoff"),
|
|
|
|
REG_TYPE_STR(LRHEADER, "LR header"),
|
|
|
|
REG_TYPE_STR(UNMOUNT, "unmount"),
|
|
|
|
REG_TYPE_STR(COMMIT, "commit"),
|
|
|
|
REG_TYPE_STR(TRANSHDR, "trans header"),
|
|
|
|
REG_TYPE_STR(ICREATE, "inode create")
|
2005-09-02 00:42:05 -06:00
|
|
|
};
|
2016-03-06 14:40:03 -07:00
|
|
|
#undef REG_TYPE_STR
|
2005-09-02 00:42:05 -06:00
|
|
|
|
2017-06-14 22:29:48 -06:00
|
|
|
xfs_warn(mp, "ticket reservation summary:");
|
2015-07-28 19:52:04 -06:00
|
|
|
xfs_warn(mp, " unit res = %d bytes",
|
|
|
|
ticket->t_unit_res);
|
|
|
|
xfs_warn(mp, " current res = %d bytes",
|
|
|
|
ticket->t_curr_res);
|
|
|
|
xfs_warn(mp, " total reg = %u bytes (o/flow = %u bytes)",
|
|
|
|
ticket->t_res_arr_sum, ticket->t_res_o_flow);
|
|
|
|
xfs_warn(mp, " ophdrs = %u (ophdr space = %u bytes)",
|
|
|
|
ticket->t_res_num_ophdrs, ophdr_spc);
|
|
|
|
xfs_warn(mp, " ophdr + reg = %u bytes",
|
|
|
|
ticket->t_res_arr_sum + ticket->t_res_o_flow + ophdr_spc);
|
|
|
|
xfs_warn(mp, " num regions = %u",
|
|
|
|
ticket->t_res_num);
|
2005-09-02 00:42:05 -06:00
|
|
|
|
|
|
|
for (i = 0; i < ticket->t_res_num; i++) {
|
2011-03-06 16:01:35 -07:00
|
|
|
uint r_type = ticket->t_res_arr[i].r_type;
|
2013-10-11 19:59:05 -06:00
|
|
|
xfs_warn(mp, "region[%u]: %s - %u bytes", i,
|
2005-09-02 00:42:05 -06:00
|
|
|
((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ?
|
2016-03-06 14:40:03 -07:00
|
|
|
"bad-rtype" : res_type_str[r_type]),
|
2005-09-02 00:42:05 -06:00
|
|
|
ticket->t_res_arr[i].r_len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-14 22:29:50 -06:00
|
|
|
/*
|
|
|
|
* Print a summary of the transaction.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xlog_print_trans(
|
|
|
|
struct xfs_trans *tp)
|
|
|
|
{
|
|
|
|
struct xfs_mount *mp = tp->t_mountp;
|
|
|
|
struct xfs_log_item_desc *lidp;
|
|
|
|
|
|
|
|
/* dump core transaction and ticket info */
|
|
|
|
xfs_warn(mp, "transaction summary:");
|
2018-01-08 11:41:35 -07:00
|
|
|
xfs_warn(mp, " log res = %d", tp->t_log_res);
|
|
|
|
xfs_warn(mp, " log count = %d", tp->t_log_count);
|
|
|
|
xfs_warn(mp, " flags = 0x%x", tp->t_flags);
|
2017-06-14 22:29:50 -06:00
|
|
|
|
|
|
|
xlog_print_tic_res(mp, tp->t_ticket);
|
|
|
|
|
|
|
|
/* dump each log item */
|
|
|
|
list_for_each_entry(lidp, &tp->t_items, lid_trans) {
|
|
|
|
struct xfs_log_item *lip = lidp->lid_item;
|
|
|
|
struct xfs_log_vec *lv = lip->li_lv;
|
|
|
|
struct xfs_log_iovec *vec;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
xfs_warn(mp, "log item: ");
|
|
|
|
xfs_warn(mp, " type = 0x%x", lip->li_type);
|
|
|
|
xfs_warn(mp, " flags = 0x%x", lip->li_flags);
|
|
|
|
if (!lv)
|
|
|
|
continue;
|
|
|
|
xfs_warn(mp, " niovecs = %d", lv->lv_niovecs);
|
|
|
|
xfs_warn(mp, " size = %d", lv->lv_size);
|
|
|
|
xfs_warn(mp, " bytes = %d", lv->lv_bytes);
|
|
|
|
xfs_warn(mp, " buf len = %d", lv->lv_buf_len);
|
|
|
|
|
|
|
|
/* dump each iovec for the log item */
|
|
|
|
vec = lv->lv_iovecp;
|
|
|
|
for (i = 0; i < lv->lv_niovecs; i++) {
|
|
|
|
int dumplen = min(vec->i_len, 32);
|
|
|
|
|
|
|
|
xfs_warn(mp, " iovec[%d]", i);
|
|
|
|
xfs_warn(mp, " type = 0x%x", vec->i_type);
|
|
|
|
xfs_warn(mp, " len = %d", vec->i_len);
|
|
|
|
xfs_warn(mp, " first %d bytes of iovec[%d]:", dumplen, i);
|
2017-06-26 09:54:16 -06:00
|
|
|
xfs_hex_dump(vec->i_addr, dumplen);
|
2017-06-14 22:29:50 -06:00
|
|
|
|
|
|
|
vec++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-22 18:29:44 -06:00
|
|
|
/*
|
|
|
|
* Calculate the potential space needed by the log vector. Each region gets
|
|
|
|
* its own xlog_op_header_t and may need to be double word aligned.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xlog_write_calc_vec_length(
|
|
|
|
struct xlog_ticket *ticket,
|
2010-03-22 18:43:17 -06:00
|
|
|
struct xfs_log_vec *log_vector)
|
2010-03-22 18:29:44 -06:00
|
|
|
{
|
2010-03-22 18:43:17 -06:00
|
|
|
struct xfs_log_vec *lv;
|
2010-03-22 18:29:44 -06:00
|
|
|
int headers = 0;
|
|
|
|
int len = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* acct for start rec of xact */
|
|
|
|
if (ticket->t_flags & XLOG_TIC_INITED)
|
|
|
|
headers++;
|
|
|
|
|
2010-03-22 18:43:17 -06:00
|
|
|
for (lv = log_vector; lv; lv = lv->lv_next) {
|
2013-06-27 00:04:51 -06:00
|
|
|
/* we don't write ordered log vectors */
|
|
|
|
if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED)
|
|
|
|
continue;
|
|
|
|
|
2010-03-22 18:43:17 -06:00
|
|
|
headers += lv->lv_niovecs;
|
|
|
|
|
|
|
|
for (i = 0; i < lv->lv_niovecs; i++) {
|
|
|
|
struct xfs_log_iovec *vecp = &lv->lv_iovecp[i];
|
2010-03-22 18:29:44 -06:00
|
|
|
|
2010-03-22 18:43:17 -06:00
|
|
|
len += vecp->i_len;
|
|
|
|
xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type);
|
|
|
|
}
|
2010-03-22 18:29:44 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ticket->t_res_num_ophdrs += headers;
|
|
|
|
len += headers * sizeof(struct xlog_op_header);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If first write for transaction, insert start record We can't be trying to
|
|
|
|
* commit if we are inited. We can't have any "partial_copy" if we are inited.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xlog_write_start_rec(
|
2010-03-22 18:47:38 -06:00
|
|
|
struct xlog_op_header *ophdr,
|
2010-03-22 18:29:44 -06:00
|
|
|
struct xlog_ticket *ticket)
|
|
|
|
{
|
|
|
|
if (!(ticket->t_flags & XLOG_TIC_INITED))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
|
|
|
|
ophdr->oh_clientid = ticket->t_clientid;
|
|
|
|
ophdr->oh_len = 0;
|
|
|
|
ophdr->oh_flags = XLOG_START_TRANS;
|
|
|
|
ophdr->oh_res2 = 0;
|
|
|
|
|
|
|
|
ticket->t_flags &= ~XLOG_TIC_INITED;
|
|
|
|
|
|
|
|
return sizeof(struct xlog_op_header);
|
|
|
|
}
|
|
|
|
|
|
|
|
static xlog_op_header_t *
|
|
|
|
xlog_write_setup_ophdr(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2010-03-22 18:47:38 -06:00
|
|
|
struct xlog_op_header *ophdr,
|
2010-03-22 18:29:44 -06:00
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
uint flags)
|
|
|
|
{
|
|
|
|
ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
|
|
|
|
ophdr->oh_clientid = ticket->t_clientid;
|
|
|
|
ophdr->oh_res2 = 0;
|
|
|
|
|
|
|
|
/* are we copying a commit or unmount record? */
|
|
|
|
ophdr->oh_flags = flags;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We've seen logs corrupted with bad transaction client ids. This
|
|
|
|
* makes sure that XFS doesn't generate them on. Turn this into an EIO
|
|
|
|
* and shut down the filesystem.
|
|
|
|
*/
|
|
|
|
switch (ophdr->oh_clientid) {
|
|
|
|
case XFS_TRANSACTION:
|
|
|
|
case XFS_VOLUME:
|
|
|
|
case XFS_LOG:
|
|
|
|
break;
|
|
|
|
default:
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp,
|
2018-01-09 13:02:55 -07:00
|
|
|
"Bad XFS transaction clientid 0x%x in ticket "PTR_FMT,
|
2010-03-22 18:29:44 -06:00
|
|
|
ophdr->oh_clientid, ticket);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ophdr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the parameters of the region copy into the log. This has
|
|
|
|
* to handle region write split across multiple log buffers - this
|
|
|
|
* state is kept external to this function so that this code can
|
2013-08-07 04:11:02 -06:00
|
|
|
* be written in an obvious, self documenting manner.
|
2010-03-22 18:29:44 -06:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xlog_write_setup_copy(
|
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
struct xlog_op_header *ophdr,
|
|
|
|
int space_available,
|
|
|
|
int space_required,
|
|
|
|
int *copy_off,
|
|
|
|
int *copy_len,
|
|
|
|
int *last_was_partial_copy,
|
|
|
|
int *bytes_consumed)
|
|
|
|
{
|
|
|
|
int still_to_copy;
|
|
|
|
|
|
|
|
still_to_copy = space_required - *bytes_consumed;
|
|
|
|
*copy_off = *bytes_consumed;
|
|
|
|
|
|
|
|
if (still_to_copy <= space_available) {
|
|
|
|
/* write of region completes here */
|
|
|
|
*copy_len = still_to_copy;
|
|
|
|
ophdr->oh_len = cpu_to_be32(*copy_len);
|
|
|
|
if (*last_was_partial_copy)
|
|
|
|
ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS);
|
|
|
|
*last_was_partial_copy = 0;
|
|
|
|
*bytes_consumed = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* partial write of region, needs extra log op header reservation */
|
|
|
|
*copy_len = space_available;
|
|
|
|
ophdr->oh_len = cpu_to_be32(*copy_len);
|
|
|
|
ophdr->oh_flags |= XLOG_CONTINUE_TRANS;
|
|
|
|
if (*last_was_partial_copy)
|
|
|
|
ophdr->oh_flags |= XLOG_WAS_CONT_TRANS;
|
|
|
|
*bytes_consumed += *copy_len;
|
|
|
|
(*last_was_partial_copy)++;
|
|
|
|
|
|
|
|
/* account for new log op header */
|
|
|
|
ticket->t_curr_res -= sizeof(struct xlog_op_header);
|
|
|
|
ticket->t_res_num_ophdrs++;
|
|
|
|
|
|
|
|
return sizeof(struct xlog_op_header);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xlog_write_copy_finish(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2010-03-22 18:29:44 -06:00
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
uint flags,
|
|
|
|
int *record_cnt,
|
|
|
|
int *data_cnt,
|
|
|
|
int *partial_copy,
|
|
|
|
int *partial_copy_len,
|
|
|
|
int log_offset,
|
|
|
|
struct xlog_in_core **commit_iclog)
|
|
|
|
{
|
|
|
|
if (*partial_copy) {
|
|
|
|
/*
|
|
|
|
* This iclog has already been marked WANT_SYNC by
|
|
|
|
* xlog_state_get_iclog_space.
|
|
|
|
*/
|
|
|
|
xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
|
|
|
|
*record_cnt = 0;
|
|
|
|
*data_cnt = 0;
|
|
|
|
return xlog_state_release_iclog(log, iclog);
|
|
|
|
}
|
|
|
|
|
|
|
|
*partial_copy = 0;
|
|
|
|
*partial_copy_len = 0;
|
|
|
|
|
|
|
|
if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) {
|
|
|
|
/* no more space in this iclog - push it. */
|
|
|
|
xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
|
|
|
|
*record_cnt = 0;
|
|
|
|
*data_cnt = 0;
|
|
|
|
|
|
|
|
spin_lock(&log->l_icloglock);
|
|
|
|
xlog_state_want_sync(log, iclog);
|
|
|
|
spin_unlock(&log->l_icloglock);
|
|
|
|
|
|
|
|
if (!commit_iclog)
|
|
|
|
return xlog_state_release_iclog(log, iclog);
|
|
|
|
ASSERT(flags & XLOG_COMMIT_TRANS);
|
|
|
|
*commit_iclog = iclog;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Write some region out to in-core log
|
|
|
|
*
|
|
|
|
* This will be called when writing externally provided regions or when
|
|
|
|
* writing out a commit record for a given transaction.
|
|
|
|
*
|
|
|
|
* General algorithm:
|
|
|
|
* 1. Find total length of this write. This may include adding to the
|
|
|
|
* lengths passed in.
|
|
|
|
* 2. Check whether we violate the tickets reservation.
|
|
|
|
* 3. While writing to this iclog
|
|
|
|
* A. Reserve as much space in this iclog as can get
|
|
|
|
* B. If this is first write, save away start lsn
|
|
|
|
* C. While writing this region:
|
|
|
|
* 1. If first write of transaction, write start record
|
|
|
|
* 2. Write log operation header (header per region)
|
|
|
|
* 3. Find out if we can fit entire region into this iclog
|
|
|
|
* 4. Potentially, verify destination memcpy ptr
|
|
|
|
* 5. Memcpy (partial) region
|
|
|
|
* 6. If partial copy, release iclog; otherwise, continue
|
|
|
|
* copying more regions into current iclog
|
|
|
|
* 4. Mark want sync bit (in simulation mode)
|
|
|
|
* 5. Release iclog for potential flush to on-disk log.
|
|
|
|
*
|
|
|
|
* ERRORS:
|
|
|
|
* 1. Panic if reservation is overrun. This should never happen since
|
|
|
|
* reservation amounts are generated internal to the filesystem.
|
|
|
|
* NOTES:
|
|
|
|
* 1. Tickets are single threaded data structures.
|
|
|
|
* 2. The XLOG_END_TRANS & XLOG_CONTINUE_TRANS flags are passed down to the
|
|
|
|
* syncing routine. When a single log_write region needs to span
|
|
|
|
* multiple in-core logs, the XLOG_CONTINUE_TRANS bit should be set
|
|
|
|
* on all log operation writes which don't contain the end of the
|
|
|
|
* region. The XLOG_END_TRANS bit is used for the in-core log
|
|
|
|
* operation which contains the end of the continued log_write region.
|
|
|
|
* 3. When xlog_state_get_iclog_space() grabs the rest of the current iclog,
|
|
|
|
* we don't really know exactly how much space will be used. As a result,
|
|
|
|
* we don't update ic_offset until the end when we know exactly how many
|
|
|
|
* bytes have been written out.
|
|
|
|
*/
|
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
|
|
|
int
|
2010-02-15 16:34:54 -07:00
|
|
|
xlog_write(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2010-03-22 18:43:17 -06:00
|
|
|
struct xfs_log_vec *log_vector,
|
2010-02-15 16:34:54 -07:00
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
xfs_lsn_t *start_lsn,
|
|
|
|
struct xlog_in_core **commit_iclog,
|
|
|
|
uint flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-03-22 18:35:45 -06:00
|
|
|
struct xlog_in_core *iclog = NULL;
|
2010-03-22 18:43:17 -06:00
|
|
|
struct xfs_log_iovec *vecp;
|
|
|
|
struct xfs_log_vec *lv;
|
2010-03-22 18:35:45 -06:00
|
|
|
int len;
|
|
|
|
int index;
|
|
|
|
int partial_copy = 0;
|
|
|
|
int partial_copy_len = 0;
|
|
|
|
int contwr = 0;
|
|
|
|
int record_cnt = 0;
|
|
|
|
int data_cnt = 0;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
*start_lsn = 0;
|
|
|
|
|
2010-03-22 18:43:17 -06:00
|
|
|
len = xlog_write_calc_vec_length(ticket, log_vector);
|
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
|
|
|
|
2011-12-06 14:58:07 -07:00
|
|
|
/*
|
|
|
|
* Region headers and bytes are already accounted for.
|
|
|
|
* We only need to take into account start records and
|
|
|
|
* split regions in this function.
|
|
|
|
*/
|
|
|
|
if (ticket->t_flags & XLOG_TIC_INITED)
|
|
|
|
ticket->t_curr_res -= sizeof(xlog_op_header_t);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Commit record headers need to be accounted for. These
|
|
|
|
* come in as separate writes so are easy to detect.
|
|
|
|
*/
|
|
|
|
if (flags & (XLOG_COMMIT_TRANS | XLOG_UNMOUNT_TRANS))
|
|
|
|
ticket->t_curr_res -= sizeof(xlog_op_header_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
|
|
|
|
2017-06-14 22:29:48 -06:00
|
|
|
if (ticket->t_curr_res < 0) {
|
|
|
|
xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
|
|
|
|
"ctx ticket reservation ran out. Need to up reservation");
|
2010-03-22 18:43:17 -06:00
|
|
|
xlog_print_tic_res(log->l_mp, ticket);
|
2017-06-14 22:29:48 -06:00
|
|
|
xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-03-22 18:43:17 -06:00
|
|
|
index = 0;
|
|
|
|
lv = log_vector;
|
|
|
|
vecp = lv->lv_iovecp;
|
2013-06-27 00:04:51 -06:00
|
|
|
while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
|
2010-03-22 18:47:38 -06:00
|
|
|
void *ptr;
|
2010-03-22 18:35:45 -06:00
|
|
|
int log_offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-03-22 18:35:45 -06:00
|
|
|
error = xlog_state_get_iclog_space(log, len, &iclog, ticket,
|
|
|
|
&contwr, &log_offset);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-03-22 18:35:45 -06:00
|
|
|
ASSERT(log_offset <= iclog->ic_size - 1);
|
2010-03-22 18:47:38 -06:00
|
|
|
ptr = iclog->ic_datap + log_offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-03-22 18:35:45 -06:00
|
|
|
/* start_lsn is the first lsn written to. That's all we need. */
|
|
|
|
if (!*start_lsn)
|
|
|
|
*start_lsn = be64_to_cpu(iclog->ic_header.h_lsn);
|
2010-03-22 18:29:44 -06:00
|
|
|
|
2010-03-22 18:35:45 -06:00
|
|
|
/*
|
|
|
|
* This loop writes out as many regions as can fit in the amount
|
|
|
|
* of space which was allocated by xlog_state_get_iclog_space().
|
|
|
|
*/
|
2013-06-27 00:04:51 -06:00
|
|
|
while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
|
|
|
|
struct xfs_log_iovec *reg;
|
2010-03-22 18:35:45 -06:00
|
|
|
struct xlog_op_header *ophdr;
|
|
|
|
int start_rec_copy;
|
|
|
|
int copy_len;
|
|
|
|
int copy_off;
|
2013-06-27 00:04:51 -06:00
|
|
|
bool ordered = false;
|
|
|
|
|
|
|
|
/* ordered log vectors have no regions to write */
|
|
|
|
if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) {
|
|
|
|
ASSERT(lv->lv_niovecs == 0);
|
|
|
|
ordered = true;
|
|
|
|
goto next_lv;
|
|
|
|
}
|
2010-03-22 18:35:45 -06:00
|
|
|
|
2013-06-27 00:04:51 -06:00
|
|
|
reg = &vecp[index];
|
2017-06-16 12:00:05 -06:00
|
|
|
ASSERT(reg->i_len % sizeof(int32_t) == 0);
|
|
|
|
ASSERT((unsigned long)ptr % sizeof(int32_t) == 0);
|
2010-03-22 18:35:45 -06:00
|
|
|
|
|
|
|
start_rec_copy = xlog_write_start_rec(ptr, ticket);
|
|
|
|
if (start_rec_copy) {
|
|
|
|
record_cnt++;
|
2010-03-22 18:47:38 -06:00
|
|
|
xlog_write_adv_cnt(&ptr, &len, &log_offset,
|
2010-03-22 18:35:45 -06:00
|
|
|
start_rec_copy);
|
|
|
|
}
|
2010-03-22 18:29:44 -06:00
|
|
|
|
2010-03-22 18:35:45 -06:00
|
|
|
ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);
|
|
|
|
if (!ophdr)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2010-03-22 18:35:45 -06:00
|
|
|
|
2010-03-22 18:47:38 -06:00
|
|
|
xlog_write_adv_cnt(&ptr, &len, &log_offset,
|
2010-03-22 18:35:45 -06:00
|
|
|
sizeof(struct xlog_op_header));
|
|
|
|
|
|
|
|
len += xlog_write_setup_copy(ticket, ophdr,
|
|
|
|
iclog->ic_size-log_offset,
|
2010-03-22 18:43:17 -06:00
|
|
|
reg->i_len,
|
2010-03-22 18:35:45 -06:00
|
|
|
©_off, ©_len,
|
|
|
|
&partial_copy,
|
|
|
|
&partial_copy_len);
|
|
|
|
xlog_verify_dest_ptr(log, ptr);
|
|
|
|
|
2015-10-11 23:04:15 -06:00
|
|
|
/*
|
|
|
|
* Copy region.
|
|
|
|
*
|
|
|
|
* Unmount records just log an opheader, so can have
|
|
|
|
* empty payloads with no data region to copy. Hence we
|
|
|
|
* only copy the payload if the vector says it has data
|
|
|
|
* to copy.
|
|
|
|
*/
|
2010-03-22 18:35:45 -06:00
|
|
|
ASSERT(copy_len >= 0);
|
2015-10-11 23:04:15 -06:00
|
|
|
if (copy_len > 0) {
|
|
|
|
memcpy(ptr, reg->i_addr + copy_off, copy_len);
|
|
|
|
xlog_write_adv_cnt(&ptr, &len, &log_offset,
|
|
|
|
copy_len);
|
|
|
|
}
|
2010-03-22 18:35:45 -06:00
|
|
|
copy_len += start_rec_copy + sizeof(xlog_op_header_t);
|
|
|
|
record_cnt++;
|
|
|
|
data_cnt += contwr ? copy_len : 0;
|
|
|
|
|
|
|
|
error = xlog_write_copy_finish(log, iclog, flags,
|
|
|
|
&record_cnt, &data_cnt,
|
|
|
|
&partial_copy,
|
|
|
|
&partial_copy_len,
|
|
|
|
log_offset,
|
|
|
|
commit_iclog);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if we had a partial copy, we need to get more iclog
|
|
|
|
* space but we don't want to increment the region
|
|
|
|
* index because there is still more is this region to
|
|
|
|
* write.
|
|
|
|
*
|
|
|
|
* If we completed writing this region, and we flushed
|
|
|
|
* the iclog (indicated by resetting of the record
|
|
|
|
* count), then we also need to get more log space. If
|
|
|
|
* this was the last record, though, we are done and
|
|
|
|
* can just return.
|
|
|
|
*/
|
|
|
|
if (partial_copy)
|
|
|
|
break;
|
|
|
|
|
2010-03-22 18:43:17 -06:00
|
|
|
if (++index == lv->lv_niovecs) {
|
2013-06-27 00:04:51 -06:00
|
|
|
next_lv:
|
2010-03-22 18:43:17 -06:00
|
|
|
lv = lv->lv_next;
|
|
|
|
index = 0;
|
|
|
|
if (lv)
|
|
|
|
vecp = lv->lv_iovecp;
|
|
|
|
}
|
2017-10-09 12:38:54 -06:00
|
|
|
if (record_cnt == 0 && !ordered) {
|
2010-03-22 18:43:17 -06:00
|
|
|
if (!lv)
|
2010-03-22 18:35:45 -06:00
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(len == 0);
|
|
|
|
|
|
|
|
xlog_state_finish_copy(log, iclog, record_cnt, data_cnt);
|
|
|
|
if (!commit_iclog)
|
|
|
|
return xlog_state_release_iclog(log, iclog);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(flags & XLOG_COMMIT_TRANS);
|
|
|
|
*commit_iclog = iclog;
|
|
|
|
return 0;
|
2010-03-22 18:35:45 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* State Machine functions
|
|
|
|
*
|
|
|
|
*****************************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Clean iclogs starting from the head. This ordering must be
|
|
|
|
* maintained, so an iclog doesn't become ACTIVE beyond one that
|
|
|
|
* is SYNCING. This is also required to maintain the notion that we use
|
2008-08-13 00:34:31 -06:00
|
|
|
* a ordered wait queue to hold off would be writers to the log when every
|
2005-04-16 16:20:36 -06:00
|
|
|
* iclog is trying to sync to disk.
|
|
|
|
*
|
|
|
|
* State Change: DIRTY -> ACTIVE
|
|
|
|
*/
|
2005-06-20 23:36:52 -06:00
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_state_clean_log(
|
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_in_core_t *iclog;
|
|
|
|
int changed = 0;
|
|
|
|
|
|
|
|
iclog = log->l_iclog;
|
|
|
|
do {
|
|
|
|
if (iclog->ic_state == XLOG_STATE_DIRTY) {
|
|
|
|
iclog->ic_state = XLOG_STATE_ACTIVE;
|
|
|
|
iclog->ic_offset = 0;
|
2008-04-09 20:18:39 -06:00
|
|
|
ASSERT(iclog->ic_callback == NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* If the number of ops in this iclog indicate it just
|
|
|
|
* contains the dummy transaction, we can
|
|
|
|
* change state into IDLE (the second time around).
|
|
|
|
* Otherwise we should change the state into
|
|
|
|
* NEED a dummy.
|
|
|
|
* We don't need to cover the dummy.
|
|
|
|
*/
|
|
|
|
if (!changed &&
|
2007-10-11 18:59:34 -06:00
|
|
|
(be32_to_cpu(iclog->ic_header.h_num_logops) ==
|
|
|
|
XLOG_COVER_OPS)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
changed = 1;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We have two dirty iclogs so start over
|
|
|
|
* This could also be num of ops indicates
|
|
|
|
* this is not the dummy going out.
|
|
|
|
*/
|
|
|
|
changed = 2;
|
|
|
|
}
|
|
|
|
iclog->ic_header.h_num_logops = 0;
|
|
|
|
memset(iclog->ic_header.h_cycle_data, 0,
|
|
|
|
sizeof(iclog->ic_header.h_cycle_data));
|
|
|
|
iclog->ic_header.h_lsn = 0;
|
|
|
|
} else if (iclog->ic_state == XLOG_STATE_ACTIVE)
|
|
|
|
/* do nothing */;
|
|
|
|
else
|
|
|
|
break; /* stop cleaning */
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
} while (iclog != log->l_iclog);
|
|
|
|
|
|
|
|
/* log is locked when we are called */
|
|
|
|
/*
|
|
|
|
* Change state for the dummy log recording.
|
|
|
|
* We usually go to NEED. But we go to NEED2 if the changed indicates
|
|
|
|
* we are done writing the dummy record.
|
|
|
|
* If we are done with the second dummy recored (DONE2), then
|
|
|
|
* we go to IDLE.
|
|
|
|
*/
|
|
|
|
if (changed) {
|
|
|
|
switch (log->l_covered_state) {
|
|
|
|
case XLOG_STATE_COVER_IDLE:
|
|
|
|
case XLOG_STATE_COVER_NEED:
|
|
|
|
case XLOG_STATE_COVER_NEED2:
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_NEED;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XLOG_STATE_COVER_DONE:
|
|
|
|
if (changed == 1)
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_NEED2;
|
|
|
|
else
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_NEED;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XLOG_STATE_COVER_DONE2:
|
|
|
|
if (changed == 1)
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_IDLE;
|
|
|
|
else
|
|
|
|
log->l_covered_state = XLOG_STATE_COVER_NEED;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ASSERT(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} /* xlog_state_clean_log */
|
|
|
|
|
|
|
|
STATIC xfs_lsn_t
|
|
|
|
xlog_get_lowest_lsn(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_in_core_t *lsn_log;
|
|
|
|
xfs_lsn_t lowest_lsn, lsn;
|
|
|
|
|
|
|
|
lsn_log = log->l_iclog;
|
|
|
|
lowest_lsn = 0;
|
|
|
|
do {
|
|
|
|
if (!(lsn_log->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY))) {
|
2007-10-11 18:59:34 -06:00
|
|
|
lsn = be64_to_cpu(lsn_log->ic_header.h_lsn);
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((lsn && !lowest_lsn) ||
|
|
|
|
(XFS_LSN_CMP(lsn, lowest_lsn) < 0)) {
|
|
|
|
lowest_lsn = lsn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
lsn_log = lsn_log->ic_next;
|
|
|
|
} while (lsn_log != log->l_iclog);
|
2006-01-14 18:37:08 -07:00
|
|
|
return lowest_lsn;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
STATIC void
|
|
|
|
xlog_state_do_callback(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
int aborted,
|
|
|
|
struct xlog_in_core *ciclog)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_in_core_t *iclog;
|
|
|
|
xlog_in_core_t *first_iclog; /* used to know when we've
|
|
|
|
* processed all iclogs once */
|
|
|
|
xfs_log_callback_t *cb, *cb_next;
|
|
|
|
int flushcnt = 0;
|
|
|
|
xfs_lsn_t lowest_lsn;
|
|
|
|
int ioerrors; /* counter: iclogs with errors */
|
|
|
|
int loopdidcallbacks; /* flag: inner loop did callbacks*/
|
|
|
|
int funcdidcallbacks; /* flag: function did callbacks */
|
|
|
|
int repeats; /* for issuing console warnings if
|
|
|
|
* looping too many times */
|
2008-05-19 00:34:27 -06:00
|
|
|
int wake = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
first_iclog = iclog = log->l_iclog;
|
|
|
|
ioerrors = 0;
|
|
|
|
funcdidcallbacks = 0;
|
|
|
|
repeats = 0;
|
|
|
|
|
|
|
|
do {
|
|
|
|
/*
|
|
|
|
* Scan all iclogs starting with the one pointed to by the
|
|
|
|
* log. Reset this starting point each time the log is
|
|
|
|
* unlocked (during callbacks).
|
|
|
|
*
|
|
|
|
* Keep looping through iclogs until one full pass is made
|
|
|
|
* without running any callbacks.
|
|
|
|
*/
|
|
|
|
first_iclog = log->l_iclog;
|
|
|
|
iclog = log->l_iclog;
|
|
|
|
loopdidcallbacks = 0;
|
|
|
|
repeats++;
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
|
|
|
/* skip all iclogs in the ACTIVE & DIRTY states */
|
|
|
|
if (iclog->ic_state &
|
|
|
|
(XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY)) {
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Between marking a filesystem SHUTDOWN and stopping
|
|
|
|
* the log, we do flush all iclogs to disk (if there
|
|
|
|
* wasn't a log I/O error). So, we do want things to
|
|
|
|
* go smoothly in case of just a SHUTDOWN w/o a
|
|
|
|
* LOG_IO_ERROR.
|
|
|
|
*/
|
|
|
|
if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
|
|
|
|
/*
|
|
|
|
* Can only perform callbacks in order. Since
|
|
|
|
* this iclog is not in the DONE_SYNC/
|
|
|
|
* DO_CALLBACK state, we skip the rest and
|
|
|
|
* just try to clean up. If we set our iclog
|
|
|
|
* to DO_CALLBACK, we will not process it when
|
|
|
|
* we retry since a previous iclog is in the
|
|
|
|
* CALLBACK and the state cannot change since
|
2007-10-11 01:37:10 -06:00
|
|
|
* we are holding the l_icloglock.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
if (!(iclog->ic_state &
|
|
|
|
(XLOG_STATE_DONE_SYNC |
|
|
|
|
XLOG_STATE_DO_CALLBACK))) {
|
|
|
|
if (ciclog && (ciclog->ic_state ==
|
|
|
|
XLOG_STATE_DONE_SYNC)) {
|
|
|
|
ciclog->ic_state = XLOG_STATE_DO_CALLBACK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We now have an iclog that is in either the
|
|
|
|
* DO_CALLBACK or DONE_SYNC states. The other
|
|
|
|
* states (WANT_SYNC, SYNCING, or CALLBACK were
|
|
|
|
* caught by the above if and are going to
|
|
|
|
* clean (i.e. we aren't doing their callbacks)
|
|
|
|
* see the above if.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We will do one more check here to see if we
|
|
|
|
* have chased our tail around.
|
|
|
|
*/
|
|
|
|
|
|
|
|
lowest_lsn = xlog_get_lowest_lsn(log);
|
2007-10-11 18:59:34 -06:00
|
|
|
if (lowest_lsn &&
|
|
|
|
XFS_LSN_CMP(lowest_lsn,
|
2010-12-03 04:11:29 -07:00
|
|
|
be64_to_cpu(iclog->ic_header.h_lsn)) < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = iclog->ic_next;
|
|
|
|
continue; /* Leave this iclog for
|
|
|
|
* another thread */
|
|
|
|
}
|
|
|
|
|
|
|
|
iclog->ic_state = XLOG_STATE_CALLBACK;
|
|
|
|
|
|
|
|
|
2010-12-03 04:11:29 -07:00
|
|
|
/*
|
xfs: only update the last_sync_lsn when a transaction completes
The log write code stamps each iclog with the current tail LSN in
the iclog header so that recovery knows where to find the tail of
thelog once it has found the head. Normally this is taken from the
first item on the AIL - the log item that corresponds to the oldest
active item in the log.
The problem is that when the AIL is empty, the tail lsn is dervied
from the the l_last_sync_lsn, which is the LSN of the last iclog to
be written to the log. In most cases this doesn't happen, because
the AIL is rarely empty on an active filesystem. However, when it
does, it opens up an interesting case when the transaction being
committed to the iclog spans multiple iclogs.
That is, the first iclog is stamped with the l_last_sync_lsn, and IO
is issued. Then the next iclog is setup, the changes copied into the
iclog (takes some time), and then the l_last_sync_lsn is stamped
into the header and IO is issued. This is still the same
transaction, so the tail lsn of both iclogs must be the same for log
recovery to find the entire transaction to be able to replay it.
The problem arises in that the iclog buffer IO completion updates
the l_last_sync_lsn with it's own LSN. Therefore, If the first iclog
completes it's IO before the second iclog is filled and has the tail
lsn stamped in it, it will stamp the LSN of the first iclog into
it's tail lsn field. If the system fails at this point, log recovery
will not see a complete transaction, so the transaction will no be
replayed.
The fix is simple - the l_last_sync_lsn is updated when a iclog
buffer IO completes, and this is incorrect. The l_last_sync_lsn
shoul dbe updated when a transaction is completed by a iclog buffer
IO. That is, only iclog buffers that have transaction commit
callbacks attached to them should update the l_last_sync_lsn. This
means that the last_sync_lsn will only move forward when a commit
record it written, not in the middle of a large transaction that is
rolling through multiple iclog buffers.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-10-08 04:56:12 -06:00
|
|
|
* Completion of a iclog IO does not imply that
|
|
|
|
* a transaction has completed, as transactions
|
|
|
|
* can be large enough to span many iclogs. We
|
|
|
|
* cannot change the tail of the log half way
|
|
|
|
* through a transaction as this may be the only
|
|
|
|
* transaction in the log and moving th etail to
|
|
|
|
* point to the middle of it will prevent
|
|
|
|
* recovery from finding the start of the
|
|
|
|
* transaction. Hence we should only update the
|
|
|
|
* last_sync_lsn if this iclog contains
|
|
|
|
* transaction completion callbacks on it.
|
|
|
|
*
|
|
|
|
* We have to do this before we drop the
|
2010-12-03 04:11:29 -07:00
|
|
|
* icloglock to ensure we are the only one that
|
|
|
|
* can update it.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-12-03 04:11:29 -07:00
|
|
|
ASSERT(XFS_LSN_CMP(atomic64_read(&log->l_last_sync_lsn),
|
|
|
|
be64_to_cpu(iclog->ic_header.h_lsn)) <= 0);
|
xfs: only update the last_sync_lsn when a transaction completes
The log write code stamps each iclog with the current tail LSN in
the iclog header so that recovery knows where to find the tail of
thelog once it has found the head. Normally this is taken from the
first item on the AIL - the log item that corresponds to the oldest
active item in the log.
The problem is that when the AIL is empty, the tail lsn is dervied
from the the l_last_sync_lsn, which is the LSN of the last iclog to
be written to the log. In most cases this doesn't happen, because
the AIL is rarely empty on an active filesystem. However, when it
does, it opens up an interesting case when the transaction being
committed to the iclog spans multiple iclogs.
That is, the first iclog is stamped with the l_last_sync_lsn, and IO
is issued. Then the next iclog is setup, the changes copied into the
iclog (takes some time), and then the l_last_sync_lsn is stamped
into the header and IO is issued. This is still the same
transaction, so the tail lsn of both iclogs must be the same for log
recovery to find the entire transaction to be able to replay it.
The problem arises in that the iclog buffer IO completion updates
the l_last_sync_lsn with it's own LSN. Therefore, If the first iclog
completes it's IO before the second iclog is filled and has the tail
lsn stamped in it, it will stamp the LSN of the first iclog into
it's tail lsn field. If the system fails at this point, log recovery
will not see a complete transaction, so the transaction will no be
replayed.
The fix is simple - the l_last_sync_lsn is updated when a iclog
buffer IO completes, and this is incorrect. The l_last_sync_lsn
shoul dbe updated when a transaction is completed by a iclog buffer
IO. That is, only iclog buffers that have transaction commit
callbacks attached to them should update the l_last_sync_lsn. This
means that the last_sync_lsn will only move forward when a commit
record it written, not in the middle of a large transaction that is
rolling through multiple iclog buffers.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-10-08 04:56:12 -06:00
|
|
|
if (iclog->ic_callback)
|
|
|
|
atomic64_set(&log->l_last_sync_lsn,
|
|
|
|
be64_to_cpu(iclog->ic_header.h_lsn));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-03 04:11:29 -07:00
|
|
|
} else
|
2005-04-16 16:20:36 -06:00
|
|
|
ioerrors++;
|
2010-12-03 04:11:29 -07:00
|
|
|
|
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-09 20:18:39 -06:00
|
|
|
/*
|
|
|
|
* Keep processing entries in the callback list until
|
|
|
|
* we come around and it is empty. We need to
|
|
|
|
* atomically see that the list is empty and change the
|
|
|
|
* state to DIRTY so that we don't miss any more
|
|
|
|
* callbacks being added.
|
|
|
|
*/
|
|
|
|
spin_lock(&iclog->ic_callback_lock);
|
|
|
|
cb = iclog->ic_callback;
|
2007-08-15 23:37:36 -06:00
|
|
|
while (cb) {
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog->ic_callback_tail = &(iclog->ic_callback);
|
|
|
|
iclog->ic_callback = NULL;
|
2008-04-09 20:18:39 -06:00
|
|
|
spin_unlock(&iclog->ic_callback_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* perform callbacks in the order given */
|
2007-08-15 23:37:36 -06:00
|
|
|
for (; cb; cb = cb_next) {
|
2005-04-16 16:20:36 -06:00
|
|
|
cb_next = cb->cb_next;
|
|
|
|
cb->cb_func(cb->cb_arg, aborted);
|
|
|
|
}
|
2008-04-09 20:18:39 -06:00
|
|
|
spin_lock(&iclog->ic_callback_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
cb = iclog->ic_callback;
|
|
|
|
}
|
|
|
|
|
|
|
|
loopdidcallbacks++;
|
|
|
|
funcdidcallbacks++;
|
|
|
|
|
2008-04-09 20:18:39 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2007-08-15 23:37:36 -06:00
|
|
|
ASSERT(iclog->ic_callback == NULL);
|
2008-04-09 20:18:39 -06:00
|
|
|
spin_unlock(&iclog->ic_callback_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!(iclog->ic_state & XLOG_STATE_IOERROR))
|
|
|
|
iclog->ic_state = XLOG_STATE_DIRTY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Transition from DIRTY to ACTIVE if applicable.
|
|
|
|
* NOP if STATE_IOERROR.
|
|
|
|
*/
|
|
|
|
xlog_state_clean_log(log);
|
|
|
|
|
|
|
|
/* wake up threads waiting in xfs_log_force() */
|
2010-12-20 18:09:01 -07:00
|
|
|
wake_up_all(&iclog->ic_force_wait);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
} while (first_iclog != iclog);
|
2006-09-27 19:02:14 -06:00
|
|
|
|
|
|
|
if (repeats > 5000) {
|
|
|
|
flushcnt += repeats;
|
|
|
|
repeats = 0;
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp,
|
2006-09-27 19:02:14 -06:00
|
|
|
"%s: possible infinite loop (%d iterations)",
|
2008-04-09 20:19:21 -06:00
|
|
|
__func__, flushcnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} while (!ioerrors && loopdidcallbacks);
|
|
|
|
|
2016-01-04 13:41:16 -07:00
|
|
|
#ifdef DEBUG
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2016-01-04 13:41:16 -07:00
|
|
|
* Make one last gasp attempt to see if iclogs are being left in limbo.
|
|
|
|
* If the above loop finds an iclog earlier than the current iclog and
|
|
|
|
* in one of the syncing states, the current iclog is put into
|
|
|
|
* DO_CALLBACK and the callbacks are deferred to the completion of the
|
|
|
|
* earlier iclog. Walk the iclogs in order and make sure that no iclog
|
|
|
|
* is in DO_CALLBACK unless an earlier iclog is in one of the syncing
|
|
|
|
* states.
|
|
|
|
*
|
|
|
|
* Note that SYNCING|IOABORT is a valid state so we cannot just check
|
|
|
|
* for ic_state == SYNCING.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
if (funcdidcallbacks) {
|
|
|
|
first_iclog = iclog = log->l_iclog;
|
|
|
|
do {
|
|
|
|
ASSERT(iclog->ic_state != XLOG_STATE_DO_CALLBACK);
|
|
|
|
/*
|
|
|
|
* Terminate the loop if iclogs are found in states
|
|
|
|
* which will cause other threads to clean up iclogs.
|
|
|
|
*
|
|
|
|
* SYNCING - i/o completion will go through logs
|
|
|
|
* DONE_SYNC - interrupt thread should be waiting for
|
2007-10-11 01:37:10 -06:00
|
|
|
* l_icloglock
|
2005-04-16 16:20:36 -06:00
|
|
|
* IOERROR - give up hope all ye who enter here
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state == XLOG_STATE_WANT_SYNC ||
|
2016-01-04 13:41:16 -07:00
|
|
|
iclog->ic_state & XLOG_STATE_SYNCING ||
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog->ic_state == XLOG_STATE_DONE_SYNC ||
|
|
|
|
iclog->ic_state == XLOG_STATE_IOERROR )
|
|
|
|
break;
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
} while (first_iclog != iclog);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-05-19 00:34:27 -06:00
|
|
|
if (log->l_iclog->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_IOERROR))
|
|
|
|
wake = 1;
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2008-05-19 00:34:27 -06:00
|
|
|
|
|
|
|
if (wake)
|
2010-12-20 18:09:01 -07:00
|
|
|
wake_up_all(&log->l_flush_wait);
|
2008-05-19 00:34:27 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Finish transitioning this iclog to the dirty state.
|
|
|
|
*
|
|
|
|
* Make sure that we completely execute this routine only when this is
|
|
|
|
* the last call to the iclog. There is a good chance that iclog flushes,
|
|
|
|
* when we reach the end of the physical log, get turned into 2 separate
|
|
|
|
* calls to bwrite. Hence, one iclog flush could generate two calls to this
|
|
|
|
* routine. By using the reference count bwritecnt, we guarantee that only
|
|
|
|
* the second completion goes through.
|
|
|
|
*
|
|
|
|
* Callbacks could take time, so they are done outside the scope of the
|
2008-08-13 00:34:31 -06:00
|
|
|
* global state machine log lock.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC void
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_state_done_syncing(
|
|
|
|
xlog_in_core_t *iclog,
|
|
|
|
int aborted)
|
|
|
|
{
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log = iclog->ic_log;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT(iclog->ic_state == XLOG_STATE_SYNCING ||
|
|
|
|
iclog->ic_state == XLOG_STATE_IOERROR);
|
2008-03-05 19:44:14 -07:00
|
|
|
ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(iclog->ic_bwritecnt == 1 || iclog->ic_bwritecnt == 2);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we got an error, either on the first buffer, or in the case of
|
|
|
|
* split log writes, on the second, we mark ALL iclogs STATE_IOERROR,
|
|
|
|
* and none should ever be attempted to be written to disk
|
|
|
|
* again.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state != XLOG_STATE_IOERROR) {
|
|
|
|
if (--iclog->ic_bwritecnt == 1) {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
iclog->ic_state = XLOG_STATE_DONE_SYNC;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Someone could be sleeping prior to writing out the next
|
|
|
|
* iclog buffer, we wake them all, one will get to do the
|
|
|
|
* I/O, the others get to wait for the result.
|
|
|
|
*/
|
2010-12-20 18:09:01 -07:00
|
|
|
wake_up_all(&iclog->ic_write_wait);
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_state_do_callback(log, aborted, iclog); /* also cleans log */
|
|
|
|
} /* xlog_state_done_syncing */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the head of the in-core log ring is not (ACTIVE or DIRTY), then we must
|
2008-08-13 00:34:31 -06:00
|
|
|
* sleep. We wait on the flush queue on the head iclog as that should be
|
|
|
|
* the first iclog to complete flushing. Hence if all iclogs are syncing,
|
|
|
|
* we will wait here and all new writes will sleep until a sync completes.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* The in-core logs are used in a circular fashion. They are not used
|
|
|
|
* out-of-order even when an iclog past the head is free.
|
|
|
|
*
|
|
|
|
* return:
|
|
|
|
* * log_offset where xlog_write() can start writing into the in-core
|
|
|
|
* log's data space.
|
|
|
|
* * in-core log pointer to which xlog_write() should write.
|
|
|
|
* * boolean indicating this is a continued write to an in-core log.
|
|
|
|
* If this is the last write, then the in-core log's offset field
|
|
|
|
* needs to be incremented, depending on the amount of data which
|
|
|
|
* is copied.
|
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC int
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_state_get_iclog_space(
|
|
|
|
struct xlog *log,
|
|
|
|
int len,
|
|
|
|
struct xlog_in_core **iclogp,
|
|
|
|
struct xlog_ticket *ticket,
|
|
|
|
int *continued_write,
|
|
|
|
int *logoffsetp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int log_offset;
|
|
|
|
xlog_rec_header_t *head;
|
|
|
|
xlog_in_core_t *iclog;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
restart:
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (XLOG_FORCED_SHUTDOWN(log)) {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
iclog = log->l_iclog;
|
2008-05-19 00:34:27 -06:00
|
|
|
if (iclog->ic_state != XLOG_STATE_ACTIVE) {
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(log->l_mp, xs_log_noiclogs);
|
2008-05-19 00:34:27 -06:00
|
|
|
|
|
|
|
/* Wait for log writes to have flushed */
|
2010-12-20 18:09:01 -07:00
|
|
|
xlog_wait(&log->l_flush_wait, &log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto restart;
|
|
|
|
}
|
2008-05-19 00:34:27 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
head = &iclog->ic_header;
|
|
|
|
|
2008-03-05 19:44:14 -07:00
|
|
|
atomic_inc(&iclog->ic_refcnt); /* prevents sync */
|
2005-04-16 16:20:36 -06:00
|
|
|
log_offset = iclog->ic_offset;
|
|
|
|
|
|
|
|
/* On the 1st write to an iclog, figure out lsn. This works
|
|
|
|
* if iclogs marked XLOG_STATE_WANT_SYNC always write out what they are
|
|
|
|
* committing to. If the offset is set, that's how many blocks
|
|
|
|
* must be written.
|
|
|
|
*/
|
|
|
|
if (log_offset == 0) {
|
|
|
|
ticket->t_curr_res -= log->l_iclog_hsize;
|
2007-08-30 01:21:46 -06:00
|
|
|
xlog_tic_add_region(ticket,
|
2005-09-02 00:42:05 -06:00
|
|
|
log->l_iclog_hsize,
|
|
|
|
XLOG_REG_TYPE_LRHEADER);
|
2007-10-11 18:59:34 -06:00
|
|
|
head->h_cycle = cpu_to_be32(log->l_curr_cycle);
|
|
|
|
head->h_lsn = cpu_to_be64(
|
2007-10-11 18:58:05 -06:00
|
|
|
xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block));
|
2005-04-16 16:20:36 -06:00
|
|
|
ASSERT(log->l_curr_block >= 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there is enough room to write everything, then do it. Otherwise,
|
|
|
|
* claim the rest of the region and make sure the XLOG_STATE_WANT_SYNC
|
|
|
|
* bit is on, so this will get flushed out. Don't update ic_offset
|
|
|
|
* until you know exactly how many bytes get copied. Therefore, wait
|
|
|
|
* until later to update ic_offset.
|
|
|
|
*
|
|
|
|
* xlog_write() algorithm assumes that at least 2 xlog_op_header_t's
|
|
|
|
* can fit into remaining data section.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_size - iclog->ic_offset < 2*sizeof(xlog_op_header_t)) {
|
|
|
|
xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
|
|
|
|
|
2008-07-11 01:43:55 -06:00
|
|
|
/*
|
|
|
|
* If I'm the only one writing to this iclog, sync it to disk.
|
|
|
|
* We need to do an atomic compare and decrement here to avoid
|
|
|
|
* racing with concurrent atomic_dec_and_lock() calls in
|
|
|
|
* xlog_state_release_iclog() when there is more than one
|
|
|
|
* reference to the iclog.
|
|
|
|
*/
|
|
|
|
if (!atomic_add_unless(&iclog->ic_refcnt, -1, 1)) {
|
|
|
|
/* we are the only one */
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2008-07-11 01:43:55 -06:00
|
|
|
error = xlog_state_release_iclog(log, iclog);
|
|
|
|
if (error)
|
2006-01-14 18:37:08 -07:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Do we have enough room to write the full amount in the remainder
|
|
|
|
* of this iclog? Or must we continue a write on the next iclog and
|
|
|
|
* mark this iclog as completely taken? In the case where we switch
|
|
|
|
* iclogs (to mark it taken), this particular iclog will release/sync
|
|
|
|
* to disk in xlog_write().
|
|
|
|
*/
|
|
|
|
if (len <= iclog->ic_size - iclog->ic_offset) {
|
|
|
|
*continued_write = 0;
|
|
|
|
iclog->ic_offset += len;
|
|
|
|
} else {
|
|
|
|
*continued_write = 1;
|
|
|
|
xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
|
|
|
|
}
|
|
|
|
*iclogp = iclog;
|
|
|
|
|
|
|
|
ASSERT(iclog->ic_offset <= iclog->ic_size);
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
*logoffsetp = log_offset;
|
|
|
|
return 0;
|
|
|
|
} /* xlog_state_get_iclog_space */
|
|
|
|
|
|
|
|
/* The first cnt-1 times through here we don't need to
|
|
|
|
* move the grant write head because the permanent
|
|
|
|
* reservation has reserved cnt times the unit amount.
|
|
|
|
* Release part of current permanent unit reservation and
|
|
|
|
* reset current reservation to be one units worth. Also
|
|
|
|
* move grant reservation head forward.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_regrant_reserve_log_space(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_ticket *ticket)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-12-14 16:14:59 -07:00
|
|
|
trace_xfs_log_regrant_reserve_enter(log, ticket);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ticket->t_cnt > 0)
|
|
|
|
ticket->t_cnt--;
|
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
xlog_grant_sub_space(log, &log->l_reserve_head.grant,
|
2010-12-20 18:08:20 -07:00
|
|
|
ticket->t_curr_res);
|
2012-02-19 19:31:25 -07:00
|
|
|
xlog_grant_sub_space(log, &log->l_write_head.grant,
|
2010-12-20 18:08:20 -07:00
|
|
|
ticket->t_curr_res);
|
2005-04-16 16:20:36 -06:00
|
|
|
ticket->t_curr_res = ticket->t_unit_res;
|
2007-08-30 01:21:46 -06:00
|
|
|
xlog_tic_reset_res(ticket);
|
2009-12-14 16:14:59 -07:00
|
|
|
|
|
|
|
trace_xfs_log_regrant_reserve_sub(log, ticket);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* just return if we still have some of the pre-reserved space */
|
2010-12-20 18:29:14 -07:00
|
|
|
if (ticket->t_cnt > 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
xlog_grant_add_space(log, &log->l_reserve_head.grant,
|
2010-12-20 18:08:20 -07:00
|
|
|
ticket->t_unit_res);
|
2009-12-14 16:14:59 -07:00
|
|
|
|
|
|
|
trace_xfs_log_regrant_reserve_exit(log, ticket);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ticket->t_curr_res = ticket->t_unit_res;
|
2007-08-30 01:21:46 -06:00
|
|
|
xlog_tic_reset_res(ticket);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* xlog_regrant_reserve_log_space */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give back the space left from a reservation.
|
|
|
|
*
|
|
|
|
* All the information we need to make a correct determination of space left
|
|
|
|
* is present. For non-permanent reservations, things are quite easy. The
|
|
|
|
* count should have been decremented to zero. We only need to deal with the
|
|
|
|
* space remaining in the current reservation part of the ticket. If the
|
|
|
|
* ticket contains a permanent reservation, there may be left over space which
|
|
|
|
* needs to be released. A count of N means that N-1 refills of the current
|
|
|
|
* reservation can be done before we need to ask for more space. The first
|
|
|
|
* one goes to fill up the first current reservation. Once we run out of
|
|
|
|
* space, the count will stay at zero and the only space remaining will be
|
|
|
|
* in the current reservation field.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_ungrant_log_space(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_ticket *ticket)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-12-20 18:06:05 -07:00
|
|
|
int bytes;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ticket->t_cnt > 0)
|
|
|
|
ticket->t_cnt--;
|
|
|
|
|
2009-12-14 16:14:59 -07:00
|
|
|
trace_xfs_log_ungrant_enter(log, ticket);
|
|
|
|
trace_xfs_log_ungrant_sub(log, ticket);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-20 18:06:05 -07:00
|
|
|
/*
|
|
|
|
* If this is a permanent reservation ticket, we may be able to free
|
2005-04-16 16:20:36 -06:00
|
|
|
* up more space based on the remaining count.
|
|
|
|
*/
|
2010-12-20 18:06:05 -07:00
|
|
|
bytes = ticket->t_curr_res;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ticket->t_cnt > 0) {
|
|
|
|
ASSERT(ticket->t_flags & XLOG_TIC_PERM_RESERV);
|
2010-12-20 18:06:05 -07:00
|
|
|
bytes += ticket->t_unit_res*ticket->t_cnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
xlog_grant_sub_space(log, &log->l_reserve_head.grant, bytes);
|
|
|
|
xlog_grant_sub_space(log, &log->l_write_head.grant, bytes);
|
2010-12-20 18:06:05 -07:00
|
|
|
|
2009-12-14 16:14:59 -07:00
|
|
|
trace_xfs_log_ungrant_exit(log, ticket);
|
|
|
|
|
2012-02-19 19:31:23 -07:00
|
|
|
xfs_log_space_wake(log->l_mp);
|
2012-02-19 19:31:20 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush iclog to disk if this is the last reference to the given iclog and
|
|
|
|
* the WANT_SYNC bit is set.
|
|
|
|
*
|
|
|
|
* When this function is entered, the iclog is not necessarily in the
|
|
|
|
* WANT_SYNC state. It may be sitting around waiting to get filled.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC int
|
2008-03-05 19:44:06 -07:00
|
|
|
xlog_state_release_iclog(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int sync = 0; /* do we sync? */
|
|
|
|
|
2008-03-05 19:44:14 -07:00
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2008-03-05 19:44:14 -07:00
|
|
|
|
|
|
|
ASSERT(atomic_read(&iclog->ic_refcnt) > 0);
|
|
|
|
if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock))
|
|
|
|
return 0;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR) {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE ||
|
|
|
|
iclog->ic_state == XLOG_STATE_WANT_SYNC);
|
|
|
|
|
2008-03-05 19:44:14 -07:00
|
|
|
if (iclog->ic_state == XLOG_STATE_WANT_SYNC) {
|
2008-03-05 19:44:06 -07:00
|
|
|
/* update tail before writing to iclog */
|
2010-12-20 18:28:39 -07:00
|
|
|
xfs_lsn_t tail_lsn = xlog_assign_tail_lsn(log->l_mp);
|
2005-04-16 16:20:36 -06:00
|
|
|
sync++;
|
|
|
|
iclog->ic_state = XLOG_STATE_SYNCING;
|
2010-12-20 18:28:39 -07:00
|
|
|
iclog->ic_header.h_tail_lsn = cpu_to_be64(tail_lsn);
|
|
|
|
xlog_verify_tail_lsn(log, iclog, tail_lsn);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* cycle incremented when incrementing curr_block */
|
|
|
|
}
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We let the log lock go, so it's possible that we hit a log I/O
|
2006-03-28 15:55:14 -07:00
|
|
|
* error or some other SHUTDOWN condition that marks the iclog
|
2005-04-16 16:20:36 -06:00
|
|
|
* as XLOG_STATE_IOERROR before the bwrite. However, we know that
|
|
|
|
* this iclog has consistent data, so we ignore IOERROR
|
|
|
|
* flags after this point.
|
|
|
|
*/
|
2008-03-05 19:44:06 -07:00
|
|
|
if (sync)
|
2005-04-16 16:20:36 -06:00
|
|
|
return xlog_sync(log, iclog);
|
2006-01-14 18:37:08 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* xlog_state_release_iclog */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine will mark the current iclog in the ring as WANT_SYNC
|
|
|
|
* and move the current iclog pointer to the next iclog in the ring.
|
|
|
|
* When this routine is called from xlog_state_get_iclog_space(), the
|
|
|
|
* exact size of the iclog has not yet been determined. All we know is
|
|
|
|
* that every data block. We have run out of space in this log record.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_state_switch_iclogs(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
int eventual_size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE);
|
|
|
|
if (!eventual_size)
|
|
|
|
eventual_size = iclog->ic_offset;
|
|
|
|
iclog->ic_state = XLOG_STATE_WANT_SYNC;
|
2007-10-11 18:59:34 -06:00
|
|
|
iclog->ic_header.h_prev_block = cpu_to_be32(log->l_prev_block);
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_prev_block = log->l_curr_block;
|
|
|
|
log->l_prev_cycle = log->l_curr_cycle;
|
|
|
|
|
|
|
|
/* roll log?: ic_offset changed later */
|
|
|
|
log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize);
|
|
|
|
|
|
|
|
/* Round up to next log-sunit */
|
2008-03-05 19:44:28 -07:00
|
|
|
if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_mp->m_sb.sb_logsunit > 1) {
|
2017-06-16 12:00:05 -06:00
|
|
|
uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_curr_block = roundup(log->l_curr_block, sunit_bb);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (log->l_curr_block >= log->l_logBBsize) {
|
2015-10-11 22:59:25 -06:00
|
|
|
/*
|
|
|
|
* Rewind the current block before the cycle is bumped to make
|
|
|
|
* sure that the combined LSN never transiently moves forward
|
|
|
|
* when the log wraps to the next cycle. This is to support the
|
|
|
|
* unlocked sample of these fields from xlog_valid_lsn(). Most
|
|
|
|
* other cases should acquire l_icloglock.
|
|
|
|
*/
|
|
|
|
log->l_curr_block -= log->l_logBBsize;
|
|
|
|
ASSERT(log->l_curr_block >= 0);
|
|
|
|
smp_wmb();
|
2005-04-16 16:20:36 -06:00
|
|
|
log->l_curr_cycle++;
|
|
|
|
if (log->l_curr_cycle == XLOG_HEADER_MAGIC_NUM)
|
|
|
|
log->l_curr_cycle++;
|
|
|
|
}
|
|
|
|
ASSERT(iclog == log->l_iclog);
|
|
|
|
log->l_iclog = iclog->ic_next;
|
|
|
|
} /* xlog_state_switch_iclogs */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write out all data in the in-core log as of this exact moment in time.
|
|
|
|
*
|
|
|
|
* Data may be written to the in-core log during this call. However,
|
|
|
|
* we don't guarantee this data will be written out. A change from past
|
|
|
|
* implementation means this routine will *not* write out zero length LRs.
|
|
|
|
*
|
|
|
|
* Basically, we try and perform an intelligent scan of the in-core logs.
|
|
|
|
* If we determine there is no flushable data, we just return. There is no
|
|
|
|
* flushable data if:
|
|
|
|
*
|
|
|
|
* 1. the current iclog is active and has no data; the previous iclog
|
|
|
|
* is in the active or dirty state.
|
|
|
|
* 2. the current iclog is drity, and the previous iclog is in the
|
|
|
|
* active or dirty state.
|
|
|
|
*
|
2008-08-13 00:34:31 -06:00
|
|
|
* We may sleep if:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* 1. the current iclog is not in the active nor dirty state.
|
|
|
|
* 2. the current iclog dirty, and the previous iclog is not in the
|
|
|
|
* active nor dirty state.
|
|
|
|
* 3. the current iclog is active, and there is another thread writing
|
|
|
|
* to this particular iclog.
|
|
|
|
* 4. a) the current iclog is active and has no other writers
|
|
|
|
* b) when we return from flushing out this iclog, it is still
|
|
|
|
* not in the active nor dirty state.
|
|
|
|
*/
|
2010-01-19 02:56:46 -07:00
|
|
|
int
|
|
|
|
_xfs_log_force(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
uint flags,
|
|
|
|
int *log_flushed)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2010-01-19 02:56:46 -07:00
|
|
|
struct xlog_in_core *iclog;
|
|
|
|
xfs_lsn_t lsn;
|
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_log_force);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-12-06 14:58:07 -07:00
|
|
|
xlog_cil_force(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
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iclog = log->l_iclog;
|
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR) {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If the head iclog is not active nor dirty, we just attach
|
|
|
|
* ourselves to the head and go to sleep.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state == XLOG_STATE_ACTIVE ||
|
|
|
|
iclog->ic_state == XLOG_STATE_DIRTY) {
|
|
|
|
/*
|
|
|
|
* If the head is dirty or (active and empty), then
|
|
|
|
* we need to look at the previous iclog. If the previous
|
|
|
|
* iclog is active or dirty we are done. There is nothing
|
|
|
|
* to sync out. Otherwise, we attach ourselves to the
|
|
|
|
* previous iclog and go to sleep.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state == XLOG_STATE_DIRTY ||
|
2008-03-05 19:44:14 -07:00
|
|
|
(atomic_read(&iclog->ic_refcnt) == 0
|
|
|
|
&& iclog->ic_offset == 0)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = iclog->ic_prev;
|
|
|
|
if (iclog->ic_state == XLOG_STATE_ACTIVE ||
|
|
|
|
iclog->ic_state == XLOG_STATE_DIRTY)
|
|
|
|
goto no_sleep;
|
|
|
|
else
|
|
|
|
goto maybe_sleep;
|
|
|
|
} else {
|
2008-03-05 19:44:14 -07:00
|
|
|
if (atomic_read(&iclog->ic_refcnt) == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* We are the only one with access to this
|
|
|
|
* iclog. Flush it out now. There should
|
|
|
|
* be a roundoff of zero to show that someone
|
|
|
|
* has already taken care of the roundoff from
|
|
|
|
* the previous sync.
|
|
|
|
*/
|
2008-03-05 19:44:14 -07:00
|
|
|
atomic_inc(&iclog->ic_refcnt);
|
2007-10-11 18:59:34 -06:00
|
|
|
lsn = be64_to_cpu(iclog->ic_header.h_lsn);
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_state_switch_iclogs(log, iclog, 0);
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (xlog_state_release_iclog(log, iclog))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2010-01-19 02:56:46 -07:00
|
|
|
|
|
|
|
if (log_flushed)
|
|
|
|
*log_flushed = 1;
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2007-10-11 18:59:34 -06:00
|
|
|
if (be64_to_cpu(iclog->ic_header.h_lsn) == lsn &&
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog->ic_state != XLOG_STATE_DIRTY)
|
|
|
|
goto maybe_sleep;
|
|
|
|
else
|
|
|
|
goto no_sleep;
|
|
|
|
} else {
|
|
|
|
/* Someone else is writing to this iclog.
|
|
|
|
* Use its call to flush out the data. However,
|
|
|
|
* the other thread may not force out this LR,
|
|
|
|
* so we mark it WANT_SYNC.
|
|
|
|
*/
|
|
|
|
xlog_state_switch_iclogs(log, iclog, 0);
|
|
|
|
goto maybe_sleep;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* By the time we come around again, the iclog could've been filled
|
|
|
|
* which would give it another lsn. If we have a new lsn, just
|
|
|
|
* return because the relevant data has been flushed.
|
|
|
|
*/
|
|
|
|
maybe_sleep:
|
|
|
|
if (flags & XFS_LOG_SYNC) {
|
|
|
|
/*
|
|
|
|
* We must check if we're shutting down here, before
|
2007-10-11 01:37:10 -06:00
|
|
|
* we wait, while we're holding the l_icloglock.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Then we check again after waking up, in case our
|
|
|
|
* sleep was disturbed by a bad news.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR) {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_log_force_sleep);
|
2010-12-20 18:09:01 -07:00
|
|
|
xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* No need to grab the log lock here since we're
|
|
|
|
* only deciding whether or not to return EIO
|
|
|
|
* and the memory read should be atomic.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
|
|
|
|
no_sleep:
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
2010-01-19 02:56:46 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-19 02:56:46 -07:00
|
|
|
/*
|
|
|
|
* Wrapper for _xfs_log_force(), to be used when caller doesn't care
|
|
|
|
* about errors or whether the log was flushed or not. This is the normal
|
|
|
|
* interface to use when trying to unpin items or move the log forward.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_log_force(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
uint flags)
|
|
|
|
{
|
2016-04-05 17:46:30 -06:00
|
|
|
trace_xfs_log_force(mp, 0, _RET_IP_);
|
2017-01-09 14:41:33 -07:00
|
|
|
_xfs_log_force(mp, flags, NULL);
|
2010-01-19 02:56:46 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2010-01-19 02:56:46 -07:00
|
|
|
* Force the in-core log to disk for a specific LSN.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Find in-core log with lsn.
|
|
|
|
* If it is in the DIRTY state, just return.
|
|
|
|
* If it is in the ACTIVE state, move the in-core log into the WANT_SYNC
|
|
|
|
* state and go to sleep or return.
|
|
|
|
* If it is in any other state, go to sleep or return.
|
|
|
|
*
|
2010-01-19 02:56:46 -07:00
|
|
|
* Synchronous forces are implemented with a signal variable. All callers
|
|
|
|
* to force a given lsn to disk will wait on a the sv attached to the
|
|
|
|
* specific in-core log. When given in-core log finally completes its
|
|
|
|
* write to disk, that thread will wake up all threads waiting on the
|
|
|
|
* sv.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-01-19 02:56:46 -07:00
|
|
|
int
|
|
|
|
_xfs_log_force_lsn(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_lsn_t lsn,
|
|
|
|
uint flags,
|
|
|
|
int *log_flushed)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
2010-01-19 02:56:46 -07:00
|
|
|
struct xlog_in_core *iclog;
|
|
|
|
int already_slept = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-19 02:56:46 -07:00
|
|
|
ASSERT(lsn != 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_log_force);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-12-06 14:58:07 -07:00
|
|
|
lsn = xlog_cil_force_lsn(log, lsn);
|
|
|
|
if (lsn == NULLCOMMITLSN)
|
|
|
|
return 0;
|
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-01-19 02:56:46 -07:00
|
|
|
try_again:
|
|
|
|
spin_lock(&log->l_icloglock);
|
|
|
|
iclog = log->l_iclog;
|
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR) {
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-01-19 02:56:46 -07:00
|
|
|
do {
|
|
|
|
if (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) {
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (iclog->ic_state == XLOG_STATE_DIRTY) {
|
|
|
|
spin_unlock(&log->l_icloglock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (iclog->ic_state == XLOG_STATE_ACTIVE) {
|
|
|
|
/*
|
|
|
|
* We sleep here if we haven't already slept (e.g.
|
|
|
|
* this is the first time we've looked at the correct
|
|
|
|
* iclog buf) and the buffer before us is going to
|
|
|
|
* be sync'ed. The reason for this is that if we
|
|
|
|
* are doing sync transactions here, by waiting for
|
|
|
|
* the previous I/O to complete, we can allow a few
|
|
|
|
* more transactions into this iclog before we close
|
|
|
|
* it down.
|
|
|
|
*
|
|
|
|
* Otherwise, we mark the buffer WANT_SYNC, and bump
|
|
|
|
* up the refcnt so we can release the log (which
|
|
|
|
* drops the ref count). The state switch keeps new
|
|
|
|
* transaction commits from using this buffer. When
|
|
|
|
* the current commits finish writing into the buffer,
|
|
|
|
* the refcount will drop to zero and the buffer will
|
|
|
|
* go out then.
|
|
|
|
*/
|
|
|
|
if (!already_slept &&
|
|
|
|
(iclog->ic_prev->ic_state &
|
|
|
|
(XLOG_STATE_WANT_SYNC | XLOG_STATE_SYNCING))) {
|
|
|
|
ASSERT(!(iclog->ic_state & XLOG_STATE_IOERROR));
|
|
|
|
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_log_force_sleep);
|
2010-01-19 02:56:46 -07:00
|
|
|
|
2010-12-20 18:09:01 -07:00
|
|
|
xlog_wait(&iclog->ic_prev->ic_write_wait,
|
|
|
|
&log->l_icloglock);
|
2010-01-19 02:56:46 -07:00
|
|
|
already_slept = 1;
|
|
|
|
goto try_again;
|
|
|
|
}
|
2008-03-05 19:44:14 -07:00
|
|
|
atomic_inc(&iclog->ic_refcnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_state_switch_iclogs(log, iclog, 0);
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (xlog_state_release_iclog(log, iclog))
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2010-01-19 02:56:46 -07:00
|
|
|
if (log_flushed)
|
|
|
|
*log_flushed = 1;
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-01-19 02:56:46 -07:00
|
|
|
if ((flags & XFS_LOG_SYNC) && /* sleep */
|
|
|
|
!(iclog->ic_state &
|
|
|
|
(XLOG_STATE_ACTIVE | XLOG_STATE_DIRTY))) {
|
|
|
|
/*
|
|
|
|
* Don't wait on completion if we know that we've
|
|
|
|
* gotten a log write error.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR) {
|
|
|
|
spin_unlock(&log->l_icloglock);
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2010-01-19 02:56:46 -07:00
|
|
|
}
|
2015-10-12 01:21:22 -06:00
|
|
|
XFS_STATS_INC(mp, xs_log_force_sleep);
|
2010-12-20 18:09:01 -07:00
|
|
|
xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
|
2010-01-19 02:56:46 -07:00
|
|
|
/*
|
|
|
|
* No need to grab the log lock here since we're
|
|
|
|
* only deciding whether or not to return EIO
|
|
|
|
* and the memory read should be atomic.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_state & XLOG_STATE_IOERROR)
|
2014-06-24 22:58:08 -06:00
|
|
|
return -EIO;
|
2010-01-19 02:56:46 -07:00
|
|
|
} else { /* just return */
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-01-19 02:56:46 -07:00
|
|
|
return 0;
|
|
|
|
} while (iclog != log->l_iclog);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-01-19 02:56:46 -07:00
|
|
|
spin_unlock(&log->l_icloglock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wrapper for _xfs_log_force_lsn(), to be used when caller doesn't care
|
|
|
|
* about errors or whether the log was flushed or not. This is the normal
|
|
|
|
* interface to use when trying to unpin items or move the log forward.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xfs_log_force_lsn(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
xfs_lsn_t lsn,
|
|
|
|
uint flags)
|
|
|
|
{
|
2016-04-05 17:46:30 -06:00
|
|
|
trace_xfs_log_force(mp, lsn, _RET_IP_);
|
2017-01-09 14:41:33 -07:00
|
|
|
_xfs_log_force_lsn(mp, lsn, flags, NULL);
|
2010-01-19 02:56:46 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Called when we want to mark the current iclog as being ready to sync to
|
|
|
|
* disk.
|
|
|
|
*/
|
2007-11-22 22:28:09 -07:00
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_state_want_sync(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-08-10 08:32:44 -06:00
|
|
|
assert_spin_locked(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (iclog->ic_state == XLOG_STATE_ACTIVE) {
|
|
|
|
xlog_state_switch_iclogs(log, iclog, 0);
|
|
|
|
} else {
|
|
|
|
ASSERT(iclog->ic_state &
|
|
|
|
(XLOG_STATE_WANT_SYNC|XLOG_STATE_IOERROR));
|
|
|
|
}
|
2008-12-03 04:20:28 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* TICKET functions
|
|
|
|
*
|
|
|
|
*****************************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2009-03-29 01:55:42 -06:00
|
|
|
* Free a used ticket when its refcount falls to zero.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-11-16 23:37:10 -07:00
|
|
|
void
|
|
|
|
xfs_log_ticket_put(
|
|
|
|
xlog_ticket_t *ticket)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-11-16 23:37:10 -07:00
|
|
|
ASSERT(atomic_read(&ticket->t_ref) > 0);
|
2010-12-20 18:09:01 -07:00
|
|
|
if (atomic_dec_and_test(&ticket->t_ref))
|
2008-11-16 23:37:10 -07:00
|
|
|
kmem_zone_free(xfs_log_ticket_zone, ticket);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-16 23:37:10 -07:00
|
|
|
xlog_ticket_t *
|
|
|
|
xfs_log_ticket_get(
|
|
|
|
xlog_ticket_t *ticket)
|
|
|
|
{
|
|
|
|
ASSERT(atomic_read(&ticket->t_ref) > 0);
|
|
|
|
atomic_inc(&ticket->t_ref);
|
|
|
|
return ticket;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2013-08-12 04:50:01 -06:00
|
|
|
* Figure out the total log space unit (in bytes) that would be
|
|
|
|
* required for a log ticket.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2013-08-12 04:50:01 -06:00
|
|
|
int
|
|
|
|
xfs_log_calc_unit_res(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int unit_bytes)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-08-12 04:50:01 -06:00
|
|
|
struct xlog *log = mp->m_log;
|
|
|
|
int iclog_space;
|
|
|
|
uint num_headers;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Permanent reservations have up to 'cnt'-1 active log operations
|
|
|
|
* in the log. A unit in this case is the amount of space for one
|
|
|
|
* of these log operations. Normal reservations have a cnt of 1
|
|
|
|
* and their unit amount is the total amount of space required.
|
|
|
|
*
|
|
|
|
* The following lines of code account for non-transaction data
|
2005-09-02 00:41:43 -06:00
|
|
|
* which occupy space in the on-disk log.
|
|
|
|
*
|
|
|
|
* Normal form of a transaction is:
|
|
|
|
* <oph><trans-hdr><start-oph><reg1-oph><reg1><reg2-oph>...<commit-oph>
|
|
|
|
* and then there are LR hdrs, split-recs and roundoff at end of syncs.
|
|
|
|
*
|
|
|
|
* We need to account for all the leadup data and trailer data
|
|
|
|
* around the transaction data.
|
|
|
|
* And then we need to account for the worst case in terms of using
|
|
|
|
* more space.
|
|
|
|
* The worst case will happen if:
|
|
|
|
* - the placement of the transaction happens to be such that the
|
|
|
|
* roundoff is at its maximum
|
|
|
|
* - the transaction data is synced before the commit record is synced
|
|
|
|
* i.e. <transaction-data><roundoff> | <commit-rec><roundoff>
|
|
|
|
* Therefore the commit record is in its own Log Record.
|
|
|
|
* This can happen as the commit record is called with its
|
|
|
|
* own region to xlog_write().
|
|
|
|
* This then means that in the worst case, roundoff can happen for
|
|
|
|
* the commit-rec as well.
|
|
|
|
* The commit-rec is smaller than padding in this scenario and so it is
|
|
|
|
* not added separately.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2005-09-02 00:41:43 -06:00
|
|
|
/* for trans header */
|
|
|
|
unit_bytes += sizeof(xlog_op_header_t);
|
|
|
|
unit_bytes += sizeof(xfs_trans_header_t);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* for start-rec */
|
2005-09-02 00:41:43 -06:00
|
|
|
unit_bytes += sizeof(xlog_op_header_t);
|
|
|
|
|
2010-03-22 18:21:11 -06:00
|
|
|
/*
|
|
|
|
* for LR headers - the space for data in an iclog is the size minus
|
|
|
|
* the space used for the headers. If we use the iclog size, then we
|
|
|
|
* undercalculate the number of headers required.
|
|
|
|
*
|
|
|
|
* Furthermore - the addition of op headers for split-recs might
|
|
|
|
* increase the space required enough to require more log and op
|
|
|
|
* headers, so take that into account too.
|
|
|
|
*
|
|
|
|
* IMPORTANT: This reservation makes the assumption that if this
|
|
|
|
* transaction is the first in an iclog and hence has the LR headers
|
|
|
|
* accounted to it, then the remaining space in the iclog is
|
|
|
|
* exclusively for this transaction. i.e. if the transaction is larger
|
|
|
|
* than the iclog, it will be the only thing in that iclog.
|
|
|
|
* Fundamentally, this means we must pass the entire log vector to
|
|
|
|
* xlog_write to guarantee this.
|
|
|
|
*/
|
|
|
|
iclog_space = log->l_iclog_size - log->l_iclog_hsize;
|
|
|
|
num_headers = howmany(unit_bytes, iclog_space);
|
|
|
|
|
|
|
|
/* for split-recs - ophdrs added when data split over LRs */
|
|
|
|
unit_bytes += sizeof(xlog_op_header_t) * num_headers;
|
|
|
|
|
|
|
|
/* add extra header reservations if we overrun */
|
|
|
|
while (!num_headers ||
|
|
|
|
howmany(unit_bytes, iclog_space) > num_headers) {
|
|
|
|
unit_bytes += sizeof(xlog_op_header_t);
|
|
|
|
num_headers++;
|
|
|
|
}
|
2005-09-02 00:41:43 -06:00
|
|
|
unit_bytes += log->l_iclog_hsize * num_headers;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-09-02 00:41:43 -06:00
|
|
|
/* for commit-rec LR header - note: padding will subsume the ophdr */
|
|
|
|
unit_bytes += log->l_iclog_hsize;
|
|
|
|
|
|
|
|
/* for roundoff padding for transaction data and one for commit record */
|
2013-08-12 04:50:01 -06:00
|
|
|
if (xfs_sb_version_haslogv2(&mp->m_sb) && mp->m_sb.sb_logsunit > 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* log su roundoff */
|
2013-08-12 04:50:01 -06:00
|
|
|
unit_bytes += 2 * mp->m_sb.sb_logsunit;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/* BB roundoff */
|
2013-08-12 04:50:01 -06:00
|
|
|
unit_bytes += 2 * BBSIZE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-08-12 04:50:01 -06:00
|
|
|
return unit_bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate and initialise a new log ticket.
|
|
|
|
*/
|
|
|
|
struct xlog_ticket *
|
|
|
|
xlog_ticket_alloc(
|
|
|
|
struct xlog *log,
|
|
|
|
int unit_bytes,
|
|
|
|
int cnt,
|
|
|
|
char client,
|
|
|
|
bool permanent,
|
|
|
|
xfs_km_flags_t alloc_flags)
|
|
|
|
{
|
|
|
|
struct xlog_ticket *tic;
|
|
|
|
int unit_res;
|
|
|
|
|
|
|
|
tic = kmem_zone_zalloc(xfs_log_ticket_zone, alloc_flags);
|
|
|
|
if (!tic)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
unit_res = xfs_log_calc_unit_res(log->l_mp, unit_bytes);
|
|
|
|
|
2008-11-16 23:37:10 -07:00
|
|
|
atomic_set(&tic->t_ref, 1);
|
2012-02-19 19:31:24 -07:00
|
|
|
tic->t_task = current;
|
2010-12-20 18:02:25 -07:00
|
|
|
INIT_LIST_HEAD(&tic->t_queue);
|
2013-08-12 04:50:01 -06:00
|
|
|
tic->t_unit_res = unit_res;
|
|
|
|
tic->t_curr_res = unit_res;
|
2005-04-16 16:20:36 -06:00
|
|
|
tic->t_cnt = cnt;
|
|
|
|
tic->t_ocnt = cnt;
|
2013-03-04 05:58:20 -07:00
|
|
|
tic->t_tid = prandom_u32();
|
2005-04-16 16:20:36 -06:00
|
|
|
tic->t_clientid = client;
|
|
|
|
tic->t_flags = XLOG_TIC_INITED;
|
2012-02-19 19:31:31 -07:00
|
|
|
if (permanent)
|
2005-04-16 16:20:36 -06:00
|
|
|
tic->t_flags |= XLOG_TIC_PERM_RESERV;
|
|
|
|
|
2007-08-30 01:21:46 -06:00
|
|
|
xlog_tic_reset_res(tic);
|
2005-09-02 00:42:05 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return tic;
|
2008-11-16 23:37:10 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Log debug routines
|
|
|
|
*
|
|
|
|
******************************************************************************
|
|
|
|
*/
|
2005-11-01 21:12:04 -07:00
|
|
|
#if defined(DEBUG)
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Make sure that the destination ptr is within the valid data region of
|
|
|
|
* one of the iclogs. This uses backup pointers stored in a different
|
|
|
|
* part of the log in case we trash the log structure.
|
|
|
|
*/
|
2017-11-06 12:54:02 -07:00
|
|
|
STATIC void
|
2010-03-22 18:47:38 -06:00
|
|
|
xlog_verify_dest_ptr(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log,
|
2015-06-21 17:44:47 -06:00
|
|
|
void *ptr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int good_ptr = 0;
|
|
|
|
|
2010-03-22 18:47:38 -06:00
|
|
|
for (i = 0; i < log->l_iclog_bufs; i++) {
|
|
|
|
if (ptr >= log->l_iclog_bak[i] &&
|
|
|
|
ptr <= log->l_iclog_bak[i] + log->l_iclog_size)
|
2005-04-16 16:20:36 -06:00
|
|
|
good_ptr++;
|
|
|
|
}
|
2010-03-22 18:47:38 -06:00
|
|
|
|
|
|
|
if (!good_ptr)
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_emerg(log->l_mp, "%s: invalid ptr", __func__);
|
2010-03-22 18:47:38 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-04-07 20:45:07 -06:00
|
|
|
/*
|
|
|
|
* Check to make sure the grant write head didn't just over lap the tail. If
|
|
|
|
* the cycles are the same, we can't be overlapping. Otherwise, make sure that
|
|
|
|
* the cycles differ by exactly one and check the byte count.
|
|
|
|
*
|
|
|
|
* This check is run unlocked, so can give false positives. Rather than assert
|
|
|
|
* on failures, use a warn-once flag and a panic tag to allow the admin to
|
|
|
|
* determine if they want to panic the machine when such an error occurs. For
|
|
|
|
* debug kernels this will have the same effect as using an assert but, unlinke
|
|
|
|
* an assert, it can be turned off at runtime.
|
|
|
|
*/
|
2010-12-20 18:02:52 -07:00
|
|
|
STATIC void
|
|
|
|
xlog_verify_grant_tail(
|
2012-06-14 08:22:15 -06:00
|
|
|
struct xlog *log)
|
2010-12-20 18:02:52 -07:00
|
|
|
{
|
2010-12-20 18:28:39 -07:00
|
|
|
int tail_cycle, tail_blocks;
|
2010-12-20 18:08:20 -07:00
|
|
|
int cycle, space;
|
2010-12-20 18:02:52 -07:00
|
|
|
|
2012-02-19 19:31:25 -07:00
|
|
|
xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &space);
|
2010-12-20 18:28:39 -07:00
|
|
|
xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_blocks);
|
|
|
|
if (tail_cycle != cycle) {
|
2011-04-07 20:45:07 -06:00
|
|
|
if (cycle - 1 != tail_cycle &&
|
|
|
|
!(log->l_flags & XLOG_TAIL_WARN)) {
|
|
|
|
xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
|
|
|
|
"%s: cycle - 1 != tail_cycle", __func__);
|
|
|
|
log->l_flags |= XLOG_TAIL_WARN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (space > BBTOB(tail_blocks) &&
|
|
|
|
!(log->l_flags & XLOG_TAIL_WARN)) {
|
|
|
|
xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
|
|
|
|
"%s: space > BBTOB(tail_blocks)", __func__);
|
|
|
|
log->l_flags |= XLOG_TAIL_WARN;
|
|
|
|
}
|
2010-12-20 18:02:52 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* check if it will fit */
|
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_verify_tail_lsn(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
xfs_lsn_t tail_lsn)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int blocks;
|
|
|
|
|
|
|
|
if (CYCLE_LSN(tail_lsn) == log->l_prev_cycle) {
|
|
|
|
blocks =
|
|
|
|
log->l_logBBsize - (log->l_prev_block - BLOCK_LSN(tail_lsn));
|
|
|
|
if (blocks < BTOBB(iclog->ic_offset)+BTOBB(log->l_iclog_hsize))
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
ASSERT(CYCLE_LSN(tail_lsn)+1 == log->l_prev_cycle);
|
|
|
|
|
|
|
|
if (BLOCK_LSN(tail_lsn) == log->l_prev_block)
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_emerg(log->l_mp, "%s: tail wrapped", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
blocks = BLOCK_LSN(tail_lsn) - log->l_prev_block;
|
|
|
|
if (blocks < BTOBB(iclog->ic_offset) + 1)
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} /* xlog_verify_tail_lsn */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform a number of checks on the iclog before writing to disk.
|
|
|
|
*
|
|
|
|
* 1. Make sure the iclogs are still circular
|
|
|
|
* 2. Make sure we have a good magic number
|
|
|
|
* 3. Make sure we don't have magic numbers in the data
|
|
|
|
* 4. Check fields of each log operation header for:
|
|
|
|
* A. Valid client identifier
|
|
|
|
* B. tid ptr value falls in valid ptr space (user space code)
|
|
|
|
* C. Length in log record header is correct according to the
|
|
|
|
* individual operation headers within record.
|
|
|
|
* 5. When a bwrite will occur within 5 blocks of the front of the physical
|
|
|
|
* log, check the preceding blocks of the physical log to make sure all
|
|
|
|
* the cycle numbers agree with the current cycle number.
|
|
|
|
*/
|
|
|
|
STATIC void
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_verify_iclog(
|
|
|
|
struct xlog *log,
|
|
|
|
struct xlog_in_core *iclog,
|
|
|
|
int count,
|
2012-11-12 16:32:59 -07:00
|
|
|
bool syncing)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_op_header_t *ophead;
|
|
|
|
xlog_in_core_t *icptr;
|
|
|
|
xlog_in_core_2_t *xhdr;
|
2015-06-21 17:44:47 -06:00
|
|
|
void *base_ptr, *ptr, *p;
|
2015-06-21 17:43:32 -06:00
|
|
|
ptrdiff_t field_offset;
|
2017-06-16 12:00:05 -06:00
|
|
|
uint8_t clientid;
|
2005-04-16 16:20:36 -06:00
|
|
|
int len, i, j, k, op_len;
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
/* check validity of iclog pointers */
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
icptr = log->l_iclog;
|
2013-10-30 15:01:00 -06:00
|
|
|
for (i = 0; i < log->l_iclog_bufs; i++, icptr = icptr->ic_next)
|
|
|
|
ASSERT(icptr);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (icptr != log->l_iclog)
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_emerg(log->l_mp, "%s: corrupt iclog ring", __func__);
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* check log magic numbers */
|
2011-07-08 06:36:05 -06:00
|
|
|
if (iclog->ic_header.h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_emerg(log->l_mp, "%s: invalid magic num", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-06-21 17:44:47 -06:00
|
|
|
base_ptr = ptr = &iclog->ic_header;
|
|
|
|
p = &iclog->ic_header;
|
|
|
|
for (ptr += BBSIZE; ptr < base_ptr + count; ptr += BBSIZE) {
|
2011-07-08 06:36:05 -06:00
|
|
|
if (*(__be32 *)ptr == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_emerg(log->l_mp, "%s: unexpected magic num",
|
|
|
|
__func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* check fields */
|
2007-10-11 18:59:34 -06:00
|
|
|
len = be32_to_cpu(iclog->ic_header.h_num_logops);
|
2015-06-21 17:44:47 -06:00
|
|
|
base_ptr = ptr = iclog->ic_datap;
|
|
|
|
ophead = ptr;
|
2008-11-27 20:23:38 -07:00
|
|
|
xhdr = iclog->ic_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < len; i++) {
|
2015-06-21 17:44:47 -06:00
|
|
|
ophead = ptr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* clientid is only 1 byte */
|
2015-06-21 17:44:47 -06:00
|
|
|
p = &ophead->oh_clientid;
|
|
|
|
field_offset = p - base_ptr;
|
2012-11-12 16:32:59 -07:00
|
|
|
if (!syncing || (field_offset & 0x1ff)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
clientid = ophead->oh_clientid;
|
|
|
|
} else {
|
2015-06-21 17:45:10 -06:00
|
|
|
idx = BTOBBT((char *)&ophead->oh_clientid - iclog->ic_datap);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
|
|
|
|
j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
|
|
|
k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
2007-10-11 18:58:05 -06:00
|
|
|
clientid = xlog_get_client_id(
|
|
|
|
xhdr[j].hic_xheader.xh_cycle_data[k]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2007-10-11 18:58:05 -06:00
|
|
|
clientid = xlog_get_client_id(
|
|
|
|
iclog->ic_header.h_cycle_data[idx]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (clientid != XFS_TRANSACTION && clientid != XFS_LOG)
|
2011-03-06 16:01:35 -07:00
|
|
|
xfs_warn(log->l_mp,
|
2018-01-09 13:02:55 -07:00
|
|
|
"%s: invalid clientid %d op "PTR_FMT" offset 0x%lx",
|
2011-03-06 16:01:35 -07:00
|
|
|
__func__, clientid, ophead,
|
|
|
|
(unsigned long)field_offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* check length */
|
2015-06-21 17:44:47 -06:00
|
|
|
p = &ophead->oh_len;
|
|
|
|
field_offset = p - base_ptr;
|
2012-11-12 16:32:59 -07:00
|
|
|
if (!syncing || (field_offset & 0x1ff)) {
|
2007-10-11 18:58:59 -06:00
|
|
|
op_len = be32_to_cpu(ophead->oh_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2015-06-21 17:43:32 -06:00
|
|
|
idx = BTOBBT((uintptr_t)&ophead->oh_len -
|
|
|
|
(uintptr_t)iclog->ic_datap);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
|
|
|
|
j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
|
|
|
k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
|
2007-10-11 18:59:34 -06:00
|
|
|
op_len = be32_to_cpu(xhdr[j].hic_xheader.xh_cycle_data[k]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2007-10-11 18:59:34 -06:00
|
|
|
op_len = be32_to_cpu(iclog->ic_header.h_cycle_data[idx]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ptr += sizeof(xlog_op_header_t) + op_len;
|
|
|
|
}
|
|
|
|
} /* xlog_verify_iclog */
|
2005-11-01 21:12:04 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2007-10-11 01:37:10 -06:00
|
|
|
* Mark all iclogs IOERROR. l_icloglock is held by the caller.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xlog_state_ioerror(
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_in_core_t *iclog, *ic;
|
|
|
|
|
|
|
|
iclog = log->l_iclog;
|
|
|
|
if (! (iclog->ic_state & XLOG_STATE_IOERROR)) {
|
|
|
|
/*
|
|
|
|
* Mark all the incore logs IOERROR.
|
|
|
|
* From now on, no log flushes will result.
|
|
|
|
*/
|
|
|
|
ic = iclog;
|
|
|
|
do {
|
|
|
|
ic->ic_state = XLOG_STATE_IOERROR;
|
|
|
|
ic = ic->ic_next;
|
|
|
|
} while (ic != iclog);
|
2006-01-14 18:37:08 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Return non-zero, if state transition has already happened.
|
|
|
|
*/
|
2006-01-14 18:37:08 -07:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called from xfs_force_shutdown, when we're forcibly
|
|
|
|
* shutting down the filesystem, typically because of an IO error.
|
|
|
|
* Our main objectives here are to make sure that:
|
2014-10-01 17:02:28 -06:00
|
|
|
* a. if !logerror, flush the logs to disk. Anything modified
|
|
|
|
* after this is ignored.
|
|
|
|
* b. the filesystem gets marked 'SHUTDOWN' for all interested
|
2005-04-16 16:20:36 -06:00
|
|
|
* parties to find out, 'atomically'.
|
2014-10-01 17:02:28 -06:00
|
|
|
* c. those who're sleeping on log reservations, pinned objects and
|
2005-04-16 16:20:36 -06:00
|
|
|
* other resources get woken up, and be told the bad news.
|
2014-10-01 17:02:28 -06:00
|
|
|
* d. nothing new gets queued up after (b) and (c) are done.
|
2010-05-16 23:51:59 -06:00
|
|
|
*
|
2014-10-01 17:02:28 -06:00
|
|
|
* Note: for the !logerror case we need to flush the regions held in memory out
|
|
|
|
* to disk first. This needs to be done before the log is marked as shutdown,
|
|
|
|
* otherwise the iclog writes will fail.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_log_force_umount(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
int logerror)
|
|
|
|
{
|
2012-06-14 08:22:16 -06:00
|
|
|
struct xlog *log;
|
2005-04-16 16:20:36 -06:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
log = mp->m_log;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this happens during log recovery, don't worry about
|
|
|
|
* locking; the log isn't open for business yet.
|
|
|
|
*/
|
|
|
|
if (!log ||
|
|
|
|
log->l_flags & XLOG_ACTIVE_RECOVERY) {
|
|
|
|
mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
|
2008-11-27 20:23:31 -07:00
|
|
|
if (mp->m_sb_bp)
|
2016-02-09 21:01:11 -07:00
|
|
|
mp->m_sb_bp->b_flags |= XBF_DONE;
|
2006-01-14 18:37:08 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Somebody could've already done the hard work for us.
|
|
|
|
* No need to get locks for this.
|
|
|
|
*/
|
|
|
|
if (logerror && log->l_iclog->ic_state & XLOG_STATE_IOERROR) {
|
|
|
|
ASSERT(XLOG_FORCED_SHUTDOWN(log));
|
2006-01-14 18:37:08 -07:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-05-16 23:51:59 -06:00
|
|
|
|
|
|
|
/*
|
2014-10-01 17:02:28 -06:00
|
|
|
* Flush all the completed transactions to disk before marking the log
|
|
|
|
* being shut down. We need to do it in this order to ensure that
|
|
|
|
* completed operations are safely on disk before we shut down, and that
|
|
|
|
* we don't have to issue any buffer IO after the shutdown flags are set
|
|
|
|
* to guarantee this.
|
2010-05-16 23:51:59 -06:00
|
|
|
*/
|
2011-12-06 14:58:07 -07:00
|
|
|
if (!logerror)
|
2014-10-01 17:02:28 -06:00
|
|
|
_xfs_log_force(mp, XFS_LOG_SYNC, NULL);
|
2010-05-16 23:51:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2010-12-20 18:29:01 -07:00
|
|
|
* mark the filesystem and the as in a shutdown state and wake
|
|
|
|
* everybody up to tell them the bad news.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
|
2008-11-27 20:23:31 -07:00
|
|
|
if (mp->m_sb_bp)
|
2016-02-09 21:01:11 -07:00
|
|
|
mp->m_sb_bp->b_flags |= XBF_DONE;
|
2008-11-27 20:23:31 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2014-10-01 17:02:28 -06:00
|
|
|
* Mark the log and the iclogs with IO error flags to prevent any
|
|
|
|
* further log IO from being issued or completed.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
log->l_flags |= XLOG_IO_ERROR;
|
2014-10-01 17:02:28 -06:00
|
|
|
retval = xlog_state_ioerror(log);
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2010-12-20 18:02:25 -07:00
|
|
|
* We don't want anybody waiting for log reservations after this. That
|
|
|
|
* means we have to wake up everybody queued up on reserveq as well as
|
|
|
|
* writeq. In addition, we make sure in xlog_{re}grant_log_space that
|
|
|
|
* we don't enqueue anything once the SHUTDOWN flag is set, and this
|
2010-12-20 18:29:01 -07:00
|
|
|
* action is protected by the grant locks.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2012-02-19 19:31:27 -07:00
|
|
|
xlog_grant_head_wake_all(&log->l_reserve_head);
|
|
|
|
xlog_grant_head_wake_all(&log->l_write_head);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
2014-05-06 16:05:50 -06:00
|
|
|
* Wake up everybody waiting on xfs_log_force. Wake the CIL push first
|
|
|
|
* as if the log writes were completed. The abort handling in the log
|
|
|
|
* item committed callback functions will do this again under lock to
|
|
|
|
* avoid races.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2014-05-06 16:05:50 -06:00
|
|
|
wake_up_all(&log->l_cilp->xc_commit_wait);
|
2005-04-16 16:20:36 -06:00
|
|
|
xlog_state_do_callback(log, XFS_LI_ABORTED, NULL);
|
|
|
|
|
|
|
|
#ifdef XFSERRORDEBUG
|
|
|
|
{
|
|
|
|
xlog_in_core_t *iclog;
|
|
|
|
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_lock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = log->l_iclog;
|
|
|
|
do {
|
|
|
|
ASSERT(iclog->ic_callback == 0);
|
|
|
|
iclog = iclog->ic_next;
|
|
|
|
} while (iclog != log->l_iclog);
|
2007-10-11 01:37:10 -06:00
|
|
|
spin_unlock(&log->l_icloglock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* return non-zero if log IOERROR transition had already happened */
|
2006-01-14 18:37:08 -07:00
|
|
|
return retval;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-06-20 23:36:52 -06:00
|
|
|
STATIC int
|
2012-06-14 08:22:16 -06:00
|
|
|
xlog_iclogs_empty(
|
|
|
|
struct xlog *log)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
xlog_in_core_t *iclog;
|
|
|
|
|
|
|
|
iclog = log->l_iclog;
|
|
|
|
do {
|
|
|
|
/* endianness does not matter here, zero is zero in
|
|
|
|
* any language.
|
|
|
|
*/
|
|
|
|
if (iclog->ic_header.h_num_logops)
|
2006-01-14 18:37:08 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
iclog = iclog->ic_next;
|
|
|
|
} while (iclog != log->l_iclog);
|
2006-01-14 18:37:08 -07:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-10-08 04:56:02 -06:00
|
|
|
|
2015-10-11 22:59:25 -06:00
|
|
|
/*
|
|
|
|
* Verify that an LSN stamped into a piece of metadata is valid. This is
|
|
|
|
* intended for use in read verifiers on v5 superblocks.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
xfs_log_check_lsn(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_lsn_t lsn)
|
|
|
|
{
|
|
|
|
struct xlog *log = mp->m_log;
|
|
|
|
bool valid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* norecovery mode skips mount-time log processing and unconditionally
|
|
|
|
* resets the in-core LSN. We can't validate in this mode, but
|
|
|
|
* modifications are not allowed anyways so just return true.
|
|
|
|
*/
|
|
|
|
if (mp->m_flags & XFS_MOUNT_NORECOVERY)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some metadata LSNs are initialized to NULL (e.g., the agfl). This is
|
|
|
|
* handled by recovery and thus safe to ignore here.
|
|
|
|
*/
|
|
|
|
if (lsn == NULLCOMMITLSN)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
valid = xlog_valid_lsn(mp->m_log, lsn);
|
|
|
|
|
|
|
|
/* warn the user about what's gone wrong before verifier failure */
|
|
|
|
if (!valid) {
|
|
|
|
spin_lock(&log->l_icloglock);
|
|
|
|
xfs_warn(mp,
|
|
|
|
"Corruption warning: Metadata has LSN (%d:%d) ahead of current LSN (%d:%d). "
|
|
|
|
"Please unmount and run xfs_repair (>= v4.3) to resolve.",
|
|
|
|
CYCLE_LSN(lsn), BLOCK_LSN(lsn),
|
|
|
|
log->l_curr_cycle, log->l_curr_block);
|
|
|
|
spin_unlock(&log->l_icloglock);
|
|
|
|
}
|
|
|
|
|
|
|
|
return valid;
|
|
|
|
}
|