// SPDX-License-Identifier: GPL-2.0

  /*

   * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   * All Rights Reserved.

   */

  #include "xfs.h"

  #include "xfs_fs.h"

  #include "xfs_shared.h"

  #include "xfs_format.h"

  #include "xfs_log_format.h"
  #include "xfs_trans_resv.h"

  #include "xfs_mount.h"

  #include "xfs_errortag.h"

  #include "xfs_error.h"

  #include "xfs_trans.h"
  #include "xfs_trans_priv.h"
  #include "xfs_log.h"

  #include "xfs_log_priv.h"

  #include "xfs_trace.h"

  #include "xfs_sysfs.h"

  #include "xfs_sb.h"

  #include "xfs_health.h"

  kmem_zone_t	*xfs_log_ticket_zone;

  /* Local miscellaneous function prototypes */

  STATIC struct xlog *
  xlog_alloc_log(
  	struct xfs_mount	*mp,
  	struct xfs_buftarg	*log_target,
  	xfs_daddr_t		blk_offset,
  	int			num_bblks);

  STATIC int
  xlog_space_left(
  	struct xlog		*log,
  	atomic64_t		*head);

  STATIC void
  xlog_dealloc_log(
  	struct xlog		*log);

  
  /* local state machine functions */

  STATIC void xlog_state_done_syncing(

  	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 void
  xlog_state_switch_iclogs(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog,
  	int			eventual_size);
  STATIC void

  xlog_grant_push_ail(

  	struct xlog		*log,
  	int			need_bytes);
  STATIC void

  xlog_sync(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog);

  #if defined(DEBUG)

  STATIC void
  xlog_verify_dest_ptr(
  	struct xlog		*log,

  	void			*ptr);

  STATIC void
  xlog_verify_grant_tail(

  	struct xlog *log);
  STATIC void
  xlog_verify_iclog(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog,

  	int			count);

  STATIC void
  xlog_verify_tail_lsn(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog,
  	xfs_lsn_t		tail_lsn);

  #else
  #define xlog_verify_dest_ptr(a,b)

  #define xlog_verify_grant_tail(a)

  #define xlog_verify_iclog(a,b,c)

  #define xlog_verify_tail_lsn(a,b,c)
  #endif

  STATIC int
  xlog_iclogs_empty(
  	struct xlog		*log);

  static void

  xlog_grant_sub_space(

  	struct xlog		*log,
  	atomic64_t		*head,
  	int			bytes)

  {

  	int64_t	head_val = atomic64_read(head);
  	int64_t new, old;

  	do {
  		int	cycle, space;

  		xlog_crack_grant_head_val(head_val, &cycle, &space);

  		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);

  }
  
  static void

  xlog_grant_add_space(

  	struct xlog		*log,
  	atomic64_t		*head,
  	int			bytes)

  {

  	int64_t	head_val = atomic64_read(head);
  	int64_t new, old;

  	do {
  		int		tmp;
  		int		cycle, space;

  		xlog_crack_grant_head_val(head_val, &cycle, &space);

  		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);

  }

  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);
  }

  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);
  }

  static inline int
  xlog_ticket_reservation(

  	struct xlog		*log,

  	struct xlog_grant_head	*head,
  	struct xlog_ticket	*tic)

  {

  	if (head == &log->l_write_head) {
  		ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV);
  		return tic->t_unit_res;
  	} else {

  		if (tic->t_flags & XLOG_TIC_PERM_RESERV)

  			return tic->t_unit_res * tic->t_cnt;

  		else

  			return tic->t_unit_res;

  	}

  }
  
  STATIC bool

  xlog_grant_head_wake(

  	struct xlog		*log,

  	struct xlog_grant_head	*head,

  	int			*free_bytes)
  {
  	struct xlog_ticket	*tic;
  	int			need_bytes;

  	bool			woken_task = false;

  	list_for_each_entry(tic, &head->waiters, t_queue) {

  
  		/*
  		 * There is a chance that the size of the CIL checkpoints in
  		 * progress at the last AIL push target calculation resulted in
  		 * limiting the target to the log head (l_last_sync_lsn) at the
  		 * time. This may not reflect where the log head is now as the
  		 * CIL checkpoints may have completed.
  		 *
  		 * Hence when we are woken here, it may be that the head of the
  		 * log that has moved rather than the tail. As the tail didn't
  		 * move, there still won't be space available for the
  		 * reservation we require.  However, if the AIL has already
  		 * pushed to the target defined by the old log head location, we
  		 * will hang here waiting for something else to update the AIL
  		 * push target.
  		 *
  		 * Therefore, if there isn't space to wake the first waiter on
  		 * the grant head, we need to push the AIL again to ensure the
  		 * target reflects both the current log tail and log head
  		 * position before we wait for the tail to move again.
  		 */

  		need_bytes = xlog_ticket_reservation(log, head, tic);

  		if (*free_bytes < need_bytes) {
  			if (!woken_task)
  				xlog_grant_push_ail(log, need_bytes);

  			return false;

  		}

  		*free_bytes -= need_bytes;
  		trace_xfs_log_grant_wake_up(log, tic);

  		wake_up_process(tic->t_task);

  		woken_task = true;

  	}
  
  	return true;
  }
  
  STATIC int

  xlog_grant_head_wait(

  	struct xlog		*log,

  	struct xlog_grant_head	*head,

  	struct xlog_ticket	*tic,

  	int			need_bytes) __releases(&head->lock)
  					    __acquires(&head->lock)

  {

  	list_add_tail(&tic->t_queue, &head->waiters);

  
  	do {
  		if (XLOG_FORCED_SHUTDOWN(log))
  			goto shutdown;
  		xlog_grant_push_ail(log, need_bytes);

  		__set_current_state(TASK_UNINTERRUPTIBLE);

  		spin_unlock(&head->lock);

  		XFS_STATS_INC(log->l_mp, xs_sleep_logspace);

  		trace_xfs_log_grant_sleep(log, tic);
  		schedule();

  		trace_xfs_log_grant_wake(log, tic);

  		spin_lock(&head->lock);

  		if (XLOG_FORCED_SHUTDOWN(log))
  			goto shutdown;

  	} while (xlog_space_left(log, &head->grant) < need_bytes);

  
  	list_del_init(&tic->t_queue);
  	return 0;
  shutdown:
  	list_del_init(&tic->t_queue);

  	return -EIO;

  }

  /*
   * 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(

  	struct xlog		*log,

  	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;
  }

  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++;
  }

  /*

   * Replenish the byte reservation required by moving the grant write head.
   */
  int
  xfs_log_regrant(
  	struct xfs_mount	*mp,
  	struct xlog_ticket	*tic)
  {

  	struct xlog		*log = mp->m_log;

  	int			need_bytes;
  	int			error = 0;
  
  	if (XLOG_FORCED_SHUTDOWN(log))

  		return -EIO;

  	XFS_STATS_INC(mp, xs_try_logspace);

  
  	/*
  	 * 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 to 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,

  	uint8_t		 	client,

  	bool			permanent)

  {

  	struct xlog		*log = mp->m_log;

  	struct xlog_ticket	*tic;
  	int			need_bytes;
  	int			error = 0;
  
  	ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
  
  	if (XLOG_FORCED_SHUTDOWN(log))

  		return -EIO;

  	XFS_STATS_INC(mp, xs_try_logspace);

  
  	ASSERT(*ticp == NULL);

  	tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent);

  	*ticp = tic;

  	xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt
  					    : tic->t_unit_res);

  
  	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;
  }

  static bool
  __xlog_state_release_iclog(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog)
  {
  	lockdep_assert_held(&log->l_icloglock);
  
  	if (iclog->ic_state == XLOG_STATE_WANT_SYNC) {
  		/* update tail before writing to iclog */
  		xfs_lsn_t tail_lsn = xlog_assign_tail_lsn(log->l_mp);
  
  		iclog->ic_state = XLOG_STATE_SYNCING;
  		iclog->ic_header.h_tail_lsn = cpu_to_be64(tail_lsn);
  		xlog_verify_tail_lsn(log, iclog, tail_lsn);
  		/* cycle incremented when incrementing curr_block */
  		return true;
  	}
  
  	ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE);
  	return false;
  }
  
  /*
   * Flush iclog to disk if this is the last reference to the given iclog and the
   * it is in the WANT_SYNC state.
   */
  static int
  xlog_state_release_iclog(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog)
  {
  	lockdep_assert_held(&log->l_icloglock);

  	if (iclog->ic_state == XLOG_STATE_IOERROR)

  		return -EIO;
  
  	if (atomic_dec_and_test(&iclog->ic_refcnt) &&
  	    __xlog_state_release_iclog(log, iclog)) {
  		spin_unlock(&log->l_icloglock);
  		xlog_sync(log, iclog);
  		spin_lock(&log->l_icloglock);
  	}
  
  	return 0;
  }

  void

  xfs_log_release_iclog(

  	struct xlog_in_core	*iclog)

  {

  	struct xlog		*log = iclog->ic_log;

  	bool			sync = false;

  	if (atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock)) {

  		if (iclog->ic_state != XLOG_STATE_IOERROR)
  			sync = __xlog_state_release_iclog(log, iclog);

  		spin_unlock(&log->l_icloglock);

  	}

  
  	if (sync)
  		xlog_sync(log, iclog);

  }
  
  /*

   * 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_log_mount(
  	xfs_mount_t	*mp,
  	xfs_buftarg_t	*log_target,
  	xfs_daddr_t	blk_offset,
  	int		num_bblks)

  {

  	bool		fatal = xfs_sb_version_hascrc(&mp->m_sb);

  	int		error = 0;
  	int		min_logfsbs;

  	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
  		xfs_notice(mp, "Mounting V%d Filesystem",
  			   XFS_SB_VERSION_NUM(&mp->m_sb));
  	} else {

  		xfs_notice(mp,

  "Mounting V%d filesystem in no-recovery mode. Filesystem will be inconsistent.",
  			   XFS_SB_VERSION_NUM(&mp->m_sb));

  		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);

  	}
  
  	mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);

  	if (IS_ERR(mp->m_log)) {

  		error = PTR_ERR(mp->m_log);

  		goto out;
  	}

  	/*

  	 * 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);

  		error = -EINVAL;

  	} 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);

  		error = -EINVAL;

  	} 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);

  		error = -EINVAL;

  	} 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;

  	}
  	if (error) {

  		/*
  		 * Log check errors are always fatal on v5; or whenever bad
  		 * metadata leads to a crash.
  		 */
  		if (fatal) {

  			xfs_crit(mp, "AAIEEE! Log failed size checks. Abort!");
  			ASSERT(0);
  			goto out_free_log;
  		}

  		xfs_crit(mp, "Log size out of supported range.");

  		xfs_crit(mp,

  "Continuing onwards, but if log hangs are experienced then please report this message in the bug report.");

  	}
  
  	/*

  	 * Initialize the AIL now we have a log.
  	 */

  	error = xfs_trans_ail_init(mp);
  	if (error) {

  		xfs_warn(mp, "AIL initialisation failed: error %d", error);

  		goto out_free_log;

  	}

  	mp->m_log->l_ailp = mp->m_ail;

  
  	/*

  	 * skip log recovery on a norecovery mount.  pretend it all
  	 * just worked.
  	 */
  	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {

  		int	readonly = (mp->m_flags & XFS_MOUNT_RDONLY);

  
  		if (readonly)

  			mp->m_flags &= ~XFS_MOUNT_RDONLY;

  		error = xlog_recover(mp->m_log);

  
  		if (readonly)

  			mp->m_flags |= XFS_MOUNT_RDONLY;

  		if (error) {

  			xfs_warn(mp, "log mount/recovery failed: error %d",
  				error);

  			xlog_recover_cancel(mp->m_log);

  			goto out_destroy_ail;

  		}
  	}

  	error = xfs_sysfs_init(&mp->m_log->l_kobj, &xfs_log_ktype, &mp->m_kobj,
  			       "log");
  	if (error)
  		goto out_destroy_ail;

  	/* Normal transactions can now occur */
  	mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;

  	/*
  	 * 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);

  	return 0;

  
  out_destroy_ail:
  	xfs_trans_ail_destroy(mp);
  out_free_log:
  	xlog_dealloc_log(mp->m_log);

  out:

  	return error;

  }

  
  /*

   * 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.

   *

   * 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.

   */
  int

  xfs_log_mount_finish(
  	struct xfs_mount	*mp)

  {

  	int	error = 0;

  	bool	readonly = (mp->m_flags & XFS_MOUNT_RDONLY);

  	bool	recovered = mp->m_log->l_flags & XLOG_RECOVERY_NEEDED;

  	if (mp->m_flags & XFS_MOUNT_NORECOVERY) {

  		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);

  		return 0;

  	} else if (readonly) {
  		/* Allow unlinked processing to proceed */
  		mp->m_flags &= ~XFS_MOUNT_RDONLY;

  	}

  	/*
  	 * 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.

  	 *
  	 * 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

  	 * lru inodes after clearing SB_ACTIVE because we don't

  	 * 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.

  	 */

  	mp->m_super->s_flags |= SB_ACTIVE;

  	error = xlog_recover_finish(mp->m_log);
  	if (!error)
  		xfs_log_work_queue(mp);

  	mp->m_super->s_flags &= ~SB_ACTIVE;

  	evict_inodes(mp->m_super);

  	/*
  	 * 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);

  	if (readonly)
  		mp->m_flags |= XFS_MOUNT_RDONLY;

  	return error;
  }
  
  /*
   * The mount has failed. Cancel the recovery if it hasn't completed and destroy
   * the log.
   */

  void

  xfs_log_mount_cancel(
  	struct xfs_mount	*mp)
  {

  	xlog_recover_cancel(mp->m_log);

  	xfs_log_unmount(mp);

  }
  
  /*

   * Wait for the iclog to be written disk, or return an error if the log has been
   * shut down.
   */
  static int
  xlog_wait_on_iclog(
  	struct xlog_in_core	*iclog)
  		__releases(iclog->ic_log->l_icloglock)
  {
  	struct xlog		*log = iclog->ic_log;
  
  	if (!XLOG_FORCED_SHUTDOWN(log) &&
  	    iclog->ic_state != XLOG_STATE_ACTIVE &&
  	    iclog->ic_state != XLOG_STATE_DIRTY) {
  		XFS_STATS_INC(log->l_mp, xs_log_force_sleep);
  		xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
  	} else {
  		spin_unlock(&log->l_icloglock);
  	}
  
  	if (XLOG_FORCED_SHUTDOWN(log))
  		return -EIO;
  	return 0;
  }
  
  /*

   * Write out an unmount record using the ticket provided. We have to account for
   * the data space used in the unmount ticket as this write is not done from a
   * transaction context that has already done the accounting for us.

   */

  static int
  xlog_write_unmount_record(
  	struct xlog		*log,
  	struct xlog_ticket	*ticket,
  	xfs_lsn_t		*lsn,
  	uint			flags)

  {

  	struct xfs_unmount_log_format ulf = {

  		.magic = XLOG_UNMOUNT_TYPE,
  	};
  	struct xfs_log_iovec reg = {

  		.i_addr = &ulf,
  		.i_len = sizeof(ulf),

  		.i_type = XLOG_REG_TYPE_UNMOUNT,
  	};
  	struct xfs_log_vec vec = {
  		.lv_niovecs = 1,
  		.lv_iovecp = &reg,
  	};

  
  	/* account for space used by record data */
  	ticket->t_curr_res -= sizeof(ulf);
  	return xlog_write(log, &vec, ticket, lsn, NULL, flags, false);
  }
  
  /*
   * Mark the filesystem clean by writing an unmount record to the head of the
   * log.
   */
  static void
  xlog_unmount_write(
  	struct xlog		*log)
  {
  	struct xfs_mount	*mp = log->l_mp;

  	struct xlog_in_core	*iclog;
  	struct xlog_ticket	*tic = NULL;
  	xfs_lsn_t		lsn;

  	uint			flags = XLOG_UNMOUNT_TRANS;

  	int			error;
  
  	error = xfs_log_reserve(mp, 600, 1, &tic, XFS_LOG, 0);
  	if (error)
  		goto out_err;

  	error = xlog_write_unmount_record(log, tic, &lsn, flags);

  	/*
  	 * At this point, we're umounting anyway, so there's no point in
  	 * transitioning log state to IOERROR. Just continue...
  	 */
  out_err:
  	if (error)
  		xfs_alert(mp, "%s: unmount record failed", __func__);
  
  	spin_lock(&log->l_icloglock);
  	iclog = log->l_iclog;
  	atomic_inc(&iclog->ic_refcnt);

  	if (iclog->ic_state == XLOG_STATE_ACTIVE)
  		xlog_state_switch_iclogs(log, iclog, 0);
  	else
  		ASSERT(iclog->ic_state == XLOG_STATE_WANT_SYNC ||
  		       iclog->ic_state == XLOG_STATE_IOERROR);

  	error = xlog_state_release_iclog(log, iclog);

  	xlog_wait_on_iclog(iclog);

  
  	if (tic) {
  		trace_xfs_log_umount_write(log, tic);

  		xfs_log_ticket_ungrant(log, tic);

  	}
  }

  static void
  xfs_log_unmount_verify_iclog(
  	struct xlog		*log)
  {
  	struct xlog_in_core	*iclog = log->l_iclog;
  
  	do {
  		ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE);
  		ASSERT(iclog->ic_offset == 0);
  	} while ((iclog = iclog->ic_next) != log->l_iclog);
  }

  /*
   * 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

   * currently architecture converted and "Unmount" is a bit foo.

   * As far as I know, there weren't any dependencies on the old behaviour.
   */

  static void

  xfs_log_unmount_write(
  	struct xfs_mount	*mp)

  {

  	struct xlog		*log = mp->m_log;

  	/*

  	 * Don't write out unmount record on norecovery mounts or ro devices.

  	 * Or, if we are doing a forced umount (typically because of IO errors).
  	 */

  	if (mp->m_flags & XFS_MOUNT_NORECOVERY ||

  	    xfs_readonly_buftarg(log->l_targ)) {

  		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);

  		return;

  	}

  	xfs_log_force(mp, XFS_LOG_SYNC);

  	if (XLOG_FORCED_SHUTDOWN(log))
  		return;

  
  	/*
  	 * If we think the summary counters are bad, avoid writing the unmount
  	 * record to force log recovery at next mount, after which the summary
  	 * counters will be recalculated.  Refer to xlog_check_unmount_rec for
  	 * more details.
  	 */
  	if (XFS_TEST_ERROR(xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS), mp,
  			XFS_ERRTAG_FORCE_SUMMARY_RECALC)) {
  		xfs_alert(mp, "%s: will fix summary counters at next mount",
  				__func__);
  		return;
  	}

  	xfs_log_unmount_verify_iclog(log);

  	xlog_unmount_write(log);

  }

  
  /*

   * Empty the log for unmount/freeze.

   *
   * 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

   * record.

   */
  void

  xfs_log_quiesce(
  	struct xfs_mount	*mp)

  {

  	cancel_delayed_work_sync(&mp->m_log->l_work);

  	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);

  }
  
  /*
   * 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);

  	xfs_trans_ail_destroy(mp);

  
  	xfs_sysfs_del(&mp->m_log->l_kobj);

  	xlog_dealloc_log(mp->m_log);

  }

  void
  xfs_log_item_init(
  	struct xfs_mount	*mp,
  	struct xfs_log_item	*item,
  	int			type,

  	const struct xfs_item_ops *ops)

  {
  	item->li_mountp = mp;
  	item->li_ailp = mp->m_ail;
  	item->li_type = type;
  	item->li_ops = ops;

  	item->li_lv = NULL;
  
  	INIT_LIST_HEAD(&item->li_ail);
  	INIT_LIST_HEAD(&item->li_cil);

  	INIT_LIST_HEAD(&item->li_bio_list);

  	INIT_LIST_HEAD(&item->li_trans);

  }

  /*
   * Wake up processes waiting for log space after we have moved the log tail.

   */

  void

  xfs_log_space_wake(

  	struct xfs_mount	*mp)

  {

  	struct xlog		*log = mp->m_log;

  	int			free_bytes;

  	if (XLOG_FORCED_SHUTDOWN(log))
  		return;

  	if (!list_empty_careful(&log->l_write_head.waiters)) {

  		ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));

  		spin_lock(&log->l_write_head.lock);
  		free_bytes = xlog_space_left(log, &log->l_write_head.grant);

  		xlog_grant_head_wake(log, &log->l_write_head, &free_bytes);

  		spin_unlock(&log->l_write_head.lock);

  	}

  	if (!list_empty_careful(&log->l_reserve_head.waiters)) {

  		ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));

  		spin_lock(&log->l_reserve_head.lock);
  		free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);

  		xlog_grant_head_wake(log, &log->l_reserve_head, &free_bytes);

  		spin_unlock(&log->l_reserve_head.lock);

  	}

  }

  
  /*

   * 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.

   *

   * 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.

   */

  static int

  xfs_log_need_covered(xfs_mount_t *mp)
  {

  	struct xlog	*log = mp->m_log;

  	int		needed = 0;

  	if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))

  		return 0;

  	if (!xlog_cil_empty(log))
  		return 0;

  	spin_lock(&log->l_icloglock);

  	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:

  		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;

  	default:

  		needed = 1;

  		break;

  	}

  	spin_unlock(&log->l_icloglock);

  	return needed;

  }

  /*

   * We may be holding the log iclog lock upon entering this routine.
   */
  xfs_lsn_t

  xlog_assign_tail_lsn_locked(

  	struct xfs_mount	*mp)

  {

  	struct xlog		*log = mp->m_log;

  	struct xfs_log_item	*lip;
  	xfs_lsn_t		tail_lsn;

  	assert_spin_locked(&mp->m_ail->ail_lock);

  	/*
  	 * 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,

  	 * and use that when the AIL was empty.

  	 */

  	lip = xfs_ail_min(mp->m_ail);
  	if (lip)
  		tail_lsn = lip->li_lsn;
  	else

  		tail_lsn = atomic64_read(&log->l_last_sync_lsn);

  	trace_xfs_log_assign_tail_lsn(log, tail_lsn);

  	atomic64_set(&log->l_tail_lsn, tail_lsn);

  	return tail_lsn;

  }

  xfs_lsn_t
  xlog_assign_tail_lsn(
  	struct xfs_mount	*mp)
  {
  	xfs_lsn_t		tail_lsn;

  	spin_lock(&mp->m_ail->ail_lock);

  	tail_lsn = xlog_assign_tail_lsn_locked(mp);

  	spin_unlock(&mp->m_ail->ail_lock);

  
  	return tail_lsn;
  }

  /*
   * 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.
   */

  STATIC int

  xlog_space_left(

  	struct xlog	*log,

  	atomic64_t	*head)

  {

  	int		free_bytes;
  	int		tail_bytes;
  	int		tail_cycle;
  	int		head_cycle;
  	int		head_bytes;

  	xlog_crack_grant_head(head, &head_cycle, &head_bytes);

  	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);
  	tail_bytes = BBTOB(tail_bytes);

  	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)

  		return 0;

  	else if (tail_cycle < head_cycle) {
  		ASSERT(tail_cycle == (head_cycle - 1));
  		free_bytes = tail_bytes - head_bytes;

  	} 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.
  		 */

  		xfs_alert(log->l_mp, "xlog_space_left: head behind tail");

  		xfs_alert(log->l_mp,

  			  "  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);

  		ASSERT(0);
  		free_bytes = log->l_logsize;
  	}
  	return free_bytes;

  }

  static void

  xlog_ioend_work(
  	struct work_struct	*work)

  {

  	struct xlog_in_core     *iclog =
  		container_of(work, struct xlog_in_core, ic_end_io_work);
  	struct xlog		*log = iclog->ic_log;

  	int			error;

  	error = blk_status_to_errno(iclog->ic_bio.bi_status);

  #ifdef DEBUG
  	/* treat writes with injected CRC errors as failed */
  	if (iclog->ic_fail_crc)

  		error = -EIO;

  #endif

  	/*

  	 * Race to shutdown the filesystem if we see an error.

  	 */

  	if (XFS_TEST_ERROR(error, log->l_mp, XFS_ERRTAG_IODONE_IOERR)) {
  		xfs_alert(log->l_mp, "log I/O error %d", error);
  		xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);

  	}

  	xlog_state_done_syncing(iclog);

  	bio_uninit(&iclog->ic_bio);

  	/*

  	 * Drop the lock to signal that we are done. Nothing references the
  	 * iclog after this, so an unmount waiting on this lock can now tear it
  	 * down safely. As such, it is unsafe to reference the iclog after the
  	 * unlock as we could race with it being freed.

  	 */

  	up(&iclog->ic_sema);

  }

  
  /*

   * Return size of each in-core log record buffer.
   *

   * All machines get 8 x 32kB buffers by default, unless tuned otherwise.

   *
   * 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

  xlog_get_iclog_buffer_size(
  	struct xfs_mount	*mp,
  	struct xlog		*log)

  {

  	if (mp->m_logbufs <= 0)

  		mp->m_logbufs = XLOG_MAX_ICLOGS;
  	if (mp->m_logbsize <= 0)
  		mp->m_logbsize = XLOG_BIG_RECORD_BSIZE;
  
  	log->l_iclog_bufs = mp->m_logbufs;
  	log->l_iclog_size = mp->m_logbsize;

  
  	/*

  	 * # headers = size / 32k - one header holds cycles from 32k of data.

  	 */

  	log->l_iclog_heads =
  		DIV_ROUND_UP(mp->m_logbsize, XLOG_HEADER_CYCLE_SIZE);
  	log->l_iclog_hsize = log->l_iclog_heads << BBSHIFT;
  }

  void
  xfs_log_work_queue(
  	struct xfs_mount        *mp)
  {

  	queue_delayed_work(mp->m_sync_workqueue, &mp->m_log->l_work,

  				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.
   */

  static void

  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 */

  	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

  		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);
  }

  /*
   * 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.
   */

  STATIC struct xlog *
  xlog_alloc_log(
  	struct xfs_mount	*mp,
  	struct xfs_buftarg	*log_target,
  	xfs_daddr_t		blk_offset,
  	int			num_bblks)

  {

  	struct xlog		*log;

  	xlog_rec_header_t	*head;
  	xlog_in_core_t		**iclogp;
  	xlog_in_core_t		*iclog, *prev_iclog=NULL;

  	int			i;

  	int			error = -ENOMEM;

  	uint			log2_size = 0;

  	log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);

  	if (!log) {

  		xfs_warn(mp, "Log allocation failed: No memory!");

  		goto out;
  	}

  
  	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;

  	INIT_DELAYED_WORK(&log->l_work, xfs_log_worker);

  
  	log->l_prev_block  = -1;

  	/* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */

  	xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0);
  	xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0);

  	log->l_curr_cycle  = 1;	    /* 0 is bad since this is initial value */

  
  	xlog_grant_head_init(&log->l_reserve_head);
  	xlog_grant_head_init(&log->l_write_head);

  	error = -EFSCORRUPTED;

  	if (xfs_sb_version_hassector(&mp->m_sb)) {

  	        log2_size = mp->m_sb.sb_logsectlog;
  		if (log2_size < BBSHIFT) {

  			xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)",
  				log2_size, BBSHIFT);

  			goto out_free_log;
  		}

  	        log2_size -= BBSHIFT;
  		if (log2_size > mp->m_sectbb_log) {

  			xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)",
  				log2_size, mp->m_sectbb_log);

  			goto out_free_log;
  		}

  
  		/* for larger sector sizes, must have v2 or external log */
  		if (log2_size && log->l_logBBstart > 0 &&
  			    !xfs_sb_version_haslogv2(&mp->m_sb)) {

  			xfs_warn(mp,
  		"log sector size (0x%x) invalid for configuration.",
  				log2_size);

  			goto out_free_log;
  		}

  	}

  	log->l_sectBBsize = 1 << log2_size;

  
  	xlog_get_iclog_buffer_size(mp, log);

  	spin_lock_init(&log->l_icloglock);

  	init_waitqueue_head(&log->l_flush_wait);

  	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++) {

  		int align_mask = xfs_buftarg_dma_alignment(mp->m_logdev_targp);

  		size_t bvec_size = howmany(log->l_iclog_size, PAGE_SIZE) *
  				sizeof(struct bio_vec);

  
  		iclog = kmem_zalloc(sizeof(*iclog) + bvec_size, KM_MAYFAIL);
  		if (!iclog)

  			goto out_free_iclog;

  		*iclogp = iclog;

  		iclog->ic_prev = prev_iclog;
  		prev_iclog = iclog;

  		iclog->ic_data = kmem_alloc_io(log->l_iclog_size, align_mask,

  						KM_MAYFAIL | KM_ZERO);

  		if (!iclog->ic_data)

  			goto out_free_iclog;

  #ifdef DEBUG

  		log->l_iclog_bak[i] = &iclog->ic_header;

  #endif

  		head = &iclog->ic_header;
  		memset(head, 0, sizeof(xlog_rec_header_t));

  		head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
  		head->h_version = cpu_to_be32(

  			xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);

  		head->h_size = cpu_to_be32(log->l_iclog_size);

  		/* new fields */

  		head->h_fmt = cpu_to_be32(XLOG_FMT);

  		memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));

  		iclog->ic_size = log->l_iclog_size - log->l_iclog_hsize;

  		iclog->ic_state = XLOG_STATE_ACTIVE;
  		iclog->ic_log = log;

  		atomic_set(&iclog->ic_refcnt, 0);
  		spin_lock_init(&iclog->ic_callback_lock);

  		INIT_LIST_HEAD(&iclog->ic_callbacks);

  		iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;

  		init_waitqueue_head(&iclog->ic_force_wait);
  		init_waitqueue_head(&iclog->ic_write_wait);

  		INIT_WORK(&iclog->ic_end_io_work, xlog_ioend_work);
  		sema_init(&iclog->ic_sema, 1);

  
  		iclogp = &iclog->ic_next;
  	}
  	*iclogp = log->l_iclog;			/* complete ring */
  	log->l_iclog->ic_prev = prev_iclog;	/* re-write 1st prev ptr */

  	log->l_ioend_workqueue = alloc_workqueue("xfs-log/%s",
  			WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_HIGHPRI, 0,

  			mp->m_super->s_id);

  	if (!log->l_ioend_workqueue)
  		goto out_free_iclog;

  	error = xlog_cil_init(log);
  	if (error)

  		goto out_destroy_workqueue;

  	return log;

  out_destroy_workqueue:
  	destroy_workqueue(log->l_ioend_workqueue);

  out_free_iclog:
  	for (iclog = log->l_iclog; iclog; iclog = prev_iclog) {
  		prev_iclog = iclog->ic_next;

  		kmem_free(iclog->ic_data);

  		kmem_free(iclog);

  		if (prev_iclog == log->l_iclog)
  			break;

  	}

  out_free_log:
  	kmem_free(log);

  out:

  	return ERR_PTR(error);

  }	/* xlog_alloc_log */

  /*
   * Write out the commit record of a transaction associated with the given

   * ticket to close off a running log write. Return the lsn of the commit record.

   */

  int

  xlog_commit_record(

  	struct xlog		*log,

  	struct xlog_ticket	*ticket,
  	struct xlog_in_core	**iclog,

  	xfs_lsn_t		*lsn)

  {

  	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 = &reg,
  	};

  	int	error;

  	if (XLOG_FORCED_SHUTDOWN(log))
  		return -EIO;
  
  	error = xlog_write(log, &vec, ticket, lsn, iclog, XLOG_COMMIT_TRANS,
  			   false);

  	if (error)

  		xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);

  	return error;

  }

  
  /*

   * Compute the LSN that we'd need to push the log tail towards in order to have
   * (a) enough on-disk log space to log the number of bytes specified, (b) at
   * least 25% of the log space free, and (c) at least 256 blocks free.  If the
   * log free space already meets all three thresholds, this function returns
   * NULLCOMMITLSN.

   */

  xfs_lsn_t
  xlog_grant_push_threshold(

  	struct xlog	*log,

  	int		need_bytes)

  {

  	xfs_lsn_t	threshold_lsn = 0;

  	xfs_lsn_t	last_sync_lsn;

  	int		free_blocks;
  	int		free_bytes;
  	int		threshold_block;
  	int		threshold_cycle;
  	int		free_threshold;
  
  	ASSERT(BTOBB(need_bytes) < log->l_logBBsize);

  	free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);

  	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 NULLCOMMITLSN;

  	xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle,
  						&threshold_block);
  	threshold_block += free_threshold;

  	if (threshold_block >= log->l_logBBsize) {

  		threshold_block -= log->l_logBBsize;
  		threshold_cycle += 1;

  	}

  	threshold_lsn = xlog_assign_lsn(threshold_cycle,
  					threshold_block);
  	/*
  	 * Don't pass in an lsn greater than the lsn of the last

  	 * 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.

  	 */

  	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;

  	return threshold_lsn;
  }
  
  /*
   * Push the tail of the log if we need to do so to maintain the free log space
   * thresholds set out by xlog_grant_push_threshold.  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.
   */
  STATIC void
  xlog_grant_push_ail(
  	struct xlog	*log,
  	int		need_bytes)
  {
  	xfs_lsn_t	threshold_lsn;
  
  	threshold_lsn = xlog_grant_push_threshold(log, need_bytes);
  	if (threshold_lsn == NULLCOMMITLSN || XLOG_FORCED_SHUTDOWN(log))
  		return;

  	/*
  	 * 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.
  	 */

  	xfs_ail_push(log->l_ailp, threshold_lsn);

  }

  /*

   * 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;

  	char			*dp;

  
  	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.
   */

  __le32

  xlog_cksum(
  	struct xlog		*log,
  	struct xlog_rec_header	*rhead,
  	char			*dp,
  	int			size)
  {

  	uint32_t		crc;

  
  	/* first generate the crc for the record header ... */

  	crc = xfs_start_cksum_update((char *)rhead,

  			      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;

  		int		xheads;

  		xheads = DIV_ROUND_UP(size, XLOG_HEADER_CYCLE_SIZE);

  		for (i = 1; i < xheads; i++) {

  			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);
  }

  static void
  xlog_bio_end_io(
  	struct bio		*bio)
  {
  	struct xlog_in_core	*iclog = bio->bi_private;

  	queue_work(iclog->ic_log->l_ioend_workqueue,

  		   &iclog->ic_end_io_work);
  }

  static int

  xlog_map_iclog_data(
  	struct bio		*bio,
  	void			*data,
  	size_t			count)
  {
  	do {
  		struct page	*page = kmem_to_page(data);
  		unsigned int	off = offset_in_page(data);
  		size_t		len = min_t(size_t, count, PAGE_SIZE - off);

  		if (bio_add_page(bio, page, len, off) != len)
  			return -EIO;

  
  		data += len;
  		count -= len;
  	} while (count);

  
  	return 0;

  }

  STATIC void
  xlog_write_iclog(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog,

  	uint64_t		bno,

  	unsigned int		count,

  	bool			need_flush)

  {

  	ASSERT(bno < log->l_logBBsize);

  
  	/*
  	 * We lock the iclogbufs here so that we can serialise against I/O
  	 * 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 archieve that.
  	 */

  	down(&iclog->ic_sema);

  	if (unlikely(iclog->ic_state == XLOG_STATE_IOERROR)) {

  		/*
  		 * It would seem logical to return EIO here, but we rely on
  		 * the log state machine to propagate I/O errors instead of

  		 * doing it here.  We kick of the state machine and unlock
  		 * the buffer manually, the code needs to be kept in sync
  		 * with the I/O completion path.

  		 */

  		xlog_state_done_syncing(iclog);

  		up(&iclog->ic_sema);

  		return;

  	}

  	bio_init(&iclog->ic_bio, iclog->ic_bvec, howmany(count, PAGE_SIZE));
  	bio_set_dev(&iclog->ic_bio, log->l_targ->bt_bdev);
  	iclog->ic_bio.bi_iter.bi_sector = log->l_logBBstart + bno;
  	iclog->ic_bio.bi_end_io = xlog_bio_end_io;
  	iclog->ic_bio.bi_private = iclog;

  
  	/*
  	 * We use REQ_SYNC | REQ_IDLE here to tell the block layer the are more
  	 * IOs coming immediately after this one. This prevents the block layer
  	 * writeback throttle from throttling log writes behind background
  	 * metadata writeback and causing priority inversions.
  	 */
  	iclog->ic_bio.bi_opf = REQ_OP_WRITE | REQ_META | REQ_SYNC |
  				REQ_IDLE | REQ_FUA;

  	if (need_flush)
  		iclog->ic_bio.bi_opf |= REQ_PREFLUSH;

  	if (xlog_map_iclog_data(&iclog->ic_bio, iclog->ic_data, count)) {
  		xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR);
  		return;
  	}

  	if (is_vmalloc_addr(iclog->ic_data))

  		flush_kernel_vmap_range(iclog->ic_data, count);

  
  	/*
  	 * If this log buffer would straddle the end of the log we will have
  	 * to split it up into two bios, so that we can continue at the start.
  	 */
  	if (bno + BTOBB(count) > log->l_logBBsize) {
  		struct bio *split;
  
  		split = bio_split(&iclog->ic_bio, log->l_logBBsize - bno,
  				  GFP_NOIO, &fs_bio_set);
  		bio_chain(split, &iclog->ic_bio);
  		submit_bio(split);
  
  		/* restart at logical offset zero for the remainder */
  		iclog->ic_bio.bi_iter.bi_sector = log->l_logBBstart;
  	}
  
  	submit_bio(&iclog->ic_bio);

  }

  
  /*

   * We need to bump cycle number for the part of the iclog that is
   * written to the start of the log. Watch out for the header magic
   * number case, though.
   */

  static void

  xlog_split_iclog(
  	struct xlog		*log,
  	void			*data,
  	uint64_t		bno,
  	unsigned int		count)
  {
  	unsigned int		split_offset = BBTOB(log->l_logBBsize - bno);
  	unsigned int		i;
  
  	for (i = split_offset; i < count; i += BBSIZE) {
  		uint32_t cycle = get_unaligned_be32(data + i);
  
  		if (++cycle == XLOG_HEADER_MAGIC_NUM)
  			cycle++;
  		put_unaligned_be32(cycle, data + i);
  	}

  }

  static int
  xlog_calc_iclog_size(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog,
  	uint32_t		*roundoff)
  {
  	uint32_t		count_init, count;
  	bool			use_lsunit;
  
  	use_lsunit = xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
  			log->l_mp->m_sb.sb_logsunit > 1;
  
  	/* Add for LR header */
  	count_init = log->l_iclog_hsize + iclog->ic_offset;
  
  	/* Round out the log write size */
  	if (use_lsunit) {
  		/* we have a v2 stripe unit to use */
  		count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init));
  	} else {
  		count = BBTOB(BTOBB(count_init));
  	}
  
  	ASSERT(count >= count_init);
  	*roundoff = count - count_init;
  
  	if (use_lsunit)
  		ASSERT(*roundoff < log->l_mp->m_sb.sb_logsunit);
  	else
  		ASSERT(*roundoff < BBTOB(1));
  	return count;
  }

  /*

   * 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

   * xlog_write_iclog knows about the fact that the log may not start with
   * block zero on a given device.

   */

  STATIC void

  xlog_sync(
  	struct xlog		*log,
  	struct xlog_in_core	*iclog)

  {

  	unsigned int		count;		/* byte count of bwrite */
  	unsigned int		roundoff;       /* roundoff to BB or stripe */
  	uint64_t		bno;

  	unsigned int		size;

  	bool			need_flush = true, split = false;