xfs_log.c 114 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
Linus Torvalds's avatar
Linus Torvalds committed
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
Linus Torvalds's avatar
Linus Torvalds committed
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
Linus Torvalds's avatar
Linus Torvalds committed
17 18
 */
#include "xfs.h"
19
#include "xfs_fs.h"
20
#include "xfs_shared.h"
21
#include "xfs_format.h"
22 23
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
Linus Torvalds's avatar
Linus Torvalds committed
24 25
#include "xfs_mount.h"
#include "xfs_error.h"
26 27 28
#include "xfs_trans.h"
#include "xfs_trans_priv.h"
#include "xfs_log.h"
Linus Torvalds's avatar
Linus Torvalds committed
29 30
#include "xfs_log_priv.h"
#include "xfs_log_recover.h"
31
#include "xfs_inode.h"
32
#include "xfs_trace.h"
33
#include "xfs_fsops.h"
34
#include "xfs_cksum.h"
35
#include "xfs_sysfs.h"
36
#include "xfs_sb.h"
Linus Torvalds's avatar
Linus Torvalds committed
37

38
kmem_zone_t	*xfs_log_ticket_zone;
Linus Torvalds's avatar
Linus Torvalds committed
39 40

/* Local miscellaneous function prototypes */
41 42 43 44 45 46 47
STATIC int
xlog_commit_record(
	struct xlog		*log,
	struct xlog_ticket	*ticket,
	struct xlog_in_core	**iclog,
	xfs_lsn_t		*commitlsnp);

Mark Tinguely's avatar
Mark Tinguely committed
48 49 50 51 52 53
STATIC struct xlog *
xlog_alloc_log(
	struct xfs_mount	*mp,
	struct xfs_buftarg	*log_target,
	xfs_daddr_t		blk_offset,
	int			num_bblks);
54 55 56 57
STATIC int
xlog_space_left(
	struct xlog		*log,
	atomic64_t		*head);
Mark Tinguely's avatar
Mark Tinguely committed
58 59 60 61 62 63 64
STATIC int
xlog_sync(
	struct xlog		*log,
	struct xlog_in_core	*iclog);
STATIC void
xlog_dealloc_log(
	struct xlog		*log);
Linus Torvalds's avatar
Linus Torvalds committed
65 66 67

/* local state machine functions */
STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int);
Mark Tinguely's avatar
Mark Tinguely committed
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
STATIC void
xlog_state_do_callback(
	struct xlog		*log,
	int			aborted,
	struct xlog_in_core	*iclog);
STATIC int
xlog_state_get_iclog_space(
	struct xlog		*log,
	int			len,
	struct xlog_in_core	**iclog,
	struct xlog_ticket	*ticket,
	int			*continued_write,
	int			*logoffsetp);
STATIC int
xlog_state_release_iclog(
	struct xlog		*log,
	struct xlog_in_core	*iclog);
STATIC void
xlog_state_switch_iclogs(
	struct xlog		*log,
	struct xlog_in_core	*iclog,
	int			eventual_size);
STATIC void
xlog_state_want_sync(
	struct xlog		*log,
	struct xlog_in_core	*iclog);
Linus Torvalds's avatar
Linus Torvalds committed
94

95 96
STATIC void
xlog_grant_push_ail(
Mark Tinguely's avatar
Mark Tinguely committed
97 98 99 100 101 102 103 104 105 106
	struct xlog		*log,
	int			need_bytes);
STATIC void
xlog_regrant_reserve_log_space(
	struct xlog		*log,
	struct xlog_ticket	*ticket);
STATIC void
xlog_ungrant_log_space(
	struct xlog		*log,
	struct xlog_ticket	*ticket);
Linus Torvalds's avatar
Linus Torvalds committed
107

108
#if defined(DEBUG)
Mark Tinguely's avatar
Mark Tinguely committed
109 110 111
STATIC void
xlog_verify_dest_ptr(
	struct xlog		*log,
112
	void			*ptr);
113 114
STATIC void
xlog_verify_grant_tail(
Mark Tinguely's avatar
Mark Tinguely committed
115 116 117 118 119 120
	struct xlog *log);
STATIC void
xlog_verify_iclog(
	struct xlog		*log,
	struct xlog_in_core	*iclog,
	int			count,
121
	bool                    syncing);
Mark Tinguely's avatar
Mark Tinguely committed
122 123 124 125 126
STATIC void
xlog_verify_tail_lsn(
	struct xlog		*log,
	struct xlog_in_core	*iclog,
	xfs_lsn_t		tail_lsn);
Linus Torvalds's avatar
Linus Torvalds committed
127 128
#else
#define xlog_verify_dest_ptr(a,b)
129
#define xlog_verify_grant_tail(a)
Linus Torvalds's avatar
Linus Torvalds committed
130 131 132 133
#define xlog_verify_iclog(a,b,c,d)
#define xlog_verify_tail_lsn(a,b,c)
#endif

Mark Tinguely's avatar
Mark Tinguely committed
134 135 136
STATIC int
xlog_iclogs_empty(
	struct xlog		*log);
Linus Torvalds's avatar
Linus Torvalds committed
137

138
static void
139
xlog_grant_sub_space(
140 141 142
	struct xlog		*log,
	atomic64_t		*head,
	int			bytes)
143
{
144 145
	int64_t	head_val = atomic64_read(head);
	int64_t new, old;
146

147 148
	do {
		int	cycle, space;
149

150
		xlog_crack_grant_head_val(head_val, &cycle, &space);
151

152 153 154 155 156 157 158 159 160 161
		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);
162 163 164
}

static void
165
xlog_grant_add_space(
166 167 168
	struct xlog		*log,
	atomic64_t		*head,
	int			bytes)
169
{
170 171
	int64_t	head_val = atomic64_read(head);
	int64_t new, old;
172

173 174 175
	do {
		int		tmp;
		int		cycle, space;
176

177
		xlog_crack_grant_head_val(head_val, &cycle, &space);
178

179 180 181 182 183 184 185 186 187 188 189 190
		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);
191
}
192

193 194 195 196 197 198 199 200 201
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);
}

202 203 204 205 206 207 208 209 210 211 212 213
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);
}

214 215
static inline int
xlog_ticket_reservation(
216
	struct xlog		*log,
217 218
	struct xlog_grant_head	*head,
	struct xlog_ticket	*tic)
219
{
220 221 222 223
	if (head == &log->l_write_head) {
		ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV);
		return tic->t_unit_res;
	} else {
224
		if (tic->t_flags & XLOG_TIC_PERM_RESERV)
225
			return tic->t_unit_res * tic->t_cnt;
226
		else
227
			return tic->t_unit_res;
228 229 230 231
	}
}

STATIC bool
232
xlog_grant_head_wake(
233
	struct xlog		*log,
234
	struct xlog_grant_head	*head,
235 236 237 238 239
	int			*free_bytes)
{
	struct xlog_ticket	*tic;
	int			need_bytes;

240 241
	list_for_each_entry(tic, &head->waiters, t_queue) {
		need_bytes = xlog_ticket_reservation(log, head, tic);
242 243 244
		if (*free_bytes < need_bytes)
			return false;

245 246
		*free_bytes -= need_bytes;
		trace_xfs_log_grant_wake_up(log, tic);
247
		wake_up_process(tic->t_task);
248 249 250 251 252 253
	}

	return true;
}

STATIC int
254
xlog_grant_head_wait(
255
	struct xlog		*log,
256
	struct xlog_grant_head	*head,
257
	struct xlog_ticket	*tic,
258 259
	int			need_bytes) __releases(&head->lock)
					    __acquires(&head->lock)
260
{
261
	list_add_tail(&tic->t_queue, &head->waiters);
262 263 264 265 266 267

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

268
		__set_current_state(TASK_UNINTERRUPTIBLE);
269
		spin_unlock(&head->lock);
270

271
		XFS_STATS_INC(log->l_mp, xs_sleep_logspace);
272

273 274
		trace_xfs_log_grant_sleep(log, tic);
		schedule();
275 276
		trace_xfs_log_grant_wake(log, tic);

277
		spin_lock(&head->lock);
278 279
		if (XLOG_FORCED_SHUTDOWN(log))
			goto shutdown;
280
	} while (xlog_space_left(log, &head->grant) < need_bytes);
281 282 283 284 285

	list_del_init(&tic->t_queue);
	return 0;
shutdown:
	list_del_init(&tic->t_queue);
286
	return -EIO;
287 288
}

289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
/*
 * 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(
308
	struct xlog		*log,
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
	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;
}

343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
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++;
}
366

367 368 369 370 371 372 373 374
/*
 * Replenish the byte reservation required by moving the grant write head.
 */
int
xfs_log_regrant(
	struct xfs_mount	*mp,
	struct xlog_ticket	*tic)
{
375
	struct xlog		*log = mp->m_log;
376 377 378 379
	int			need_bytes;
	int			error = 0;

	if (XLOG_FORCED_SHUTDOWN(log))
380
		return -EIO;
381

382
	XFS_STATS_INC(mp, xs_try_logspace);
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440

	/*
	 * This is a new transaction on the ticket, so we need to change the
	 * transaction ID so that the next transaction has a different TID in
	 * the log. Just add one to the existing tid so that we can see chains
	 * of rolling transactions in the log easily.
	 */
	tic->t_tid++;

	xlog_grant_push_ail(log, tic->t_unit_res);

	tic->t_curr_res = tic->t_unit_res;
	xlog_tic_reset_res(tic);

	if (tic->t_cnt > 0)
		return 0;

	trace_xfs_log_regrant(log, tic);

	error = xlog_grant_head_check(log, &log->l_write_head, tic,
				      &need_bytes);
	if (error)
		goto out_error;

	xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes);
	trace_xfs_log_regrant_exit(log, tic);
	xlog_verify_grant_tail(log);
	return 0;

out_error:
	/*
	 * If we are failing, make sure the ticket doesn't have any current
	 * reservations.  We don't want to add this back when the ticket/
	 * transaction gets cancelled.
	 */
	tic->t_curr_res = 0;
	tic->t_cnt = 0;	/* ungrant will give back unit_res * t_cnt. */
	return error;
}

/*
 * Reserve log space and return a ticket corresponding the reservation.
 *
 * Each reservation is going to reserve extra space for a log record header.
 * When writes happen to the on-disk log, we don't subtract the length of the
 * log record header from any reservation.  By wasting space in each
 * reservation, we prevent over allocation problems.
 */
int
xfs_log_reserve(
	struct xfs_mount	*mp,
	int		 	unit_bytes,
	int		 	cnt,
	struct xlog_ticket	**ticp,
	__uint8_t	 	client,
	bool			permanent,
	uint		 	t_type)
{
441
	struct xlog		*log = mp->m_log;
442 443 444 445 446 447 448
	struct xlog_ticket	*tic;
	int			need_bytes;
	int			error = 0;

	ASSERT(client == XFS_TRANSACTION || client == XFS_LOG);

	if (XLOG_FORCED_SHUTDOWN(log))
449
		return -EIO;
450

451
	XFS_STATS_INC(mp, xs_try_logspace);
452 453 454 455 456

	ASSERT(*ticp == NULL);
	tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent,
				KM_SLEEP | KM_MAYFAIL);
	if (!tic)
457
		return -ENOMEM;
458 459 460 461

	tic->t_trans_type = t_type;
	*ticp = tic;

462 463
	xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt
					    : tic->t_unit_res);
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489

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


Linus Torvalds's avatar
Linus Torvalds committed
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
/*
 * NOTES:
 *
 *	1. currblock field gets updated at startup and after in-core logs
 *		marked as with WANT_SYNC.
 */

/*
 * This routine is called when a user of a log manager ticket is done with
 * the reservation.  If the ticket was ever used, then a commit record for
 * the associated transaction is written out as a log operation header with
 * no data.  The flag XLOG_TIC_INITED is set when the first write occurs with
 * a given ticket.  If the ticket was one with a permanent reservation, then
 * a few operations are done differently.  Permanent reservation tickets by
 * default don't release the reservation.  They just commit the current
 * transaction with the belief that the reservation is still needed.  A flag
 * must be passed in before permanent reservations are actually released.
 * When these type of tickets are not released, they need to be set into
 * the inited state again.  By doing this, a start record will be written
 * out when the next write occurs.
 */
xfs_lsn_t
512 513 514 515
xfs_log_done(
	struct xfs_mount	*mp,
	struct xlog_ticket	*ticket,
	struct xlog_in_core	**iclog,
516
	bool			regrant)
Linus Torvalds's avatar
Linus Torvalds committed
517
{
518
	struct xlog		*log = mp->m_log;
519
	xfs_lsn_t		lsn = 0;
Linus Torvalds's avatar
Linus Torvalds committed
520 521 522 523 524 525 526

	if (XLOG_FORCED_SHUTDOWN(log) ||
	    /*
	     * If nothing was ever written, don't write out commit record.
	     * If we get an error, just continue and give back the log ticket.
	     */
	    (((ticket->t_flags & XLOG_TIC_INITED) == 0) &&
527
	     (xlog_commit_record(log, ticket, iclog, &lsn)))) {
Linus Torvalds's avatar
Linus Torvalds committed
528
		lsn = (xfs_lsn_t) -1;
529
		regrant = false;
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532
	}


533
	if (!regrant) {
534 535
		trace_xfs_log_done_nonperm(log, ticket);

Linus Torvalds's avatar
Linus Torvalds committed
536
		/*
537
		 * Release ticket if not permanent reservation or a specific
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540 541
		 * request has been made to release a permanent reservation.
		 */
		xlog_ungrant_log_space(log, ticket);
	} else {
542 543
		trace_xfs_log_done_perm(log, ticket);

Linus Torvalds's avatar
Linus Torvalds committed
544
		xlog_regrant_reserve_log_space(log, ticket);
545 546 547 548
		/* If this ticket was a permanent reservation and we aren't
		 * trying to release it, reset the inited flags; so next time
		 * we write, a start record will be written out.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
549
		ticket->t_flags |= XLOG_TIC_INITED;
550
	}
Linus Torvalds's avatar
Linus Torvalds committed
551

552
	xfs_log_ticket_put(ticket);
Linus Torvalds's avatar
Linus Torvalds committed
553
	return lsn;
554
}
Linus Torvalds's avatar
Linus Torvalds committed
555 556 557 558 559 560 561 562

/*
 * Attaches a new iclog I/O completion callback routine during
 * transaction commit.  If the log is in error state, a non-zero
 * return code is handed back and the caller is responsible for
 * executing the callback at an appropriate time.
 */
int
563 564 565 566
xfs_log_notify(
	struct xfs_mount	*mp,
	struct xlog_in_core	*iclog,
	xfs_log_callback_t	*cb)
Linus Torvalds's avatar
Linus Torvalds committed
567
{
Eric Sandeen's avatar
Eric Sandeen committed
568
	int	abortflg;
Linus Torvalds's avatar
Linus Torvalds committed
569

570
	spin_lock(&iclog->ic_callback_lock);
Linus Torvalds's avatar
Linus Torvalds committed
571 572 573 574 575 576 577 578
	abortflg = (iclog->ic_state & XLOG_STATE_IOERROR);
	if (!abortflg) {
		ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) ||
			      (iclog->ic_state == XLOG_STATE_WANT_SYNC));
		cb->cb_next = NULL;
		*(iclog->ic_callback_tail) = cb;
		iclog->ic_callback_tail = &(cb->cb_next);
	}
579
	spin_unlock(&iclog->ic_callback_lock);
Linus Torvalds's avatar
Linus Torvalds committed
580
	return abortflg;
581
}
Linus Torvalds's avatar
Linus Torvalds committed
582 583

int
584 585 586
xfs_log_release_iclog(
	struct xfs_mount	*mp,
	struct xlog_in_core	*iclog)
Linus Torvalds's avatar
Linus Torvalds committed
587
{
588
	if (xlog_state_release_iclog(mp->m_log, iclog)) {
589
		xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
590
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
	}

	return 0;
}

/*
 * Mount a log filesystem
 *
 * mp		- ubiquitous xfs mount point structure
 * log_target	- buftarg of on-disk log device
 * blk_offset	- Start block # where block size is 512 bytes (BBSIZE)
 * num_bblocks	- Number of BBSIZE blocks in on-disk log
 *
 * Return error or zero.
 */
int
607 608 609 610 611
xfs_log_mount(
	xfs_mount_t	*mp,
	xfs_buftarg_t	*log_target,
	xfs_daddr_t	blk_offset,
	int		num_bblks)
Linus Torvalds's avatar
Linus Torvalds committed
612
{
613 614
	int		error = 0;
	int		min_logfsbs;
615

616 617 618 619
	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
		xfs_notice(mp, "Mounting V%d Filesystem",
			   XFS_SB_VERSION_NUM(&mp->m_sb));
	} else {
620
		xfs_notice(mp,
621 622
"Mounting V%d filesystem in no-recovery mode. Filesystem will be inconsistent.",
			   XFS_SB_VERSION_NUM(&mp->m_sb));
623
		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
Linus Torvalds's avatar
Linus Torvalds committed
624 625 626
	}

	mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
627
	if (IS_ERR(mp->m_log)) {
628
		error = PTR_ERR(mp->m_log);
629 630
		goto out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
631

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
	/*
	 * 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);
652
		error = -EINVAL;
653 654 655 656
	} 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);
657
		error = -EINVAL;
658 659 660 661 662
	} 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);
663
		error = -EINVAL;
664 665 666 667 668 669 670
	}
	if (error) {
		if (xfs_sb_version_hascrc(&mp->m_sb)) {
			xfs_crit(mp, "AAIEEE! Log failed size checks. Abort!");
			ASSERT(0);
			goto out_free_log;
		}
671
		xfs_crit(mp, "Log size out of supported range.");
672
		xfs_crit(mp,
673
"Continuing onwards, but if log hangs are experienced then please report this message in the bug report.");
674 675
	}

676 677 678 679 680
	/*
	 * Initialize the AIL now we have a log.
	 */
	error = xfs_trans_ail_init(mp);
	if (error) {
681
		xfs_warn(mp, "AIL initialisation failed: error %d", error);
682
		goto out_free_log;
683
	}
684
	mp->m_log->l_ailp = mp->m_ail;
685

Linus Torvalds's avatar
Linus Torvalds committed
686 687 688 689 690
	/*
	 * skip log recovery on a norecovery mount.  pretend it all
	 * just worked.
	 */
	if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
691
		int	readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
Linus Torvalds's avatar
Linus Torvalds committed
692 693

		if (readonly)
694
			mp->m_flags &= ~XFS_MOUNT_RDONLY;
Linus Torvalds's avatar
Linus Torvalds committed
695

696
		error = xlog_recover(mp->m_log);
Linus Torvalds's avatar
Linus Torvalds committed
697 698

		if (readonly)
699
			mp->m_flags |= XFS_MOUNT_RDONLY;
Linus Torvalds's avatar
Linus Torvalds committed
700
		if (error) {
701 702
			xfs_warn(mp, "log mount/recovery failed: error %d",
				error);
703
			xlog_recover_cancel(mp->m_log);
704
			goto out_destroy_ail;
Linus Torvalds's avatar
Linus Torvalds committed
705 706 707
		}
	}

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

Linus Torvalds's avatar
Linus Torvalds committed
713 714 715
	/* Normal transactions can now occur */
	mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY;

716 717 718 719 720 721 722
	/*
	 * 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);

Linus Torvalds's avatar
Linus Torvalds committed
723
	return 0;
724 725 726 727 728

out_destroy_ail:
	xfs_trans_ail_destroy(mp);
out_free_log:
	xlog_dealloc_log(mp->m_log);
729
out:
730
	return error;
731
}
Linus Torvalds's avatar
Linus Torvalds committed
732 733

/*
734 735 736 737
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
738
 *
739 740 741
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
742 743
 */
