Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 99428ad0 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Alex Elder
Browse files

xfs: reindent xlog_write 



Reindent xlog_write to normal one tab indents and move all variable
declarations into the closest enclosing block.

Split from a bigger patch by Dave Chinner.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDave Chinner <dchinner@redhat.com>
parent b5203cd0

fs/xfs/xfs_log.c

+120 −106
Original line number Diff line number Diff line
@@ -1866,24 +1866,18 @@ xlog_write( 
	struct xlog_in_core	**commit_iclog,

	uint			flags)

{

    xlog_t	     *log = mp->m_log;

    xlog_in_core_t   *iclog = NULL;  /* ptr to current in-core log */

    xlog_op_header_t *logop_head;    /* ptr to log operation header */

    __psint_t	     ptr;	     /* copy address into data region */

    int		     len;	     /* # xlog_write() bytes 2 still copy */

    int		     index;	     /* region index currently copying */

    int		     log_offset;     /* offset (from 0) into data region */

    int		     start_rec_copy; /* # bytes to copy for start record */

    int		     partial_copy;   /* did we split a region? */

    int		     partial_copy_len;/* # bytes copied if split region */

    int		     copy_len;	     /* # bytes actually memcpy'ing */

    int		     copy_off;	     /* # bytes from entry start */

    int		     contwr;	     /* continued write of in-core log? */

	struct log		*log = mp->m_log;

	struct xlog_in_core	*iclog = NULL;

	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;

    int		     record_cnt = 0, data_cnt = 0;



    partial_copy_len = partial_copy = 0;

    contwr = *start_lsn = 0;

	*start_lsn = 0;



	len = xlog_write_calc_vec_length(ticket, reg, nentries);

	if (ticket->t_curr_res < len) {
@@ -1895,15 +1889,21 @@ xlog_write( 
		/* Customer configurable panic */

		xfs_cmn_err(XFS_PTAG_LOGRES, CE_ALERT, mp,

	"xfs_log_write: reservation ran out. Need to up reservation");



		/* If we did not panic, shutdown the filesystem */

		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);

#endif

    } else

	}



	ticket->t_curr_res -= len;



	for (index = 0; index < nentries; ) {

	if ((error = xlog_state_get_iclog_space(log, len, &iclog, ticket,

					       &contwr, &log_offset)))

		__psint_t	ptr;

		int		log_offset;



		error = xlog_state_get_iclog_space(log, len, &iclog, ticket,

						   &contwr, &log_offset);

		if (error)

			return error;



		ASSERT(log_offset <= iclog->ic_size - 1);
@@ -1913,52 +1913,65 @@ xlog_write( 
		if (!*start_lsn)

			*start_lsn = be64_to_cpu(iclog->ic_header.h_lsn);



	/* This loop writes out as many regions as can fit in the amount

		/*

		 * This loop writes out as many regions as can fit in the amount

		 * of space which was allocated by xlog_state_get_iclog_space().

		 */

		while (index < nentries) {

			struct xlog_op_header	*ophdr;

			int			start_rec_copy;

			int			copy_len;

			int			copy_off;



			ASSERT(reg[index].i_len % sizeof(__int32_t) == 0);

			ASSERT((__psint_t)ptr % sizeof(__int32_t) == 0);



			start_rec_copy = xlog_write_start_rec(ptr, ticket);

			if (start_rec_copy) {

				record_cnt++;

		xlog_write_adv_cnt(ptr, len, log_offset, start_rec_copy);

				xlog_write_adv_cnt(ptr, len, log_offset,

						   start_rec_copy);

			}



	    logop_head = xlog_write_setup_ophdr(log, ptr, ticket, flags);

	    if (!logop_head)

			ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);

			if (!ophdr)

				return XFS_ERROR(EIO);

	    xlog_write_adv_cnt(ptr, len, log_offset, sizeof(xlog_op_header_t));



	    len += xlog_write_setup_copy(ticket, logop_head,

			xlog_write_adv_cnt(ptr, len, log_offset,

					   sizeof(struct xlog_op_header));



			len += xlog_write_setup_copy(ticket, ophdr,

						     iclog->ic_size-log_offset,

					 reg[index].i_len, &copy_off,

					 &copy_len, &partial_copy,

						     reg[index].i_len,

						     &copy_off, &copy_len,

						     &partial_copy,

						     &partial_copy_len);

			xlog_verify_dest_ptr(log, ptr);



			/* copy region */

			ASSERT(copy_len >= 0);

	    memcpy((xfs_caddr_t)ptr, reg[index].i_addr + copy_off, copy_len);

			memcpy((xfs_caddr_t)ptr, reg[index].i_addr + copy_off,

			       copy_len);

			xlog_write_adv_cnt(ptr, len, log_offset, copy_len);



	    /* make copy_len total bytes copied, including headers */

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

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

			 * 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
@@ -1975,18 +1988,19 @@ xlog_write( 
					return 0;

				break;

			}

	} /* while (index < nentries) */

    } /* for (index = 0; index < nentries; ) */

		}

	}



	ASSERT(len == 0);



	xlog_state_finish_copy(log, iclog, record_cnt, data_cnt);

    if (commit_iclog) {

	if (!commit_iclog)

		return xlog_state_release_iclog(log, iclog);



	ASSERT(flags & XLOG_COMMIT_TRANS);

	*commit_iclog = iclog;

	return 0;

}

    return xlog_state_release_iclog(log, iclog);

}	/* xlog_write */





/*****************************************************************************