PageRenderTime 69ms CodeModel.GetById 11ms app.highlight 44ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/xfs/xfs_log.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 3753 lines | 2261 code | 440 blank | 1052 comment | 420 complexity | 0d6ab3726121eb7735de7103e0722919 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0

Large files files are truncated, but you can click here to view the full file

   1/*
   2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3 * All Rights Reserved.
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License as
   7 * published by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it would be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write the Free Software Foundation,
  16 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18#include "xfs.h"
  19#include "xfs_fs.h"
  20#include "xfs_types.h"
  21#include "xfs_bit.h"
  22#include "xfs_log.h"
  23#include "xfs_inum.h"
  24#include "xfs_trans.h"
  25#include "xfs_sb.h"
  26#include "xfs_ag.h"
  27#include "xfs_mount.h"
  28#include "xfs_error.h"
  29#include "xfs_log_priv.h"
  30#include "xfs_buf_item.h"
  31#include "xfs_bmap_btree.h"
  32#include "xfs_alloc_btree.h"
  33#include "xfs_ialloc_btree.h"
  34#include "xfs_log_recover.h"
  35#include "xfs_trans_priv.h"
  36#include "xfs_dinode.h"
  37#include "xfs_inode.h"
  38#include "xfs_rw.h"
  39#include "xfs_trace.h"
  40
  41kmem_zone_t	*xfs_log_ticket_zone;
  42
  43/* Local miscellaneous function prototypes */
  44STATIC int	 xlog_commit_record(struct log *log, struct xlog_ticket *ticket,
  45				    xlog_in_core_t **, xfs_lsn_t *);
  46STATIC xlog_t *  xlog_alloc_log(xfs_mount_t	*mp,
  47				xfs_buftarg_t	*log_target,
  48				xfs_daddr_t	blk_offset,
  49				int		num_bblks);
  50STATIC int	 xlog_space_left(struct log *log, atomic64_t *head);
  51STATIC int	 xlog_sync(xlog_t *log, xlog_in_core_t *iclog);
  52STATIC void	 xlog_dealloc_log(xlog_t *log);
  53
  54/* local state machine functions */
  55STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int);
  56STATIC void xlog_state_do_callback(xlog_t *log,int aborted, xlog_in_core_t *iclog);
  57STATIC int  xlog_state_get_iclog_space(xlog_t		*log,
  58				       int		len,
  59				       xlog_in_core_t	**iclog,
  60				       xlog_ticket_t	*ticket,
  61				       int		*continued_write,
  62				       int		*logoffsetp);
  63STATIC int  xlog_state_release_iclog(xlog_t		*log,
  64				     xlog_in_core_t	*iclog);
  65STATIC void xlog_state_switch_iclogs(xlog_t		*log,
  66				     xlog_in_core_t *iclog,
  67				     int		eventual_size);
  68STATIC void xlog_state_want_sync(xlog_t	*log, xlog_in_core_t *iclog);
  69
  70/* local functions to manipulate grant head */
  71STATIC int  xlog_grant_log_space(xlog_t		*log,
  72				 xlog_ticket_t	*xtic);
  73STATIC void xlog_grant_push_ail(struct log	*log,
  74				int		need_bytes);
  75STATIC void xlog_regrant_reserve_log_space(xlog_t	 *log,
  76					   xlog_ticket_t *ticket);
  77STATIC int xlog_regrant_write_log_space(xlog_t		*log,
  78					 xlog_ticket_t  *ticket);
  79STATIC void xlog_ungrant_log_space(xlog_t	 *log,
  80				   xlog_ticket_t *ticket);
  81
  82#if defined(DEBUG)
  83STATIC void	xlog_verify_dest_ptr(xlog_t *log, char *ptr);
  84STATIC void	xlog_verify_grant_tail(struct log *log);
  85STATIC void	xlog_verify_iclog(xlog_t *log, xlog_in_core_t *iclog,
  86				  int count, boolean_t syncing);
  87STATIC void	xlog_verify_tail_lsn(xlog_t *log, xlog_in_core_t *iclog,
  88				     xfs_lsn_t tail_lsn);
  89#else
  90#define xlog_verify_dest_ptr(a,b)
  91#define xlog_verify_grant_tail(a)
  92#define xlog_verify_iclog(a,b,c,d)
  93#define xlog_verify_tail_lsn(a,b,c)
  94#endif
  95
  96STATIC int	xlog_iclogs_empty(xlog_t *log);
  97
  98static void
  99xlog_grant_sub_space(
 100	struct log	*log,
 101	atomic64_t	*head,
 102	int		bytes)
 103{
 104	int64_t	head_val = atomic64_read(head);
 105	int64_t new, old;
 106
 107	do {
 108		int	cycle, space;
 109
 110		xlog_crack_grant_head_val(head_val, &cycle, &space);
 111
 112		space -= bytes;
 113		if (space < 0) {
 114			space += log->l_logsize;
 115			cycle--;
 116		}
 117
 118		old = head_val;
 119		new = xlog_assign_grant_head_val(cycle, space);
 120		head_val = atomic64_cmpxchg(head, old, new);
 121	} while (head_val != old);
 122}
 123
 124static void
 125xlog_grant_add_space(
 126	struct log	*log,
 127	atomic64_t	*head,
 128	int		bytes)
 129{
 130	int64_t	head_val = atomic64_read(head);
 131	int64_t new, old;
 132
 133	do {
 134		int		tmp;
 135		int		cycle, space;
 136
 137		xlog_crack_grant_head_val(head_val, &cycle, &space);
 138
 139		tmp = log->l_logsize - space;
 140		if (tmp > bytes)
 141			space += bytes;
 142		else {
 143			space = bytes - tmp;
 144			cycle++;
 145		}
 146
 147		old = head_val;
 148		new = xlog_assign_grant_head_val(cycle, space);
 149		head_val = atomic64_cmpxchg(head, old, new);
 150	} while (head_val != old);
 151}
 152
 153static void
 154xlog_tic_reset_res(xlog_ticket_t *tic)
 155{
 156	tic->t_res_num = 0;
 157	tic->t_res_arr_sum = 0;
 158	tic->t_res_num_ophdrs = 0;
 159}
 160
 161static void
 162xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type)
 163{
 164	if (tic->t_res_num == XLOG_TIC_LEN_MAX) {
 165		/* add to overflow and start again */
 166		tic->t_res_o_flow += tic->t_res_arr_sum;
 167		tic->t_res_num = 0;
 168		tic->t_res_arr_sum = 0;
 169	}
 170
 171	tic->t_res_arr[tic->t_res_num].r_len = len;
 172	tic->t_res_arr[tic->t_res_num].r_type = type;
 173	tic->t_res_arr_sum += len;
 174	tic->t_res_num++;
 175}
 176
 177/*
 178 * NOTES:
 179 *
 180 *	1. currblock field gets updated at startup and after in-core logs
 181 *		marked as with WANT_SYNC.
 182 */
 183
 184/*
 185 * This routine is called when a user of a log manager ticket is done with
 186 * the reservation.  If the ticket was ever used, then a commit record for
 187 * the associated transaction is written out as a log operation header with
 188 * no data.  The flag XLOG_TIC_INITED is set when the first write occurs with
 189 * a given ticket.  If the ticket was one with a permanent reservation, then
 190 * a few operations are done differently.  Permanent reservation tickets by
 191 * default don't release the reservation.  They just commit the current
 192 * transaction with the belief that the reservation is still needed.  A flag
 193 * must be passed in before permanent reservations are actually released.
 194 * When these type of tickets are not released, they need to be set into
 195 * the inited state again.  By doing this, a start record will be written
 196 * out when the next write occurs.
 197 */
 198xfs_lsn_t
 199xfs_log_done(
 200	struct xfs_mount	*mp,
 201	struct xlog_ticket	*ticket,
 202	struct xlog_in_core	**iclog,
 203	uint			flags)
 204{
 205	struct log		*log = mp->m_log;
 206	xfs_lsn_t		lsn = 0;
 207
 208	if (XLOG_FORCED_SHUTDOWN(log) ||
 209	    /*
 210	     * If nothing was ever written, don't write out commit record.
 211	     * If we get an error, just continue and give back the log ticket.
 212	     */
 213	    (((ticket->t_flags & XLOG_TIC_INITED) == 0) &&
 214	     (xlog_commit_record(log, ticket, iclog, &lsn)))) {
 215		lsn = (xfs_lsn_t) -1;
 216		if (ticket->t_flags & XLOG_TIC_PERM_RESERV) {
 217			flags |= XFS_LOG_REL_PERM_RESERV;
 218		}
 219	}
 220
 221
 222	if ((ticket->t_flags & XLOG_TIC_PERM_RESERV) == 0 ||
 223	    (flags & XFS_LOG_REL_PERM_RESERV)) {
 224		trace_xfs_log_done_nonperm(log, ticket);
 225
 226		/*
 227		 * Release ticket if not permanent reservation or a specific
 228		 * request has been made to release a permanent reservation.
 229		 */
 230		xlog_ungrant_log_space(log, ticket);
 231		xfs_log_ticket_put(ticket);
 232	} else {
 233		trace_xfs_log_done_perm(log, ticket);
 234
 235		xlog_regrant_reserve_log_space(log, ticket);
 236		/* If this ticket was a permanent reservation and we aren't
 237		 * trying to release it, reset the inited flags; so next time
 238		 * we write, a start record will be written out.
 239		 */
 240		ticket->t_flags |= XLOG_TIC_INITED;
 241	}
 242
 243	return lsn;
 244}
 245
 246/*
 247 * Attaches a new iclog I/O completion callback routine during
 248 * transaction commit.  If the log is in error state, a non-zero
 249 * return code is handed back and the caller is responsible for
 250 * executing the callback at an appropriate time.
 251 */
 252int
 253xfs_log_notify(
 254	struct xfs_mount	*mp,
 255	struct xlog_in_core	*iclog,
 256	xfs_log_callback_t	*cb)
 257{
 258	int	abortflg;
 259
 260	spin_lock(&iclog->ic_callback_lock);
 261	abortflg = (iclog->ic_state & XLOG_STATE_IOERROR);
 262	if (!abortflg) {
 263		ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) ||
 264			      (iclog->ic_state == XLOG_STATE_WANT_SYNC));
 265		cb->cb_next = NULL;
 266		*(iclog->ic_callback_tail) = cb;
 267		iclog->ic_callback_tail = &(cb->cb_next);
 268	}
 269	spin_unlock(&iclog->ic_callback_lock);
 270	return abortflg;
 271}
 272
 273int
 274xfs_log_release_iclog(
 275	struct xfs_mount	*mp,
 276	struct xlog_in_core	*iclog)
 277{
 278	if (xlog_state_release_iclog(mp->m_log, iclog)) {
 279		xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
 280		return EIO;
 281	}
 282
 283	return 0;
 284}
 285
 286/*
 287 *  1. Reserve an amount of on-disk log space and return a ticket corresponding
 288 *	to the reservation.
 289 *  2. Potentially, push buffers at tail of log to disk.
 290 *
 291 * Each reservation is going to reserve extra space for a log record header.
 292 * When writes happen to the on-disk log, we don't subtract the length of the
 293 * log record header from any reservation.  By wasting space in each
 294 * reservation, we prevent over allocation problems.
 295 */
 296int
 297xfs_log_reserve(
 298	struct xfs_mount	*mp,
 299	int		 	unit_bytes,
 300	int		 	cnt,
 301	struct xlog_ticket	**ticket,
 302	__uint8_t	 	client,
 303	uint		 	flags,
 304	uint		 	t_type)
 305{
 306	struct log		*log = mp->m_log;
 307	struct xlog_ticket	*internal_ticket;
 308	int			retval = 0;
 309
 310	ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);
 311
 312	if (XLOG_FORCED_SHUTDOWN(log))
 313		return XFS_ERROR(EIO);
 314
 315	XFS_STATS_INC(xs_try_logspace);
 316
 317
 318	if (*ticket != NULL) {
 319		ASSERT(flags & XFS_LOG_PERM_RESERV);
 320		internal_ticket = *ticket;
 321
 322		/*
 323		 * this is a new transaction on the ticket, so we need to
 324		 * change the transaction ID so that the next transaction has a
 325		 * different TID in the log. Just add one to the existing tid
 326		 * so that we can see chains of rolling transactions in the log
 327		 * easily.
 328		 */
 329		internal_ticket->t_tid++;
 330
 331		trace_xfs_log_reserve(log, internal_ticket);
 332
 333		xlog_grant_push_ail(log, internal_ticket->t_unit_res);
 334		retval = xlog_regrant_write_log_space(log, internal_ticket);
 335	} else {
 336		/* may sleep if need to allocate more tickets */
 337		internal_ticket = xlog_ticket_alloc(log, unit_bytes, cnt,
 338						  client, flags,
 339						  KM_SLEEP|KM_MAYFAIL);
 340		if (!internal_ticket)
 341			return XFS_ERROR(ENOMEM);
 342		internal_ticket->t_trans_type = t_type;
 343		*ticket = internal_ticket;
 344
 345		trace_xfs_log_reserve(log, internal_ticket);
 346
 347		xlog_grant_push_ail(log,
 348				    (internal_ticket->t_unit_res *
 349				     internal_ticket->t_cnt));
 350		retval = xlog_grant_log_space(log, internal_ticket);
 351	}
 352
 353	return retval;
 354}	/* xfs_log_reserve */
 355
 356
 357/*
 358 * Mount a log filesystem
 359 *
 360 * mp		- ubiquitous xfs mount point structure
 361 * log_target	- buftarg of on-disk log device
 362 * blk_offset	- Start block # where block size is 512 bytes (BBSIZE)
 363 * num_bblocks	- Number of BBSIZE blocks in on-disk log
 364 *
 365 * Return error or zero.
 366 */
 367int
 368xfs_log_mount(
 369	xfs_mount_t	*mp,
 370	xfs_buftarg_t	*log_target,
 371	xfs_daddr_t	blk_offset,
 372	int		num_bblks)
 373{
 374	int		error;
 375
 376	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY))
 377		xfs_notice(mp, "Mounting Filesystem");
 378	else {
 379		xfs_notice(mp,
 380"Mounting filesystem in no-recovery mode.  Filesystem will be inconsistent.");
 381		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
 382	}
 383
 384	mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
 385	if (IS_ERR(mp->m_log)) {
 386		error = -PTR_ERR(mp->m_log);
 387		goto out;
 388	}
 389
 390	/*
 391	 * Initialize the AIL now we have a log.
 392	 */
 393	error = xfs_trans_ail_init(mp);
 394	if (error) {
 395		xfs_warn(mp, "AIL initialisation failed: error %d", error);
 396		goto out_free_log;
 397	}
 398	mp->m_log->l_ailp = mp->m_ail;
 399
 400	/*
 401	 * skip log recovery on a norecovery mount.  pretend it all
 402	 * just worked.
 403	 */
 404	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
 405		int	readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
 406
 407		if (readonly)
 408			mp->m_flags &= ~XFS_MOUNT_RDONLY;
 409
 410		error = xlog_recover(mp->m_log);
 411
 412		if (readonly)
 413			mp->m_flags |= XFS_MOUNT_RDONLY;
 414		if (error) {
 415			xfs_warn(mp, "log mount/recovery failed: error %d",
 416				error);
 417			goto out_destroy_ail;
 418		}
 419	}
 420
 421	/* Normal transactions can now occur */
 422	mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
 423
 424	/*
 425	 * Now the log has been fully initialised and we know were our
 426	 * space grant counters are, we can initialise the permanent ticket
 427	 * needed for delayed logging to work.
 428	 */
 429	xlog_cil_init_post_recovery(mp->m_log);
 430
 431	return 0;
 432
 433out_destroy_ail:
 434	xfs_trans_ail_destroy(mp);
 435out_free_log:
 436	xlog_dealloc_log(mp->m_log);
 437out:
 438	return error;
 439}
 440
 441/*
 442 * Finish the recovery of the file system.  This is separate from
 443 * the xfs_log_mount() call, because it depends on the code in
 444 * xfs_mountfs() to read in the root and real-time bitmap inodes
 445 * between calling xfs_log_mount() and here.
 446 *
 447 * mp		- ubiquitous xfs mount point structure
 448 */
 449int
 450xfs_log_mount_finish(xfs_mount_t *mp)
 451{
 452	int	error;
 453
 454	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY))
 455		error = xlog_recover_finish(mp->m_log);
 456	else {
 457		error = 0;
 458		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
 459	}
 460
 461	return error;
 462}
 463
 464/*
 465 * Final log writes as part of unmount.
 466 *
 467 * Mark the filesystem clean as unmount happens.  Note that during relocation
 468 * this routine needs to be executed as part of source-bag while the
 469 * deallocation must not be done until source-end.
 470 */
 471
 472/*
 473 * Unmount record used to have a string "Unmount filesystem--" in the
 474 * data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE).
 475 * We just write the magic number now since that particular field isn't
 476 * currently architecture converted and "nUmount" is a bit foo.
 477 * As far as I know, there weren't any dependencies on the old behaviour.
 478 */
 479
 480int
 481xfs_log_unmount_write(xfs_mount_t *mp)
 482{
 483	xlog_t		 *log = mp->m_log;
 484	xlog_in_core_t	 *iclog;
 485#ifdef DEBUG
 486	xlog_in_core_t	 *first_iclog;
 487#endif
 488	xlog_ticket_t	*tic = NULL;
 489	xfs_lsn_t	 lsn;
 490	int		 error;
 491
 492	/*
 493	 * Don't write out unmount record on read-only mounts.
 494	 * Or, if we are doing a forced umount (typically because of IO errors).
 495	 */
 496	if (mp->m_flags & XFS_MOUNT_RDONLY)
 497		return 0;
 498
 499	error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
 500	ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log)));
 501
 502#ifdef DEBUG
 503	first_iclog = iclog = log->l_iclog;
 504	do {
 505		if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
 506			ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE);
 507			ASSERT(iclog->ic_offset == 0);
 508		}
 509		iclog = iclog->ic_next;
 510	} while (iclog != first_iclog);
 511#endif
 512	if (! (XLOG_FORCED_SHUTDOWN(log))) {
 513		error = xfs_log_reserve(mp, 600, 1, &tic,
 514					XFS_LOG, 0, XLOG_UNMOUNT_REC_TYPE);
 515		if (!error) {
 516			/* the data section must be 32 bit size aligned */
 517			struct {
 518			    __uint16_t magic;
 519			    __uint16_t pad1;
 520			    __uint32_t pad2; /* may as well make it 64 bits */
 521			} magic = {
 522				.magic = XLOG_UNMOUNT_TYPE,
 523			};
 524			struct xfs_log_iovec reg = {
 525				.i_addr = &magic,
 526				.i_len = sizeof(magic),
 527				.i_type = XLOG_REG_TYPE_UNMOUNT,
 528			};
 529			struct xfs_log_vec vec = {
 530				.lv_niovecs = 1,
 531				.lv_iovecp = &reg,
 532			};
 533
 534			/* remove inited flag */
 535			tic->t_flags = 0;
 536			error = xlog_write(log, &vec, tic, &lsn,
 537					   NULL, XLOG_UNMOUNT_TRANS);
 538			/*
 539			 * At this point, we're umounting anyway,
 540			 * so there's no point in transitioning log state
 541			 * to IOERROR. Just continue...
 542			 */
 543		}
 544
 545		if (error)
 546			xfs_alert(mp, "%s: unmount record failed", __func__);
 547
 548
 549		spin_lock(&log->l_icloglock);
 550		iclog = log->l_iclog;
 551		atomic_inc(&iclog->ic_refcnt);
 552		xlog_state_want_sync(log, iclog);
 553		spin_unlock(&log->l_icloglock);
 554		error = xlog_state_release_iclog(log, iclog);
 555
 556		spin_lock(&log->l_icloglock);
 557		if (!(iclog->ic_state == XLOG_STATE_ACTIVE ||
 558		      iclog->ic_state == XLOG_STATE_DIRTY)) {
 559			if (!XLOG_FORCED_SHUTDOWN(log)) {
 560				xlog_wait(&iclog->ic_force_wait,
 561							&log->l_icloglock);
 562			} else {
 563				spin_unlock(&log->l_icloglock);
 564			}
 565		} else {
 566			spin_unlock(&log->l_icloglock);
 567		}
 568		if (tic) {
 569			trace_xfs_log_umount_write(log, tic);
 570			xlog_ungrant_log_space(log, tic);
 571			xfs_log_ticket_put(tic);
 572		}
 573	} else {
 574		/*
 575		 * We're already in forced_shutdown mode, couldn't
 576		 * even attempt to write out the unmount transaction.
 577		 *
 578		 * Go through the motions of sync'ing and releasing
 579		 * the iclog, even though no I/O will actually happen,
 580		 * we need to wait for other log I/Os that may already
 581		 * be in progress.  Do this as a separate section of
 582		 * code so we'll know if we ever get stuck here that
 583		 * we're in this odd situation of trying to unmount
 584		 * a file system that went into forced_shutdown as
 585		 * the result of an unmount..
 586		 */
 587		spin_lock(&log->l_icloglock);
 588		iclog = log->l_iclog;
 589		atomic_inc(&iclog->ic_refcnt);
 590
 591		xlog_state_want_sync(log, iclog);
 592		spin_unlock(&log->l_icloglock);
 593		error =  xlog_state_release_iclog(log, iclog);
 594
 595		spin_lock(&log->l_icloglock);
 596
 597		if ( ! (   iclog->ic_state == XLOG_STATE_ACTIVE
 598			|| iclog->ic_state == XLOG_STATE_DIRTY
 599			|| iclog->ic_state == XLOG_STATE_IOERROR) ) {
 600
 601				xlog_wait(&iclog->ic_force_wait,
 602							&log->l_icloglock);
 603		} else {
 604			spin_unlock(&log->l_icloglock);
 605		}
 606	}
 607
 608	return error;
 609}	/* xfs_log_unmount_write */
 610
 611/*
 612 * Deallocate log structures for unmount/relocation.
 613 *
 614 * We need to stop the aild from running before we destroy
 615 * and deallocate the log as the aild references the log.
 616 */
 617void
 618xfs_log_unmount(xfs_mount_t *mp)
 619{
 620	xfs_trans_ail_destroy(mp);
 621	xlog_dealloc_log(mp->m_log);
 622}
 623
 624void
 625xfs_log_item_init(
 626	struct xfs_mount	*mp,
 627	struct xfs_log_item	*item,
 628	int			type,
 629	struct xfs_item_ops	*ops)
 630{
 631	item->li_mountp = mp;
 632	item->li_ailp = mp->m_ail;
 633	item->li_type = type;
 634	item->li_ops = ops;
 635	item->li_lv = NULL;
 636
 637	INIT_LIST_HEAD(&item->li_ail);
 638	INIT_LIST_HEAD(&item->li_cil);
 639}
 640
 641/*
 642 * Write region vectors to log.  The write happens using the space reservation
 643 * of the ticket (tic).  It is not a requirement that all writes for a given
 644 * transaction occur with one call to xfs_log_write(). However, it is important
 645 * to note that the transaction reservation code makes an assumption about the
 646 * number of log headers a transaction requires that may be violated if you
 647 * don't pass all the transaction vectors in one call....
 648 */
 649int
 650xfs_log_write(
 651	struct xfs_mount	*mp,
 652	struct xfs_log_iovec	reg[],
 653	int			nentries,
 654	struct xlog_ticket	*tic,
 655	xfs_lsn_t		*start_lsn)
 656{
 657	struct log		*log = mp->m_log;
 658	int			error;
 659	struct xfs_log_vec	vec = {
 660		.lv_niovecs = nentries,
 661		.lv_iovecp = reg,
 662	};
 663
 664	if (XLOG_FORCED_SHUTDOWN(log))
 665		return XFS_ERROR(EIO);
 666
 667	error = xlog_write(log, &vec, tic, start_lsn, NULL, 0);
 668	if (error)
 669		xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
 670	return error;
 671}
 672
 673void
 674xfs_log_move_tail(xfs_mount_t	*mp,
 675		  xfs_lsn_t	tail_lsn)
 676{
 677	xlog_ticket_t	*tic;
 678	xlog_t		*log = mp->m_log;
 679	int		need_bytes, free_bytes;
 680
 681	if (XLOG_FORCED_SHUTDOWN(log))
 682		return;
 683
 684	if (tail_lsn == 0)
 685		tail_lsn = atomic64_read(&log->l_last_sync_lsn);
 686
 687	/* tail_lsn == 1 implies that we weren't passed a valid value.  */
 688	if (tail_lsn != 1)
 689		atomic64_set(&log->l_tail_lsn, tail_lsn);
 690
 691	if (!list_empty_careful(&log->l_writeq)) {
 692#ifdef DEBUG
 693		if (log->l_flags & XLOG_ACTIVE_RECOVERY)
 694			panic("Recovery problem");
 695#endif
 696		spin_lock(&log->l_grant_write_lock);
 697		free_bytes = xlog_space_left(log, &log->l_grant_write_head);
 698		list_for_each_entry(tic, &log->l_writeq, t_queue) {
 699			ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV);
 700
 701			if (free_bytes < tic->t_unit_res && tail_lsn != 1)
 702				break;
 703			tail_lsn = 0;
 704			free_bytes -= tic->t_unit_res;
 705			trace_xfs_log_regrant_write_wake_up(log, tic);
 706			wake_up(&tic->t_wait);
 707		}
 708		spin_unlock(&log->l_grant_write_lock);
 709	}
 710
 711	if (!list_empty_careful(&log->l_reserveq)) {
 712#ifdef DEBUG
 713		if (log->l_flags & XLOG_ACTIVE_RECOVERY)
 714			panic("Recovery problem");
 715#endif
 716		spin_lock(&log->l_grant_reserve_lock);
 717		free_bytes = xlog_space_left(log, &log->l_grant_reserve_head);
 718		list_for_each_entry(tic, &log->l_reserveq, t_queue) {
 719			if (tic->t_flags & XLOG_TIC_PERM_RESERV)
 720				need_bytes = tic->t_unit_res*tic->t_cnt;
 721			else
 722				need_bytes = tic->t_unit_res;
 723			if (free_bytes < need_bytes && tail_lsn != 1)
 724				break;
 725			tail_lsn = 0;
 726			free_bytes -= need_bytes;
 727			trace_xfs_log_grant_wake_up(log, tic);
 728			wake_up(&tic->t_wait);
 729		}
 730		spin_unlock(&log->l_grant_reserve_lock);
 731	}
 732}
 733
 734/*
 735 * Determine if we have a transaction that has gone to disk
 736 * that needs to be covered. To begin the transition to the idle state
 737 * firstly the log needs to be idle (no AIL and nothing in the iclogs).
 738 * If we are then in a state where covering is needed, the caller is informed
 739 * that dummy transactions are required to move the log into the idle state.
 740 *
 741 * Because this is called as part of the sync process, we should also indicate
 742 * that dummy transactions should be issued in anything but the covered or
 743 * idle states. This ensures that the log tail is accurately reflected in
 744 * the log at the end of the sync, hence if a crash occurrs avoids replay
 745 * of transactions where the metadata is already on disk.
 746 */
 747int
 748xfs_log_need_covered(xfs_mount_t *mp)
 749{
 750	int		needed = 0;
 751	xlog_t		*log = mp->m_log;
 752
 753	if (!xfs_fs_writable(mp))
 754		return 0;
 755
 756	spin_lock(&log->l_icloglock);
 757	switch (log->l_covered_state) {
 758	case XLOG_STATE_COVER_DONE:
 759	case XLOG_STATE_COVER_DONE2:
 760	case XLOG_STATE_COVER_IDLE:
 761		break;
 762	case XLOG_STATE_COVER_NEED:
 763	case XLOG_STATE_COVER_NEED2:
 764		if (!xfs_ail_min_lsn(log->l_ailp) &&
 765		    xlog_iclogs_empty(log)) {
 766			if (log->l_covered_state == XLOG_STATE_COVER_NEED)
 767				log->l_covered_state = XLOG_STATE_COVER_DONE;
 768			else
 769				log->l_covered_state = XLOG_STATE_COVER_DONE2;
 770		}
 771		/* FALLTHRU */
 772	default:
 773		needed = 1;
 774		break;
 775	}
 776	spin_unlock(&log->l_icloglock);
 777	return needed;
 778}
 779
 780/******************************************************************************
 781 *
 782 *	local routines
 783 *
 784 ******************************************************************************
 785 */
 786
 787/* xfs_trans_tail_ail returns 0 when there is nothing in the list.
 788 * The log manager must keep track of the last LR which was committed
 789 * to disk.  The lsn of this LR will become the new tail_lsn whenever
 790 * xfs_trans_tail_ail returns 0.  If we don't do this, we run into
 791 * the situation where stuff could be written into the log but nothing
 792 * was ever in the AIL when asked.  Eventually, we panic since the
 793 * tail hits the head.
 794 *
 795 * We may be holding the log iclog lock upon entering this routine.
 796 */
 797xfs_lsn_t
 798xlog_assign_tail_lsn(
 799	struct xfs_mount	*mp)
 800{
 801	xfs_lsn_t		tail_lsn;
 802	struct log		*log = mp->m_log;
 803
 804	tail_lsn = xfs_ail_min_lsn(mp->m_ail);
 805	if (!tail_lsn)
 806		tail_lsn = atomic64_read(&log->l_last_sync_lsn);
 807
 808	atomic64_set(&log->l_tail_lsn, tail_lsn);
 809	return tail_lsn;
 810}
 811
 812/*
 813 * Return the space in the log between the tail and the head.  The head
 814 * is passed in the cycle/bytes formal parms.  In the special case where
 815 * the reserve head has wrapped passed the tail, this calculation is no
 816 * longer valid.  In this case, just return 0 which means there is no space
 817 * in the log.  This works for all places where this function is called
 818 * with the reserve head.  Of course, if the write head were to ever
 819 * wrap the tail, we should blow up.  Rather than catch this case here,
 820 * we depend on other ASSERTions in other parts of the code.   XXXmiken
 821 *
 822 * This code also handles the case where the reservation head is behind
 823 * the tail.  The details of this case are described below, but the end
 824 * result is that we return the size of the log as the amount of space left.
 825 */
 826STATIC int
 827xlog_space_left(
 828	struct log	*log,
 829	atomic64_t	*head)
 830{
 831	int		free_bytes;
 832	int		tail_bytes;
 833	int		tail_cycle;
 834	int		head_cycle;
 835	int		head_bytes;
 836
 837	xlog_crack_grant_head(head, &head_cycle, &head_bytes);
 838	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);
 839	tail_bytes = BBTOB(tail_bytes);
 840	if (tail_cycle == head_cycle && head_bytes >= tail_bytes)
 841		free_bytes = log->l_logsize - (head_bytes - tail_bytes);
 842	else if (tail_cycle + 1 < head_cycle)
 843		return 0;
 844	else if (tail_cycle < head_cycle) {
 845		ASSERT(tail_cycle == (head_cycle - 1));
 846		free_bytes = tail_bytes - head_bytes;
 847	} else {
 848		/*
 849		 * The reservation head is behind the tail.
 850		 * In this case we just want to return the size of the
 851		 * log as the amount of space left.
 852		 */
 853		xfs_alert(log->l_mp,
 854			"xlog_space_left: head behind tail\n"
 855			"  tail_cycle = %d, tail_bytes = %d\n"
 856			"  GH   cycle = %d, GH   bytes = %d",
 857			tail_cycle, tail_bytes, head_cycle, head_bytes);
 858		ASSERT(0);
 859		free_bytes = log->l_logsize;
 860	}
 861	return free_bytes;
 862}
 863
 864
 865/*
 866 * Log function which is called when an io completes.
 867 *
 868 * The log manager needs its own routine, in order to control what
 869 * happens with the buffer after the write completes.
 870 */
 871void
 872xlog_iodone(xfs_buf_t *bp)
 873{
 874	xlog_in_core_t	*iclog = bp->b_fspriv;
 875	xlog_t		*l = iclog->ic_log;
 876	int		aborted = 0;
 877
 878	/*
 879	 * Race to shutdown the filesystem if we see an error.
 880	 */
 881	if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp,
 882			XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) {
 883		xfs_ioerror_alert("xlog_iodone", l->l_mp, bp, XFS_BUF_ADDR(bp));
 884		XFS_BUF_STALE(bp);
 885		xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
 886		/*
 887		 * This flag will be propagated to the trans-committed
 888		 * callback routines to let them know that the log-commit
 889		 * didn't succeed.
 890		 */
 891		aborted = XFS_LI_ABORTED;
 892	} else if (iclog->ic_state & XLOG_STATE_IOERROR) {
 893		aborted = XFS_LI_ABORTED;
 894	}
 895
 896	/* log I/O is always issued ASYNC */
 897	ASSERT(XFS_BUF_ISASYNC(bp));
 898	xlog_state_done_syncing(iclog, aborted);
 899	/*
 900	 * do not reference the buffer (bp) here as we could race
 901	 * with it being freed after writing the unmount record to the
 902	 * log.
 903	 */
 904
 905}	/* xlog_iodone */
 906
 907/*
 908 * Return size of each in-core log record buffer.
 909 *
 910 * All machines get 8 x 32kB buffers by default, unless tuned otherwise.
 911 *
 912 * If the filesystem blocksize is too large, we may need to choose a
 913 * larger size since the directory code currently logs entire blocks.
 914 */
 915
 916STATIC void
 917xlog_get_iclog_buffer_size(xfs_mount_t	*mp,
 918			   xlog_t	*log)
 919{
 920	int size;
 921	int xhdrs;
 922
 923	if (mp->m_logbufs <= 0)
 924		log->l_iclog_bufs = XLOG_MAX_ICLOGS;
 925	else
 926		log->l_iclog_bufs = mp->m_logbufs;
 927
 928	/*
 929	 * Buffer size passed in from mount system call.
 930	 */
 931	if (mp->m_logbsize > 0) {
 932		size = log->l_iclog_size = mp->m_logbsize;
 933		log->l_iclog_size_log = 0;
 934		while (size != 1) {
 935			log->l_iclog_size_log++;
 936			size >>= 1;
 937		}
 938
 939		if (xfs_sb_version_haslogv2(&mp->m_sb)) {
 940			/* # headers = size / 32k
 941			 * one header holds cycles from 32k of data
 942			 */
 943
 944			xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE;
 945			if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE)
 946				xhdrs++;
 947			log->l_iclog_hsize = xhdrs << BBSHIFT;
 948			log->l_iclog_heads = xhdrs;
 949		} else {
 950			ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE);
 951			log->l_iclog_hsize = BBSIZE;
 952			log->l_iclog_heads = 1;
 953		}
 954		goto done;
 955	}
 956
 957	/* All machines use 32kB buffers by default. */
 958	log->l_iclog_size = XLOG_BIG_RECORD_BSIZE;
 959	log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT;
 960
 961	/* the default log size is 16k or 32k which is one header sector */
 962	log->l_iclog_hsize = BBSIZE;
 963	log->l_iclog_heads = 1;
 964
 965done:
 966	/* are we being asked to make the sizes selected above visible? */
 967	if (mp->m_logbufs == 0)
 968		mp->m_logbufs = log->l_iclog_bufs;
 969	if (mp->m_logbsize == 0)
 970		mp->m_logbsize = log->l_iclog_size;
 971}	/* xlog_get_iclog_buffer_size */
 972
 973
 974/*
 975 * This routine initializes some of the log structure for a given mount point.
 976 * Its primary purpose is to fill in enough, so recovery can occur.  However,
 977 * some other stuff may be filled in too.
 978 */
 979STATIC xlog_t *
 980xlog_alloc_log(xfs_mount_t	*mp,
 981	       xfs_buftarg_t	*log_target,
 982	       xfs_daddr_t	blk_offset,
 983	       int		num_bblks)
 984{
 985	xlog_t			*log;
 986	xlog_rec_header_t	*head;
 987	xlog_in_core_t		**iclogp;
 988	xlog_in_core_t		*iclog, *prev_iclog=NULL;
 989	xfs_buf_t		*bp;
 990	int			i;
 991	int			error = ENOMEM;
 992	uint			log2_size = 0;
 993
 994	log = kmem_zalloc(sizeof(xlog_t), KM_MAYFAIL);
 995	if (!log) {
 996		xfs_warn(mp, "Log allocation failed: No memory!");
 997		goto out;
 998	}
 999
1000	log->l_mp	   = mp;
1001	log->l_targ	   = log_target;
1002	log->l_logsize     = BBTOB(num_bblks);
1003	log->l_logBBstart  = blk_offset;
1004	log->l_logBBsize   = num_bblks;
1005	log->l_covered_state = XLOG_STATE_COVER_IDLE;
1006	log->l_flags	   |= XLOG_ACTIVE_RECOVERY;
1007
1008	log->l_prev_block  = -1;
1009	/* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */
1010	xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0);
1011	xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0);
1012	log->l_curr_cycle  = 1;	    /* 0 is bad since this is initial value */
1013	xlog_assign_grant_head(&log->l_grant_reserve_head, 1, 0);
1014	xlog_assign_grant_head(&log->l_grant_write_head, 1, 0);
1015	INIT_LIST_HEAD(&log->l_reserveq);
1016	INIT_LIST_HEAD(&log->l_writeq);
1017	spin_lock_init(&log->l_grant_reserve_lock);
1018	spin_lock_init(&log->l_grant_write_lock);
1019
1020	error = EFSCORRUPTED;
1021	if (xfs_sb_version_hassector(&mp->m_sb)) {
1022	        log2_size = mp->m_sb.sb_logsectlog;
1023		if (log2_size < BBSHIFT) {
1024			xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)",
1025				log2_size, BBSHIFT);
1026			goto out_free_log;
1027		}
1028
1029	        log2_size -= BBSHIFT;
1030		if (log2_size > mp->m_sectbb_log) {
1031			xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)",
1032				log2_size, mp->m_sectbb_log);
1033			goto out_free_log;
1034		}
1035
1036		/* for larger sector sizes, must have v2 or external log */
1037		if (log2_size && log->l_logBBstart > 0 &&
1038			    !xfs_sb_version_haslogv2(&mp->m_sb)) {
1039			xfs_warn(mp,
1040		"log sector size (0x%x) invalid for configuration.",
1041				log2_size);
1042			goto out_free_log;
1043		}
1044	}
1045	log->l_sectBBsize = 1 << log2_size;
1046
1047	xlog_get_iclog_buffer_size(mp, log);
1048
1049	error = ENOMEM;
1050	bp = xfs_buf_get_empty(log->l_iclog_size, mp->m_logdev_targp);
1051	if (!bp)
1052		goto out_free_log;
1053	bp->b_iodone = xlog_iodone;
1054	ASSERT(xfs_buf_islocked(bp));
1055	log->l_xbuf = bp;
1056
1057	spin_lock_init(&log->l_icloglock);
1058	init_waitqueue_head(&log->l_flush_wait);
1059
1060	/* log record size must be multiple of BBSIZE; see xlog_rec_header_t */
1061	ASSERT((XFS_BUF_SIZE(bp) & BBMASK) == 0);
1062
1063	iclogp = &log->l_iclog;
1064	/*
1065	 * The amount of memory to allocate for the iclog structure is
1066	 * rather funky due to the way the structure is defined.  It is
1067	 * done this way so that we can use different sizes for machines
1068	 * with different amounts of memory.  See the definition of
1069	 * xlog_in_core_t in xfs_log_priv.h for details.
1070	 */
1071	ASSERT(log->l_iclog_size >= 4096);
1072	for (i=0; i < log->l_iclog_bufs; i++) {
1073		*iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL);
1074		if (!*iclogp)
1075			goto out_free_iclog;
1076
1077		iclog = *iclogp;
1078		iclog->ic_prev = prev_iclog;
1079		prev_iclog = iclog;
1080
1081		bp = xfs_buf_get_uncached(mp->m_logdev_targp,
1082						log->l_iclog_size, 0);
1083		if (!bp)
1084			goto out_free_iclog;
1085
1086		bp->b_iodone = xlog_iodone;
1087		iclog->ic_bp = bp;
1088		iclog->ic_data = bp->b_addr;
1089#ifdef DEBUG
1090		log->l_iclog_bak[i] = (xfs_caddr_t)&(iclog->ic_header);
1091#endif
1092		head = &iclog->ic_header;
1093		memset(head, 0, sizeof(xlog_rec_header_t));
1094		head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1095		head->h_version = cpu_to_be32(
1096			xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1097		head->h_size = cpu_to_be32(log->l_iclog_size);
1098		/* new fields */
1099		head->h_fmt = cpu_to_be32(XLOG_FMT);
1100		memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));
1101
1102		iclog->ic_size = XFS_BUF_SIZE(bp) - log->l_iclog_hsize;
1103		iclog->ic_state = XLOG_STATE_ACTIVE;
1104		iclog->ic_log = log;
1105		atomic_set(&iclog->ic_refcnt, 0);
1106		spin_lock_init(&iclog->ic_callback_lock);
1107		iclog->ic_callback_tail = &(iclog->ic_callback);
1108		iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
1109
1110		ASSERT(xfs_buf_islocked(iclog->ic_bp));
1111		init_waitqueue_head(&iclog->ic_force_wait);
1112		init_waitqueue_head(&iclog->ic_write_wait);
1113
1114		iclogp = &iclog->ic_next;
1115	}
1116	*iclogp = log->l_iclog;			/* complete ring */
1117	log->l_iclog->ic_prev = prev_iclog;	/* re-write 1st prev ptr */
1118
1119	error = xlog_cil_init(log);
1120	if (error)
1121		goto out_free_iclog;
1122	return log;
1123
1124out_free_iclog:
1125	for (iclog = log->l_iclog; iclog; iclog = prev_iclog) {
1126		prev_iclog = iclog->ic_next;
1127		if (iclog->ic_bp)
1128			xfs_buf_free(iclog->ic_bp);
1129		kmem_free(iclog);
1130	}
1131	spinlock_destroy(&log->l_icloglock);
1132	xfs_buf_free(log->l_xbuf);
1133out_free_log:
1134	kmem_free(log);
1135out:
1136	return ERR_PTR(-error);
1137}	/* xlog_alloc_log */
1138
1139
1140/*
1141 * Write out the commit record of a transaction associated with the given
1142 * ticket.  Return the lsn of the commit record.
1143 */
1144STATIC int
1145xlog_commit_record(
1146	struct log		*log,
1147	struct xlog_ticket	*ticket,
1148	struct xlog_in_core	**iclog,
1149	xfs_lsn_t		*commitlsnp)
1150{
1151	struct xfs_mount *mp = log->l_mp;
1152	int	error;
1153	struct xfs_log_iovec reg = {
1154		.i_addr = NULL,
1155		.i_len = 0,
1156		.i_type = XLOG_REG_TYPE_COMMIT,
1157	};
1158	struct xfs_log_vec vec = {
1159		.lv_niovecs = 1,
1160		.lv_iovecp = &reg,
1161	};
1162
1163	ASSERT_ALWAYS(iclog);
1164	error = xlog_write(log, &vec, ticket, commitlsnp, iclog,
1165					XLOG_COMMIT_TRANS);
1166	if (error)
1167		xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
1168	return error;
1169}
1170
1171/*
1172 * Push on the buffer cache code if we ever use more than 75% of the on-disk
1173 * log space.  This code pushes on the lsn which would supposedly free up
1174 * the 25% which we want to leave free.  We may need to adopt a policy which
1175 * pushes on an lsn which is further along in the log once we reach the high
1176 * water mark.  In this manner, we would be creating a low water mark.
1177 */
1178STATIC void
1179xlog_grant_push_ail(
1180	struct log	*log,
1181	int		need_bytes)
1182{
1183	xfs_lsn_t	threshold_lsn = 0;
1184	xfs_lsn_t	last_sync_lsn;
1185	int		free_blocks;
1186	int		free_bytes;
1187	int		threshold_block;
1188	int		threshold_cycle;
1189	int		free_threshold;
1190
1191	ASSERT(BTOBB(need_bytes) < log->l_logBBsize);
1192
1193	free_bytes = xlog_space_left(log, &log->l_grant_reserve_head);
1194	free_blocks = BTOBBT(free_bytes);
1195
1196	/*
1197	 * Set the threshold for the minimum number of free blocks in the
1198	 * log to the maximum of what the caller needs, one quarter of the
1199	 * log, and 256 blocks.
1200	 */
1201	free_threshold = BTOBB(need_bytes);
1202	free_threshold = MAX(free_threshold, (log->l_logBBsize >> 2));
1203	free_threshold = MAX(free_threshold, 256);
1204	if (free_blocks >= free_threshold)
1205		return;
1206
1207	xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle,
1208						&threshold_block);
1209	threshold_block += free_threshold;
1210	if (threshold_block >= log->l_logBBsize) {
1211		threshold_block -= log->l_logBBsize;
1212		threshold_cycle += 1;
1213	}
1214	threshold_lsn = xlog_assign_lsn(threshold_cycle,
1215					threshold_block);
1216	/*
1217	 * Don't pass in an lsn greater than the lsn of the last
1218	 * log record known to be on disk. Use a snapshot of the last sync lsn
1219	 * so that it doesn't change between the compare and the set.
1220	 */
1221	last_sync_lsn = atomic64_read(&log->l_last_sync_lsn);
1222	if (XFS_LSN_CMP(threshold_lsn, last_sync_lsn) > 0)
1223		threshold_lsn = last_sync_lsn;
1224
1225	/*
1226	 * Get the transaction layer to kick the dirty buffers out to
1227	 * disk asynchronously. No point in trying to do this if
1228	 * the filesystem is shutting down.
1229	 */
1230	if (!XLOG_FORCED_SHUTDOWN(log))
1231		xfs_ail_push(log->l_ailp, threshold_lsn);
1232}
1233
1234/*
1235 * The bdstrat callback function for log bufs. This gives us a central
1236 * place to trap bufs in case we get hit by a log I/O error and need to
1237 * shutdown. Actually, in practice, even when we didn't get a log error,
1238 * we transition the iclogs to IOERROR state *after* flushing all existing
1239 * iclogs to disk. This is because we don't want anymore new transactions to be
1240 * started or completed afterwards.
1241 */
1242STATIC int
1243xlog_bdstrat(
1244	struct xfs_buf		*bp)
1245{
1246	struct xlog_in_core	*iclog = bp->b_fspriv;
1247
1248	if (iclog->ic_state & XLOG_STATE_IOERROR) {
1249		xfs_buf_ioerror(bp, EIO);
1250		XFS_BUF_STALE(bp);
1251		xfs_buf_ioend(bp, 0);
1252		/*
1253		 * It would seem logical to return EIO here, but we rely on
1254		 * the log state machine to propagate I/O errors instead of
1255		 * doing it here.
1256		 */
1257		return 0;
1258	}
1259
1260	xfs_buf_iorequest(bp);
1261	return 0;
1262}
1263
1264/*
1265 * Flush out the in-core log (iclog) to the on-disk log in an asynchronous 
1266 * fashion.  Previously, we should have moved the current iclog
1267 * ptr in the log to point to the next available iclog.  This allows further
1268 * write to continue while this code syncs out an iclog ready to go.
1269 * Before an in-core log can be written out, the data section must be scanned
1270 * to save away the 1st word of each BBSIZE block into the header.  We replace
1271 * it with the current cycle count.  Each BBSIZE block is tagged with the
1272 * cycle count because there in an implicit assumption that drives will
1273 * guarantee that entire 512 byte blocks get written at once.  In other words,
1274 * we can't have part of a 512 byte block written and part not written.  By
1275 * tagging each block, we will know which blocks are valid when recovering
1276 * after an unclean shutdown.
1277 *
1278 * This routine is single threaded on the iclog.  No other thread can be in
1279 * this routine with the same iclog.  Changing contents of iclog can there-
1280 * fore be done without grabbing the state machine lock.  Updating the global
1281 * log will require grabbing the lock though.
1282 *
1283 * The entire log manager uses a logical block numbering scheme.  Only
1284 * log_sync (and then only bwrite()) know about the fact that the log may
1285 * not start with block zero on a given device.  The log block start offset
1286 * is added immediately before calling bwrite().
1287 */
1288
1289STATIC int
1290xlog_sync(xlog_t		*log,
1291	  xlog_in_core_t	*iclog)
1292{
1293	xfs_caddr_t	dptr;		/* pointer to byte sized element */
1294	xfs_buf_t	*bp;
1295	int		i;
1296	uint		count;		/* byte count of bwrite */
1297	uint		count_init;	/* initial count before roundup */
1298	int		roundoff;       /* roundoff to BB or stripe */
1299	int		split = 0;	/* split write into two regions */
1300	int		error;
1301	int		v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb);
1302
1303	XFS_STATS_INC(xs_log_writes);
1304	ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
1305
1306	/* Add for LR header */
1307	count_init = log->l_iclog_hsize + iclog->ic_offset;
1308
1309	/* Round out the log write size */
1310	if (v2 && log->l_mp->m_sb.sb_logsunit > 1) {
1311		/* we have a v2 stripe unit to use */
1312		count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init));
1313	} else {
1314		count = BBTOB(BTOBB(count_init));
1315	}
1316	roundoff = count - count_init;
1317	ASSERT(roundoff >= 0);
1318	ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 && 
1319                roundoff < log->l_mp->m_sb.sb_logsunit)
1320		|| 
1321		(log->l_mp->m_sb.sb_logsunit <= 1 && 
1322		 roundoff < BBTOB(1)));
1323
1324	/* move grant heads by roundoff in sync */
1325	xlog_grant_add_space(log, &log->l_grant_reserve_head, roundoff);
1326	xlog_grant_add_space(log, &log->l_grant_write_head, roundoff);
1327
1328	/* put cycle number in every block */
1329	xlog_pack_data(log, iclog, roundoff); 
1330
1331	/* real byte length */
1332	if (v2) {
1333		iclog->ic_header.h_len =
1334			cpu_to_be32(iclog->ic_offset + roundoff);
1335	} else {
1336		iclog->ic_header.h_len =
1337			cpu_to_be32(iclog->ic_offset);
1338	}
1339
1340	bp = iclog->ic_bp;
1341	XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)));
1342
1343	XFS_STATS_ADD(xs_log_blocks, BTOBB(count));
1344
1345	/* Do we need to split this write into 2 parts? */
1346	if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) {
1347		split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)));
1348		count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp));
1349		iclog->ic_bwritecnt = 2;	/* split into 2 writes */
1350	} else {
1351		iclog->ic_bwritecnt = 1;
1352	}
1353	XFS_BUF_SET_COUNT(bp, count);
1354	bp->b_fspriv = iclog;
1355	XFS_BUF_ZEROFLAGS(bp);
1356	XFS_BUF_ASYNC(bp);
1357	bp->b_flags |= XBF_SYNCIO;
1358
1359	if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) {
1360		bp->b_flags |= XBF_FUA;
1361
1362		/*
1363		 * Flush the data device before flushing the log to make
1364		 * sure all meta data written back from the AIL actually made
1365		 * it to disk before stamping the new log tail LSN into the
1366		 * log buffer.  For an external log we need to issue the
1367		 * flush explicitly, and unfortunately synchronously here;
1368		 * for an internal log we can simply use the block layer
1369		 * state machine for preflushes.
1370		 */
1371		if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
1372			xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
1373		else
1374			bp->b_flags |= XBF_FLUSH;
1375	}
1376
1377	ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1378	ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1379
1380	xlog_verify_iclog(log, iclog, count, B_TRUE);
1381
1382	/* account for log which doesn't start at block #0 */
1383	XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1384	/*
1385	 * Don't call xfs_bwrite here. We do log-syncs even when the filesystem
1386	 * is shutting down.
1387	 */
1388	XFS_BUF_WRITE(bp);
1389
1390	if ((error = xlog_bdstrat(bp))) {
1391		xfs_ioerror_alert("xlog_sync", log->l_mp, bp,
1392				  XFS_BUF_ADDR(bp));
1393		return error;
1394	}
1395	if (split) {
1396		bp = iclog->ic_log->l_xbuf;
1397		XFS_BUF_SET_ADDR(bp, 0);	     /* logical 0 */
1398		xfs_buf_associate_memory(bp,
1399				(char *)&iclog->ic_header + count, split);
1400		bp->b_fspriv = iclog;
1401		XFS_BUF_ZEROFLAGS(bp);
1402		XFS_BUF_ASYNC(bp);
1403		bp->b_flags |= XBF_SYNCIO;
1404		if (log->l_mp->m_flags & XFS_MOUNT_BARRIER)
1405			bp->b_flags |= XBF_FUA;
1406		dptr = bp->b_addr;
1407		/*
1408		 * Bump the cycle numbers at the start of each block
1409		 * since this part of the buffer is at the start of
1410		 * a new cycle.  Watch out for the header magic number
1411		 * case, though.
1412		 */
1413		for (i = 0; i < split; i += BBSIZE) {
1414			be32_add_cpu((__be32 *)dptr, 1);
1415			if (be32_to_cpu(*(__be32 *)dptr) == XLOG_HEADER_MAGIC_NUM)
1416				be32_add_cpu((__be32 *)dptr, 1);
1417			dptr += BBSIZE;
1418		}
1419
1420		ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
1421		ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);
1422
1423		/* account for internal log which doesn't start at block #0 */
1424		XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1425		XFS_BUF_WRITE(bp);
1426		if ((error = xlog_bdstrat(bp))) {
1427			xfs_ioerror_alert("xlog_sync (split)", log->l_mp,
1428					  bp, XFS_BUF_ADDR(bp));
1429			return error;
1430		}
1431	}
1432	return 0;
1433}	/* xlog_sync */
1434
1435
1436/*
1437 * Deallocate a log structure
1438 */
1439STATIC void
1440xlog_dealloc_log(xlog_t *log)
1441{
1442	xlog_in_core_t	*iclog, *next_iclog;
1443	int		i;
1444
1445	xlog_cil_destroy(log);
1446
1447	/*
1448	 * always need to ensure that the extra buffer does not point to memory
1449	 * owned by another log buffer before we free it.
1450	 */
1451	xfs_buf_set_empty(log->l_xbuf, log->l_iclog_size);
1452	xfs_buf_free(log->l_xbuf);
1453
1454	iclog = log->l_iclog;
1455	for (i=0; i<log->l_iclog_bufs; i++) {
1456		xfs_buf_free(iclog->ic_bp);
1457		next_iclog = iclog->ic_next;
1458		kmem_free(iclog);
1459		iclog = next_iclog;
1460	}
1461	spinlock_destroy(&log->l_icloglock);
1462
1463	log->l_mp->m_log = NULL;
1464	kmem_free(log);
1465}	/* xlog_dealloc_log */
1466
1467/*
1468 * Update counters atomically now that memcpy is done.
1469 */
1470/* ARGSUSED */
1471static inline void
1472xlog_state_finish_copy(xlog_t		*log,
1473		       xlog_in_core_t	*iclog,
1474		       int		record_cnt,
1475		       int		copy_bytes)
1476{
1477	spin_lock(&log->l_icloglock);
1478
1479	be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt);
1480	iclog->ic_offset += copy_bytes;
1481
1482	spin_unlock(&log->l_icloglock);
1483}	/* xlog_state_finish_copy */
1484
1485
1486
1487
1488/*
1489 * print out info relating to regions written which consume
1490 * the reservation
1491 */
1492void
1493xlog_print_tic_res(
1494	struct xfs_mount	*mp,
1495	struct xlog_ticket	*ticket)
1496{
1497	uint i;
1498	uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t);
1499
1500	/* match with XLOG_REG_TYPE_* in xfs_log.h */
1501	static char *res_type_str[XLOG_REG_TYPE_MAX] = {
1502	    "bformat",
1503	    "bchunk",
1504	    "efi_format",
1505	    "efd_format",
1506	    "iformat",
1507	    "icore",
1508	    "iext",
1509	    "ibroot",
1510	    "ilocal",
1511	    "iattr_ext",
1512	    "iattr_broot",
1513	    "iattr_local",
1514	    "qformat",
1515	    "dquot",
1516	    "quotaoff",
1517	    "LR header",
1518	    "unmount",
1519	    "commit",
1520	    "trans header"
1521	};
1522	static char *trans_type_str[XFS_TRANS_TYPE_MAX] = {
1523	    "SETATTR_NOT_SIZE",
1524	    "SETATTR_SIZE",
1525	    "INACTIVE",
1526	    "CREATE",
1527	    "CREATE_TRUNC",
1528	    "TRUNCATE_FILE",
1529	    "REMOVE",
1530	    "LINK",
1531	    "RENAME",
1532	    "MKDIR",
1533	    "RMDIR",
1534	    "SYMLINK",
1535	    "SET_DMATTRS",
1536	    "GROWFS",
1537	    "STRAT_WRITE",
1538	    "DIOSTRAT",
1539	    "WRITE_SYNC",
1540	    "WRITEID",
1541	    "ADDAFORK",
1542	    "ATTRINVAL",
1543	    "ATRUNCATE",
1544	    "ATTR_SET",
1545	    "ATTR_RM",
1546	    "ATTR_FLAG",
1547	    "CLEAR_AGI_BUCKET",
1548	    "QM_SBCHANGE",
1549	    "DUMMY1",
1550	    "DUMMY2",
1551	    "QM_QUOTAOFF",
1552	    "QM_DQALLOC",
1553	    "QM_SETQLIM",
1554	    "QM_DQCLUSTER",
1555	    "QM_QINOCREATE",
1556	    "QM_QUOTAOFF_END",
1557	    "SB_UNIT",
1558	    "FSYNC_TS",
1559	    "GROWFSRT_ALLOC",
1560	    "GROWFSRT_ZERO",
1561	    "GROWFSRT_FREE",
1562	    "SWAPEXT"
1563	};
1564
1565	xfs_warn(mp,
1566		"xfs_log_write: reservation summary:\n"
1567		"  trans type  = %s (%u)\n"
1568		"  unit res    = %d bytes\n"
1569		"  current res = %d bytes\n"
1570		"  total reg   = %u bytes (o/flow = %u bytes)\n"
1571		"  ophdrs      = %u (ophdr space = %u bytes)\n"
1572		"  ophdr + reg = %u bytes\n"
1573		"  num regions = %u\n",
1574		((ticket->t_trans_type <= 0 ||
1575		  ticket->t_trans_type > XFS_TRANS_TYPE_MAX) ?
1576		  "bad-trans-type" : trans_type_str[ticket->t_trans_type-1]),
1577		ticket->t_trans_type,
1578		ticket->t_unit_res,
1579		ticket->t_curr_res,
1580		ticket->t_res_arr_sum, ticket->t_res_o_flow,
1581		ticket->t_res_num_ophdrs, ophdr_spc,
1582		ticket->t_res_arr_sum +
1583		ticket->t_res_o_flow + ophdr_spc,
1584		ticket->t_res_num);
1585
1586	for (i = 0; i < ticket->t_res_num; i++) {
1587		uint r_type = ticket->t_res_arr[i].r_type;
1588		xfs_warn(mp, "region[%u]: %s - %u bytes\n", i,
1589			    ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ?
1590			    "bad-rtype" : res_type_str[r_type-1]),
1591			    ticket->t_res_arr[i].r_len);
1592	}
1593
1594	xfs_alert_tag(mp, XFS_PTAG_LOGRES,
1595		"xfs_log_write: reservation ran out. Need to up reservation");
1596	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1597}
1598
1599/*
1600 * Calculate the potential space needed by the log vector.  Each region gets
1601 * its own xlog_op_header_t and may need to be double word aligned.
1602 */
1603static int
1604xlog_write_calc_vec_length(
1605	struct xlog_ticket	*ticket,
1606	struct xfs_log_vec	*log_vector)
1607{
1608	struct xfs_log_vec	*lv;
1609	int			headers = 0;
1610	int			len = 0;
1611	int			i;
1612
1613	/* acct for start rec of xact */
1614	if (ticket->t_flags & XLOG_TIC_INITED)
1615		headers++;
1616
1617	for (lv = log_vector; lv; lv = lv->lv_next) {
1618		headers += lv->lv_niovecs;
1619
1620		for (i = 0; i < lv->lv_niovecs; i++) {
1621			struct xfs_log_iovec	*vecp = &lv->lv_iovecp[i];
1622
1623			len += vecp->i_len;
1624			xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type);
1625		}
1626	}
1627
1628	ticket->t_res_num_ophdrs += headers;
1629	len += headers * sizeof(struct xlog_op_header);
1630
1631	return len;
1632}
1633
1634/*
1635 * If first write for transaction, insert start record  We can't be trying to
1636 * commit if we are inited.  We can't have any "partial_copy" if we are inited.
1637 */
1638static int
1639xlog_write_start_rec(
1640	struct xlog_op_header	*ophdr,
1641	struct xlog_ticket	*ticket)
1642{
1643	if (!(ticket->t_flags & XLOG_TIC_INITED))
1644		return 0;
1645
1646	ophdr->oh_tid	= cpu_to_be32(ticket->t_tid);
1647	ophdr->oh_clientid = ticket->t_clientid;
1648	ophdr->oh_len = 0;
1649	ophdr->oh_flags = XLOG_START_TRANS;
1650	ophdr->oh_res2 = 0;
1651
1652	ticket->t_flags &= ~XLOG_TIC_INITED;
1653
1654	return sizeof(struct xlog_op_header);
1655}
1656
1657static xlog_op_header_t *
1658xlog_write_setup_ophdr(
1659	struct log		*log,
1660	struct xlog_op_header	*ophdr,
1661	struct xlog_ticket	*ticket,
1662	uint			flags)
1663{
1664	ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
1665	ophdr->oh_clientid = ticket->t_clientid;
1666	ophdr->oh_res2 = 0;
1667
1668	/* are we copying a commit or unmount record? */
1669	ophdr->oh_flags = flags;
1670
1671	/*
1672	 * We've seen logs corrupted with bad transaction client ids.  This
1673	 * makes sure that XFS doesn't generate them on.  Turn this into an EIO
1674	 * and shut down the filesystem.
1675	 */
1676	switch (ophdr->oh_clientid)  {
1677	case XFS_TRANSACTION:
1678	case XFS_VOLUME:
1679	case XFS_LOG:
1680		break;
1681	default:
1682		xfs_warn(log->l_mp,
1683			"Bad XFS transaction clientid 0x%x in ticket 0x%p",
1684			ophdr->oh_clientid, ticket);
1685		return NULL;
1686	}
1687
1688	return ophdr;
1689}
1690
1691/*
1692 * Set up the parameters of the region copy into the log. This has
1693 * to handle region write split across multiple log buffers - this
1694 * state is kept external to this function so that this code can
1695 * can be written in an obvious, self documenting manner.
1696 */
1697static int
1698xlog_write_setup_copy(
1699	struct xlog_ticket	*ticket,
1700	struct xlog_op_header	*ophdr,
1701	int			space_available,
1702	int			space_required,
1703	int			*copy_off,
1704	int			*copy_len,
1705	int			*last_was_partial_copy,
1706	int			*bytes_consumed)
1707{
1708	int			still_to_copy;
1709
1710	still_to_copy = space_required - *bytes_consumed;
1711	*copy_off = *bytes_consumed;
1712
1713	if (still_to_copy <= space_available) {
1714		/* write of region completes here */
1715		*copy_len = still_to_copy;
1716		ophdr->oh_len = cpu_to_be32(*copy_len);
1717		if (*last_was_partial_copy)
1718			ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS);
1719		*last_was_partial_copy = 0;
1720		*bytes_consumed = 0;
1721		return 0;
1722	}
1723
1724	/* partial write of region, needs extra log op header reservation */
1725	*copy_len = space_available;
1726	ophdr->oh_len = cpu_to_be32(*copy_len);
1727	ophdr->oh_flags |= XLOG_CONTINUE_TRANS;
1728	if (*last_was_partial_copy)
1729		ophdr->oh_flags |= XLOG_WAS_CONT_TRANS;
1730	*bytes_consumed += *copy_len;
1731	(*last_was_partial_copy)++;
1732
1733	/* account for new log op header */
1734	ticket->t_curr_res -= sizeof(struct xlog_op_header);
1735	ticket->t_res_num_ophdrs++;
1736
1737	return sizeof(struct xlog_op_header);
1738}
1739
1740static int
1741xlog_write_copy_finish(
1742	struct log		*log,
1743	struct xlog_in_core	*iclog,
1744	uint			flags,
1745	int			*record_cnt,
1746	int			*data_cnt,
1747	int			*partial_copy,
1748	int			*partial_copy_len,
1749	int			log_offset,
1750	struct xlog_in_core	**commit_iclog)
1751{
1752	if (*partial_copy) {
1753		/*
1754		 * This iclog has already been marked WANT_SYNC by
1755		 * xlog_state_get_iclog_space.
1756		 */
1757		xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
1758		*record_cnt = 0;
1759		*data_cnt = 0;
1760		return xlog_state_release_iclog(log, iclog);
1761	}
1762
1763	*partial_copy = 0;
1764	*partial_copy_len = 0;
1765
1766	if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) {
1767		/* no more space in this iclog - push it. */
1768		xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
1769		*record_cnt = 0;
1770		*data_cnt = 0;
1771
1772		spin_lock(&log->l_icloglock);
1773		xlog_state_want_sync(log, iclog);
1774		spin_unlock(&log->l_icloglock);
1775
1776		if (!commit_iclog)
1777			return xlog_state_release_iclog(log, iclog);
1778		ASSERT(flags & XLOG_COMMIT_TRANS);
1779		*commit_iclog = iclog;
1780	}
1781
1782	return 0;
1783}
1784
1785/*
1786 * Write some region out to in-core log
1787 *
1788 * This will be called when writing externally provided regions or when
1789 * writing out a commit record for a given transaction.
1790 *
1791 * General algorithm:
1792 *	1. Find total length of this write.  This may include adding to the
1793 *		lengths passed in.
1794 *	2. Check whether we violate the tickets reservation.
1795 *	3. While writing to this iclog
1796 *	    A. Reserve as much space in this iclog as can get
1797 *	    B. If this is first write, save away start lsn
1798 *	    C. While writing this region:
1799 *		1. If first write of transaction, write start record
1800 *		2. Write log operation header (header per region)
1801 *		3. Find out if we can fit entire region into this iclog
1802 *		4. Potentially, verify destination memcpy ptr
1803 *		5. Memcpy (partial) region
1804 *		6. If partial copy, release iclog; otherwise, continue
1805 *			copying more regions into cu…

Large files files are truncated, but you can click here to view the full file