int
744 745
xfs_log_mount_finish(
	struct xfs_mount	*mp)
Linus Torvalds's avatar
Linus Torvalds committed
746
{
747
	int	error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
748

749
	if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
750
		ASSERT(mp->m_flags & XFS_MOUNT_RDONLY);
751
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
752 753
	}

754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
	error = xlog_recover_finish(mp->m_log);
	if (!error)
		xfs_log_work_queue(mp);

	return error;
}

/*
 * The mount has failed. Cancel the recovery if it hasn't completed and destroy
 * the log.
 */
int
xfs_log_mount_cancel(
	struct xfs_mount	*mp)
{
	int			error;

	error = xlog_recover_cancel(mp->m_log);
	xfs_log_unmount(mp);
773

Linus Torvalds's avatar
Linus Torvalds committed
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
	return error;
}

/*
 * Final log writes as part of unmount.
 *
 * Mark the filesystem clean as unmount happens.  Note that during relocation
 * this routine needs to be executed as part of source-bag while the
 * deallocation must not be done until source-end.
 */

/*
 * Unmount record used to have a string "Unmount filesystem--" in the
 * data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE).
 * We just write the magic number now since that particular field isn't
789
 * currently architecture converted and "Unmount" is a bit foo.
Linus Torvalds's avatar
Linus Torvalds committed
790 791 792 793 794 795
 * As far as I know, there weren't any dependencies on the old behaviour.
 */

int
xfs_log_unmount_write(xfs_mount_t *mp)
{
Mark Tinguely's avatar
Mark Tinguely committed
796
	struct xlog	 *log = mp->m_log;
Linus Torvalds's avatar
Linus Torvalds committed
797 798 799 800
	xlog_in_core_t	 *iclog;
#ifdef DEBUG
	xlog_in_core_t	 *first_iclog;
#endif
801
	xlog_ticket_t	*tic = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
802 803 804 805 806 807 808
	xfs_lsn_t	 lsn;
	int		 error;

	/*
	 * Don't write out unmount record on read-only mounts.
	 * Or, if we are doing a forced umount (typically because of IO errors).
	 */
809
	if (mp->m_flags & XFS_MOUNT_RDONLY)
Linus Torvalds's avatar
Linus Torvalds committed
810 811
		return 0;

812
	error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL);
813
	ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log)));
Linus Torvalds's avatar
Linus Torvalds committed
814 815 816 817 818 819 820 821 822 823 824 825

#ifdef DEBUG
	first_iclog = iclog = log->l_iclog;
	do {
		if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
			ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE);
			ASSERT(iclog->ic_offset == 0);
		}
		iclog = iclog->ic_next;
	} while (iclog != first_iclog);
#endif
	if (! (XLOG_FORCED_SHUTDOWN(log))) {
826 827
		error = xfs_log_reserve(mp, 600, 1, &tic,
					XFS_LOG, 0, XLOG_UNMOUNT_REC_TYPE);
Linus Torvalds's avatar
Linus Torvalds committed
828
		if (!error) {
829 830 831 832 833 834 835 836 837
			/* the data section must be 32 bit size aligned */
			struct {
			    __uint16_t magic;
			    __uint16_t pad1;
			    __uint32_t pad2; /* may as well make it 64 bits */
			} magic = {
				.magic = XLOG_UNMOUNT_TYPE,
			};
			struct xfs_log_iovec reg = {
838
				.i_addr = &magic,
839 840 841 842 843 844 845 846
				.i_len = sizeof(magic),
				.i_type = XLOG_REG_TYPE_UNMOUNT,
			};
			struct xfs_log_vec vec = {
				.lv_niovecs = 1,
				.lv_iovecp = &reg,
			};

847
			/* remove inited flag, and account for space used */
848
			tic->t_flags = 0;
849
			tic->t_curr_res -= sizeof(magic);
850
			error = xlog_write(log, &vec, tic, &lsn,
Linus Torvalds's avatar
Linus Torvalds committed
851 852 853 854 855 856 857 858
					   NULL, XLOG_UNMOUNT_TRANS);
			/*
			 * At this point, we're umounting anyway,
			 * so there's no point in transitioning log state
			 * to IOERROR. Just continue...
			 */
		}

859 860
		if (error)
			xfs_alert(mp, "%s: unmount record failed", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
861 862


Eric Sandeen's avatar
Eric Sandeen committed
863
		spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
864
		iclog = log->l_iclog;
865
		atomic_inc(&iclog->ic_refcnt);
Linus Torvalds's avatar
Linus Torvalds committed
866
		xlog_state_want_sync(log, iclog);
867
		spin_unlock(&log->l_icloglock);
868
		error = xlog_state_release_iclog(log, iclog);
Linus Torvalds's avatar
Linus Torvalds committed
869

Eric Sandeen's avatar
Eric Sandeen committed
870
		spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
871 872 873
		if (!(iclog->ic_state == XLOG_STATE_ACTIVE ||
		      iclog->ic_state == XLOG_STATE_DIRTY)) {
			if (!XLOG_FORCED_SHUTDOWN(log)) {
874 875
				xlog_wait(&iclog->ic_force_wait,
							&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
876
			} else {
Eric Sandeen's avatar
Eric Sandeen committed
877
				spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
878 879
			}
		} else {
Eric Sandeen's avatar
Eric Sandeen committed
880
			spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
881
		}
882
		if (tic) {
883
			trace_xfs_log_umount_write(log, tic);
884
			xlog_ungrant_log_space(log, tic);
885
			xfs_log_ticket_put(tic);
886
		}
Linus Torvalds's avatar
Linus Torvalds committed
887 888 889 890 891 892 893
	} else {
		/*
		 * We're already in forced_shutdown mode, couldn't
		 * even attempt to write out the unmount transaction.
		 *
		 * Go through the motions of sync'ing and releasing
		 * the iclog, even though no I/O will actually happen,
894
		 * we need to wait for other log I/Os that may already
Linus Torvalds's avatar
Linus Torvalds committed
895 896 897 898 899 900
		 * be in progress.  Do this as a separate section of
		 * code so we'll know if we ever get stuck here that
		 * we're in this odd situation of trying to unmount
		 * a file system that went into forced_shutdown as
		 * the result of an unmount..
		 */
Eric Sandeen's avatar
Eric Sandeen committed
901
		spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
902
		iclog = log->l_iclog;
903
		atomic_inc(&iclog->ic_refcnt);
Linus Torvalds's avatar
Linus Torvalds committed
904 905

		xlog_state_want_sync(log, iclog);
906
		spin_unlock(&log->l_icloglock);
907
		error =  xlog_state_release_iclog(log, iclog);
Linus Torvalds's avatar
Linus Torvalds committed
908

Eric Sandeen's avatar
Eric Sandeen committed
909
		spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
910 911 912 913 914

		if ( ! (   iclog->ic_state == XLOG_STATE_ACTIVE
			|| iclog->ic_state == XLOG_STATE_DIRTY
			|| iclog->ic_state == XLOG_STATE_IOERROR) ) {

915 916
				xlog_wait(&iclog->ic_force_wait,
							&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
917
		} else {
Eric Sandeen's avatar
Eric Sandeen committed
918
			spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
919 920 921
		}
	}

922
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
923 924 925
}	/* xfs_log_unmount_write */

/*
926
 * Empty the log for unmount/freeze.
927 928 929 930 931
 *
 * 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
932
 * record.
Linus Torvalds's avatar
Linus Torvalds committed
933 934
 */
void
935 936
xfs_log_quiesce(
	struct xfs_mount	*mp)
Linus Torvalds's avatar
Linus Torvalds committed
937
{
938
	cancel_delayed_work_sync(&mp->m_log->l_work);
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
	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);
954 955 956 957 958 959 960 961 962 963 964 965 966 967
}

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

969
	xfs_trans_ail_destroy(mp);
970 971 972

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

973
	xlog_dealloc_log(mp->m_log);
Linus Torvalds's avatar
Linus Torvalds committed
974 975
}

976 977 978 979 980
void
xfs_log_item_init(
	struct xfs_mount	*mp,
	struct xfs_log_item	*item,
	int			type,
981
	const struct xfs_item_ops *ops)
982 983 984 985 986
{
	item->li_mountp = mp;
	item->li_ailp = mp->m_ail;
	item->li_type = type;
	item->li_ops = ops;
987 988 989 990
	item->li_lv = NULL;

	INIT_LIST_HEAD(&item->li_ail);
	INIT_LIST_HEAD(&item->li_cil);
991 992
}

993 994 995
/*
 * Wake up processes waiting for log space after we have moved the log tail.
 */
Linus Torvalds's avatar
Linus Torvalds committed
996
void
997
xfs_log_space_wake(
998
	struct xfs_mount	*mp)
Linus Torvalds's avatar
Linus Torvalds committed
999
{
1000
	struct xlog		*log = mp->m_log;
1001
	int			free_bytes;
Linus Torvalds's avatar
Linus Torvalds committed
1002 1003 1004 1005

	if (XLOG_FORCED_SHUTDOWN(log))
		return;

1006
	if (!list_empty_careful(&log->l_write_head.waiters)) {
1007 1008
		ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));

1009 1010
		spin_lock(&log->l_write_head.lock);
		free_bytes = xlog_space_left(log, &log->l_write_head.grant);
1011
		xlog_grant_head_wake(log, &log->l_write_head, &free_bytes);
1012
		spin_unlock(&log->l_write_head.lock);
Linus Torvalds's avatar
Linus Torvalds committed
1013
	}
1014

1015
	if (!list_empty_careful(&log->l_reserve_head.waiters)) {
1016 1017
		ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY));

1018 1019
		spin_lock(&log->l_reserve_head.lock);
		free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
1020
		xlog_grant_head_wake(log, &log->l_reserve_head, &free_bytes);
1021
		spin_unlock(&log->l_reserve_head.lock);
Linus Torvalds's avatar
Linus Torvalds committed
1022
	}
1023
}
Linus Torvalds's avatar
Linus Torvalds committed
1024 1025

/*
1026 1027 1028 1029
 * 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.
1030
 *
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
1041 1042 1043 1044
 */
int
xfs_log_need_covered(xfs_mount_t *mp)
{
Mark Tinguely's avatar
Mark Tinguely committed
1045
	struct xlog	*log = mp->m_log;
1046
	int		needed = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1047

1048
	if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))
Linus Torvalds's avatar
Linus Torvalds committed
1049 1050
		return 0;

1051 1052 1053
	if (!xlog_cil_empty(log))
		return 0;

Eric Sandeen's avatar
Eric Sandeen committed
1054
	spin_lock(&log->l_icloglock);
1055 1056 1057 1058 1059 1060 1061
	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:
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
		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;
1073
	default:
Linus Torvalds's avatar
Linus Torvalds committed
1074
		needed = 1;
1075
		break;
Linus Torvalds's avatar
Linus Torvalds committed
1076
	}
Eric Sandeen's avatar
Eric Sandeen committed
1077
	spin_unlock(&log->l_icloglock);
1078
	return needed;
Linus Torvalds's avatar
Linus Torvalds committed
1079 1080
}

1081
/*
Linus Torvalds's avatar
Linus Torvalds committed
1082 1083 1084
 * We may be holding the log iclog lock upon entering this routine.
 */
xfs_lsn_t
1085
xlog_assign_tail_lsn_locked(
1086
	struct xfs_mount	*mp)
Linus Torvalds's avatar
Linus Torvalds committed
1087
{
1088
	struct xlog		*log = mp->m_log;
1089 1090 1091 1092
	struct xfs_log_item	*lip;
	xfs_lsn_t		tail_lsn;

	assert_spin_locked(&mp->m_ail->xa_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1093

1094 1095 1096
	/*
	 * 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,
1097
	 * and use that when the AIL was empty.
1098
	 */
1099 1100 1101 1102
	lip = xfs_ail_min(mp->m_ail);
	if (lip)
		tail_lsn = lip->li_lsn;
	else
1103
		tail_lsn = atomic64_read(&log->l_last_sync_lsn);
Dave Chinner's avatar
Dave Chinner committed
1104
	trace_xfs_log_assign_tail_lsn(log, tail_lsn);
1105
	atomic64_set(&log->l_tail_lsn, tail_lsn);
Linus Torvalds's avatar
Linus Torvalds committed
1106
	return tail_lsn;
1107
}
Linus Torvalds's avatar
Linus Torvalds committed
1108

1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
xfs_lsn_t
xlog_assign_tail_lsn(
	struct xfs_mount	*mp)
{
	xfs_lsn_t		tail_lsn;

	spin_lock(&mp->m_ail->xa_lock);
	tail_lsn = xlog_assign_tail_lsn_locked(mp);
	spin_unlock(&mp->m_ail->xa_lock);

	return tail_lsn;
}

Linus Torvalds's avatar
Linus Torvalds committed
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
/*
 * 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.
 */
1136
STATIC int
1137
xlog_space_left(
1138
	struct xlog	*log,
1139
	atomic64_t	*head)
Linus Torvalds's avatar
Linus Torvalds committed
1140
{
1141 1142 1143 1144 1145
	int		free_bytes;
	int		tail_bytes;
	int		tail_cycle;
	int		head_cycle;
	int		head_bytes;
Linus Torvalds's avatar
Linus Torvalds committed
1146

1147
	xlog_crack_grant_head(head, &head_cycle, &head_bytes);
1148 1149
	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes);
	tail_bytes = BBTOB(tail_bytes);
1150 1151 1152
	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)
Linus Torvalds's avatar
Linus Torvalds committed
1153
		return 0;
1154 1155 1156
	else if (tail_cycle < head_cycle) {
		ASSERT(tail_cycle == (head_cycle - 1));
		free_bytes = tail_bytes - head_bytes;
Linus Torvalds's avatar
Linus Torvalds committed
1157 1158 1159 1160 1161 1162
	} 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.
		 */
1163
		xfs_alert(log->l_mp, "xlog_space_left: head behind tail");
1164
		xfs_alert(log->l_mp,
1165 1166 1167 1168 1169
			  "  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);
Linus Torvalds's avatar
Linus Torvalds committed
1170 1171 1172 1173
		ASSERT(0);
		free_bytes = log->l_logsize;
	}
	return free_bytes;
1174
}
Linus Torvalds's avatar
Linus Torvalds committed
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185


/*
 * Log function which is called when an io completes.
 *
 * The log manager needs its own routine, in order to control what
 * happens with the buffer after the write completes.
 */
void
xlog_iodone(xfs_buf_t *bp)
{
Mark Tinguely's avatar
Mark Tinguely committed
1186 1187 1188
	struct xlog_in_core	*iclog = bp->b_fspriv;
	struct xlog		*l = iclog->ic_log;
	int			aborted = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1189 1190

	/*
1191 1192 1193
	 * Race to shutdown the filesystem if we see an error or the iclog is in
	 * IOABORT state. The IOABORT state is only set in DEBUG mode to inject
	 * CRC errors into log recovery.
Linus Torvalds's avatar
Linus Torvalds committed
1194
	 */
1195 1196 1197 1198 1199 1200
	if (XFS_TEST_ERROR(bp->b_error, l->l_mp, XFS_ERRTAG_IODONE_IOERR,
			   XFS_RANDOM_IODONE_IOERR) ||
	    iclog->ic_state & XLOG_STATE_IOABORT) {
		if (iclog->ic_state & XLOG_STATE_IOABORT)
			iclog->ic_state &= ~XLOG_STATE_IOABORT;

1201
		xfs_buf_ioerror_alert(bp, __func__);
1202
		xfs_buf_stale(bp);
1203
		xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
Linus Torvalds's avatar
Linus Torvalds committed
1204 1205 1206 1207 1208 1209 1210 1211 1212
		/*
		 * This flag will be propagated to the trans-committed
		 * callback routines to let them know that the log-commit
		 * didn't succeed.
		 */
		aborted = XFS_LI_ABORTED;
	} else if (iclog->ic_state & XLOG_STATE_IOERROR) {
		aborted = XFS_LI_ABORTED;
	}
1213 1214

	/* log I/O is always issued ASYNC */
1215
	ASSERT(bp->b_flags & XBF_ASYNC);
Linus Torvalds's avatar
Linus Torvalds committed
1216
	xlog_state_done_syncing(iclog, aborted);
1217

1218
	/*
1219 1220 1221 1222
	 * drop the buffer lock now that we are done. Nothing references
	 * the buffer after this, so an unmount waiting on this lock can now
	 * tear it down safely. As such, it is unsafe to reference the buffer
	 * (bp) after the unlock as we could race with it being freed.
1223
	 */
1224
	xfs_buf_unlock(bp);
1225
}
Linus Torvalds's avatar
Linus Torvalds committed
1226 1227 1228 1229

/*
 * Return size of each in-core log record buffer.
 *
Malcolm Parsons's avatar
Malcolm Parsons committed
1230
 * All machines get 8 x 32kB buffers by default, unless tuned otherwise.
Linus Torvalds's avatar
Linus Torvalds committed
1231 1232 1233 1234 1235 1236
 *
 * 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
Mark Tinguely's avatar
Mark Tinguely committed
1237 1238 1239
xlog_get_iclog_buffer_size(
	struct xfs_mount	*mp,
	struct xlog		*log)
Linus Torvalds's avatar
Linus Torvalds committed
1240 1241 1242 1243
{
	int size;
	int xhdrs;

1244 1245 1246
	if (mp->m_logbufs <= 0)
		log->l_iclog_bufs = XLOG_MAX_ICLOGS;
	else
1247
		log->l_iclog_bufs = mp->m_logbufs;
Linus Torvalds's avatar
Linus Torvalds committed
1248 1249 1250 1251

	/*
	 * Buffer size passed in from mount system call.
	 */
1252
	if (mp->m_logbsize > 0) {
Linus Torvalds's avatar
Linus Torvalds committed
1253 1254 1255 1256 1257 1258 1259
		size = log->l_iclog_size = mp->m_logbsize;
		log->l_iclog_size_log = 0;
		while (size != 1) {
			log->l_iclog_size_log++;
			size >>= 1;
		}

1260
		if (xfs_sb_version_haslogv2(&mp->m_sb)) {
Malcolm Parsons's avatar
Malcolm Parsons committed
1261 1262
			/* # headers = size / 32k
			 * one header holds cycles from 32k of data
Linus Torvalds's avatar
Linus Torvalds committed
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
			 */

			xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE;
			if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE)
				xhdrs++;
			log->l_iclog_hsize = xhdrs << BBSHIFT;
			log->l_iclog_heads = xhdrs;
		} else {
			ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE);
			log->l_iclog_hsize = BBSIZE;
			log->l_iclog_heads = 1;
		}
1275
		goto done;
Linus Torvalds's avatar
Linus Torvalds committed
1276 1277
	}

Malcolm Parsons's avatar
Malcolm Parsons committed
1278
	/* All machines use 32kB buffers by default. */
1279 1280
	log->l_iclog_size = XLOG_BIG_RECORD_BSIZE;
	log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT;
Linus Torvalds's avatar
Linus Torvalds committed
1281 1282 1283 1284 1285

	/* the default log size is 16k or 32k which is one header sector */
	log->l_iclog_hsize = BBSIZE;
	log->l_iclog_heads = 1;

1286 1287
done:
	/* are we being asked to make the sizes selected above visible? */
1288 1289 1290 1291
	if (mp->m_logbufs == 0)
		mp->m_logbufs = log->l_iclog_bufs;
	if (mp->m_logbsize == 0)
		mp->m_logbsize = log->l_iclog_size;
Linus Torvalds's avatar
Linus Torvalds committed
1292 1293 1294
}	/* xlog_get_iclog_buffer_size */


1295 1296 1297 1298
void
xfs_log_work_queue(
	struct xfs_mount        *mp)
{
1299
	queue_delayed_work(mp->m_log_workqueue, &mp->m_log->l_work,
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
				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.
 */
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 */
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
	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
1331 1332 1333 1334 1335 1336 1337 1338 1339
		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);
}

Linus Torvalds's avatar
Linus Torvalds committed
1340 1341 1342 1343 1344
/*
 * 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.
 */
Mark Tinguely's avatar
Mark Tinguely committed
1345 1346 1347 1348 1349 1350
STATIC struct xlog *
xlog_alloc_log(
	struct xfs_mount	*mp,
	struct xfs_buftarg	*log_target,
	xfs_daddr_t		blk_offset,
	int			num_bblks)
Linus Torvalds's avatar
Linus Torvalds committed
1351
{
Mark Tinguely's avatar
Mark Tinguely committed
1352
	struct xlog		*log;
Linus Torvalds's avatar
Linus Torvalds committed
1353 1354 1355 1356 1357
	xlog_rec_header_t	*head;
	xlog_in_core_t		**iclogp;
	xlog_in_core_t		*iclog, *prev_iclog=NULL;
	xfs_buf_t		*bp;
	int			i;
1358
	int			error = -ENOMEM;
1359
	uint			log2_size = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1360

Mark Tinguely's avatar
Mark Tinguely committed
1361
	log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);
1362
	if (!log) {
1363
		xfs_warn(mp, "Log allocation failed: No memory!");
1364 1365
		goto out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1366 1367 1368 1369 1370 1371 1372 1373

	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;
1374
	INIT_DELAYED_WORK(&log->l_work, xfs_log_worker);
Linus Torvalds's avatar
Linus Torvalds committed
1375 1376 1377

	log->l_prev_block  = -1;
	/* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */
1378 1379
	xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0);
	xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1380
	log->l_curr_cycle  = 1;	    /* 0 is bad since this is initial value */
1381 1382 1383

	xlog_grant_head_init(&log->l_reserve_head);
	xlog_grant_head_init(&log->l_write_head);
Linus Torvalds's avatar
Linus Torvalds committed
1384

1385
	error = -EFSCORRUPTED;
1386
	if (xfs_sb_version_hassector(&mp->m_sb)) {
1387 1388
	        log2_size = mp->m_sb.sb_logsectlog;
		if (log2_size < BBSHIFT) {
1389 1390
			xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)",
				log2_size, BBSHIFT);
1391 1392 1393
			goto out_free_log;
		}

1394 1395
	        log2_size -= BBSHIFT;
		if (log2_size > mp->m_sectbb_log) {
1396 1397
			xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)",
				log2_size, mp->m_sectbb_log);
1398 1399
			goto out_free_log;
		}
1400 1401 1402 1403

		/* for larger sector sizes, must have v2 or external log */
		if (log2_size && log->l_logBBstart > 0 &&
			    !xfs_sb_version_haslogv2(&mp->m_sb)) {
1404 1405 1406
			xfs_warn(mp,
		"log sector size (0x%x) invalid for configuration.",
				log2_size);
1407 1408
			goto out_free_log;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1409
	}
1410
	log->l_sectBBsize = 1 << log2_size;
Linus Torvalds's avatar
Linus Torvalds committed
1411 1412 1413

	xlog_get_iclog_buffer_size(mp, log);

1414 1415 1416 1417 1418
	/*
	 * Use a NULL block for the extra log buffer used during splits so that
	 * it will trigger errors if we ever try to do IO on it without first
	 * having set it up properly.
	 */
1419
	error = -ENOMEM;
1420 1421
	bp = xfs_buf_alloc(mp->m_logdev_targp, XFS_BUF_DADDR_NULL,
			   BTOBB(log->l_iclog_size), 0);
1422 1423
	if (!bp)
		goto out_free_log;
1424 1425 1426 1427 1428 1429

	/*
	 * The iclogbuf buffer locks are held over IO but we are not going to do
	 * IO yet.  Hence unlock the buffer so that the log IO path can grab it
	 * when appropriately.
	 */
1430
	ASSERT(xfs_buf_islocked(bp));
1431 1432
	xfs_buf_unlock(bp);

1433 1434
	/* use high priority wq for log I/O completion */
	bp->b_ioend_wq = mp->m_log_workqueue;
1435
	bp->b_iodone = xlog_iodone;
Linus Torvalds's avatar
Linus Torvalds committed
1436 1437
	log->l_xbuf = bp;

Eric Sandeen's avatar
Eric Sandeen committed
1438
	spin_lock_init(&log->l_icloglock);
1439
	init_waitqueue_head(&log->l_flush_wait);
Linus Torvalds's avatar
Linus Torvalds committed
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450

	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++) {
1451 1452 1453 1454
		*iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL);
		if (!*iclogp)
			goto out_free_iclog;

Linus Torvalds's avatar
Linus Torvalds committed
1455 1456 1457
		iclog = *iclogp;
		iclog->ic_prev = prev_iclog;
		prev_iclog = iclog;
1458

1459
		bp = xfs_buf_get_uncached(mp->m_logdev_targp,
1460
						BTOBB(log->l_iclog_size), 0);
1461 1462
		if (!bp)
			goto out_free_iclog;
1463

1464 1465 1466
		ASSERT(xfs_buf_islocked(bp));
		xfs_buf_unlock(bp);

1467 1468
		/* use high priority wq for log I/O completion */
		bp->b_ioend_wq = mp->m_log_workqueue;
1469
		bp->b_iodone = xlog_iodone;
1470
		iclog->ic_bp = bp;
1471
		iclog->ic_data = bp->b_addr;
1472
#ifdef DEBUG
1473
		log->l_iclog_bak[i] = &iclog->ic_header;
1474
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1475 1476
		head = &iclog->ic_header;
		memset(head, 0, sizeof(xlog_rec_header_t));
1477 1478
		head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
		head->h_version = cpu_to_be32(
1479
			xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1480
		head->h_size = cpu_to_be32(log->l_iclog_size);
Linus Torvalds's avatar
Linus Torvalds committed
1481
		/* new fields */
1482
		head->h_fmt = cpu_to_be32(XLOG_FMT);
Linus Torvalds's avatar
Linus Torvalds committed
1483 1484
		memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));

1485
		iclog->ic_size = BBTOB(bp->b_length) - log->l_iclog_hsize;
Linus Torvalds's avatar
Linus Torvalds committed
1486 1487
		iclog->ic_state = XLOG_STATE_ACTIVE;
		iclog->ic_log = log;
1488 1489
		atomic_set(&iclog->ic_refcnt, 0);
		spin_lock_init(&iclog->ic_callback_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1490
		iclog->ic_callback_tail = &(iclog->ic_callback);
1491
		iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
Linus Torvalds's avatar
Linus Torvalds committed
1492

1493 1494
		init_waitqueue_head(&iclog->ic_force_wait);
		init_waitqueue_head(&iclog->ic_write_wait);
Linus Torvalds's avatar
Linus Torvalds committed
1495 1496 1497 1498 1499 1500

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

1501 1502 1503
	error = xlog_cil_init(log);
	if (error)
		goto out_free_iclog;
Linus Torvalds's avatar
Linus Torvalds committed
1504
	return log;
1505 1506 1507 1508

out_free_iclog:
	for (iclog = log->l_iclog; iclog; iclog = prev_iclog) {
		prev_iclog = iclog->ic_next;
1509
		if (iclog->ic_bp)
1510 1511 1512 1513 1514 1515 1516
			xfs_buf_free(iclog->ic_bp);
		kmem_free(iclog);
	}
	spinlock_destroy(&log->l_icloglock);
	xfs_buf_free(log->l_xbuf);
out_free_log:
	kmem_free(log);
1517
out:
1518
	return ERR_PTR(error);
Linus Torvalds's avatar
Linus Torvalds committed
1519 1520 1521 1522 1523 1524 1525 1526
}	/* xlog_alloc_log */


/*
 * Write out the commit record of a transaction associated with the given
 * ticket.  Return the lsn of the commit record.
 */
STATIC int
1527
xlog_commit_record(
1528
	struct xlog		*log,
1529 1530 1531
	struct xlog_ticket	*ticket,
	struct xlog_in_core	**iclog,
	xfs_lsn_t		*commitlsnp)
Linus Torvalds's avatar
Linus Torvalds committed
1532
{
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
	struct xfs_mount *mp = log->l_mp;
	int	error;
	struct xfs_log_iovec reg = {
		.i_addr = NULL,
		.i_len = 0,
		.i_type = XLOG_REG_TYPE_COMMIT,
	};
	struct xfs_log_vec vec = {
		.lv_niovecs = 1,
		.lv_iovecp = &reg,
	};
Linus Torvalds's avatar
Linus Torvalds committed
1544 1545

	ASSERT_ALWAYS(iclog);
1546 1547 1548
	error = xlog_write(log, &vec, ticket, commitlsnp, iclog,
					XLOG_COMMIT_TRANS);
	if (error)
1549
		xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
1550
	return error;
1551
}
Linus Torvalds's avatar
Linus Torvalds committed
1552 1553 1554 1555 1556 1557 1558 1559

/*
 * Push on the buffer cache code if we ever use more than 75% of the on-disk
 * log space.  This code pushes on the lsn which would supposedly free up
 * the 25% which we want to leave free.  We may need to adopt a policy which
 * pushes on an lsn which is further along in the log once we reach the high
 * water mark.  In this manner, we would be creating a low water mark.
 */
1560
STATIC void
1561
xlog_grant_push_ail(
1562
	struct xlog	*log,
1563
	int		need_bytes)
Linus Torvalds's avatar
Linus Torvalds committed
1564
{
1565
	xfs_lsn_t	threshold_lsn = 0;
1566
	xfs_lsn_t	last_sync_lsn;
1567 1568 1569 1570 1571 1572 1573 1574
	int		free_blocks;
	int		free_bytes;
	int		threshold_block;
	int		threshold_cycle;
	int		free_threshold;

	ASSERT(BTOBB(need_bytes) < log->l_logBBsize);

1575
	free_bytes = xlog_space_left(log, &log->l_reserve_head.grant);
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588
	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;

1589 1590 1591
	xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle,
						&threshold_block);
	threshold_block += free_threshold;
Linus Torvalds's avatar
Linus Torvalds committed
1592
	if (threshold_block >= log->l_logBBsize) {
1593 1594
		threshold_block -= log->l_logBBsize;
		threshold_cycle += 1;
Linus Torvalds's avatar
Linus Torvalds committed
1595
	}
1596 1597 1598 1599
	threshold_lsn = xlog_assign_lsn(threshold_cycle,
					threshold_block);
	/*
	 * Don't pass in an lsn greater than the lsn of the last
1600 1601
	 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
1602
	 */
1603 1604 1605
	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;
1606 1607 1608 1609 1610 1611 1612

	/*
	 * Get the transaction layer to kick the dirty buffers out to
	 * disk asynchronously. No point in trying to do this if
	 * the filesystem is shutting down.
	 */
	if (!XLOG_FORCED_SHUTDOWN(log))
1613
		xfs_ail_push(log->l_ailp, threshold_lsn);
1614
}
Linus Torvalds's avatar
Linus Torvalds committed
1615

1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
/*
 * 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;
1628
	char			*dp;
1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662

	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.
 */
1663
__le32
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
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((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;
1681
		int		xheads;
1682

1683 1684 1685
		xheads = size / XLOG_HEADER_CYCLE_SIZE;
		if (size % XLOG_HEADER_CYCLE_SIZE)
			xheads++;
1686

1687
		for (i = 1; i < xheads; i++) {
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
			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);
}

1699 1700 1701 1702 1703 1704 1705
/*
 * The bdstrat callback function for log bufs. This gives us a central
 * place to trap bufs in case we get hit by a log I/O error and need to
 * shutdown. Actually, in practice, even when we didn't get a log error,
 * we transition the iclogs to IOERROR state *after* flushing all existing
 * iclogs to disk. This is because we don't want anymore new transactions to be
 * started or completed afterwards.
1706 1707 1708 1709 1710 1711
 *
 * We lock the iclogbufs here so that we can serialise against IO completion
 * during unmount. We might be processing a shutdown triggered during unmount,
 * and that can occur asynchronously to the unmount thread, and hence we need to
 * ensure that completes before tearing down the iclogbufs. Hence we need to
 * hold the buffer lock across the log IO to acheive that.
1712 1713 1714 1715 1716
 */
STATIC int
xlog_bdstrat(
	struct xfs_buf		*bp)
{
1717
	struct xlog_in_core	*iclog = bp->b_fspriv;
1718

1719
	xfs_buf_lock(bp);
1720
	if (iclog->ic_state & XLOG_STATE_IOERROR) {
1721
		xfs_buf_ioerror(bp, -EIO);
1722
		xfs_buf_stale(bp);
1723
		xfs_buf_ioend(bp);
1724 1725 1726
		/*
		 * It would seem logical to return EIO here, but we rely on
		 * the log state machine to propagate I/O errors instead of
1727 1728
		 * doing it here. Similarly, IO completion will unlock the
		 * buffer, so we don't do it here.
1729 1730 1731 1732
		 */
		return 0;
	}

1733
	xfs_buf_submit(bp);
1734 1735
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761

/*
 * Flush out the in-core log (iclog) to the on-disk log in an asynchronous 
 * fashion.  Previously, we should have moved the current iclog
 * ptr in the log to point to the next available iclog.  This allows further
 * write to continue while this code syncs out an iclog ready to go.
 * Before an in-core log can be written out, the data section must be scanned
 * to save away the 1st word of each BBSIZE block into the header.  We replace
 * it with the current cycle count.  Each BBSIZE block is tagged with the
 * cycle count because there in an implicit assumption that drives will
 * guarantee that entire 512 byte blocks get written at once.  In other words,
 * we can't have part of a 512 byte block written and part not written.  By
 * tagging each block, we will know which blocks are valid when recovering
 * after an unclean shutdown.
 *
 * This routine is single threaded on the iclog.  No other thread can be in
 * this routine with the same iclog.  Changing contents of iclog can there-
 * fore be done without grabbing the state machine lock.  Updating the global
 * log will require grabbing the lock though.
 *
 * The entire log manager uses a logical block numbering scheme.  Only
 * log_sync (and then only bwrite()) know about the fact that the log may
 * not start with block zero on a given device.  The log block start offset
 * is added immediately before calling bwrite().
 */

1762
STATIC int
Mark Tinguely's avatar
Mark Tinguely committed
1763 1764 1765
xlog_sync(
	struct xlog		*log,
	struct xlog_in_core	*iclog)
Linus Torvalds's avatar
Linus Torvalds committed
1766 1767
{
	xfs_buf_t	*bp;
1768
	int		i;
Linus Torvalds's avatar
Linus Torvalds committed
1769 1770 1771 1772 1773
	uint		count;		/* byte count of bwrite */
	uint		count_init;	/* initial count before roundup */
	int		roundoff;       /* roundoff to BB or stripe */
	int		split = 0;	/* split write into two regions */
	int		error;
1774
	int		v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb);
1775
	int		size;
Linus Torvalds's avatar
Linus Torvalds committed
1776

1777
	XFS_STATS_INC(log->l_mp, xs_log_writes);
1778
	ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
Linus Torvalds's avatar
Linus Torvalds committed
1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798

	/* Add for LR header */
	count_init = log->l_iclog_hsize + iclog->ic_offset;

	/* Round out the log write size */
	if (v2 && log->l_mp->m_sb.sb_logsunit > 1) {
		/* we have a v2 stripe unit to use */
		count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init));
	} else {
		count = BBTOB(BTOBB(count_init));
	}
	roundoff = count - count_init;
	ASSERT(roundoff >= 0);
	ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 && 
                roundoff < log->l_mp->m_sb.sb_logsunit)
		|| 
		(log->l_mp->m_sb.sb_logsunit <= 1 && 
		 roundoff < BBTOB(1)));

	/* move grant heads by roundoff in sync */
1799 1800
	xlog_grant_add_space(log, &log->l_reserve_head.grant, roundoff);
	xlog_grant_add_space(log, &log->l_write_head.grant, roundoff);
Linus Torvalds's avatar
Linus Torvalds committed
1801 1802 1803 1804 1805

	/* put cycle number in every block */
	xlog_pack_data(log, iclog, roundoff); 

	/* real byte length */
1806 1807 1808 1809
	size = iclog->ic_offset;
	if (v2)
		size += roundoff;
	iclog->ic_header.h_len = cpu_to_be32(size);
Linus Torvalds's avatar
Linus Torvalds committed
1810

1811
	bp = iclog->ic_bp;
1812
	XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)));
Linus Torvalds's avatar
Linus Torvalds committed
1813

1814
	XFS_STATS_ADD(log->l_mp, xs_log_blocks, BTOBB(count));
Linus Torvalds's avatar
Linus Torvalds committed
1815 1816 1817

	/* Do we need to split this write into 2 parts? */
	if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) {
1818 1819
		char		*dptr;

Linus Torvalds's avatar
Linus Torvalds committed
1820 1821
		split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)));
		count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp));
1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
		iclog->ic_bwritecnt = 2;

		/*
		 * Bump the cycle numbers at the start of each block in the
		 * part of the iclog that ends up in the buffer that gets
		 * written to the start of the log.
		 *
		 * Watch out for the header magic number case, though.
		 */
		dptr = (char *)&iclog->ic_header + count;
		for (i = 0; i < split; i += BBSIZE) {
			__uint32_t cycle = be32_to_cpu(*(__be32 *)dptr);
			if (++cycle == XLOG_HEADER_MAGIC_NUM)
				cycle++;
			*(__be32 *)dptr = cpu_to_be32(cycle);

			dptr += BBSIZE;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1840 1841 1842
	} else {
		iclog->ic_bwritecnt = 1;
	}
1843 1844 1845 1846

	/* calculcate the checksum */
	iclog->ic_header.h_crc = xlog_cksum(log, &iclog->ic_header,
					    iclog->ic_datap, size);
1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
#ifdef DEBUG
	/*
	 * Intentionally corrupt the log record CRC based on the error injection
	 * frequency, if defined. This facilitates testing log recovery in the
	 * event of torn writes. Hence, set the IOABORT state to abort the log
	 * write on I/O completion and shutdown the fs. The subsequent mount
	 * detects the bad CRC and attempts to recover.
	 */
	if (log->l_badcrc_factor &&
	    (prandom_u32() % log->l_badcrc_factor == 0)) {
		iclog->ic_header.h_crc &= 0xAAAAAAAA;
		iclog->ic_state |= XLOG_STATE_IOABORT;
		xfs_warn(log->l_mp,
	"Intentionally corrupted log record at LSN 0x%llx. Shutdown imminent.",
			 be64_to_cpu(iclog->ic_header.h_lsn));
	}
#endif
1864

1865
	bp->b_io_length = BTOBB(count);
1866
	bp->b_fspriv = iclog;
1867
	bp->b_flags &= ~(XBF_FUA | XBF_FLUSH);
1868
	bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE);
1869

1870
	if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) {
1871 1872
		bp->b_flags |= XBF_FUA;

1873
		/*
1874 1875 1876 1877 1878 1879 1880
		 * Flush the data device before flushing the log to make
		 * sure all meta data written back from the AIL actually made
		 * it to disk before stamping the new log tail LSN into the
		 * log buffer.  For an external log we need to issue the
		 * flush explicitly, and unfortunately synchronously here;
		 * for an internal log we can simply use the block layer
		 * state machine for preflushes.
1881 1882 1883
		 */
		if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
			xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
1884 1885
		else
			bp->b_flags |= XBF_FLUSH;
1886
	}
Linus Torvalds's avatar
Linus Torvalds committed
1887 1888 1889 1890

	ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
	ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);

1891
	xlog_verify_iclog(log, iclog, count, true);
Linus Torvalds's avatar
Linus Torvalds committed
1892 1893 1894

	/* account for log which doesn't start at block #0 */
	XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1895

Linus Torvalds's avatar
Linus Torvalds committed
1896 1897 1898 1899
	/*
	 * Don't call xfs_bwrite here. We do log-syncs even when the filesystem
	 * is shutting down.
	 */
1900 1901 1902
	error = xlog_bdstrat(bp);
	if (error) {
		xfs_buf_ioerror_alert(bp, "xlog_sync");
1903
		return error;
Linus Torvalds's avatar
Linus Torvalds committed
1904 1905
	}
	if (split) {
1906
		bp = iclog->ic_log->l_xbuf;
Linus Torvalds's avatar
Linus Torvalds committed
1907
		XFS_BUF_SET_ADDR(bp, 0);	     /* logical 0 */
1908 1909
		xfs_buf_associate_memory(bp,
				(char *)&iclog->ic_header + count, split);
1910
		bp->b_fspriv = iclog;
1911
		bp->b_flags &= ~(XBF_FUA | XBF_FLUSH);
1912
		bp->b_flags |= (XBF_ASYNC | XBF_SYNCIO | XBF_WRITE);
1913
		if (log->l_mp->m_flags & XFS_MOUNT_BARRIER)
1914
			bp->b_flags |= XBF_FUA;
Linus Torvalds's avatar
Linus Torvalds committed
1915 1916 1917 1918

		ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
		ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize);

1919
		/* account for internal log which doesn't start at block #0 */
Linus Torvalds's avatar
Linus Torvalds committed
1920
		XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1921 1922 1923
		error = xlog_bdstrat(bp);
		if (error) {
			xfs_buf_ioerror_alert(bp, "xlog_sync (split)");
1924
			return error;
Linus Torvalds's avatar
Linus Torvalds committed
1925 1926
		}
	}
1927
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1928 1929 1930
}	/* xlog_sync */

/*
1931
 * Deallocate a log structure
Linus Torvalds's avatar
Linus Torvalds committed
1932
 */
1933
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
1934 1935
xlog_dealloc_log(
	struct xlog	*log)
Linus Torvalds's avatar
Linus Torvalds committed
1936 1937 1938 1939
{
	xlog_in_core_t	*iclog, *next_iclog;
	int		i;

1940 1941
	xlog_cil_destroy(log);

1942
	/*
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
	 * Cycle all the iclogbuf locks to make sure all log IO completion
	 * is done before we tear down these buffers.
	 */
	iclog = log->l_iclog;
	for (i = 0; i < log->l_iclog_bufs; i++) {
		xfs_buf_lock(iclog->ic_bp);
		xfs_buf_unlock(iclog->ic_bp);
		iclog = iclog->ic_next;
	}

	/*
	 * Always need to ensure that the extra buffer does not point to memory
	 * owned by another log buffer before we free it. Also, cycle the lock
	 * first to ensure we've completed IO on it.
1957
	 */
1958 1959
	xfs_buf_lock(log->l_xbuf);
	xfs_buf_unlock(log->l_xbuf);
1960
	xfs_buf_set_empty(log->l_xbuf, BTOBB(log->l_iclog_size));
1961 1962
	xfs_buf_free(log->l_xbuf);

Linus Torvalds's avatar
Linus Torvalds committed
1963
	iclog = log->l_iclog;
1964
	for (i = 0; i < log->l_iclog_bufs; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
1965 1966
		xfs_buf_free(iclog->ic_bp);
		next_iclog = iclog->ic_next;
1967
		kmem_free(iclog);
Linus Torvalds's avatar
Linus Torvalds committed
1968 1969 1970 1971 1972
		iclog = next_iclog;
	}
	spinlock_destroy(&log->l_icloglock);

	log->l_mp->m_log = NULL;
1973
	kmem_free(log);
1974
}	/* xlog_dealloc_log */
Linus Torvalds's avatar
Linus Torvalds committed
1975 1976 1977 1978 1979 1980

/*
 * Update counters atomically now that memcpy is done.
 */
/* ARGSUSED */
static inline void
Mark Tinguely's avatar
Mark Tinguely committed
1981 1982 1983 1984 1985
xlog_state_finish_copy(
	struct xlog		*log,
	struct xlog_in_core	*iclog,
	int			record_cnt,
	int			copy_bytes)
Linus Torvalds's avatar
Linus Torvalds committed
1986
{
Eric Sandeen's avatar
Eric Sandeen committed
1987
	spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
1988

1989
	be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt);
Linus Torvalds's avatar
Linus Torvalds committed
1990 1991
	iclog->ic_offset += copy_bytes;

Eric Sandeen's avatar
Eric Sandeen committed
1992
	spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
1993 1994 1995 1996 1997
}	/* xlog_state_finish_copy */




1998 1999 2000 2001
/*
 * print out info relating to regions written which consume
 * the reservation
 */
2002 2003 2004 2005
void
xlog_print_tic_res(
	struct xfs_mount	*mp,
	struct xlog_ticket	*ticket)
2006 2007 2008 2009 2010
{
	uint i;
	uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t);

	/* match with XLOG_REG_TYPE_* in xfs_log.h */
2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
#define REG_TYPE_STR(type, str)	[XLOG_REG_TYPE_##type] = str
	static char *res_type_str[XLOG_REG_TYPE_MAX + 1] = {
	    REG_TYPE_STR(BFORMAT, "bformat"),
	    REG_TYPE_STR(BCHUNK, "bchunk"),
	    REG_TYPE_STR(EFI_FORMAT, "efi_format"),
	    REG_TYPE_STR(EFD_FORMAT, "efd_format"),
	    REG_TYPE_STR(IFORMAT, "iformat"),
	    REG_TYPE_STR(ICORE, "icore"),
	    REG_TYPE_STR(IEXT, "iext"),
	    REG_TYPE_STR(IBROOT, "ibroot"),
	    REG_TYPE_STR(ILOCAL, "ilocal"),
	    REG_TYPE_STR(IATTR_EXT, "iattr_ext"),
	    REG_TYPE_STR(IATTR_BROOT, "iattr_broot"),
	    REG_TYPE_STR(IATTR_LOCAL, "iattr_local"),
	    REG_TYPE_STR(QFORMAT, "qformat"),
	    REG_TYPE_STR(DQUOT, "dquot"),
	    REG_TYPE_STR(QUOTAOFF, "quotaoff"),
	    REG_TYPE_STR(LRHEADER, "LR header"),
	    REG_TYPE_STR(UNMOUNT, "unmount"),
	    REG_TYPE_STR(COMMIT, "commit"),
	    REG_TYPE_STR(TRANSHDR, "trans header"),
	    REG_TYPE_STR(ICREATE, "inode create")
2033
	};
2034 2035
#undef REG_TYPE_STR
#define TRANS_TYPE_STR(type)	[XFS_TRANS_##type] = #type
2036
	static char *trans_type_str[XFS_TRANS_TYPE_MAX] = {
2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077
	    TRANS_TYPE_STR(SETATTR_NOT_SIZE),
	    TRANS_TYPE_STR(SETATTR_SIZE),
	    TRANS_TYPE_STR(INACTIVE),
	    TRANS_TYPE_STR(CREATE),
	    TRANS_TYPE_STR(CREATE_TRUNC),
	    TRANS_TYPE_STR(TRUNCATE_FILE),
	    TRANS_TYPE_STR(REMOVE),
	    TRANS_TYPE_STR(LINK),
	    TRANS_TYPE_STR(RENAME),
	    TRANS_TYPE_STR(MKDIR),
	    TRANS_TYPE_STR(RMDIR),
	    TRANS_TYPE_STR(SYMLINK),
	    TRANS_TYPE_STR(SET_DMATTRS),
	    TRANS_TYPE_STR(GROWFS),
	    TRANS_TYPE_STR(STRAT_WRITE),
	    TRANS_TYPE_STR(DIOSTRAT),
	    TRANS_TYPE_STR(WRITEID),
	    TRANS_TYPE_STR(ADDAFORK),
	    TRANS_TYPE_STR(ATTRINVAL),
	    TRANS_TYPE_STR(ATRUNCATE),
	    TRANS_TYPE_STR(ATTR_SET),
	    TRANS_TYPE_STR(ATTR_RM),
	    TRANS_TYPE_STR(ATTR_FLAG),
	    TRANS_TYPE_STR(CLEAR_AGI_BUCKET),
	    TRANS_TYPE_STR(SB_CHANGE),
	    TRANS_TYPE_STR(DUMMY1),
	    TRANS_TYPE_STR(DUMMY2),
	    TRANS_TYPE_STR(QM_QUOTAOFF),
	    TRANS_TYPE_STR(QM_DQALLOC),
	    TRANS_TYPE_STR(QM_SETQLIM),
	    TRANS_TYPE_STR(QM_DQCLUSTER),
	    TRANS_TYPE_STR(QM_QINOCREATE),
	    TRANS_TYPE_STR(QM_QUOTAOFF_END),
	    TRANS_TYPE_STR(FSYNC_TS),
	    TRANS_TYPE_STR(GROWFSRT_ALLOC),
	    TRANS_TYPE_STR(GROWFSRT_ZERO),
	    TRANS_TYPE_STR(GROWFSRT_FREE),
	    TRANS_TYPE_STR(SWAPEXT),
	    TRANS_TYPE_STR(CHECKPOINT),
	    TRANS_TYPE_STR(ICREATE),
	    TRANS_TYPE_STR(CREATE_TMPFILE)
2078
	};
2079
#undef TRANS_TYPE_STR
2080

2081 2082 2083 2084
	xfs_warn(mp, "xlog_write: reservation summary:");
	xfs_warn(mp, "  trans type  = %s (%u)",
		 ((ticket->t_trans_type <= 0 ||
		   ticket->t_trans_type > XFS_TRANS_TYPE_MAX) ?
2085
		  "bad-trans-type" : trans_type_str[ticket->t_trans_type]),
2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
		 ticket->t_trans_type);
	xfs_warn(mp, "  unit res    = %d bytes",
		 ticket->t_unit_res);
	xfs_warn(mp, "  current res = %d bytes",
		 ticket->t_curr_res);
	xfs_warn(mp, "  total reg   = %u bytes (o/flow = %u bytes)",
		 ticket->t_res_arr_sum, ticket->t_res_o_flow);
	xfs_warn(mp, "  ophdrs      = %u (ophdr space = %u bytes)",
		 ticket->t_res_num_ophdrs, ophdr_spc);
	xfs_warn(mp, "  ophdr + reg = %u bytes",
		 ticket->t_res_arr_sum + ticket->t_res_o_flow + ophdr_spc);
	xfs_warn(mp, "  num regions = %u",
		 ticket->t_res_num);
2099 2100

	for (i = 0; i < ticket->t_res_num; i++) {
2101
		uint r_type = ticket->t_res_arr[i].r_type;
2102
		xfs_warn(mp, "region[%u]: %s - %u bytes", i,
2103
			    ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ?
2104
			    "bad-rtype" : res_type_str[r_type]),
2105 2106
			    ticket->t_res_arr[i].r_len);
	}
2107

2108
	xfs_alert_tag(mp, XFS_PTAG_LOGRES,
2109
		"xlog_write: reservation ran out. Need to up reservation");
2110
	xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
2111 2112
}

Dave Chinner's avatar
Dave Chinner committed
2113 2114 2115 2116 2117 2118 2119
/*
 * Calculate the potential space needed by the log vector.  Each region gets
 * its own xlog_op_header_t and may need to be double word aligned.
 */
static int
xlog_write_calc_vec_length(
	struct xlog_ticket	*ticket,
2120
	struct xfs_log_vec	*log_vector)
Dave Chinner's avatar
Dave Chinner committed
2121
{
2122
	struct xfs_log_vec	*lv;
Dave Chinner's avatar
Dave Chinner committed
2123 2124 2125 2126 2127 2128 2129 2130
	int			headers = 0;
	int			len = 0;
	int			i;

	/* acct for start rec of xact */
	if (ticket->t_flags & XLOG_TIC_INITED)
		headers++;

2131
	for (lv = log_vector; lv; lv = lv->lv_next) {
2132 2133 2134 2135
		/* we don't write ordered log vectors */
		if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED)
			continue;

2136 2137 2138 2139
		headers += lv->lv_niovecs;

		for (i = 0; i < lv->lv_niovecs; i++) {
			struct xfs_log_iovec	*vecp = &lv->lv_iovecp[i];
Dave Chinner's avatar
Dave Chinner committed
2140

2141 2142 2143
			len += vecp->i_len;
			xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type);
		}
Dave Chinner's avatar
Dave Chinner committed
2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157
	}

	ticket->t_res_num_ophdrs += headers;
	len += headers * sizeof(struct xlog_op_header);

	return len;
}

/*
 * If first write for transaction, insert start record  We can't be trying to
 * commit if we are inited.  We can't have any "partial_copy" if we are inited.
 */
static int
xlog_write_start_rec(
2158
	struct xlog_op_header	*ophdr,
Dave Chinner's avatar
Dave Chinner committed
2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
	struct xlog_ticket	*ticket)
{
	if (!(ticket->t_flags & XLOG_TIC_INITED))
		return 0;

	ophdr->oh_tid	= cpu_to_be32(ticket->t_tid);
	ophdr->oh_clientid = ticket->t_clientid;
	ophdr->oh_len = 0;
	ophdr->oh_flags = XLOG_START_TRANS;
	ophdr->oh_res2 = 0;

	ticket->t_flags &= ~XLOG_TIC_INITED;

	return sizeof(struct xlog_op_header);
}

static xlog_op_header_t *
xlog_write_setup_ophdr(
2177
	struct xlog		*log,
2178
	struct xlog_op_header	*ophdr,
Dave Chinner's avatar
Dave Chinner committed
2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
	struct xlog_ticket	*ticket,
	uint			flags)
{
	ophdr->oh_tid = cpu_to_be32(ticket->t_tid);
	ophdr->oh_clientid = ticket->t_clientid;
	ophdr->oh_res2 = 0;

	/* are we copying a commit or unmount record? */
	ophdr->oh_flags = flags;

	/*
	 * We've seen logs corrupted with bad transaction client ids.  This
	 * makes sure that XFS doesn't generate them on.  Turn this into an EIO
	 * and shut down the filesystem.
	 */
	switch (ophdr->oh_clientid)  {
	case XFS_TRANSACTION:
	case XFS_VOLUME:
	case XFS_LOG:
		break;
	default:
2200
		xfs_warn(log->l_mp,
Dave Chinner's avatar
Dave Chinner committed
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
			"Bad XFS transaction clientid 0x%x in ticket 0x%p",
			ophdr->oh_clientid, ticket);
		return NULL;
	}

	return ophdr;
}

/*
 * Set up the parameters of the region copy into the log. This has
 * to handle region write split across multiple log buffers - this
 * state is kept external to this function so that this code can
2213
 * be written in an obvious, self documenting manner.
Dave Chinner's avatar
Dave Chinner committed
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
 */
static int
xlog_write_setup_copy(
	struct xlog_ticket	*ticket,
	struct xlog_op_header	*ophdr,
	int			space_available,
	int			space_required,
	int			*copy_off,
	int			*copy_len,
	int			*last_was_partial_copy,
	int			*bytes_consumed)
{
	int			still_to_copy;

	still_to_copy = space_required - *bytes_consumed;
	*copy_off = *bytes_consumed;

	if (still_to_copy <= space_available) {
		/* write of region completes here */
		*copy_len = still_to_copy;
		ophdr->oh_len = cpu_to_be32(*copy_len);
		if (*last_was_partial_copy)
			ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS);
		*last_was_partial_copy = 0;
		*bytes_consumed = 0;
		return 0;
	}

	/* partial write of region, needs extra log op header reservation */
	*copy_len = space_available;
	ophdr->oh_len = cpu_to_be32(*copy_len);
	ophdr->oh_flags |= XLOG_CONTINUE_TRANS;
	if (*last_was_partial_copy)
		ophdr->oh_flags |= XLOG_WAS_CONT_TRANS;
	*bytes_consumed += *copy_len;
	(*last_was_partial_copy)++;

	/* account for new log op header */
	ticket->t_curr_res -= sizeof(struct xlog_op_header);
	ticket->t_res_num_ophdrs++;

	return sizeof(struct xlog_op_header);
}

static int
xlog_write_copy_finish(
2260
	struct xlog		*log,
Dave Chinner's avatar
Dave Chinner committed
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302
	struct xlog_in_core	*iclog,
	uint			flags,
	int			*record_cnt,
	int			*data_cnt,
	int			*partial_copy,
	int			*partial_copy_len,
	int			log_offset,
	struct xlog_in_core	**commit_iclog)
{
	if (*partial_copy) {
		/*
		 * This iclog has already been marked WANT_SYNC by
		 * xlog_state_get_iclog_space.
		 */
		xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
		*record_cnt = 0;
		*data_cnt = 0;
		return xlog_state_release_iclog(log, iclog);
	}

	*partial_copy = 0;
	*partial_copy_len = 0;

	if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) {
		/* no more space in this iclog - push it. */
		xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt);
		*record_cnt = 0;
		*data_cnt = 0;

		spin_lock(&log->l_icloglock);
		xlog_state_want_sync(log, iclog);
		spin_unlock(&log->l_icloglock);

		if (!commit_iclog)
			return xlog_state_release_iclog(log, iclog);
		ASSERT(flags & XLOG_COMMIT_TRANS);
		*commit_iclog = iclog;
	}

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342
/*
 * Write some region out to in-core log
 *
 * This will be called when writing externally provided regions or when
 * writing out a commit record for a given transaction.
 *
 * General algorithm:
 *	1. Find total length of this write.  This may include adding to the
 *		lengths passed in.
 *	2. Check whether we violate the tickets reservation.
 *	3. While writing to this iclog
 *	    A. Reserve as much space in this iclog as can get
 *	    B. If this is first write, save away start lsn
 *	    C. While writing this region:
 *		1. If first write of transaction, write start record
 *		2. Write log operation header (header per region)
 *		3. Find out if we can fit entire region into this iclog
 *		4. Potentially, verify destination memcpy ptr
 *		5. Memcpy (partial) region
 *		6. If partial copy, release iclog; otherwise, continue
 *			copying more regions into current iclog
 *	4. Mark want sync bit (in simulation mode)
 *	5. Release iclog for potential flush to on-disk log.
 *
 * ERRORS:
 * 1.	Panic if reservation is overrun.  This should never happen since
 *	reservation amounts are generated internal to the filesystem.
 * NOTES:
 * 1. Tickets are single threaded data structures.
 * 2. The XLOG_END_TRANS & XLOG_CONTINUE_TRANS flags are passed down to the
 *	syncing routine.  When a single log_write region needs to span
 *	multiple in-core logs, the XLOG_CONTINUE_TRANS bit should be set
 *	on all log operation writes which don't contain the end of the
 *	region.  The XLOG_END_TRANS bit is used for the in-core log
 *	operation which contains the end of the continued log_write region.
 * 3. When xlog_state_get_iclog_space() grabs the rest of the current iclog,
 *	we don't really know exactly how much space will be used.  As a result,
 *	we don't update ic_offset until the end when we know exactly how many
 *	bytes have been written out.
 */
2343
int
2344
xlog_write(
2345
	struct xlog		*log,
2346
	struct xfs_log_vec	*log_vector,
2347 2348 2349 2350
	struct xlog_ticket	*ticket,
	xfs_lsn_t		*start_lsn,
	struct xlog_in_core	**commit_iclog,
	uint			flags)
Linus Torvalds's avatar
Linus Torvalds committed
2351
{
Christoph Hellwig's avatar
Christoph Hellwig committed
2352
	struct xlog_in_core	*iclog = NULL;
2353 2354
	struct xfs_log_iovec	*vecp;
	struct xfs_log_vec	*lv;
Christoph Hellwig's avatar
Christoph Hellwig committed
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365
	int			len;
	int			index;
	int			partial_copy = 0;
	int			partial_copy_len = 0;
	int			contwr = 0;
	int			record_cnt = 0;
	int			data_cnt = 0;
	int			error;

	*start_lsn = 0;

2366
	len = xlog_write_calc_vec_length(ticket, log_vector);
2367

2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381
	/*
	 * Region headers and bytes are already accounted for.
	 * We only need to take into account start records and
	 * split regions in this function.
	 */
	if (ticket->t_flags & XLOG_TIC_INITED)
		ticket->t_curr_res -= sizeof(xlog_op_header_t);

	/*
	 * Commit record headers need to be accounted for. These
	 * come in as separate writes so are easy to detect.
	 */
	if (flags & (XLOG_COMMIT_TRANS | XLOG_UNMOUNT_TRANS))
		ticket->t_curr_res -= sizeof(xlog_op_header_t);
2382 2383

	if (ticket->t_curr_res < 0)
2384
		xlog_print_tic_res(log->l_mp, ticket);
Linus Torvalds's avatar
Linus Torvalds committed
2385

2386 2387 2388
	index = 0;
	lv = log_vector;
	vecp = lv->lv_iovecp;
2389
	while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
2390
		void		*ptr;
Christoph Hellwig's avatar
Christoph Hellwig committed
2391
		int		log_offset;
Linus Torvalds's avatar
Linus Torvalds committed
2392

Christoph Hellwig's avatar
Christoph Hellwig committed
2393 2394 2395 2396
		error = xlog_state_get_iclog_space(log, len, &iclog, ticket,
						   &contwr, &log_offset);
		if (error)
			return error;
Linus Torvalds's avatar
Linus Torvalds committed
2397

Christoph Hellwig's avatar
Christoph Hellwig committed
2398
		ASSERT(log_offset <= iclog->ic_size - 1);
2399
		ptr = iclog->ic_datap + log_offset;
Linus Torvalds's avatar
Linus Torvalds committed
2400

Christoph Hellwig's avatar
Christoph Hellwig committed
2401 2402 2403
		/* start_lsn is the first lsn written to. That's all we need. */
		if (!*start_lsn)
			*start_lsn = be64_to_cpu(iclog->ic_header.h_lsn);
Dave Chinner's avatar
Dave Chinner committed
2404

Christoph Hellwig's avatar
Christoph Hellwig committed
2405 2406 2407 2408
		/*
		 * This loop writes out as many regions as can fit in the amount
		 * of space which was allocated by xlog_state_get_iclog_space().
		 */
2409 2410
		while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) {
			struct xfs_log_iovec	*reg;
Christoph Hellwig's avatar
Christoph Hellwig committed
2411 2412 2413 2414
			struct xlog_op_header	*ophdr;
			int			start_rec_copy;
			int			copy_len;
			int			copy_off;
2415 2416 2417 2418 2419 2420 2421 2422
			bool			ordered = false;

			/* ordered log vectors have no regions to write */
			if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) {
				ASSERT(lv->lv_niovecs == 0);
				ordered = true;
				goto next_lv;
			}
Christoph Hellwig's avatar
Christoph Hellwig committed
2423

2424
			reg = &vecp[index];
2425
			ASSERT(reg->i_len % sizeof(__int32_t) == 0);
2426
			ASSERT((unsigned long)ptr % sizeof(__int32_t) == 0);
Christoph Hellwig's avatar
Christoph Hellwig committed
2427 2428 2429 2430

			start_rec_copy = xlog_write_start_rec(ptr, ticket);
			if (start_rec_copy) {
				record_cnt++;
2431
				xlog_write_adv_cnt(&ptr, &len, &log_offset,
Christoph Hellwig's avatar
Christoph Hellwig committed
2432 2433
						   start_rec_copy);
			}
Dave Chinner's avatar
Dave Chinner committed
2434

Christoph Hellwig's avatar
Christoph Hellwig committed
2435 2436
			ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags);
			if (!ophdr)
2437
				return -EIO;
Christoph Hellwig's avatar
Christoph Hellwig committed
2438

2439
			xlog_write_adv_cnt(&ptr, &len, &log_offset,
Christoph Hellwig's avatar
Christoph Hellwig committed
2440 2441 2442 2443
					   sizeof(struct xlog_op_header));

			len += xlog_write_setup_copy(ticket, ophdr,
						     iclog->ic_size-log_offset,
2444
						     reg->i_len,
Christoph Hellwig's avatar
Christoph Hellwig committed
2445 2446 2447 2448 2449
						     &copy_off, &copy_len,
						     &partial_copy,
						     &partial_copy_len);
			xlog_verify_dest_ptr(log, ptr);

2450 2451 2452 2453 2454 2455 2456 2457
			/*
			 * Copy region.
			 *
			 * Unmount records just log an opheader, so can have
			 * empty payloads with no data region to copy. Hence we
			 * only copy the payload if the vector says it has data
			 * to copy.
			 */
Christoph Hellwig's avatar
Christoph Hellwig committed
2458
			ASSERT(copy_len >= 0);
2459 2460 2461 2462 2463
			if (copy_len > 0) {
				memcpy(ptr, reg->i_addr + copy_off, copy_len);
				xlog_write_adv_cnt(&ptr, &len, &log_offset,
						   copy_len);
			}
Christoph Hellwig's avatar
Christoph Hellwig committed
2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491
			copy_len += start_rec_copy + sizeof(xlog_op_header_t);
			record_cnt++;
			data_cnt += contwr ? copy_len : 0;

			error = xlog_write_copy_finish(log, iclog, flags,
						       &record_cnt, &data_cnt,
						       &partial_copy,
						       &partial_copy_len,
						       log_offset,
						       commit_iclog);
			if (error)
				return error;

			/*
			 * if we had a partial copy, we need to get more iclog
			 * space but we don't want to increment the region
			 * index because there is still more is this region to
			 * write.
			 *
			 * If we completed writing this region, and we flushed
			 * the iclog (indicated by resetting of the record
			 * count), then we also need to get more log space. If
			 * this was the last record, though, we are done and
			 * can just return.
			 */
			if (partial_copy)
				break;

2492
			if (++index == lv->lv_niovecs) {
2493
next_lv:
2494 2495 2496 2497 2498
				lv = lv->lv_next;
				index = 0;
				if (lv)
					vecp = lv->lv_iovecp;
			}
2499
			if (record_cnt == 0 && ordered == false) {
2500
				if (!lv)
Christoph Hellwig's avatar
Christoph Hellwig committed
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511
					return 0;
				break;
			}
		}
	}

	ASSERT(len == 0);

	xlog_state_finish_copy(log, iclog, record_cnt, data_cnt);
	if (!commit_iclog)
		return xlog_state_release_iclog(log, iclog);
Linus Torvalds's avatar
Linus Torvalds committed
2512 2513 2514 2515

	ASSERT(flags & XLOG_COMMIT_TRANS);
	*commit_iclog = iclog;
	return 0;
Christoph Hellwig's avatar
Christoph Hellwig committed
2516
}
Linus Torvalds's avatar
Linus Torvalds committed
2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528


/*****************************************************************************
 *
 *		State Machine functions
 *
 *****************************************************************************
 */

/* Clean iclogs starting from the head.  This ordering must be
 * maintained, so an iclog doesn't become ACTIVE beyond one that
 * is SYNCING.  This is also required to maintain the notion that we use
2529
 * a ordered wait queue to hold off would be writers to the log when every
Linus Torvalds's avatar
Linus Torvalds committed
2530 2531 2532 2533
 * iclog is trying to sync to disk.
 *
 * State Change: DIRTY -> ACTIVE
 */
2534
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
2535 2536
xlog_state_clean_log(
	struct xlog *log)
Linus Torvalds's avatar
Linus Torvalds committed
2537 2538 2539 2540 2541 2542 2543 2544 2545
{
	xlog_in_core_t	*iclog;
	int changed = 0;

	iclog = log->l_iclog;
	do {
		if (iclog->ic_state == XLOG_STATE_DIRTY) {
			iclog->ic_state	= XLOG_STATE_ACTIVE;
			iclog->ic_offset       = 0;
2546
			ASSERT(iclog->ic_callback == NULL);
Linus Torvalds's avatar
Linus Torvalds committed
2547 2548 2549 2550 2551 2552 2553 2554 2555
			/*
			 * If the number of ops in this iclog indicate it just
			 * contains the dummy transaction, we can
			 * change state into IDLE (the second time around).
			 * Otherwise we should change the state into
			 * NEED a dummy.
			 * We don't need to cover the dummy.
			 */
			if (!changed &&
2556 2557
			   (be32_to_cpu(iclog->ic_header.h_num_logops) ==
			   		XLOG_COVER_OPS)) {
Linus Torvalds's avatar
Linus Torvalds committed
2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615
				changed = 1;
			} else {
				/*
				 * We have two dirty iclogs so start over
				 * This could also be num of ops indicates
				 * this is not the dummy going out.
				 */
				changed = 2;
			}
			iclog->ic_header.h_num_logops = 0;
			memset(iclog->ic_header.h_cycle_data, 0,
			      sizeof(iclog->ic_header.h_cycle_data));
			iclog->ic_header.h_lsn = 0;
		} else if (iclog->ic_state == XLOG_STATE_ACTIVE)
			/* do nothing */;
		else
			break;	/* stop cleaning */
		iclog = iclog->ic_next;
	} while (iclog != log->l_iclog);

	/* log is locked when we are called */
	/*
	 * Change state for the dummy log recording.
	 * We usually go to NEED. But we go to NEED2 if the changed indicates
	 * we are done writing the dummy record.
	 * If we are done with the second dummy recored (DONE2), then
	 * we go to IDLE.
	 */
	if (changed) {
		switch (log->l_covered_state) {
		case XLOG_STATE_COVER_IDLE:
		case XLOG_STATE_COVER_NEED:
		case XLOG_STATE_COVER_NEED2:
			log->l_covered_state = XLOG_STATE_COVER_NEED;
			break;

		case XLOG_STATE_COVER_DONE:
			if (changed == 1)
				log->l_covered_state = XLOG_STATE_COVER_NEED2;
			else
				log->l_covered_state = XLOG_STATE_COVER_NEED;
			break;

		case XLOG_STATE_COVER_DONE2:
			if (changed == 1)
				log->l_covered_state = XLOG_STATE_COVER_IDLE;
			else
				log->l_covered_state = XLOG_STATE_COVER_NEED;
			break;

		default:
			ASSERT(0);
		}
	}
}	/* xlog_state_clean_log */

STATIC xfs_lsn_t
xlog_get_lowest_lsn(
Mark Tinguely's avatar
Mark Tinguely committed
2616
	struct xlog	*log)
Linus Torvalds's avatar
Linus Torvalds committed
2617 2618 2619 2620 2621 2622 2623 2624
{
	xlog_in_core_t  *lsn_log;
	xfs_lsn_t	lowest_lsn, lsn;

	lsn_log = log->l_iclog;
	lowest_lsn = 0;
	do {
	    if (!(lsn_log->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY))) {
2625
		lsn = be64_to_cpu(lsn_log->ic_header.h_lsn);
Linus Torvalds's avatar
Linus Torvalds committed
2626 2627 2628 2629 2630 2631 2632
		if ((lsn && !lowest_lsn) ||
		    (XFS_LSN_CMP(lsn, lowest_lsn) < 0)) {
			lowest_lsn = lsn;
		}
	    }
	    lsn_log = lsn_log->ic_next;
	} while (lsn_log != log->l_iclog);
2633
	return lowest_lsn;
Linus Torvalds's avatar
Linus Torvalds committed
2634 2635 2636 2637 2638
}


STATIC void
xlog_state_do_callback(
Mark Tinguely's avatar
Mark Tinguely committed
2639 2640 2641
	struct xlog		*log,
	int			aborted,
	struct xlog_in_core	*ciclog)
Linus Torvalds's avatar
Linus Torvalds committed
2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
{
	xlog_in_core_t	   *iclog;
	xlog_in_core_t	   *first_iclog;	/* used to know when we've
						 * processed all iclogs once */
	xfs_log_callback_t *cb, *cb_next;
	int		   flushcnt = 0;
	xfs_lsn_t	   lowest_lsn;
	int		   ioerrors;	/* counter: iclogs with errors */
	int		   loopdidcallbacks; /* flag: inner loop did callbacks*/
	int		   funcdidcallbacks; /* flag: function did callbacks */
	int		   repeats;	/* for issuing console warnings if
					 * looping too many times */
2654
	int		   wake = 0;
Linus Torvalds's avatar
Linus Torvalds committed
2655

Eric Sandeen's avatar
Eric Sandeen committed
2656
	spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
	first_iclog = iclog = log->l_iclog;
	ioerrors = 0;
	funcdidcallbacks = 0;
	repeats = 0;

	do {
		/*
		 * Scan all iclogs starting with the one pointed to by the
		 * log.  Reset this starting point each time the log is
		 * unlocked (during callbacks).
		 *
		 * Keep looping through iclogs until one full pass is made
		 * without running any callbacks.
		 */
		first_iclog = log->l_iclog;
		iclog = log->l_iclog;
		loopdidcallbacks = 0;
		repeats++;

		do {

			/* skip all iclogs in the ACTIVE & DIRTY states */
			if (iclog->ic_state &
			    (XLOG_STATE_ACTIVE|XLOG_STATE_DIRTY)) {
				iclog = iclog->ic_next;
				continue;
			}

			/*
			 * Between marking a filesystem SHUTDOWN and stopping
			 * the log, we do flush all iclogs to disk (if there
			 * wasn't a log I/O error). So, we do want things to
			 * go smoothly in case of just a SHUTDOWN  w/o a
			 * LOG_IO_ERROR.
			 */
			if (!(iclog->ic_state & XLOG_STATE_IOERROR)) {
				/*
				 * Can only perform callbacks in order.  Since
				 * this iclog is not in the DONE_SYNC/
				 * DO_CALLBACK state, we skip the rest and
				 * just try to clean up.  If we set our iclog
				 * to DO_CALLBACK, we will not process it when
				 * we retry since a previous iclog is in the
				 * CALLBACK and the state cannot change since
Eric Sandeen's avatar
Eric Sandeen committed
2701
				 * we are holding the l_icloglock.
Linus Torvalds's avatar
Linus Torvalds committed
2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726
				 */
				if (!(iclog->ic_state &
					(XLOG_STATE_DONE_SYNC |
						 XLOG_STATE_DO_CALLBACK))) {
					if (ciclog && (ciclog->ic_state ==
							XLOG_STATE_DONE_SYNC)) {
						ciclog->ic_state = XLOG_STATE_DO_CALLBACK;
					}
					break;
				}
				/*
				 * We now have an iclog that is in either the
				 * DO_CALLBACK or DONE_SYNC states. The other
				 * states (WANT_SYNC, SYNCING, or CALLBACK were
				 * caught by the above if and are going to
				 * clean (i.e. we aren't doing their callbacks)
				 * see the above if.
				 */

				/*
				 * We will do one more check here to see if we
				 * have chased our tail around.
				 */

				lowest_lsn = xlog_get_lowest_lsn(log);
2727 2728
				if (lowest_lsn &&
				    XFS_LSN_CMP(lowest_lsn,
2729
						be64_to_cpu(iclog->ic_header.h_lsn)) < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
2730 2731 2732 2733 2734 2735 2736 2737
					iclog = iclog->ic_next;
					continue; /* Leave this iclog for
						   * another thread */
				}

				iclog->ic_state = XLOG_STATE_CALLBACK;


2738
				/*
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751
				 * Completion of a iclog IO does not imply that
				 * a transaction has completed, as transactions
				 * can be large enough to span many iclogs. We
				 * cannot change the tail of the log half way
				 * through a transaction as this may be the only
				 * transaction in the log and moving th etail to
				 * point to the middle of it will prevent
				 * recovery from finding the start of the
				 * transaction. Hence we should only update the
				 * last_sync_lsn if this iclog contains
				 * transaction completion callbacks on it.
				 *
				 * We have to do this before we drop the
2752 2753
				 * icloglock to ensure we are the only one that
				 * can update it.
Linus Torvalds's avatar
Linus Torvalds committed
2754
				 */
2755 2756
				ASSERT(XFS_LSN_CMP(atomic64_read(&log->l_last_sync_lsn),
					be64_to_cpu(iclog->ic_header.h_lsn)) <= 0);
2757 2758 2759
				if (iclog->ic_callback)
					atomic64_set(&log->l_last_sync_lsn,
						be64_to_cpu(iclog->ic_header.h_lsn));
Linus Torvalds's avatar
Linus Torvalds committed
2760

2761
			} else
Linus Torvalds's avatar
Linus Torvalds committed
2762
				ioerrors++;
2763 2764

			spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
2765

2766 2767 2768 2769 2770 2771 2772 2773 2774
			/*
			 * Keep processing entries in the callback list until
			 * we come around and it is empty.  We need to
			 * atomically see that the list is empty and change the
			 * state to DIRTY so that we don't miss any more
			 * callbacks being added.
			 */
			spin_lock(&iclog->ic_callback_lock);
			cb = iclog->ic_callback;
2775
			while (cb) {
Linus Torvalds's avatar
Linus Torvalds committed
2776 2777
				iclog->ic_callback_tail = &(iclog->ic_callback);
				iclog->ic_callback = NULL;
2778
				spin_unlock(&iclog->ic_callback_lock);
Linus Torvalds's avatar
Linus Torvalds committed
2779 2780

				/* perform callbacks in the order given */
2781
				for (; cb; cb = cb_next) {
Linus Torvalds's avatar
Linus Torvalds committed
2782 2783 2784
					cb_next = cb->cb_next;
					cb->cb_func(cb->cb_arg, aborted);
				}
2785
				spin_lock(&iclog->ic_callback_lock);
Linus Torvalds's avatar
Linus Torvalds committed
2786 2787 2788 2789 2790 2791
				cb = iclog->ic_callback;
			}

			loopdidcallbacks++;
			funcdidcallbacks++;

2792
			spin_lock(&log->l_icloglock);
2793
			ASSERT(iclog->ic_callback == NULL);
2794
			spin_unlock(&iclog->ic_callback_lock);
Linus Torvalds's avatar
Linus Torvalds committed
2795 2796 2797 2798 2799 2800 2801 2802 2803 2804
			if (!(iclog->ic_state & XLOG_STATE_IOERROR))
				iclog->ic_state = XLOG_STATE_DIRTY;

			/*
			 * Transition from DIRTY to ACTIVE if applicable.
			 * NOP if STATE_IOERROR.
			 */
			xlog_state_clean_log(log);

			/* wake up threads waiting in xfs_log_force() */
2805
			wake_up_all(&iclog->ic_force_wait);
Linus Torvalds's avatar
Linus Torvalds committed
2806 2807 2808

			iclog = iclog->ic_next;
		} while (first_iclog != iclog);
2809 2810 2811 2812

		if (repeats > 5000) {
			flushcnt += repeats;
			repeats = 0;
2813
			xfs_warn(log->l_mp,
2814
				"%s: possible infinite loop (%d iterations)",
2815
				__func__, flushcnt);
Linus Torvalds's avatar
Linus Torvalds committed
2816 2817 2818
		}
	} while (!ioerrors && loopdidcallbacks);

2819
#ifdef DEBUG
Linus Torvalds's avatar
Linus Torvalds committed
2820
	/*
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830
	 * Make one last gasp attempt to see if iclogs are being left in limbo.
	 * If the above loop finds an iclog earlier than the current iclog and
	 * in one of the syncing states, the current iclog is put into
	 * DO_CALLBACK and the callbacks are deferred to the completion of the
	 * earlier iclog. Walk the iclogs in order and make sure that no iclog
	 * is in DO_CALLBACK unless an earlier iclog is in one of the syncing
	 * states.
	 *
	 * Note that SYNCING|IOABORT is a valid state so we cannot just check
	 * for ic_state == SYNCING.
Linus Torvalds's avatar
Linus Torvalds committed
2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841
	 */
	if (funcdidcallbacks) {
		first_iclog = iclog = log->l_iclog;
		do {
			ASSERT(iclog->ic_state != XLOG_STATE_DO_CALLBACK);
			/*
			 * Terminate the loop if iclogs are found in states
			 * which will cause other threads to clean up iclogs.
			 *
			 * SYNCING - i/o completion will go through logs
			 * DONE_SYNC - interrupt thread should be waiting for
Eric Sandeen's avatar
Eric Sandeen committed
2842
			 *              l_icloglock
Linus Torvalds's avatar
Linus Torvalds committed
2843 2844 2845
			 * IOERROR - give up hope all ye who enter here
			 */
			if (iclog->ic_state == XLOG_STATE_WANT_SYNC ||
2846
			    iclog->ic_state & XLOG_STATE_SYNCING ||
Linus Torvalds's avatar
Linus Torvalds committed
2847 2848 2849 2850 2851 2852 2853 2854
			    iclog->ic_state == XLOG_STATE_DONE_SYNC ||
			    iclog->ic_state == XLOG_STATE_IOERROR )
				break;
			iclog = iclog->ic_next;
		} while (first_iclog != iclog);
	}
#endif

2855 2856
	if (log->l_iclog->ic_state & (XLOG_STATE_ACTIVE|XLOG_STATE_IOERROR))
		wake = 1;
Eric Sandeen's avatar
Eric Sandeen committed
2857
	spin_unlock(&log->l_icloglock);
2858 2859

	if (wake)
2860
		wake_up_all(&log->l_flush_wait);
2861
}
Linus Torvalds's avatar
Linus Torvalds committed
2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874


/*
 * Finish transitioning this iclog to the dirty state.
 *
 * Make sure that we completely execute this routine only when this is
 * the last call to the iclog.  There is a good chance that iclog flushes,
 * when we reach the end of the physical log, get turned into 2 separate
 * calls to bwrite.  Hence, one iclog flush could generate two calls to this
 * routine.  By using the reference count bwritecnt, we guarantee that only
 * the second completion goes through.
 *
 * Callbacks could take time, so they are done outside the scope of the
2875
 * global state machine log lock.
Linus Torvalds's avatar
Linus Torvalds committed
2876
 */
2877
STATIC void
Linus Torvalds's avatar
Linus Torvalds committed
2878 2879 2880 2881
xlog_state_done_syncing(
	xlog_in_core_t	*iclog,
	int		aborted)
{
Mark Tinguely's avatar
Mark Tinguely committed
2882
	struct xlog	   *log = iclog->ic_log;
Linus Torvalds's avatar
Linus Torvalds committed
2883

Eric Sandeen's avatar
Eric Sandeen committed
2884
	spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
2885 2886 2887

	ASSERT(iclog->ic_state == XLOG_STATE_SYNCING ||
	       iclog->ic_state == XLOG_STATE_IOERROR);
2888
	ASSERT(atomic_read(&iclog->ic_refcnt) == 0);
Linus Torvalds's avatar
Linus Torvalds committed
2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899
	ASSERT(iclog->ic_bwritecnt == 1 || iclog->ic_bwritecnt == 2);


	/*
	 * If we got an error, either on the first buffer, or in the case of
	 * split log writes, on the second, we mark ALL iclogs STATE_IOERROR,
	 * and none should ever be attempted to be written to disk
	 * again.
	 */
	if (iclog->ic_state != XLOG_STATE_IOERROR) {
		if (--iclog->ic_bwritecnt == 1) {
Eric Sandeen's avatar
Eric Sandeen committed
2900
			spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
2901 2902 2903 2904 2905 2906 2907 2908 2909 2910
			return;
		}
		iclog->ic_state = XLOG_STATE_DONE_SYNC;
	}

	/*
	 * Someone could be sleeping prior to writing out the next
	 * iclog buffer, we wake them all, one will get to do the
	 * I/O, the others get to wait for the result.
	 */
2911
	wake_up_all(&iclog->ic_write_wait);
Eric Sandeen's avatar
Eric Sandeen committed
2912
	spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
2913 2914 2915 2916 2917 2918
	xlog_state_do_callback(log, aborted, iclog);	/* also cleans log */
}	/* xlog_state_done_syncing */


/*
 * If the head of the in-core log ring is not (ACTIVE or DIRTY), then we must
2919 2920 2921
 * sleep.  We wait on the flush queue on the head iclog as that should be
 * the first iclog to complete flushing. Hence if all iclogs are syncing,
 * we will wait here and all new writes will sleep until a sync completes.
Linus Torvalds's avatar
Linus Torvalds committed
2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934
 *
 * The in-core logs are used in a circular fashion. They are not used
 * out-of-order even when an iclog past the head is free.
 *
 * return:
 *	* log_offset where xlog_write() can start writing into the in-core
 *		log's data space.
 *	* in-core log pointer to which xlog_write() should write.
 *	* boolean indicating this is a continued write to an in-core log.
 *		If this is the last write, then the in-core log's offset field
 *		needs to be incremented, depending on the amount of data which
 *		is copied.
 */
2935
STATIC int
Mark Tinguely's avatar
Mark Tinguely committed
2936 2937 2938 2939 2940 2941 2942
xlog_state_get_iclog_space(
	struct xlog		*log,
	int			len,
	struct xlog_in_core	**iclogp,
	struct xlog_ticket	*ticket,
	int			*continued_write,
	int			*logoffsetp)
Linus Torvalds's avatar
Linus Torvalds committed
2943 2944 2945 2946 2947 2948 2949
{
	int		  log_offset;
	xlog_rec_header_t *head;
	xlog_in_core_t	  *iclog;
	int		  error;

restart:
Eric Sandeen's avatar
Eric Sandeen committed
2950
	spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
2951
	if (XLOG_FORCED_SHUTDOWN(log)) {
Eric Sandeen's avatar
Eric Sandeen committed
2952
		spin_unlock(&log->l_icloglock);
2953
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
2954 2955 2956
	}

	iclog = log->l_iclog;
2957
	if (iclog->ic_state != XLOG_STATE_ACTIVE) {
2958
		XFS_STATS_INC(log->l_mp, xs_log_noiclogs);
2959 2960

		/* Wait for log writes to have flushed */
2961
		xlog_wait(&log->l_flush_wait, &log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
2962 2963
		goto restart;
	}
2964

Linus Torvalds's avatar
Linus Torvalds committed
2965 2966
	head = &iclog->ic_header;

2967
	atomic_inc(&iclog->ic_refcnt);	/* prevents sync */
Linus Torvalds's avatar
Linus Torvalds committed
2968 2969 2970 2971 2972 2973 2974 2975 2976
	log_offset = iclog->ic_offset;

	/* On the 1st write to an iclog, figure out lsn.  This works
	 * if iclogs marked XLOG_STATE_WANT_SYNC always write out what they are
	 * committing to.  If the offset is set, that's how many blocks
	 * must be written.
	 */
	if (log_offset == 0) {
		ticket->t_curr_res -= log->l_iclog_hsize;
2977
		xlog_tic_add_region(ticket,
2978 2979
				    log->l_iclog_hsize,
				    XLOG_REG_TYPE_LRHEADER);
2980 2981
		head->h_cycle = cpu_to_be32(log->l_curr_cycle);
		head->h_lsn = cpu_to_be64(
2982
			xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block));
Linus Torvalds's avatar
Linus Torvalds committed
2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
		ASSERT(log->l_curr_block >= 0);
	}

	/* If there is enough room to write everything, then do it.  Otherwise,
	 * claim the rest of the region and make sure the XLOG_STATE_WANT_SYNC
	 * bit is on, so this will get flushed out.  Don't update ic_offset
	 * until you know exactly how many bytes get copied.  Therefore, wait
	 * until later to update ic_offset.
	 *
	 * xlog_write() algorithm assumes that at least 2 xlog_op_header_t's
	 * can fit into remaining data section.
	 */
	if (iclog->ic_size - iclog->ic_offset < 2*sizeof(xlog_op_header_t)) {
		xlog_state_switch_iclogs(log, iclog, iclog->ic_size);

2998 2999 3000 3001 3002 3003 3004 3005 3006
		/*
		 * If I'm the only one writing to this iclog, sync it to disk.
		 * We need to do an atomic compare and decrement here to avoid
		 * racing with concurrent atomic_dec_and_lock() calls in
		 * xlog_state_release_iclog() when there is more than one
		 * reference to the iclog.
		 */
		if (!atomic_add_unless(&iclog->ic_refcnt, -1, 1)) {
			/* we are the only one */
Eric Sandeen's avatar
Eric Sandeen committed
3007
			spin_unlock(&log->l_icloglock);
3008 3009
			error = xlog_state_release_iclog(log, iclog);
			if (error)
3010
				return error;
Linus Torvalds's avatar
Linus Torvalds committed
3011
		} else {
Eric Sandeen's avatar
Eric Sandeen committed
3012
			spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032
		}
		goto restart;
	}

	/* Do we have enough room to write the full amount in the remainder
	 * of this iclog?  Or must we continue a write on the next iclog and
	 * mark this iclog as completely taken?  In the case where we switch
	 * iclogs (to mark it taken), this particular iclog will release/sync
	 * to disk in xlog_write().
	 */
	if (len <= iclog->ic_size - iclog->ic_offset) {
		*continued_write = 0;
		iclog->ic_offset += len;
	} else {
		*continued_write = 1;
		xlog_state_switch_iclogs(log, iclog, iclog->ic_size);
	}
	*iclogp = iclog;

	ASSERT(iclog->ic_offset <= iclog->ic_size);
Eric Sandeen's avatar
Eric Sandeen committed
3033
	spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046

	*logoffsetp = log_offset;
	return 0;
}	/* xlog_state_get_iclog_space */

/* The first cnt-1 times through here we don't need to
 * move the grant write head because the permanent
 * reservation has reserved cnt times the unit amount.
 * Release part of current permanent unit reservation and
 * reset current reservation to be one units worth.  Also
 * move grant reservation head forward.
 */
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
3047 3048 3049
xlog_regrant_reserve_log_space(
	struct xlog		*log,
	struct xlog_ticket	*ticket)
Linus Torvalds's avatar
Linus Torvalds committed
3050
{
3051 3052
	trace_xfs_log_regrant_reserve_enter(log, ticket);

Linus Torvalds's avatar
Linus Torvalds committed
3053 3054 3055
	if (ticket->t_cnt > 0)
		ticket->t_cnt--;

3056
	xlog_grant_sub_space(log, &log->l_reserve_head.grant,
3057
					ticket->t_curr_res);
3058
	xlog_grant_sub_space(log, &log->l_write_head.grant,
3059
					ticket->t_curr_res);
Linus Torvalds's avatar
Linus Torvalds committed
3060
	ticket->t_curr_res = ticket->t_unit_res;
3061
	xlog_tic_reset_res(ticket);
3062 3063 3064

	trace_xfs_log_regrant_reserve_sub(log, ticket);

Linus Torvalds's avatar
Linus Torvalds committed
3065
	/* just return if we still have some of the pre-reserved space */
3066
	if (ticket->t_cnt > 0)
Linus Torvalds's avatar
Linus Torvalds committed
3067 3068
		return;

3069
	xlog_grant_add_space(log, &log->l_reserve_head.grant,
3070
					ticket->t_unit_res);
3071 3072 3073

	trace_xfs_log_regrant_reserve_exit(log, ticket);

Linus Torvalds's avatar
Linus Torvalds committed
3074
	ticket->t_curr_res = ticket->t_unit_res;
3075
	xlog_tic_reset_res(ticket);
Linus Torvalds's avatar
Linus Torvalds committed
3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093
}	/* xlog_regrant_reserve_log_space */


/*
 * Give back the space left from a reservation.
 *
 * All the information we need to make a correct determination of space left
 * is present.  For non-permanent reservations, things are quite easy.  The
 * count should have been decremented to zero.  We only need to deal with the
 * space remaining in the current reservation part of the ticket.  If the
 * ticket contains a permanent reservation, there may be left over space which
 * needs to be released.  A count of N means that N-1 refills of the current
 * reservation can be done before we need to ask for more space.  The first
 * one goes to fill up the first current reservation.  Once we run out of
 * space, the count will stay at zero and the only space remaining will be
 * in the current reservation field.
 */
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
3094 3095 3096
xlog_ungrant_log_space(
	struct xlog		*log,
	struct xlog_ticket	*ticket)
Linus Torvalds's avatar
Linus Torvalds committed
3097
{
3098 3099
	int	bytes;

Linus Torvalds's avatar
Linus Torvalds committed
3100 3101 3102
	if (ticket->t_cnt > 0)
		ticket->t_cnt--;

3103 3104
	trace_xfs_log_ungrant_enter(log, ticket);
	trace_xfs_log_ungrant_sub(log, ticket);
Linus Torvalds's avatar
Linus Torvalds committed
3105

3106 3107
	/*
	 * If this is a permanent reservation ticket, we may be able to free
Linus Torvalds's avatar
Linus Torvalds committed
3108 3109
	 * up more space based on the remaining count.
	 */
3110
	bytes = ticket->t_curr_res;
Linus Torvalds's avatar
Linus Torvalds committed
3111 3112
	if (ticket->t_cnt > 0) {
		ASSERT(ticket->t_flags & XLOG_TIC_PERM_RESERV);
3113
		bytes += ticket->t_unit_res*ticket->t_cnt;
Linus Torvalds's avatar
Linus Torvalds committed
3114 3115
	}

3116 3117
	xlog_grant_sub_space(log, &log->l_reserve_head.grant, bytes);
	xlog_grant_sub_space(log, &log->l_write_head.grant, bytes);
3118

3119 3120
	trace_xfs_log_ungrant_exit(log, ticket);

3121
	xfs_log_space_wake(log->l_mp);
3122
}
Linus Torvalds's avatar
Linus Torvalds committed
3123 3124 3125 3126 3127 3128 3129 3130 3131 3132

/*
 * Flush iclog to disk if this is the last reference to the given iclog and
 * the WANT_SYNC bit is set.
 *
 * When this function is entered, the iclog is not necessarily in the
 * WANT_SYNC state.  It may be sitting around waiting to get filled.
 *
 *
 */
3133
STATIC int
3134
xlog_state_release_iclog(
Mark Tinguely's avatar
Mark Tinguely committed
3135 3136
	struct xlog		*log,
	struct xlog_in_core	*iclog)
Linus Torvalds's avatar
Linus Torvalds committed
3137 3138 3139
{
	int		sync = 0;	/* do we sync? */

3140
	if (iclog->ic_state & XLOG_STATE_IOERROR)
3141
		return -EIO;
3142 3143 3144 3145 3146

	ASSERT(atomic_read(&iclog->ic_refcnt) > 0);
	if (!atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock))
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
3147
	if (iclog->ic_state & XLOG_STATE_IOERROR) {
Eric Sandeen's avatar
Eric Sandeen committed
3148
		spin_unlock(&log->l_icloglock);
3149
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
3150 3151 3152 3153
	}
	ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE ||
	       iclog->ic_state == XLOG_STATE_WANT_SYNC);

3154
	if (iclog->ic_state == XLOG_STATE_WANT_SYNC) {
3155
		/* update tail before writing to iclog */
3156
		xfs_lsn_t tail_lsn = xlog_assign_tail_lsn(log->l_mp);
Linus Torvalds's avatar
Linus Torvalds committed
3157 3158
		sync++;
		iclog->ic_state = XLOG_STATE_SYNCING;
3159 3160
		iclog->ic_header.h_tail_lsn = cpu_to_be64(tail_lsn);
		xlog_verify_tail_lsn(log, iclog, tail_lsn);
Linus Torvalds's avatar
Linus Torvalds committed
3161 3162
		/* cycle incremented when incrementing curr_block */
	}
Eric Sandeen's avatar
Eric Sandeen committed
3163
	spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3164 3165 3166

	/*
	 * We let the log lock go, so it's possible that we hit a log I/O
3167
	 * error or some other SHUTDOWN condition that marks the iclog
Linus Torvalds's avatar
Linus Torvalds committed
3168 3169 3170 3171
	 * as XLOG_STATE_IOERROR before the bwrite. However, we know that
	 * this iclog has consistent data, so we ignore IOERROR
	 * flags after this point.
	 */
3172
	if (sync)
Linus Torvalds's avatar
Linus Torvalds committed
3173
		return xlog_sync(log, iclog);
3174
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
}	/* xlog_state_release_iclog */


/*
 * This routine will mark the current iclog in the ring as WANT_SYNC
 * and move the current iclog pointer to the next iclog in the ring.
 * When this routine is called from xlog_state_get_iclog_space(), the
 * exact size of the iclog has not yet been determined.  All we know is
 * that every data block.  We have run out of space in this log record.
 */
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
3186 3187 3188 3189
xlog_state_switch_iclogs(
	struct xlog		*log,
	struct xlog_in_core	*iclog,
	int			eventual_size)
Linus Torvalds's avatar
Linus Torvalds committed
3190 3191 3192 3193 3194
{
	ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE);
	if (!eventual_size)
		eventual_size = iclog->ic_offset;
	iclog->ic_state = XLOG_STATE_WANT_SYNC;
3195
	iclog->ic_header.h_prev_block = cpu_to_be32(log->l_prev_block);
Linus Torvalds's avatar
Linus Torvalds committed
3196 3197 3198 3199 3200 3201 3202
	log->l_prev_block = log->l_curr_block;
	log->l_prev_cycle = log->l_curr_cycle;

	/* roll log?: ic_offset changed later */
	log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize);

	/* Round up to next log-sunit */
3203
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
Linus Torvalds's avatar
Linus Torvalds committed
3204 3205 3206 3207 3208 3209
	    log->l_mp->m_sb.sb_logsunit > 1) {
		__uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
		log->l_curr_block = roundup(log->l_curr_block, sunit_bb);
	}

	if (log->l_curr_block >= log->l_logBBsize) {
3210 3211 3212 3213 3214 3215 3216 3217 3218 3219
		/*
		 * Rewind the current block before the cycle is bumped to make
		 * sure that the combined LSN never transiently moves forward
		 * when the log wraps to the next cycle. This is to support the
		 * unlocked sample of these fields from xlog_valid_lsn(). Most
		 * other cases should acquire l_icloglock.
		 */
		log->l_curr_block -= log->l_logBBsize;
		ASSERT(log->l_curr_block >= 0);
		smp_wmb();
Linus Torvalds's avatar
Linus Torvalds committed
3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
		log->l_curr_cycle++;
		if (log->l_curr_cycle == XLOG_HEADER_MAGIC_NUM)
			log->l_curr_cycle++;
	}
	ASSERT(iclog == log->l_iclog);
	log->l_iclog = iclog->ic_next;
}	/* xlog_state_switch_iclogs */

/*
 * Write out all data in the in-core log as of this exact moment in time.
 *
 * Data may be written to the in-core log during this call.  However,
 * we don't guarantee this data will be written out.  A change from past
 * implementation means this routine will *not* write out zero length LRs.
 *
 * Basically, we try and perform an intelligent scan of the in-core logs.
 * If we determine there is no flushable data, we just return.  There is no
 * flushable data if:
 *
 *	1. the current iclog is active and has no data; the previous iclog
 *		is in the active or dirty state.
 *	2. the current iclog is drity, and the previous iclog is in the
 *		active or dirty state.
 *
3244
 * We may sleep if:
Linus Torvalds's avatar
Linus Torvalds committed
3245 3246 3247 3248 3249 3250 3251 3252 3253 3254
 *
 *	1. the current iclog is not in the active nor dirty state.
 *	2. the current iclog dirty, and the previous iclog is not in the
 *		active nor dirty state.
 *	3. the current iclog is active, and there is another thread writing
 *		to this particular iclog.
 *	4. a) the current iclog is active and has no other writers
 *	   b) when we return from flushing out this iclog, it is still
 *		not in the active nor dirty state.
 */
3255 3256 3257 3258 3259
int
_xfs_log_force(
	struct xfs_mount	*mp,
	uint			flags,
	int			*log_flushed)
Linus Torvalds's avatar
Linus Torvalds committed
3260
{
3261
	struct xlog		*log = mp->m_log;
3262 3263 3264
	struct xlog_in_core	*iclog;
	xfs_lsn_t		lsn;

3265
	XFS_STATS_INC(mp, xs_log_force);
Linus Torvalds's avatar
Linus Torvalds committed
3266

3267
	xlog_cil_force(log);
3268

Eric Sandeen's avatar
Eric Sandeen committed
3269
	spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3270 3271 3272

	iclog = log->l_iclog;
	if (iclog->ic_state & XLOG_STATE_IOERROR) {
Eric Sandeen's avatar
Eric Sandeen committed
3273
		spin_unlock(&log->l_icloglock);
3274
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
	}

	/* If the head iclog is not active nor dirty, we just attach
	 * ourselves to the head and go to sleep.
	 */
	if (iclog->ic_state == XLOG_STATE_ACTIVE ||
	    iclog->ic_state == XLOG_STATE_DIRTY) {
		/*
		 * If the head is dirty or (active and empty), then
		 * we need to look at the previous iclog.  If the previous
		 * iclog is active or dirty we are done.  There is nothing
		 * to sync out.  Otherwise, we attach ourselves to the
		 * previous iclog and go to sleep.
		 */
		if (iclog->ic_state == XLOG_STATE_DIRTY ||
3290 3291
		    (atomic_read(&iclog->ic_refcnt) == 0
		     && iclog->ic_offset == 0)) {
Linus Torvalds's avatar
Linus Torvalds committed
3292 3293 3294 3295 3296 3297 3298
			iclog = iclog->ic_prev;
			if (iclog->ic_state == XLOG_STATE_ACTIVE ||
			    iclog->ic_state == XLOG_STATE_DIRTY)
				goto no_sleep;
			else
				goto maybe_sleep;
		} else {
3299
			if (atomic_read(&iclog->ic_refcnt) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
3300 3301 3302 3303 3304 3305
				/* We are the only one with access to this
				 * iclog.  Flush it out now.  There should
				 * be a roundoff of zero to show that someone
				 * has already taken care of the roundoff from
				 * the previous sync.
				 */
3306
				atomic_inc(&iclog->ic_refcnt);
3307
				lsn = be64_to_cpu(iclog->ic_header.h_lsn);
Linus Torvalds's avatar
Linus Torvalds committed
3308
				xlog_state_switch_iclogs(log, iclog, 0);
Eric Sandeen's avatar
Eric Sandeen committed
3309
				spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3310 3311

				if (xlog_state_release_iclog(log, iclog))
3312
					return -EIO;
3313 3314 3315

				if (log_flushed)
					*log_flushed = 1;
Eric Sandeen's avatar
Eric Sandeen committed
3316
				spin_lock(&log->l_icloglock);
3317
				if (be64_to_cpu(iclog->ic_header.h_lsn) == lsn &&
Linus Torvalds's avatar
Linus Torvalds committed
3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341
				    iclog->ic_state != XLOG_STATE_DIRTY)
					goto maybe_sleep;
				else
					goto no_sleep;
			} else {
				/* Someone else is writing to this iclog.
				 * Use its call to flush out the data.  However,
				 * the other thread may not force out this LR,
				 * so we mark it WANT_SYNC.
				 */
				xlog_state_switch_iclogs(log, iclog, 0);
				goto maybe_sleep;
			}
		}
	}

	/* By the time we come around again, the iclog could've been filled
	 * which would give it another lsn.  If we have a new lsn, just
	 * return because the relevant data has been flushed.
	 */
maybe_sleep:
	if (flags & XFS_LOG_SYNC) {
		/*
		 * We must check if we're shutting down here, before
Eric Sandeen's avatar
Eric Sandeen committed
3342
		 * we wait, while we're holding the l_icloglock.
Linus Torvalds's avatar
Linus Torvalds committed
3343 3344 3345 3346
		 * Then we check again after waking up, in case our
		 * sleep was disturbed by a bad news.
		 */
		if (iclog->ic_state & XLOG_STATE_IOERROR) {
Eric Sandeen's avatar
Eric Sandeen committed
3347
			spin_unlock(&log->l_icloglock);
3348
			return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
3349
		}
3350
		XFS_STATS_INC(mp, xs_log_force_sleep);
3351
		xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3352 3353 3354 3355 3356 3357
		/*
		 * No need to grab the log lock here since we're
		 * only deciding whether or not to return EIO
		 * and the memory read should be atomic.
		 */
		if (iclog->ic_state & XLOG_STATE_IOERROR)
3358
			return -EIO;
3359 3360
		if (log_flushed)
			*log_flushed = 1;
Linus Torvalds's avatar
Linus Torvalds committed
3361 3362 3363
	} else {

no_sleep:
Eric Sandeen's avatar
Eric Sandeen committed
3364
		spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3365 3366
	}
	return 0;
3367
}
Linus Torvalds's avatar
Linus Torvalds committed
3368

3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380
/*
 * Wrapper for _xfs_log_force(), to be used when caller doesn't care
 * about errors or whether the log was flushed or not. This is the normal
 * interface to use when trying to unpin items or move the log forward.
 */
void
xfs_log_force(
	xfs_mount_t	*mp,
	uint		flags)
{
	int	error;

3381
	trace_xfs_log_force(mp, 0);
3382
	error = _xfs_log_force(mp, flags, NULL);
3383 3384
	if (error)
		xfs_warn(mp, "%s: error %d returned.", __func__, error);
3385
}
Linus Torvalds's avatar
Linus Torvalds committed
3386 3387

/*
3388
 * Force the in-core log to disk for a specific LSN.
Linus Torvalds's avatar
Linus Torvalds committed
3389 3390 3391 3392 3393 3394 3395
 *
 * Find in-core log with lsn.
 *	If it is in the DIRTY state, just return.
 *	If it is in the ACTIVE state, move the in-core log into the WANT_SYNC
 *		state and go to sleep or return.
 *	If it is in any other state, go to sleep or return.
 *
3396 3397 3398 3399 3400
 * Synchronous forces are implemented with a signal variable. All callers
 * to force a given lsn to disk will wait on a the sv attached to the
 * specific in-core log.  When given in-core log finally completes its
 * write to disk, that thread will wake up all threads waiting on the
 * sv.
Linus Torvalds's avatar
Linus Torvalds committed
3401
 */
3402 3403 3404 3405 3406 3407
int
_xfs_log_force_lsn(
	struct xfs_mount	*mp,
	xfs_lsn_t		lsn,
	uint			flags,
	int			*log_flushed)
Linus Torvalds's avatar
Linus Torvalds committed
3408
{
3409
	struct xlog		*log = mp->m_log;
3410 3411
	struct xlog_in_core	*iclog;
	int			already_slept = 0;
Linus Torvalds's avatar
Linus Torvalds committed
3412

3413
	ASSERT(lsn != 0);
Linus Torvalds's avatar
Linus Torvalds committed
3414

3415
	XFS_STATS_INC(mp, xs_log_force);
Linus Torvalds's avatar
Linus Torvalds committed
3416

3417 3418 3419
	lsn = xlog_cil_force_lsn(log, lsn);
	if (lsn == NULLCOMMITLSN)
		return 0;
3420

3421 3422 3423 3424
try_again:
	spin_lock(&log->l_icloglock);
	iclog = log->l_iclog;
	if (iclog->ic_state & XLOG_STATE_IOERROR) {
Eric Sandeen's avatar
Eric Sandeen committed
3425
		spin_unlock(&log->l_icloglock);
3426
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
3427 3428
	}

3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463
	do {
		if (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) {
			iclog = iclog->ic_next;
			continue;
		}

		if (iclog->ic_state == XLOG_STATE_DIRTY) {
			spin_unlock(&log->l_icloglock);
			return 0;
		}

		if (iclog->ic_state == XLOG_STATE_ACTIVE) {
			/*
			 * We sleep here if we haven't already slept (e.g.
			 * this is the first time we've looked at the correct
			 * iclog buf) and the buffer before us is going to
			 * be sync'ed. The reason for this is that if we
			 * are doing sync transactions here, by waiting for
			 * the previous I/O to complete, we can allow a few
			 * more transactions into this iclog before we close
			 * it down.
			 *
			 * Otherwise, we mark the buffer WANT_SYNC, and bump
			 * up the refcnt so we can release the log (which
			 * drops the ref count).  The state switch keeps new
			 * transaction commits from using this buffer.  When
			 * the current commits finish writing into the buffer,
			 * the refcount will drop to zero and the buffer will
			 * go out then.
			 */
			if (!already_slept &&
			    (iclog->ic_prev->ic_state &
			     (XLOG_STATE_WANT_SYNC | XLOG_STATE_SYNCING))) {
				ASSERT(!(iclog->ic_state & XLOG_STATE_IOERROR));

3464
				XFS_STATS_INC(mp, xs_log_force_sleep);
3465

3466 3467
				xlog_wait(&iclog->ic_prev->ic_write_wait,
							&log->l_icloglock);
3468 3469 3470 3471 3472
				if (log_flushed)
					*log_flushed = 1;
				already_slept = 1;
				goto try_again;
			}
3473
			atomic_inc(&iclog->ic_refcnt);
Linus Torvalds's avatar
Linus Torvalds committed
3474
			xlog_state_switch_iclogs(log, iclog, 0);
Eric Sandeen's avatar
Eric Sandeen committed
3475
			spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3476
			if (xlog_state_release_iclog(log, iclog))
3477
				return -EIO;
3478 3479
			if (log_flushed)
				*log_flushed = 1;
Eric Sandeen's avatar
Eric Sandeen committed
3480
			spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3481 3482
		}

3483 3484 3485 3486 3487 3488 3489 3490 3491
		if ((flags & XFS_LOG_SYNC) && /* sleep */
		    !(iclog->ic_state &
		      (XLOG_STATE_ACTIVE | XLOG_STATE_DIRTY))) {
			/*
			 * Don't wait on completion if we know that we've
			 * gotten a log write error.
			 */
			if (iclog->ic_state & XLOG_STATE_IOERROR) {
				spin_unlock(&log->l_icloglock);
3492
				return -EIO;
3493
			}
3494
			XFS_STATS_INC(mp, xs_log_force_sleep);
3495
			xlog_wait(&iclog->ic_force_wait, &log->l_icloglock);
3496 3497 3498 3499 3500 3501
			/*
			 * No need to grab the log lock here since we're
			 * only deciding whether or not to return EIO
			 * and the memory read should be atomic.
			 */
			if (iclog->ic_state & XLOG_STATE_IOERROR)
3502
				return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
3503

3504 3505 3506
			if (log_flushed)
				*log_flushed = 1;
		} else {		/* just return */
Eric Sandeen's avatar
Eric Sandeen committed
3507
			spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3508 3509
		}

3510 3511
		return 0;
	} while (iclog != log->l_iclog);
Linus Torvalds's avatar
Linus Torvalds committed
3512

3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528
	spin_unlock(&log->l_icloglock);
	return 0;
}

/*
 * Wrapper for _xfs_log_force_lsn(), to be used when caller doesn't care
 * about errors or whether the log was flushed or not. This is the normal
 * interface to use when trying to unpin items or move the log forward.
 */
void
xfs_log_force_lsn(
	xfs_mount_t	*mp,
	xfs_lsn_t	lsn,
	uint		flags)
{
	int	error;
Linus Torvalds's avatar
Linus Torvalds committed
3529

3530
	trace_xfs_log_force(mp, lsn);
3531
	error = _xfs_log_force_lsn(mp, lsn, flags, NULL);
3532 3533
	if (error)
		xfs_warn(mp, "%s: error %d returned.", __func__, error);
3534
}
Linus Torvalds's avatar
Linus Torvalds committed
3535 3536 3537 3538 3539

/*
 * Called when we want to mark the current iclog as being ready to sync to
 * disk.
 */
3540
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
3541 3542 3543
xlog_state_want_sync(
	struct xlog		*log,
	struct xlog_in_core	*iclog)
Linus Torvalds's avatar
Linus Torvalds committed
3544
{
3545
	assert_spin_locked(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3546 3547 3548 3549 3550 3551 3552

	if (iclog->ic_state == XLOG_STATE_ACTIVE) {
		xlog_state_switch_iclogs(log, iclog, 0);
	} else {
		ASSERT(iclog->ic_state &
			(XLOG_STATE_WANT_SYNC|XLOG_STATE_IOERROR));
	}
3553
}
Linus Torvalds's avatar
Linus Torvalds committed
3554 3555 3556 3557 3558 3559 3560 3561 3562 3563


/*****************************************************************************
 *
 *		TICKET functions
 *
 *****************************************************************************
 */

/*
Malcolm Parsons's avatar
Malcolm Parsons committed
3564
 * Free a used ticket when its refcount falls to zero.
Linus Torvalds's avatar
Linus Torvalds committed
3565
 */
3566 3567 3568
void
xfs_log_ticket_put(
	xlog_ticket_t	*ticket)
Linus Torvalds's avatar
Linus Torvalds committed
3569
{
3570
	ASSERT(atomic_read(&ticket->t_ref) > 0);
3571
	if (atomic_dec_and_test(&ticket->t_ref))
3572 3573
		kmem_zone_free(xfs_log_ticket_zone, ticket);
}
Linus Torvalds's avatar
Linus Torvalds committed
3574

3575 3576 3577 3578 3579 3580 3581 3582
xlog_ticket_t *
xfs_log_ticket_get(
	xlog_ticket_t	*ticket)
{
	ASSERT(atomic_read(&ticket->t_ref) > 0);
	atomic_inc(&ticket->t_ref);
	return ticket;
}
Linus Torvalds's avatar
Linus Torvalds committed
3583 3584

/*
3585 3586
 * Figure out the total log space unit (in bytes) that would be
 * required for a log ticket.
Linus Torvalds's avatar
Linus Torvalds committed
3587
 */
3588 3589 3590 3591
int
xfs_log_calc_unit_res(
	struct xfs_mount	*mp,
	int			unit_bytes)
Linus Torvalds's avatar
Linus Torvalds committed
3592
{
3593 3594 3595
	struct xlog		*log = mp->m_log;
	int			iclog_space;
	uint			num_headers;
Linus Torvalds's avatar
Linus Torvalds committed
3596 3597 3598 3599 3600 3601 3602 3603

	/*
	 * Permanent reservations have up to 'cnt'-1 active log operations
	 * in the log.  A unit in this case is the amount of space for one
	 * of these log operations.  Normal reservations have a cnt of 1
	 * and their unit amount is the total amount of space required.
	 *
	 * The following lines of code account for non-transaction data
3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625
	 * which occupy space in the on-disk log.
	 *
	 * Normal form of a transaction is:
	 * <oph><trans-hdr><start-oph><reg1-oph><reg1><reg2-oph>...<commit-oph>
	 * and then there are LR hdrs, split-recs and roundoff at end of syncs.
	 *
	 * We need to account for all the leadup data and trailer data
	 * around the transaction data.
	 * And then we need to account for the worst case in terms of using
	 * more space.
	 * The worst case will happen if:
	 * - the placement of the transaction happens to be such that the
	 *   roundoff is at its maximum
	 * - the transaction data is synced before the commit record is synced
	 *   i.e. <transaction-data><roundoff> | <commit-rec><roundoff>
	 *   Therefore the commit record is in its own Log Record.
	 *   This can happen as the commit record is called with its
	 *   own region to xlog_write().
	 *   This then means that in the worst case, roundoff can happen for
	 *   the commit-rec as well.
	 *   The commit-rec is smaller than padding in this scenario and so it is
	 *   not added separately.
Linus Torvalds's avatar
Linus Torvalds committed
3626 3627
	 */

3628 3629 3630 3631
	/* for trans header */
	unit_bytes += sizeof(xlog_op_header_t);
	unit_bytes += sizeof(xfs_trans_header_t);

Linus Torvalds's avatar
Linus Torvalds committed
3632
	/* for start-rec */
3633 3634
	unit_bytes += sizeof(xlog_op_header_t);

3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663
	/*
	 * for LR headers - the space for data in an iclog is the size minus
	 * the space used for the headers. If we use the iclog size, then we
	 * undercalculate the number of headers required.
	 *
	 * Furthermore - the addition of op headers for split-recs might
	 * increase the space required enough to require more log and op
	 * headers, so take that into account too.
	 *
	 * IMPORTANT: This reservation makes the assumption that if this
	 * transaction is the first in an iclog and hence has the LR headers
	 * accounted to it, then the remaining space in the iclog is
	 * exclusively for this transaction.  i.e. if the transaction is larger
	 * than the iclog, it will be the only thing in that iclog.
	 * Fundamentally, this means we must pass the entire log vector to
	 * xlog_write to guarantee this.
	 */
	iclog_space = log->l_iclog_size - log->l_iclog_hsize;
	num_headers = howmany(unit_bytes, iclog_space);

	/* for split-recs - ophdrs added when data split over LRs */
	unit_bytes += sizeof(xlog_op_header_t) * num_headers;

	/* add extra header reservations if we overrun */
	while (!num_headers ||
	       howmany(unit_bytes, iclog_space) > num_headers) {
		unit_bytes += sizeof(xlog_op_header_t);
		num_headers++;
	}
3664
	unit_bytes += log->l_iclog_hsize * num_headers;
Linus Torvalds's avatar
Linus Torvalds committed
3665

3666 3667 3668 3669
	/* for commit-rec LR header - note: padding will subsume the ophdr */
	unit_bytes += log->l_iclog_hsize;

	/* for roundoff padding for transaction data and one for commit record */
3670
	if (xfs_sb_version_haslogv2(&mp->m_sb) && mp->m_sb.sb_logsunit > 1) {
Linus Torvalds's avatar
Linus Torvalds committed
3671
		/* log su roundoff */
3672
		unit_bytes += 2 * mp->m_sb.sb_logsunit;
Linus Torvalds's avatar
Linus Torvalds committed
3673 3674
	} else {
		/* BB roundoff */
3675
		unit_bytes += 2 * BBSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
3676 3677
        }

3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701
	return unit_bytes;
}

/*
 * Allocate and initialise a new log ticket.
 */
struct xlog_ticket *
xlog_ticket_alloc(
	struct xlog		*log,
	int			unit_bytes,
	int			cnt,
	char			client,
	bool			permanent,
	xfs_km_flags_t		alloc_flags)
{
	struct xlog_ticket	*tic;
	int			unit_res;

	tic = kmem_zone_zalloc(xfs_log_ticket_zone, alloc_flags);
	if (!tic)
		return NULL;

	unit_res = xfs_log_calc_unit_res(log->l_mp, unit_bytes);

3702
	atomic_set(&tic->t_ref, 1);
3703
	tic->t_task		= current;
3704
	INIT_LIST_HEAD(&tic->t_queue);
3705 3706
	tic->t_unit_res		= unit_res;
	tic->t_curr_res		= unit_res;
Linus Torvalds's avatar
Linus Torvalds committed
3707 3708
	tic->t_cnt		= cnt;
	tic->t_ocnt		= cnt;
3709
	tic->t_tid		= prandom_u32();
Linus Torvalds's avatar
Linus Torvalds committed
3710 3711
	tic->t_clientid		= client;
	tic->t_flags		= XLOG_TIC_INITED;
3712
	tic->t_trans_type	= 0;
3713
	if (permanent)
Linus Torvalds's avatar
Linus Torvalds committed
3714 3715
		tic->t_flags |= XLOG_TIC_PERM_RESERV;

3716
	xlog_tic_reset_res(tic);
3717

Linus Torvalds's avatar
Linus Torvalds committed
3718
	return tic;
3719
}
Linus Torvalds's avatar
Linus Torvalds committed
3720 3721 3722 3723 3724 3725 3726 3727


/******************************************************************************
 *
 *		Log debug routines
 *
 ******************************************************************************
 */
3728
#if defined(DEBUG)
Linus Torvalds's avatar
Linus Torvalds committed
3729 3730 3731 3732 3733 3734
/*
 * Make sure that the destination ptr is within the valid data region of
 * one of the iclogs.  This uses backup pointers stored in a different
 * part of the log in case we trash the log structure.
 */
void
3735
xlog_verify_dest_ptr(
3736
	struct xlog	*log,
3737
	void		*ptr)
Linus Torvalds's avatar
Linus Torvalds committed
3738 3739 3740 3741
{
	int i;
	int good_ptr = 0;

3742 3743 3744
	for (i = 0; i < log->l_iclog_bufs; i++) {
		if (ptr >= log->l_iclog_bak[i] &&
		    ptr <= log->l_iclog_bak[i] + log->l_iclog_size)
Linus Torvalds's avatar
Linus Torvalds committed
3745 3746
			good_ptr++;
	}
3747 3748

	if (!good_ptr)
3749
		xfs_emerg(log->l_mp, "%s: invalid ptr", __func__);
3750
}
Linus Torvalds's avatar
Linus Torvalds committed
3751

3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762
/*
 * Check to make sure the grant write head didn't just over lap the tail.  If
 * the cycles are the same, we can't be overlapping.  Otherwise, make sure that
 * the cycles differ by exactly one and check the byte count.
 *
 * This check is run unlocked, so can give false positives. Rather than assert
 * on failures, use a warn-once flag and a panic tag to allow the admin to
 * determine if they want to panic the machine when such an error occurs. For
 * debug kernels this will have the same effect as using an assert but, unlinke
 * an assert, it can be turned off at runtime.
 */
3763 3764
STATIC void
xlog_verify_grant_tail(
3765
	struct xlog	*log)
3766
{
3767
	int		tail_cycle, tail_blocks;
3768
	int		cycle, space;
3769

3770
	xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &space);
3771 3772
	xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_blocks);
	if (tail_cycle != cycle) {
3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785
		if (cycle - 1 != tail_cycle &&
		    !(log->l_flags & XLOG_TAIL_WARN)) {
			xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
				"%s: cycle - 1 != tail_cycle", __func__);
			log->l_flags |= XLOG_TAIL_WARN;
		}

		if (space > BBTOB(tail_blocks) &&
		    !(log->l_flags & XLOG_TAIL_WARN)) {
			xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES,
				"%s: space > BBTOB(tail_blocks)", __func__);
			log->l_flags |= XLOG_TAIL_WARN;
		}
3786 3787 3788
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
3789 3790
/* check if it will fit */
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
3791 3792 3793 3794
xlog_verify_tail_lsn(
	struct xlog		*log,
	struct xlog_in_core	*iclog,
	xfs_lsn_t		tail_lsn)
Linus Torvalds's avatar
Linus Torvalds committed
3795 3796 3797 3798 3799 3800 3801
{
    int blocks;

    if (CYCLE_LSN(tail_lsn) == log->l_prev_cycle) {
	blocks =
	    log->l_logBBsize - (log->l_prev_block - BLOCK_LSN(tail_lsn));
	if (blocks < BTOBB(iclog->ic_offset)+BTOBB(log->l_iclog_hsize))
3802
		xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
3803 3804 3805 3806
    } else {
	ASSERT(CYCLE_LSN(tail_lsn)+1 == log->l_prev_cycle);

	if (BLOCK_LSN(tail_lsn) == log->l_prev_block)
3807
		xfs_emerg(log->l_mp, "%s: tail wrapped", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
3808 3809 3810

	blocks = BLOCK_LSN(tail_lsn) - log->l_prev_block;
	if (blocks < BTOBB(iclog->ic_offset) + 1)
3811
		xfs_emerg(log->l_mp, "%s: ran out of log space", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830
    }
}	/* xlog_verify_tail_lsn */

/*
 * Perform a number of checks on the iclog before writing to disk.
 *
 * 1. Make sure the iclogs are still circular
 * 2. Make sure we have a good magic number
 * 3. Make sure we don't have magic numbers in the data
 * 4. Check fields of each log operation header for:
 *	A. Valid client identifier
 *	B. tid ptr value falls in valid ptr space (user space code)
 *	C. Length in log record header is correct according to the
 *		individual operation headers within record.
 * 5. When a bwrite will occur within 5 blocks of the front of the physical
 *	log, check the preceding blocks of the physical log to make sure all
 *	the cycle numbers agree with the current cycle number.
 */
STATIC void
Mark Tinguely's avatar
Mark Tinguely committed
3831 3832 3833 3834
xlog_verify_iclog(
	struct xlog		*log,
	struct xlog_in_core	*iclog,
	int			count,
3835
	bool                    syncing)
Linus Torvalds's avatar
Linus Torvalds committed
3836 3837 3838 3839
{
	xlog_op_header_t	*ophead;
	xlog_in_core_t		*icptr;
	xlog_in_core_2_t	*xhdr;
3840
	void			*base_ptr, *ptr, *p;
3841
	ptrdiff_t		field_offset;
Linus Torvalds's avatar
Linus Torvalds committed
3842 3843 3844 3845 3846
	__uint8_t		clientid;
	int			len, i, j, k, op_len;
	int			idx;

	/* check validity of iclog pointers */
Eric Sandeen's avatar
Eric Sandeen committed
3847
	spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3848
	icptr = log->l_iclog;
3849 3850 3851
	for (i = 0; i < log->l_iclog_bufs; i++, icptr = icptr->ic_next)
		ASSERT(icptr);

Linus Torvalds's avatar
Linus Torvalds committed
3852
	if (icptr != log->l_iclog)
3853
		xfs_emerg(log->l_mp, "%s: corrupt iclog ring", __func__);
Eric Sandeen's avatar
Eric Sandeen committed
3854
	spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
3855 3856

	/* check log magic numbers */
3857
	if (iclog->ic_header.h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
3858
		xfs_emerg(log->l_mp, "%s: invalid magic num", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
3859

3860 3861 3862
	base_ptr = ptr = &iclog->ic_header;
	p = &iclog->ic_header;
	for (ptr += BBSIZE; ptr < base_ptr + count; ptr += BBSIZE) {
3863
		if (*(__be32 *)ptr == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
3864 3865
			xfs_emerg(log->l_mp, "%s: unexpected magic num",
				__func__);
Linus Torvalds's avatar
Linus Torvalds committed
3866 3867 3868
	}

	/* check fields */
3869
	len = be32_to_cpu(iclog->ic_header.h_num_logops);
3870 3871
	base_ptr = ptr = iclog->ic_datap;
	ophead = ptr;
3872
	xhdr = iclog->ic_data;
Linus Torvalds's avatar
Linus Torvalds committed
3873
	for (i = 0; i < len; i++) {
3874
		ophead = ptr;
Linus Torvalds's avatar
Linus Torvalds committed
3875 3876

		/* clientid is only 1 byte */
3877 3878
		p = &ophead->oh_clientid;
		field_offset = p - base_ptr;
3879
		if (!syncing || (field_offset & 0x1ff)) {
Linus Torvalds's avatar
Linus Torvalds committed
3880 3881
			clientid = ophead->oh_clientid;
		} else {
3882
			idx = BTOBBT((char *)&ophead->oh_clientid - iclog->ic_datap);
Linus Torvalds's avatar
Linus Torvalds committed
3883 3884 3885
			if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
				j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
				k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3886 3887
				clientid = xlog_get_client_id(
					xhdr[j].hic_xheader.xh_cycle_data[k]);
Linus Torvalds's avatar
Linus Torvalds committed
3888
			} else {
3889 3890
				clientid = xlog_get_client_id(
					iclog->ic_header.h_cycle_data[idx]);
Linus Torvalds's avatar
Linus Torvalds committed
3891 3892 3893
			}
		}
		if (clientid != XFS_TRANSACTION && clientid != XFS_LOG)
3894 3895 3896 3897
			xfs_warn(log->l_mp,
				"%s: invalid clientid %d op 0x%p offset 0x%lx",
				__func__, clientid, ophead,
				(unsigned long)field_offset);
Linus Torvalds's avatar
Linus Torvalds committed
3898 3899

		/* check length */
3900 3901
		p = &ophead->oh_len;
		field_offset = p - base_ptr;
3902
		if (!syncing || (field_offset & 0x1ff)) {
3903
			op_len = be32_to_cpu(ophead->oh_len);
Linus Torvalds's avatar
Linus Torvalds committed
3904
		} else {
3905 3906
			idx = BTOBBT((uintptr_t)&ophead->oh_len -
				    (uintptr_t)iclog->ic_datap);
Linus Torvalds's avatar
Linus Torvalds committed
3907 3908 3909
			if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) {
				j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
				k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3910
				op_len = be32_to_cpu(xhdr[j].hic_xheader.xh_cycle_data[k]);
Linus Torvalds's avatar
Linus Torvalds committed
3911
			} else {
3912
				op_len = be32_to_cpu(iclog->ic_header.h_cycle_data[idx]);
Linus Torvalds's avatar
Linus Torvalds committed
3913 3914 3915 3916 3917
			}
		}
		ptr += sizeof(xlog_op_header_t) + op_len;
	}
}	/* xlog_verify_iclog */
3918
#endif
Linus Torvalds's avatar
Linus Torvalds committed
3919 3920

/*
Eric Sandeen's avatar
Eric Sandeen committed
3921
 * Mark all iclogs IOERROR. l_icloglock is held by the caller.
Linus Torvalds's avatar
Linus Torvalds committed
3922 3923 3924
 */
STATIC int
xlog_state_ioerror(
Mark Tinguely's avatar
Mark Tinguely committed
3925
	struct xlog	*log)
Linus Torvalds's avatar
Linus Torvalds committed
3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
{
	xlog_in_core_t	*iclog, *ic;

	iclog = log->l_iclog;
	if (! (iclog->ic_state & XLOG_STATE_IOERROR)) {
		/*
		 * Mark all the incore logs IOERROR.
		 * From now on, no log flushes will result.
		 */
		ic = iclog;
		do {
			ic->ic_state = XLOG_STATE_IOERROR;
			ic = ic->ic_next;
		} while (ic != iclog);
3940
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3941 3942 3943 3944
	}
	/*
	 * Return non-zero, if state transition has already happened.
	 */
3945
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
3946 3947 3948 3949 3950 3951
}

/*
 * This is called from xfs_force_shutdown, when we're forcibly
 * shutting down the filesystem, typically because of an IO error.
 * Our main objectives here are to make sure that:
3952 3953 3954
 *	a. if !logerror, flush the logs to disk. Anything modified
 *	   after this is ignored.
 *	b. the filesystem gets marked 'SHUTDOWN' for all interested
Linus Torvalds's avatar
Linus Torvalds committed
3955
 *	   parties to find out, 'atomically'.
3956
 *	c. those who're sleeping on log reservations, pinned objects and
Linus Torvalds's avatar
Linus Torvalds committed
3957
 *	    other resources get woken up, and be told the bad news.
3958
 *	d. nothing new gets queued up after (b) and (c) are done.
3959
 *
3960 3961 3962
 * Note: for the !logerror case we need to flush the regions held in memory out
 * to disk first. This needs to be done before the log is marked as shutdown,
 * otherwise the iclog writes will fail.
Linus Torvalds's avatar
Linus Torvalds committed
3963 3964 3965 3966 3967 3968
 */
int
xfs_log_force_umount(
	struct xfs_mount	*mp,
	int			logerror)
{
Mark Tinguely's avatar
Mark Tinguely committed
3969
	struct xlog	*log;
Linus Torvalds's avatar
Linus Torvalds committed
3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980
	int		retval;

	log = mp->m_log;

	/*
	 * If this happens during log recovery, don't worry about
	 * locking; the log isn't open for business yet.
	 */
	if (!log ||
	    log->l_flags & XLOG_ACTIVE_RECOVERY) {
		mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
3981
		if (mp->m_sb_bp)
3982
			mp->m_sb_bp->b_flags |= XBF_DONE;
3983
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3984 3985 3986 3987 3988 3989 3990 3991
	}

	/*
	 * Somebody could've already done the hard work for us.
	 * No need to get locks for this.
	 */
	if (logerror && log->l_iclog->ic_state & XLOG_STATE_IOERROR) {
		ASSERT(XLOG_FORCED_SHUTDOWN(log));
3992
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
3993
	}
3994 3995

	/*
3996 3997 3998 3999 4000
	 * Flush all the completed transactions to disk before marking the log
	 * being shut down. We need to do it in this order to ensure that
	 * completed operations are safely on disk before we shut down, and that
	 * we don't have to issue any buffer IO after the shutdown flags are set
	 * to guarantee this.
4001
	 */
4002
	if (!logerror)
4003
		_xfs_log_force(mp, XFS_LOG_SYNC, NULL);
4004

Linus Torvalds's avatar
Linus Torvalds committed
4005
	/*
4006 4007
	 * mark the filesystem and the as in a shutdown state and wake
	 * everybody up to tell them the bad news.
Linus Torvalds's avatar
Linus Torvalds committed
4008
	 */
Eric Sandeen's avatar
Eric Sandeen committed
4009
	spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
4010
	mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN;
4011
	if (mp->m_sb_bp)
4012
		mp->m_sb_bp->b_flags |= XBF_DONE;
4013

Linus Torvalds's avatar
Linus Torvalds committed
4014
	/*
4015 4016
	 * Mark the log and the iclogs with IO error flags to prevent any
	 * further log IO from being issued or completed.
Linus Torvalds's avatar
Linus Torvalds committed
4017 4018
	 */
	log->l_flags |= XLOG_IO_ERROR;
4019
	retval = xlog_state_ioerror(log);
Eric Sandeen's avatar
Eric Sandeen committed
4020
	spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
4021 4022

	/*
4023 4024 4025 4026
	 * We don't want anybody waiting for log reservations after this. That
	 * means we have to wake up everybody queued up on reserveq as well as
	 * writeq.  In addition, we make sure in xlog_{re}grant_log_space that
	 * we don't enqueue anything once the SHUTDOWN flag is set, and this
4027
	 * action is protected by the grant locks.
Linus Torvalds's avatar
Linus Torvalds committed
4028
	 */
4029 4030
	xlog_grant_head_wake_all(&log->l_reserve_head);
	xlog_grant_head_wake_all(&log->l_write_head);
Linus Torvalds's avatar
Linus Torvalds committed
4031 4032

	/*
4033 4034 4035 4036
	 * Wake up everybody waiting on xfs_log_force. Wake the CIL push first
	 * as if the log writes were completed. The abort handling in the log
	 * item committed callback functions will do this again under lock to
	 * avoid races.
Linus Torvalds's avatar
Linus Torvalds committed
4037
	 */
4038
	wake_up_all(&log->l_cilp->xc_commit_wait);
Linus Torvalds's avatar
Linus Torvalds committed
4039 4040 4041 4042 4043 4044
	xlog_state_do_callback(log, XFS_LI_ABORTED, NULL);

#ifdef XFSERRORDEBUG
	{
		xlog_in_core_t	*iclog;

Eric Sandeen's avatar
Eric Sandeen committed
4045
		spin_lock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
4046 4047 4048 4049 4050
		iclog = log->l_iclog;
		do {
			ASSERT(iclog->ic_callback == 0);
			iclog = iclog->ic_next;
		} while (iclog != log->l_iclog);
Eric Sandeen's avatar
Eric Sandeen committed
4051
		spin_unlock(&log->l_icloglock);
Linus Torvalds's avatar
Linus Torvalds committed
4052 4053 4054
	}
#endif
	/* return non-zero if log IOERROR transition had already happened */
4055
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
4056 4057
}

4058
STATIC int
Mark Tinguely's avatar
Mark Tinguely committed
4059 4060
xlog_iclogs_empty(
	struct xlog	*log)
Linus Torvalds's avatar
Linus Torvalds committed
4061 4062 4063 4064 4065 4066 4067 4068 4069
{
	xlog_in_core_t	*iclog;

	iclog = log->l_iclog;
	do {
		/* endianness does not matter here, zero is zero in
		 * any language.
		 */
		if (iclog->ic_header.h_num_logops)
4070
			return 0;
Linus Torvalds's avatar
Linus Torvalds committed
4071 4072
		iclog = iclog->ic_next;
	} while (iclog != log->l_iclog);
4073
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
4074
}
4075

4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117
/*
 * Verify that an LSN stamped into a piece of metadata is valid. This is
 * intended for use in read verifiers on v5 superblocks.
 */
bool
xfs_log_check_lsn(
	struct xfs_mount	*mp,
	xfs_lsn_t		lsn)
{
	struct xlog		*log = mp->m_log;
	bool			valid;

	/*
	 * norecovery mode skips mount-time log processing and unconditionally
	 * resets the in-core LSN. We can't validate in this mode, but
	 * modifications are not allowed anyways so just return true.
	 */
	if (mp->m_flags & XFS_MOUNT_NORECOVERY)
		return true;

	/*
	 * Some metadata LSNs are initialized to NULL (e.g., the agfl). This is
	 * handled by recovery and thus safe to ignore here.
	 */
	if (lsn == NULLCOMMITLSN)
		return true;

	valid = xlog_valid_lsn(mp->m_log, lsn);

	/* warn the user about what's gone wrong before verifier failure */
	if (!valid) {
		spin_lock(&log->l_icloglock);
		xfs_warn(mp,
"Corruption warning: Metadata has LSN (%d:%d) ahead of current LSN (%d:%d). "
"Please unmount and run xfs_repair (>= v4.3) to resolve.",
			 CYCLE_LSN(lsn), BLOCK_LSN(lsn),
			 log->l_curr_cycle, log->l_curr_block);
		spin_unlock(&log->l_icloglock);
	}

	return valid;
}