xfs_log_recover.c 104.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3
 * All Rights Reserved.
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
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.
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
17 18
 */
#include "xfs.h"
19
#include "xfs_fs.h"
L
Linus Torvalds 已提交
20
#include "xfs_types.h"
21
#include "xfs_bit.h"
L
Linus Torvalds 已提交
22
#include "xfs_log.h"
23
#include "xfs_inum.h"
L
Linus Torvalds 已提交
24
#include "xfs_trans.h"
25 26
#include "xfs_sb.h"
#include "xfs_ag.h"
L
Linus Torvalds 已提交
27 28 29
#include "xfs_mount.h"
#include "xfs_error.h"
#include "xfs_bmap_btree.h"
30 31
#include "xfs_alloc_btree.h"
#include "xfs_ialloc_btree.h"
L
Linus Torvalds 已提交
32 33
#include "xfs_dinode.h"
#include "xfs_inode.h"
34 35
#include "xfs_inode_item.h"
#include "xfs_alloc.h"
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43
#include "xfs_ialloc.h"
#include "xfs_log_priv.h"
#include "xfs_buf_item.h"
#include "xfs_log_recover.h"
#include "xfs_extfree_item.h"
#include "xfs_trans_priv.h"
#include "xfs_quota.h"
#include "xfs_rw.h"
44
#include "xfs_utils.h"
C
Christoph Hellwig 已提交
45
#include "xfs_trace.h"
L
Linus Torvalds 已提交
46 47 48 49 50 51 52 53 54

STATIC int	xlog_find_zeroed(xlog_t *, xfs_daddr_t *);
STATIC int	xlog_clear_stale_blocks(xlog_t *, xfs_lsn_t);
#if defined(DEBUG)
STATIC void	xlog_recover_check_summary(xlog_t *);
#else
#define	xlog_recover_check_summary(log)
#endif

55 56 57 58 59 60 61 62 63 64 65
/*
 * This structure is used during recovery to record the buf log items which
 * have been canceled and should not be replayed.
 */
struct xfs_buf_cancel {
	xfs_daddr_t		bc_blkno;
	uint			bc_len;
	int			bc_refcount;
	struct list_head	bc_list;
};

L
Linus Torvalds 已提交
66 67 68 69
/*
 * Sector aligned buffer routines for buffer create/read/write/access
 */

70 71 72 73 74 75 76 77 78 79 80 81 82 83
/*
 * Verify the given count of basic blocks is valid number of blocks
 * to specify for an operation involving the given XFS log buffer.
 * Returns nonzero if the count is valid, 0 otherwise.
 */

static inline int
xlog_buf_bbcount_valid(
	xlog_t		*log,
	int		bbcount)
{
	return bbcount > 0 && bbcount <= log->l_logBBsize;
}

84 85 86 87 88
/*
 * Allocate a buffer to hold log data.  The buffer needs to be able
 * to map to a range of nbblks basic blocks at any valid (basic
 * block) offset within the log.
 */
89
STATIC xfs_buf_t *
L
Linus Torvalds 已提交
90 91
xlog_get_bp(
	xlog_t		*log,
92
	int		nbblks)
L
Linus Torvalds 已提交
93
{
94 95
	struct xfs_buf	*bp;

96
	if (!xlog_buf_bbcount_valid(log, nbblks)) {
97
		xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
98 99
			nbblks);
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
100 101
		return NULL;
	}
L
Linus Torvalds 已提交
102

103 104 105
	/*
	 * We do log I/O in units of log sectors (a power-of-2
	 * multiple of the basic block size), so we round up the
L
Lucas De Marchi 已提交
106
	 * requested size to accommodate the basic blocks required
107 108 109 110 111 112 113 114 115 116
	 * for complete log sectors.
	 *
	 * In addition, the buffer may be used for a non-sector-
	 * aligned block offset, in which case an I/O of the
	 * requested size could extend beyond the end of the
	 * buffer.  If the requested size is only 1 basic block it
	 * will never straddle a sector boundary, so this won't be
	 * an issue.  Nor will this be a problem if the log I/O is
	 * done in basic blocks (sector size 1).  But otherwise we
	 * extend the buffer by one extra log sector to ensure
L
Lucas De Marchi 已提交
117
	 * there's space to accommodate this possibility.
118
	 */
119 120 121
	if (nbblks > 1 && log->l_sectBBsize > 1)
		nbblks += log->l_sectBBsize;
	nbblks = round_up(nbblks, log->l_sectBBsize);
122

123 124 125 126
	bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, BBTOB(nbblks), 0);
	if (bp)
		xfs_buf_unlock(bp);
	return bp;
L
Linus Torvalds 已提交
127 128
}

129
STATIC void
L
Linus Torvalds 已提交
130 131 132 133 134 135
xlog_put_bp(
	xfs_buf_t	*bp)
{
	xfs_buf_free(bp);
}

A
Alex Elder 已提交
136 137 138 139
/*
 * Return the address of the start of the given block number's data
 * in a log buffer.  The buffer covers a log sector-aligned region.
 */
C
Christoph Hellwig 已提交
140 141 142 143 144 145 146
STATIC xfs_caddr_t
xlog_align(
	xlog_t		*log,
	xfs_daddr_t	blk_no,
	int		nbblks,
	xfs_buf_t	*bp)
{
C
Christoph Hellwig 已提交
147
	xfs_daddr_t	offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
C
Christoph Hellwig 已提交
148

C
Christoph Hellwig 已提交
149
	ASSERT(BBTOB(offset + nbblks) <= XFS_BUF_SIZE(bp));
150
	return bp->b_addr + BBTOB(offset);
C
Christoph Hellwig 已提交
151 152
}

L
Linus Torvalds 已提交
153 154 155 156

/*
 * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
 */
C
Christoph Hellwig 已提交
157 158
STATIC int
xlog_bread_noalign(
L
Linus Torvalds 已提交
159 160 161 162 163 164 165
	xlog_t		*log,
	xfs_daddr_t	blk_no,
	int		nbblks,
	xfs_buf_t	*bp)
{
	int		error;

166
	if (!xlog_buf_bbcount_valid(log, nbblks)) {
167
		xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
168 169
			nbblks);
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
170 171 172
		return EFSCORRUPTED;
	}

173 174
	blk_no = round_down(blk_no, log->l_sectBBsize);
	nbblks = round_up(nbblks, log->l_sectBBsize);
L
Linus Torvalds 已提交
175 176 177 178 179 180 181 182 183

	ASSERT(nbblks > 0);
	ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));

	XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
	XFS_BUF_READ(bp);
	XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));

	xfsbdstrat(log->l_mp, bp);
C
Christoph Hellwig 已提交
184
	error = xfs_buf_iowait(bp);
185
	if (error)
186
		xfs_buf_ioerror_alert(bp, __func__);
L
Linus Torvalds 已提交
187 188 189
	return error;
}

C
Christoph Hellwig 已提交
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
STATIC int
xlog_bread(
	xlog_t		*log,
	xfs_daddr_t	blk_no,
	int		nbblks,
	xfs_buf_t	*bp,
	xfs_caddr_t	*offset)
{
	int		error;

	error = xlog_bread_noalign(log, blk_no, nbblks, bp);
	if (error)
		return error;

	*offset = xlog_align(log, blk_no, nbblks, bp);
	return 0;
}

208 209 210 211 212 213 214 215 216 217 218 219
/*
 * Read at an offset into the buffer. Returns with the buffer in it's original
 * state regardless of the result of the read.
 */
STATIC int
xlog_bread_offset(
	xlog_t		*log,
	xfs_daddr_t	blk_no,		/* block to read from */
	int		nbblks,		/* blocks to read */
	xfs_buf_t	*bp,
	xfs_caddr_t	offset)
{
220
	xfs_caddr_t	orig_offset = bp->b_addr;
221 222 223
	int		orig_len = bp->b_buffer_length;
	int		error, error2;

224
	error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
225 226 227 228 229 230
	if (error)
		return error;

	error = xlog_bread_noalign(log, blk_no, nbblks, bp);

	/* must reset buffer pointer even on error */
231
	error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
232 233 234 235 236
	if (error)
		return error;
	return error2;
}

L
Linus Torvalds 已提交
237 238 239 240 241
/*
 * Write out the buffer at the given block for the given number of blocks.
 * The buffer is kept locked across the write and is returned locked.
 * This can only be used for synchronous log writes.
 */
242
STATIC int
L
Linus Torvalds 已提交
243 244 245 246 247 248 249 250
xlog_bwrite(
	xlog_t		*log,
	xfs_daddr_t	blk_no,
	int		nbblks,
	xfs_buf_t	*bp)
{
	int		error;

251
	if (!xlog_buf_bbcount_valid(log, nbblks)) {
252
		xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
253 254
			nbblks);
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
255 256 257
		return EFSCORRUPTED;
	}

258 259
	blk_no = round_down(blk_no, log->l_sectBBsize);
	nbblks = round_up(nbblks, log->l_sectBBsize);
L
Linus Torvalds 已提交
260 261 262 263 264 265

	ASSERT(nbblks > 0);
	ASSERT(BBTOB(nbblks) <= XFS_BUF_SIZE(bp));

	XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
	XFS_BUF_ZEROFLAGS(bp);
266
	xfs_buf_hold(bp);
267
	xfs_buf_lock(bp);
L
Linus Torvalds 已提交
268 269
	XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));

270
	error = xfs_bwrite(bp);
271 272
	if (error)
		xfs_buf_ioerror_alert(bp, __func__);
273
	xfs_buf_relse(bp);
L
Linus Torvalds 已提交
274 275 276 277 278 279 280 281 282 283 284 285
	return error;
}

#ifdef DEBUG
/*
 * dump debug superblock and log record information
 */
STATIC void
xlog_header_check_dump(
	xfs_mount_t		*mp,
	xlog_rec_header_t	*head)
{
286
	xfs_debug(mp, "%s:  SB : uuid = %pU, fmt = %d\n",
287
		__func__, &mp->m_sb.sb_uuid, XLOG_FMT);
288
	xfs_debug(mp, "    log : uuid = %pU, fmt = %d\n",
289
		&head->h_fs_uuid, be32_to_cpu(head->h_fmt));
L
Linus Torvalds 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302
}
#else
#define xlog_header_check_dump(mp, head)
#endif

/*
 * check log record header for recovery
 */
STATIC int
xlog_header_check_recover(
	xfs_mount_t		*mp,
	xlog_rec_header_t	*head)
{
303
	ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
L
Linus Torvalds 已提交
304 305 306 307 308 309

	/*
	 * IRIX doesn't write the h_fmt field and leaves it zeroed
	 * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
	 * a dirty log created in IRIX.
	 */
310
	if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
311 312
		xfs_warn(mp,
	"dirty log written in incompatible format - can't recover");
L
Linus Torvalds 已提交
313 314 315 316 317
		xlog_header_check_dump(mp, head);
		XFS_ERROR_REPORT("xlog_header_check_recover(1)",
				 XFS_ERRLEVEL_HIGH, mp);
		return XFS_ERROR(EFSCORRUPTED);
	} else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
318 319
		xfs_warn(mp,
	"dirty log entry has mismatched uuid - can't recover");
L
Linus Torvalds 已提交
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
		xlog_header_check_dump(mp, head);
		XFS_ERROR_REPORT("xlog_header_check_recover(2)",
				 XFS_ERRLEVEL_HIGH, mp);
		return XFS_ERROR(EFSCORRUPTED);
	}
	return 0;
}

/*
 * read the head block of the log and check the header
 */
STATIC int
xlog_header_check_mount(
	xfs_mount_t		*mp,
	xlog_rec_header_t	*head)
{
336
	ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
L
Linus Torvalds 已提交
337 338 339 340 341 342 343

	if (uuid_is_nil(&head->h_fs_uuid)) {
		/*
		 * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
		 * h_fs_uuid is nil, we assume this log was last mounted
		 * by IRIX and continue.
		 */
344
		xfs_warn(mp, "nil uuid in log - IRIX style log");
L
Linus Torvalds 已提交
345
	} else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
346
		xfs_warn(mp, "log has mismatched uuid - can't recover");
L
Linus Torvalds 已提交
347 348 349 350 351 352 353 354 355 356 357 358
		xlog_header_check_dump(mp, head);
		XFS_ERROR_REPORT("xlog_header_check_mount",
				 XFS_ERRLEVEL_HIGH, mp);
		return XFS_ERROR(EFSCORRUPTED);
	}
	return 0;
}

STATIC void
xlog_recover_iodone(
	struct xfs_buf	*bp)
{
359
	if (bp->b_error) {
L
Linus Torvalds 已提交
360 361 362 363
		/*
		 * We're not going to bother about retrying
		 * this during recovery. One strike!
		 */
364
		xfs_buf_ioerror_alert(bp, __func__);
365 366
		xfs_force_shutdown(bp->b_target->bt_mount,
					SHUTDOWN_META_IO_ERROR);
L
Linus Torvalds 已提交
367
	}
368
	bp->b_iodone = NULL;
C
Christoph Hellwig 已提交
369
	xfs_buf_ioend(bp, 0);
L
Linus Torvalds 已提交
370 371 372 373 374 375 376 377
}

/*
 * This routine finds (to an approximation) the first block in the physical
 * log which contains the given cycle.  It uses a binary search algorithm.
 * Note that the algorithm can not be perfect because the disk will not
 * necessarily be perfect.
 */
D
David Chinner 已提交
378
STATIC int
L
Linus Torvalds 已提交
379 380 381 382 383 384 385 386 387
xlog_find_cycle_start(
	xlog_t		*log,
	xfs_buf_t	*bp,
	xfs_daddr_t	first_blk,
	xfs_daddr_t	*last_blk,
	uint		cycle)
{
	xfs_caddr_t	offset;
	xfs_daddr_t	mid_blk;
388
	xfs_daddr_t	end_blk;
L
Linus Torvalds 已提交
389 390 391
	uint		mid_cycle;
	int		error;

392 393 394
	end_blk = *last_blk;
	mid_blk = BLK_AVG(first_blk, end_blk);
	while (mid_blk != first_blk && mid_blk != end_blk) {
C
Christoph Hellwig 已提交
395 396
		error = xlog_bread(log, mid_blk, 1, bp, &offset);
		if (error)
L
Linus Torvalds 已提交
397
			return error;
398
		mid_cycle = xlog_get_cycle(offset);
399 400 401 402 403
		if (mid_cycle == cycle)
			end_blk = mid_blk;   /* last_half_cycle == mid_cycle */
		else
			first_blk = mid_blk; /* first_half_cycle == mid_cycle */
		mid_blk = BLK_AVG(first_blk, end_blk);
L
Linus Torvalds 已提交
404
	}
405 406 407 408
	ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) ||
	       (mid_blk == end_blk && mid_blk-1 == first_blk));

	*last_blk = end_blk;
L
Linus Torvalds 已提交
409 410 411 412 413

	return 0;
}

/*
414 415 416 417 418 419
 * Check that a range of blocks does not contain stop_on_cycle_no.
 * Fill in *new_blk with the block offset where such a block is
 * found, or with -1 (an invalid block number) if there is no such
 * block in the range.  The scan needs to occur from front to back
 * and the pointer into the region must be updated since a later
 * routine will need to perform another test.
L
Linus Torvalds 已提交
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
 */
STATIC int
xlog_find_verify_cycle(
	xlog_t		*log,
	xfs_daddr_t	start_blk,
	int		nbblks,
	uint		stop_on_cycle_no,
	xfs_daddr_t	*new_blk)
{
	xfs_daddr_t	i, j;
	uint		cycle;
	xfs_buf_t	*bp;
	xfs_daddr_t	bufblks;
	xfs_caddr_t	buf = NULL;
	int		error = 0;

436 437 438 439 440 441
	/*
	 * Greedily allocate a buffer big enough to handle the full
	 * range of basic blocks we'll be examining.  If that fails,
	 * try a smaller size.  We need to be able to read at least
	 * a log sector, or we're out of luck.
	 */
L
Linus Torvalds 已提交
442 443 444
	bufblks = 1 << ffs(nbblks);
	while (!(bp = xlog_get_bp(log, bufblks))) {
		bufblks >>= 1;
445
		if (bufblks < log->l_sectBBsize)
L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453
			return ENOMEM;
	}

	for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
		int	bcount;

		bcount = min(bufblks, (start_blk + nbblks - i));

C
Christoph Hellwig 已提交
454 455
		error = xlog_bread(log, i, bcount, bp, &buf);
		if (error)
L
Linus Torvalds 已提交
456 457 458
			goto out;

		for (j = 0; j < bcount; j++) {
459
			cycle = xlog_get_cycle(buf);
L
Linus Torvalds 已提交
460 461 462 463 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 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
			if (cycle == stop_on_cycle_no) {
				*new_blk = i+j;
				goto out;
			}

			buf += BBSIZE;
		}
	}

	*new_blk = -1;

out:
	xlog_put_bp(bp);
	return error;
}

/*
 * Potentially backup over partial log record write.
 *
 * In the typical case, last_blk is the number of the block directly after
 * a good log record.  Therefore, we subtract one to get the block number
 * of the last block in the given buffer.  extra_bblks contains the number
 * of blocks we would have read on a previous read.  This happens when the
 * last log record is split over the end of the physical log.
 *
 * extra_bblks is the number of blocks potentially verified on a previous
 * call to this routine.
 */
STATIC int
xlog_find_verify_log_record(
	xlog_t			*log,
	xfs_daddr_t		start_blk,
	xfs_daddr_t		*last_blk,
	int			extra_bblks)
{
	xfs_daddr_t		i;
	xfs_buf_t		*bp;
	xfs_caddr_t		offset = NULL;
	xlog_rec_header_t	*head = NULL;
	int			error = 0;
	int			smallmem = 0;
	int			num_blks = *last_blk - start_blk;
	int			xhdrs;

	ASSERT(start_blk != 0 || *last_blk != start_blk);

	if (!(bp = xlog_get_bp(log, num_blks))) {
		if (!(bp = xlog_get_bp(log, 1)))
			return ENOMEM;
		smallmem = 1;
	} else {
C
Christoph Hellwig 已提交
511 512
		error = xlog_bread(log, start_blk, num_blks, bp, &offset);
		if (error)
L
Linus Torvalds 已提交
513 514 515 516 517 518 519
			goto out;
		offset += ((num_blks - 1) << BBSHIFT);
	}

	for (i = (*last_blk) - 1; i >= 0; i--) {
		if (i < start_blk) {
			/* valid log record not found */
520 521
			xfs_warn(log->l_mp,
		"Log inconsistent (didn't find previous header)");
L
Linus Torvalds 已提交
522 523 524 525 526 527
			ASSERT(0);
			error = XFS_ERROR(EIO);
			goto out;
		}

		if (smallmem) {
C
Christoph Hellwig 已提交
528 529
			error = xlog_bread(log, i, 1, bp, &offset);
			if (error)
L
Linus Torvalds 已提交
530 531 532 533 534
				goto out;
		}

		head = (xlog_rec_header_t *)offset;

535
		if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
L
Linus Torvalds 已提交
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
			break;

		if (!smallmem)
			offset -= BBSIZE;
	}

	/*
	 * We hit the beginning of the physical log & still no header.  Return
	 * to caller.  If caller can handle a return of -1, then this routine
	 * will be called again for the end of the physical log.
	 */
	if (i == -1) {
		error = -1;
		goto out;
	}

	/*
	 * We have the final block of the good log (the first block
	 * of the log record _before_ the head. So we check the uuid.
	 */
	if ((error = xlog_header_check_mount(log->l_mp, head)))
		goto out;

	/*
	 * We may have found a log record header before we expected one.
	 * last_blk will be the 1st block # with a given cycle #.  We may end
	 * up reading an entire log record.  In this case, we don't want to
	 * reset last_blk.  Only when last_blk points in the middle of a log
	 * record do we update last_blk.
	 */
566
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
567
		uint	h_size = be32_to_cpu(head->h_size);
L
Linus Torvalds 已提交
568 569 570 571 572 573 574 575

		xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
		if (h_size % XLOG_HEADER_CYCLE_SIZE)
			xhdrs++;
	} else {
		xhdrs = 1;
	}

576 577
	if (*last_blk - i + extra_bblks !=
	    BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
L
Linus Torvalds 已提交
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
		*last_blk = i;

out:
	xlog_put_bp(bp);
	return error;
}

/*
 * Head is defined to be the point of the log where the next log write
 * write could go.  This means that incomplete LR writes at the end are
 * eliminated when calculating the head.  We aren't guaranteed that previous
 * LR have complete transactions.  We only know that a cycle number of
 * current cycle number -1 won't be present in the log if we start writing
 * from our current block number.
 *
 * last_blk contains the block number of the first block with a given
 * cycle number.
 *
 * Return: zero if normal, non-zero if error.
 */
598
STATIC int
L
Linus Torvalds 已提交
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
xlog_find_head(
	xlog_t 		*log,
	xfs_daddr_t	*return_head_blk)
{
	xfs_buf_t	*bp;
	xfs_caddr_t	offset;
	xfs_daddr_t	new_blk, first_blk, start_blk, last_blk, head_blk;
	int		num_scan_bblks;
	uint		first_half_cycle, last_half_cycle;
	uint		stop_on_cycle;
	int		error, log_bbnum = log->l_logBBsize;

	/* Is the end of the log device zeroed? */
	if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
		*return_head_blk = first_blk;

		/* Is the whole lot zeroed? */
		if (!first_blk) {
			/* Linux XFS shouldn't generate totally zeroed logs -
			 * mkfs etc write a dummy unmount record to a fresh
			 * log so we can store the uuid in there
			 */
621
			xfs_warn(log->l_mp, "totally zeroed log");
L
Linus Torvalds 已提交
622 623 624 625
		}

		return 0;
	} else if (error) {
626
		xfs_warn(log->l_mp, "empty log check failed");
L
Linus Torvalds 已提交
627 628 629 630 631 632 633
		return error;
	}

	first_blk = 0;			/* get cycle # of 1st block */
	bp = xlog_get_bp(log, 1);
	if (!bp)
		return ENOMEM;
C
Christoph Hellwig 已提交
634 635 636

	error = xlog_bread(log, 0, 1, bp, &offset);
	if (error)
L
Linus Torvalds 已提交
637
		goto bp_err;
C
Christoph Hellwig 已提交
638

639
	first_half_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
640 641

	last_blk = head_blk = log_bbnum - 1;	/* get cycle # of last block */
C
Christoph Hellwig 已提交
642 643
	error = xlog_bread(log, last_blk, 1, bp, &offset);
	if (error)
L
Linus Torvalds 已提交
644
		goto bp_err;
C
Christoph Hellwig 已提交
645

646
	last_half_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
	ASSERT(last_half_cycle != 0);

	/*
	 * If the 1st half cycle number is equal to the last half cycle number,
	 * then the entire log is stamped with the same cycle number.  In this
	 * case, head_blk can't be set to zero (which makes sense).  The below
	 * math doesn't work out properly with head_blk equal to zero.  Instead,
	 * we set it to log_bbnum which is an invalid block number, but this
	 * value makes the math correct.  If head_blk doesn't changed through
	 * all the tests below, *head_blk is set to zero at the very end rather
	 * than log_bbnum.  In a sense, log_bbnum and zero are the same block
	 * in a circular file.
	 */
	if (first_half_cycle == last_half_cycle) {
		/*
		 * In this case we believe that the entire log should have
		 * cycle number last_half_cycle.  We need to scan backwards
		 * from the end verifying that there are no holes still
		 * containing last_half_cycle - 1.  If we find such a hole,
		 * then the start of that hole will be the new head.  The
		 * simple case looks like
		 *        x | x ... | x - 1 | x
		 * Another case that fits this picture would be
		 *        x | x + 1 | x ... | x
671
		 * In this case the head really is somewhere at the end of the
L
Linus Torvalds 已提交
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
		 * log, as one of the latest writes at the beginning was
		 * incomplete.
		 * One more case is
		 *        x | x + 1 | x ... | x - 1 | x
		 * This is really the combination of the above two cases, and
		 * the head has to end up at the start of the x-1 hole at the
		 * end of the log.
		 *
		 * In the 256k log case, we will read from the beginning to the
		 * end of the log and search for cycle numbers equal to x-1.
		 * We don't worry about the x+1 blocks that we encounter,
		 * because we know that they cannot be the head since the log
		 * started with x.
		 */
		head_blk = log_bbnum;
		stop_on_cycle = last_half_cycle - 1;
	} else {
		/*
		 * In this case we want to find the first block with cycle
		 * number matching last_half_cycle.  We expect the log to be
		 * some variation on
693
		 *        x + 1 ... | x ... | x
L
Linus Torvalds 已提交
694 695 696 697 698 699 700 701 702
		 * The first block with cycle number x (last_half_cycle) will
		 * be where the new head belongs.  First we do a binary search
		 * for the first occurrence of last_half_cycle.  The binary
		 * search may not be totally accurate, so then we scan back
		 * from there looking for occurrences of last_half_cycle before
		 * us.  If that backwards scan wraps around the beginning of
		 * the log, then we look for occurrences of last_half_cycle - 1
		 * at the end of the log.  The cases we're looking for look
		 * like
703 704 705
		 *                               v binary search stopped here
		 *        x + 1 ... | x | x + 1 | x ... | x
		 *                   ^ but we want to locate this spot
L
Linus Torvalds 已提交
706 707
		 * or
		 *        <---------> less than scan distance
708 709
		 *        x + 1 ... | x ... | x - 1 | x
		 *                           ^ we want to locate this spot
L
Linus Torvalds 已提交
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
		 */
		stop_on_cycle = last_half_cycle;
		if ((error = xlog_find_cycle_start(log, bp, first_blk,
						&head_blk, last_half_cycle)))
			goto bp_err;
	}

	/*
	 * Now validate the answer.  Scan back some number of maximum possible
	 * blocks and make sure each one has the expected cycle number.  The
	 * maximum is determined by the total possible amount of buffering
	 * in the in-core log.  The following number can be made tighter if
	 * we actually look at the block size of the filesystem.
	 */
	num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
	if (head_blk >= num_scan_bblks) {
		/*
		 * We are guaranteed that the entire check can be performed
		 * in one buffer.
		 */
		start_blk = head_blk - num_scan_bblks;
		if ((error = xlog_find_verify_cycle(log,
						start_blk, num_scan_bblks,
						stop_on_cycle, &new_blk)))
			goto bp_err;
		if (new_blk != -1)
			head_blk = new_blk;
	} else {		/* need to read 2 parts of log */
		/*
		 * We are going to scan backwards in the log in two parts.
		 * First we scan the physical end of the log.  In this part
		 * of the log, we are looking for blocks with cycle number
		 * last_half_cycle - 1.
		 * If we find one, then we know that the log starts there, as
		 * we've found a hole that didn't get written in going around
		 * the end of the physical log.  The simple case for this is
		 *        x + 1 ... | x ... | x - 1 | x
		 *        <---------> less than scan distance
		 * If all of the blocks at the end of the log have cycle number
		 * last_half_cycle, then we check the blocks at the start of
		 * the log looking for occurrences of last_half_cycle.  If we
		 * find one, then our current estimate for the location of the
		 * first occurrence of last_half_cycle is wrong and we move
		 * back to the hole we've found.  This case looks like
		 *        x + 1 ... | x | x + 1 | x ...
		 *                               ^ binary search stopped here
		 * Another case we need to handle that only occurs in 256k
		 * logs is
		 *        x + 1 ... | x ... | x+1 | x ...
		 *                   ^ binary search stops here
		 * In a 256k log, the scan at the end of the log will see the
		 * x + 1 blocks.  We need to skip past those since that is
		 * certainly not the head of the log.  By searching for
		 * last_half_cycle-1 we accomplish that.
		 */
		ASSERT(head_blk <= INT_MAX &&
766 767
			(xfs_daddr_t) num_scan_bblks >= head_blk);
		start_blk = log_bbnum - (num_scan_bblks - head_blk);
L
Linus Torvalds 已提交
768 769 770 771 772 773
		if ((error = xlog_find_verify_cycle(log, start_blk,
					num_scan_bblks - (int)head_blk,
					(stop_on_cycle - 1), &new_blk)))
			goto bp_err;
		if (new_blk != -1) {
			head_blk = new_blk;
774
			goto validate_head;
L
Linus Torvalds 已提交
775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
		}

		/*
		 * Scan beginning of log now.  The last part of the physical
		 * log is good.  This scan needs to verify that it doesn't find
		 * the last_half_cycle.
		 */
		start_blk = 0;
		ASSERT(head_blk <= INT_MAX);
		if ((error = xlog_find_verify_cycle(log,
					start_blk, (int)head_blk,
					stop_on_cycle, &new_blk)))
			goto bp_err;
		if (new_blk != -1)
			head_blk = new_blk;
	}

792
validate_head:
L
Linus Torvalds 已提交
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
	/*
	 * Now we need to make sure head_blk is not pointing to a block in
	 * the middle of a log record.
	 */
	num_scan_bblks = XLOG_REC_SHIFT(log);
	if (head_blk >= num_scan_bblks) {
		start_blk = head_blk - num_scan_bblks; /* don't read head_blk */

		/* start ptr at last block ptr before head_blk */
		if ((error = xlog_find_verify_log_record(log, start_blk,
							&head_blk, 0)) == -1) {
			error = XFS_ERROR(EIO);
			goto bp_err;
		} else if (error)
			goto bp_err;
	} else {
		start_blk = 0;
		ASSERT(head_blk <= INT_MAX);
		if ((error = xlog_find_verify_log_record(log, start_blk,
							&head_blk, 0)) == -1) {
			/* We hit the beginning of the log during our search */
814
			start_blk = log_bbnum - (num_scan_bblks - head_blk);
L
Linus Torvalds 已提交
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
			new_blk = log_bbnum;
			ASSERT(start_blk <= INT_MAX &&
				(xfs_daddr_t) log_bbnum-start_blk >= 0);
			ASSERT(head_blk <= INT_MAX);
			if ((error = xlog_find_verify_log_record(log,
							start_blk, &new_blk,
							(int)head_blk)) == -1) {
				error = XFS_ERROR(EIO);
				goto bp_err;
			} else if (error)
				goto bp_err;
			if (new_blk != log_bbnum)
				head_blk = new_blk;
		} else if (error)
			goto bp_err;
	}

	xlog_put_bp(bp);
	if (head_blk == log_bbnum)
		*return_head_blk = 0;
	else
		*return_head_blk = head_blk;
	/*
	 * When returning here, we have a good block number.  Bad block
	 * means that during a previous crash, we didn't have a clean break
	 * from cycle number N to cycle number N-1.  In this case, we need
	 * to find the first block with cycle number N-1.
	 */
	return 0;

 bp_err:
	xlog_put_bp(bp);

	if (error)
849
		xfs_warn(log->l_mp, "failed to find log head");
L
Linus Torvalds 已提交
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
	return error;
}

/*
 * Find the sync block number or the tail of the log.
 *
 * This will be the block number of the last record to have its
 * associated buffers synced to disk.  Every log record header has
 * a sync lsn embedded in it.  LSNs hold block numbers, so it is easy
 * to get a sync block number.  The only concern is to figure out which
 * log record header to believe.
 *
 * The following algorithm uses the log record header with the largest
 * lsn.  The entire log record does not need to be valid.  We only care
 * that the header is valid.
 *
 * We could speed up search by using current head_blk buffer, but it is not
 * available.
 */
869
STATIC int
L
Linus Torvalds 已提交
870 871 872
xlog_find_tail(
	xlog_t			*log,
	xfs_daddr_t		*head_blk,
873
	xfs_daddr_t		*tail_blk)
L
Linus Torvalds 已提交
874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896
{
	xlog_rec_header_t	*rhead;
	xlog_op_header_t	*op_head;
	xfs_caddr_t		offset = NULL;
	xfs_buf_t		*bp;
	int			error, i, found;
	xfs_daddr_t		umount_data_blk;
	xfs_daddr_t		after_umount_blk;
	xfs_lsn_t		tail_lsn;
	int			hblks;

	found = 0;

	/*
	 * Find previous log record
	 */
	if ((error = xlog_find_head(log, head_blk)))
		return error;

	bp = xlog_get_bp(log, 1);
	if (!bp)
		return ENOMEM;
	if (*head_blk == 0) {				/* special case */
C
Christoph Hellwig 已提交
897 898
		error = xlog_bread(log, 0, 1, bp, &offset);
		if (error)
899
			goto done;
C
Christoph Hellwig 已提交
900

901
		if (xlog_get_cycle(offset) == 0) {
L
Linus Torvalds 已提交
902 903
			*tail_blk = 0;
			/* leave all other log inited values alone */
904
			goto done;
L
Linus Torvalds 已提交
905 906 907 908 909 910 911 912
		}
	}

	/*
	 * Search backwards looking for log record header block
	 */
	ASSERT(*head_blk < INT_MAX);
	for (i = (int)(*head_blk) - 1; i >= 0; i--) {
C
Christoph Hellwig 已提交
913 914
		error = xlog_bread(log, i, 1, bp, &offset);
		if (error)
915
			goto done;
C
Christoph Hellwig 已提交
916

917
		if (*(__be32 *)offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
L
Linus Torvalds 已提交
918 919 920 921 922 923 924 925 926 927 928 929
			found = 1;
			break;
		}
	}
	/*
	 * If we haven't found the log record header block, start looking
	 * again from the end of the physical log.  XXXmiken: There should be
	 * a check here to make sure we didn't search more than N blocks in
	 * the previous code.
	 */
	if (!found) {
		for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
C
Christoph Hellwig 已提交
930 931
			error = xlog_bread(log, i, 1, bp, &offset);
			if (error)
932
				goto done;
C
Christoph Hellwig 已提交
933

934 935
			if (*(__be32 *)offset ==
			    cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
L
Linus Torvalds 已提交
936 937 938 939 940 941
				found = 2;
				break;
			}
		}
	}
	if (!found) {
942
		xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
L
Linus Torvalds 已提交
943 944 945 946 947 948
		ASSERT(0);
		return XFS_ERROR(EIO);
	}

	/* find blk_no of tail of log */
	rhead = (xlog_rec_header_t *)offset;
949
	*tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
L
Linus Torvalds 已提交
950 951 952 953 954 955 956 957 958 959 960 961 962

	/*
	 * Reset log values according to the state of the log when we
	 * crashed.  In the case where head_blk == 0, we bump curr_cycle
	 * one because the next write starts a new cycle rather than
	 * continuing the cycle of the last good log record.  At this
	 * point we have guaranteed that all partial log records have been
	 * accounted for.  Therefore, we know that the last good log record
	 * written was complete and ended exactly on the end boundary
	 * of the physical log.
	 */
	log->l_prev_block = i;
	log->l_curr_block = (int)*head_blk;
963
	log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
L
Linus Torvalds 已提交
964 965
	if (found == 2)
		log->l_curr_cycle++;
966
	atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn));
967
	atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn));
968 969 970 971
	xlog_assign_grant_head(&log->l_grant_reserve_head, log->l_curr_cycle,
					BBTOB(log->l_curr_block));
	xlog_assign_grant_head(&log->l_grant_write_head, log->l_curr_cycle,
					BBTOB(log->l_curr_block));
L
Linus Torvalds 已提交
972 973 974 975 976 977 978 979 980 981 982 983

	/*
	 * Look for unmount record.  If we find it, then we know there
	 * was a clean unmount.  Since 'i' could be the last block in
	 * the physical log, we convert to a log block before comparing
	 * to the head_blk.
	 *
	 * Save the current tail lsn to use to pass to
	 * xlog_clear_stale_blocks() below.  We won't want to clear the
	 * unmount record if there is one, so we pass the lsn of the
	 * unmount record rather than the block after it.
	 */
984
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
985 986
		int	h_size = be32_to_cpu(rhead->h_size);
		int	h_version = be32_to_cpu(rhead->h_version);
L
Linus Torvalds 已提交
987 988 989 990 991 992 993 994 995 996 997 998 999

		if ((h_version & XLOG_VERSION_2) &&
		    (h_size > XLOG_HEADER_CYCLE_SIZE)) {
			hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
			if (h_size % XLOG_HEADER_CYCLE_SIZE)
				hblks++;
		} else {
			hblks = 1;
		}
	} else {
		hblks = 1;
	}
	after_umount_blk = (i + hblks + (int)
1000
		BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
1001
	tail_lsn = atomic64_read(&log->l_tail_lsn);
L
Linus Torvalds 已提交
1002
	if (*head_blk == after_umount_blk &&
1003
	    be32_to_cpu(rhead->h_num_logops) == 1) {
L
Linus Torvalds 已提交
1004
		umount_data_blk = (i + hblks) % log->l_logBBsize;
C
Christoph Hellwig 已提交
1005 1006
		error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
		if (error)
1007
			goto done;
C
Christoph Hellwig 已提交
1008

L
Linus Torvalds 已提交
1009 1010 1011 1012 1013 1014 1015
		op_head = (xlog_op_header_t *)offset;
		if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
			/*
			 * Set tail and last sync so that newly written
			 * log records will point recovery to after the
			 * current unmount record.
			 */
1016 1017 1018 1019
			xlog_assign_atomic_lsn(&log->l_tail_lsn,
					log->l_curr_cycle, after_umount_blk);
			xlog_assign_atomic_lsn(&log->l_last_sync_lsn,
					log->l_curr_cycle, after_umount_blk);
L
Linus Torvalds 已提交
1020
			*tail_blk = after_umount_blk;
D
David Chinner 已提交
1021 1022 1023 1024 1025 1026 1027 1028

			/*
			 * Note that the unmount was clean. If the unmount
			 * was not clean, we need to know this to rebuild the
			 * superblock counters from the perag headers if we
			 * have a filesystem using non-persistent counters.
			 */
			log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
L
Linus Torvalds 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
		}
	}

	/*
	 * Make sure that there are no blocks in front of the head
	 * with the same cycle number as the head.  This can happen
	 * because we allow multiple outstanding log writes concurrently,
	 * and the later writes might make it out before earlier ones.
	 *
	 * We use the lsn from before modifying it so that we'll never
	 * overwrite the unmount record after a clean unmount.
	 *
	 * Do this only if we are going to recover the filesystem
	 *
	 * NOTE: This used to say "if (!readonly)"
	 * However on Linux, we can & do recover a read-only filesystem.
	 * We only skip recovery if NORECOVERY is specified on mount,
	 * in which case we would not be here.
	 *
	 * But... if the -device- itself is readonly, just skip this.
	 * We can't recover this device anyway, so it won't matter.
	 */
1051
	if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
L
Linus Torvalds 已提交
1052 1053
		error = xlog_clear_stale_blocks(log, tail_lsn);

1054
done:
L
Linus Torvalds 已提交
1055 1056 1057
	xlog_put_bp(bp);

	if (error)
1058
		xfs_warn(log->l_mp, "failed to locate log tail");
L
Linus Torvalds 已提交
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
	return error;
}

/*
 * Is the log zeroed at all?
 *
 * The last binary search should be changed to perform an X block read
 * once X becomes small enough.  You can then search linearly through
 * the X blocks.  This will cut down on the number of reads we need to do.
 *
 * If the log is partially zeroed, this routine will pass back the blkno
 * of the first block with cycle number 0.  It won't have a complete LR
 * preceding it.
 *
 * Return:
 *	0  => the log is completely written to
 *	-1 => use *blk_no as the first block of the log
 *	>0 => error has occurred
 */
D
David Chinner 已提交
1078
STATIC int
L
Linus Torvalds 已提交
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
xlog_find_zeroed(
	xlog_t		*log,
	xfs_daddr_t	*blk_no)
{
	xfs_buf_t	*bp;
	xfs_caddr_t	offset;
	uint	        first_cycle, last_cycle;
	xfs_daddr_t	new_blk, last_blk, start_blk;
	xfs_daddr_t     num_scan_bblks;
	int	        error, log_bbnum = log->l_logBBsize;

1090 1091
	*blk_no = 0;

L
Linus Torvalds 已提交
1092 1093 1094 1095
	/* check totally zeroed log */
	bp = xlog_get_bp(log, 1);
	if (!bp)
		return ENOMEM;
C
Christoph Hellwig 已提交
1096 1097
	error = xlog_bread(log, 0, 1, bp, &offset);
	if (error)
L
Linus Torvalds 已提交
1098
		goto bp_err;
C
Christoph Hellwig 已提交
1099

1100
	first_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
1101 1102 1103 1104 1105 1106 1107
	if (first_cycle == 0) {		/* completely zeroed log */
		*blk_no = 0;
		xlog_put_bp(bp);
		return -1;
	}

	/* check partially zeroed log */
C
Christoph Hellwig 已提交
1108 1109
	error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
	if (error)
L
Linus Torvalds 已提交
1110
		goto bp_err;
C
Christoph Hellwig 已提交
1111

1112
	last_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
1113 1114 1115 1116 1117 1118 1119 1120 1121
	if (last_cycle != 0) {		/* log completely written to */
		xlog_put_bp(bp);
		return 0;
	} else if (first_cycle != 1) {
		/*
		 * If the cycle of the last block is zero, the cycle of
		 * the first block must be 1. If it's not, maybe we're
		 * not looking at a log... Bail out.
		 */
1122 1123
		xfs_warn(log->l_mp,
			"Log inconsistent or not a log (last==0, first!=1)");
L
Linus Torvalds 已提交
1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
		return XFS_ERROR(EINVAL);
	}

	/* we have a partially zeroed log */
	last_blk = log_bbnum-1;
	if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
		goto bp_err;

	/*
	 * Validate the answer.  Because there is no way to guarantee that
	 * the entire log is made up of log records which are the same size,
	 * we scan over the defined maximum blocks.  At this point, the maximum
	 * is not chosen to mean anything special.   XXXmiken
	 */
	num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
	ASSERT(num_scan_bblks <= INT_MAX);

	if (last_blk < num_scan_bblks)
		num_scan_bblks = last_blk;
	start_blk = last_blk - num_scan_bblks;

	/*
	 * We search for any instances of cycle number 0 that occur before
	 * our current estimate of the head.  What we're trying to detect is
	 *        1 ... | 0 | 1 | 0...
	 *                       ^ binary search ends here
	 */
	if ((error = xlog_find_verify_cycle(log, start_blk,
					 (int)num_scan_bblks, 0, &new_blk)))
		goto bp_err;
	if (new_blk != -1)
		last_blk = new_blk;

	/*
	 * Potentially backup over partial log record write.  We don't need
	 * to search the end of the log because we know it is zero.
	 */
	if ((error = xlog_find_verify_log_record(log, start_blk,
				&last_blk, 0)) == -1) {
	    error = XFS_ERROR(EIO);
	    goto bp_err;
	} else if (error)
	    goto bp_err;

	*blk_no = last_blk;
bp_err:
	xlog_put_bp(bp);
	if (error)
		return error;
	return -1;
}

/*
 * These are simple subroutines used by xlog_clear_stale_blocks() below
 * to initialize a buffer full of empty log record headers and write
 * them into the log.
 */
STATIC void
xlog_add_record(
	xlog_t			*log,
	xfs_caddr_t		buf,
	int			cycle,
	int			block,
	int			tail_cycle,
	int			tail_block)
{
	xlog_rec_header_t	*recp = (xlog_rec_header_t *)buf;

	memset(buf, 0, BBSIZE);
1193 1194 1195
	recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
	recp->h_cycle = cpu_to_be32(cycle);
	recp->h_version = cpu_to_be32(
1196
			xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1197 1198 1199
	recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
	recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
	recp->h_fmt = cpu_to_be32(XLOG_FMT);
L
Linus Torvalds 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
	memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
}

STATIC int
xlog_write_log_records(
	xlog_t		*log,
	int		cycle,
	int		start_block,
	int		blocks,
	int		tail_cycle,
	int		tail_block)
{
	xfs_caddr_t	offset;
	xfs_buf_t	*bp;
	int		balign, ealign;
1215
	int		sectbb = log->l_sectBBsize;
L
Linus Torvalds 已提交
1216 1217 1218 1219 1220
	int		end_block = start_block + blocks;
	int		bufblks;
	int		error = 0;
	int		i, j = 0;

1221 1222 1223 1224 1225 1226
	/*
	 * Greedily allocate a buffer big enough to handle the full
	 * range of basic blocks to be written.  If that fails, try
	 * a smaller size.  We need to be able to write at least a
	 * log sector, or we're out of luck.
	 */
L
Linus Torvalds 已提交
1227 1228 1229
	bufblks = 1 << ffs(blocks);
	while (!(bp = xlog_get_bp(log, bufblks))) {
		bufblks >>= 1;
1230
		if (bufblks < sectbb)
L
Linus Torvalds 已提交
1231 1232 1233 1234 1235 1236 1237
			return ENOMEM;
	}

	/* We may need to do a read at the start to fill in part of
	 * the buffer in the starting sector not covered by the first
	 * write below.
	 */
A
Alex Elder 已提交
1238
	balign = round_down(start_block, sectbb);
L
Linus Torvalds 已提交
1239
	if (balign != start_block) {
C
Christoph Hellwig 已提交
1240 1241 1242 1243
		error = xlog_bread_noalign(log, start_block, 1, bp);
		if (error)
			goto out_put_bp;

L
Linus Torvalds 已提交
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
		j = start_block - balign;
	}

	for (i = start_block; i < end_block; i += bufblks) {
		int		bcount, endcount;

		bcount = min(bufblks, end_block - start_block);
		endcount = bcount - j;

		/* We may need to do a read at the end to fill in part of
		 * the buffer in the final sector not covered by the write.
		 * If this is the same sector as the above read, skip it.
		 */
A
Alex Elder 已提交
1257
		ealign = round_down(end_block, sectbb);
L
Linus Torvalds 已提交
1258
		if (j == 0 && (start_block + endcount > ealign)) {
1259
			offset = bp->b_addr + BBTOB(ealign - start_block);
1260 1261
			error = xlog_bread_offset(log, ealign, sectbb,
							bp, offset);
C
Christoph Hellwig 已提交
1262 1263 1264
			if (error)
				break;

L
Linus Torvalds 已提交
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
		}

		offset = xlog_align(log, start_block, endcount, bp);
		for (; j < endcount; j++) {
			xlog_add_record(log, offset, cycle, i+j,
					tail_cycle, tail_block);
			offset += BBSIZE;
		}
		error = xlog_bwrite(log, start_block, endcount, bp);
		if (error)
			break;
		start_block += endcount;
		j = 0;
	}
C
Christoph Hellwig 已提交
1279 1280

 out_put_bp:
L
Linus Torvalds 已提交
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
	xlog_put_bp(bp);
	return error;
}

/*
 * This routine is called to blow away any incomplete log writes out
 * in front of the log head.  We do this so that we won't become confused
 * if we come up, write only a little bit more, and then crash again.
 * If we leave the partial log records out there, this situation could
 * cause us to think those partial writes are valid blocks since they
 * have the current cycle number.  We get rid of them by overwriting them
 * with empty log records with the old cycle number rather than the
 * current one.
 *
 * The tail lsn is passed in rather than taken from
 * the log so that we will not write over the unmount record after a
 * clean unmount in a 512 block log.  Doing so would leave the log without
 * any valid log records in it until a new one was written.  If we crashed
 * during that time we would not be able to recover.
 */
STATIC int
xlog_clear_stale_blocks(
	xlog_t		*log,
	xfs_lsn_t	tail_lsn)
{
	int		tail_cycle, head_cycle;
	int		tail_block, head_block;
	int		tail_distance, max_distance;
	int		distance;
	int		error;

	tail_cycle = CYCLE_LSN(tail_lsn);
	tail_block = BLOCK_LSN(tail_lsn);
	head_cycle = log->l_curr_cycle;
	head_block = log->l_curr_block;

	/*
	 * Figure out the distance between the new head of the log
	 * and the tail.  We want to write over any blocks beyond the
	 * head that we may have written just before the crash, but
	 * we don't want to overwrite the tail of the log.
	 */
	if (head_cycle == tail_cycle) {
		/*
		 * The tail is behind the head in the physical log,
		 * so the distance from the head to the tail is the
		 * distance from the head to the end of the log plus
		 * the distance from the beginning of the log to the
		 * tail.
		 */
		if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
			XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
					 XFS_ERRLEVEL_LOW, log->l_mp);
			return XFS_ERROR(EFSCORRUPTED);
		}
		tail_distance = tail_block + (log->l_logBBsize - head_block);
	} else {
		/*
		 * The head is behind the tail in the physical log,
		 * so the distance from the head to the tail is just
		 * the tail block minus the head block.
		 */
		if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
			XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
					 XFS_ERRLEVEL_LOW, log->l_mp);
			return XFS_ERROR(EFSCORRUPTED);
		}
		tail_distance = tail_block - head_block;
	}

	/*
	 * If the head is right up against the tail, we can't clear
	 * anything.
	 */
	if (tail_distance <= 0) {
		ASSERT(tail_distance == 0);
		return 0;
	}

	max_distance = XLOG_TOTAL_REC_SHIFT(log);
	/*
	 * Take the smaller of the maximum amount of outstanding I/O
	 * we could have and the distance to the tail to clear out.
	 * We take the smaller so that we don't overwrite the tail and
	 * we don't waste all day writing from the head to the tail
	 * for no reason.
	 */
	max_distance = MIN(max_distance, tail_distance);

	if ((head_block + max_distance) <= log->l_logBBsize) {
		/*
		 * We can stomp all the blocks we need to without
		 * wrapping around the end of the log.  Just do it
		 * in a single write.  Use the cycle number of the
		 * current cycle minus one so that the log will look like:
		 *     n ... | n - 1 ...
		 */
		error = xlog_write_log_records(log, (head_cycle - 1),
				head_block, max_distance, tail_cycle,
				tail_block);
		if (error)
			return error;
	} else {
		/*
		 * We need to wrap around the end of the physical log in
		 * order to clear all the blocks.  Do it in two separate
		 * I/Os.  The first write should be from the head to the
		 * end of the physical log, and it should use the current
		 * cycle number minus one just like above.
		 */
		distance = log->l_logBBsize - head_block;
		error = xlog_write_log_records(log, (head_cycle - 1),
				head_block, distance, tail_cycle,
				tail_block);

		if (error)
			return error;

		/*
		 * Now write the blocks at the start of the physical log.
		 * This writes the remainder of the blocks we want to clear.
		 * It uses the current cycle number since we're now on the
		 * same cycle as the head so that we get:
		 *    n ... n ... | n - 1 ...
		 *    ^^^^^ blocks we're writing
		 */
		distance = max_distance - (log->l_logBBsize - head_block);
		error = xlog_write_log_records(log, head_cycle, 0, distance,
				tail_cycle, tail_block);
		if (error)
			return error;
	}

	return 0;
}

/******************************************************************************
 *
 *		Log recover routines
 *
 ******************************************************************************
 */

STATIC xlog_recover_t *
xlog_recover_find_tid(
1426
	struct hlist_head	*head,
L
Linus Torvalds 已提交
1427 1428
	xlog_tid_t		tid)
{
1429 1430
	xlog_recover_t		*trans;
	struct hlist_node	*n;
L
Linus Torvalds 已提交
1431

1432 1433 1434
	hlist_for_each_entry(trans, n, head, r_list) {
		if (trans->r_log_tid == tid)
			return trans;
L
Linus Torvalds 已提交
1435
	}
1436
	return NULL;
L
Linus Torvalds 已提交
1437 1438 1439
}

STATIC void
1440 1441 1442 1443
xlog_recover_new_tid(
	struct hlist_head	*head,
	xlog_tid_t		tid,
	xfs_lsn_t		lsn)
L
Linus Torvalds 已提交
1444
{
1445 1446 1447 1448 1449 1450 1451 1452 1453
	xlog_recover_t		*trans;

	trans = kmem_zalloc(sizeof(xlog_recover_t), KM_SLEEP);
	trans->r_log_tid   = tid;
	trans->r_lsn	   = lsn;
	INIT_LIST_HEAD(&trans->r_itemq);

	INIT_HLIST_NODE(&trans->r_list);
	hlist_add_head(&trans->r_list, head);
L
Linus Torvalds 已提交
1454 1455 1456 1457
}

STATIC void
xlog_recover_add_item(
1458
	struct list_head	*head)
L
Linus Torvalds 已提交
1459 1460 1461 1462
{
	xlog_recover_item_t	*item;

	item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
1463 1464
	INIT_LIST_HEAD(&item->ri_list);
	list_add_tail(&item->ri_list, head);
L
Linus Torvalds 已提交
1465 1466 1467 1468
}

STATIC int
xlog_recover_add_to_cont_trans(
1469
	struct log		*log,
L
Linus Torvalds 已提交
1470 1471 1472 1473 1474 1475 1476 1477
	xlog_recover_t		*trans,
	xfs_caddr_t		dp,
	int			len)
{
	xlog_recover_item_t	*item;
	xfs_caddr_t		ptr, old_ptr;
	int			old_len;

1478
	if (list_empty(&trans->r_itemq)) {
L
Linus Torvalds 已提交
1479 1480 1481 1482 1483 1484 1485
		/* finish copying rest of trans header */
		xlog_recover_add_item(&trans->r_itemq);
		ptr = (xfs_caddr_t) &trans->r_theader +
				sizeof(xfs_trans_header_t) - len;
		memcpy(ptr, dp, len); /* d, s, l */
		return 0;
	}
1486 1487
	/* take the tail entry */
	item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
L
Linus Torvalds 已提交
1488 1489 1490 1491

	old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
	old_len = item->ri_buf[item->ri_cnt-1].i_len;

1492
	ptr = kmem_realloc(old_ptr, len+old_len, old_len, KM_SLEEP);
L
Linus Torvalds 已提交
1493 1494 1495
	memcpy(&ptr[old_len], dp, len); /* d, s, l */
	item->ri_buf[item->ri_cnt-1].i_len += len;
	item->ri_buf[item->ri_cnt-1].i_addr = ptr;
1496
	trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
	return 0;
}

/*
 * The next region to add is the start of a new region.  It could be
 * a whole region or it could be the first part of a new region.  Because
 * of this, the assumption here is that the type and size fields of all
 * format structures fit into the first 32 bits of the structure.
 *
 * This works because all regions must be 32 bit aligned.  Therefore, we
 * either have both fields or we have neither field.  In the case we have
 * neither field, the data part of the region is zero length.  We only have
 * a log_op_header and can throw away the header since a new one will appear
 * later.  If we have at least 4 bytes, then we can determine how many regions
 * will appear in the current log item.
 */
STATIC int
xlog_recover_add_to_trans(
1515
	struct log		*log,
L
Linus Torvalds 已提交
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
	xlog_recover_t		*trans,
	xfs_caddr_t		dp,
	int			len)
{
	xfs_inode_log_format_t	*in_f;			/* any will do */
	xlog_recover_item_t	*item;
	xfs_caddr_t		ptr;

	if (!len)
		return 0;
1526
	if (list_empty(&trans->r_itemq)) {
1527 1528
		/* we need to catch log corruptions here */
		if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
1529 1530
			xfs_warn(log->l_mp, "%s: bad header magic number",
				__func__);
1531 1532 1533
			ASSERT(0);
			return XFS_ERROR(EIO);
		}
L
Linus Torvalds 已提交
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
		if (len == sizeof(xfs_trans_header_t))
			xlog_recover_add_item(&trans->r_itemq);
		memcpy(&trans->r_theader, dp, len); /* d, s, l */
		return 0;
	}

	ptr = kmem_alloc(len, KM_SLEEP);
	memcpy(ptr, dp, len);
	in_f = (xfs_inode_log_format_t *)ptr;

1544 1545 1546 1547 1548
	/* take the tail entry */
	item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
	if (item->ri_total != 0 &&
	     item->ri_total == item->ri_cnt) {
		/* tail item is in use, get a new one */
L
Linus Torvalds 已提交
1549
		xlog_recover_add_item(&trans->r_itemq);
1550 1551
		item = list_entry(trans->r_itemq.prev,
					xlog_recover_item_t, ri_list);
L
Linus Torvalds 已提交
1552 1553 1554
	}

	if (item->ri_total == 0) {		/* first region to be added */
1555 1556
		if (in_f->ilf_size == 0 ||
		    in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
1557 1558
			xfs_warn(log->l_mp,
		"bad number of regions (%d) in inode log format",
1559 1560 1561 1562 1563 1564 1565 1566 1567
				  in_f->ilf_size);
			ASSERT(0);
			return XFS_ERROR(EIO);
		}

		item->ri_total = in_f->ilf_size;
		item->ri_buf =
			kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
				    KM_SLEEP);
L
Linus Torvalds 已提交
1568 1569 1570 1571 1572 1573
	}
	ASSERT(item->ri_total > item->ri_cnt);
	/* Description region is ri_buf[0] */
	item->ri_buf[item->ri_cnt].i_addr = ptr;
	item->ri_buf[item->ri_cnt].i_len  = len;
	item->ri_cnt++;
1574
	trace_xfs_log_recover_item_add(log, trans, item, 0);
L
Linus Torvalds 已提交
1575 1576 1577
	return 0;
}

1578 1579 1580 1581 1582 1583
/*
 * Sort the log items in the transaction. Cancelled buffers need
 * to be put first so they are processed before any items that might
 * modify the buffers. If they are cancelled, then the modifications
 * don't need to be replayed.
 */
L
Linus Torvalds 已提交
1584 1585
STATIC int
xlog_recover_reorder_trans(
1586 1587 1588
	struct log		*log,
	xlog_recover_t		*trans,
	int			pass)
L
Linus Torvalds 已提交
1589
{
1590 1591 1592 1593 1594
	xlog_recover_item_t	*item, *n;
	LIST_HEAD(sort_list);

	list_splice_init(&trans->r_itemq, &sort_list);
	list_for_each_entry_safe(item, n, &sort_list, ri_list) {
1595
		xfs_buf_log_format_t	*buf_f = item->ri_buf[0].i_addr;
L
Linus Torvalds 已提交
1596

1597
		switch (ITEM_TYPE(item)) {
L
Linus Torvalds 已提交
1598
		case XFS_LI_BUF:
1599
			if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
1600 1601
				trace_xfs_log_recover_item_reorder_head(log,
							trans, item, pass);
1602
				list_move(&item->ri_list, &trans->r_itemq);
L
Linus Torvalds 已提交
1603 1604 1605 1606 1607 1608 1609
				break;
			}
		case XFS_LI_INODE:
		case XFS_LI_DQUOT:
		case XFS_LI_QUOTAOFF:
		case XFS_LI_EFD:
		case XFS_LI_EFI:
1610 1611
			trace_xfs_log_recover_item_reorder_tail(log,
							trans, item, pass);
1612
			list_move_tail(&item->ri_list, &trans->r_itemq);
L
Linus Torvalds 已提交
1613 1614
			break;
		default:
1615 1616 1617
			xfs_warn(log->l_mp,
				"%s: unrecognized type of log operation",
				__func__);
L
Linus Torvalds 已提交
1618 1619 1620
			ASSERT(0);
			return XFS_ERROR(EIO);
		}
1621 1622
	}
	ASSERT(list_empty(&sort_list));
L
Linus Torvalds 已提交
1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
	return 0;
}

/*
 * Build up the table of buf cancel records so that we don't replay
 * cancelled data in the second pass.  For buffer records that are
 * not cancel records, there is nothing to do here so we just return.
 *
 * If we get a cancel record which is already in the table, this indicates
 * that the buffer was cancelled multiple times.  In order to ensure
 * that during pass 2 we keep the record in the table until we reach its
 * last occurrence in the log, we keep a reference count in the cancel
 * record in the table to tell us how many times we expect to see this
 * record during the second pass.
 */
1638 1639
STATIC int
xlog_recover_buffer_pass1(
1640
	struct log		*log,
1641
	xlog_recover_item_t	*item)
L
Linus Torvalds 已提交
1642
{
1643
	xfs_buf_log_format_t	*buf_f = item->ri_buf[0].i_addr;
1644 1645
	struct list_head	*bucket;
	struct xfs_buf_cancel	*bcp;
L
Linus Torvalds 已提交
1646 1647 1648 1649

	/*
	 * If this isn't a cancel buffer item, then just return.
	 */
1650
	if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
1651
		trace_xfs_log_recover_buf_not_cancel(log, buf_f);
1652
		return 0;
1653
	}
L
Linus Torvalds 已提交
1654 1655

	/*
1656 1657
	 * Insert an xfs_buf_cancel record into the hash table of them.
	 * If there is already an identical record, bump its reference count.
L
Linus Torvalds 已提交
1658
	 */
1659 1660 1661 1662 1663
	bucket = XLOG_BUF_CANCEL_BUCKET(log, buf_f->blf_blkno);
	list_for_each_entry(bcp, bucket, bc_list) {
		if (bcp->bc_blkno == buf_f->blf_blkno &&
		    bcp->bc_len == buf_f->blf_len) {
			bcp->bc_refcount++;
1664
			trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f);
1665
			return 0;
L
Linus Torvalds 已提交
1666
		}
1667 1668 1669 1670 1671
	}

	bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), KM_SLEEP);
	bcp->bc_blkno = buf_f->blf_blkno;
	bcp->bc_len = buf_f->blf_len;
L
Linus Torvalds 已提交
1672
	bcp->bc_refcount = 1;
1673 1674
	list_add_tail(&bcp->bc_list, bucket);

1675
	trace_xfs_log_recover_buf_cancel_add(log, buf_f);
1676
	return 0;
L
Linus Torvalds 已提交
1677 1678 1679 1680 1681 1682
}

/*
 * Check to see whether the buffer being recovered has a corresponding
 * entry in the buffer cancel record table.  If it does then return 1
 * so that it will be cancelled, otherwise return 0.  If the buffer is
1683
 * actually a buffer cancel item (XFS_BLF_CANCEL is set), then decrement
L
Linus Torvalds 已提交
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
 * the refcount on the entry in the table and remove it from the table
 * if this is the last reference.
 *
 * We remove the cancel record from the table when we encounter its
 * last occurrence in the log so that if the same buffer is re-used
 * again after its last cancellation we actually replay the changes
 * made at that point.
 */
STATIC int
xlog_check_buffer_cancelled(
1694
	struct log		*log,
L
Linus Torvalds 已提交
1695 1696 1697 1698
	xfs_daddr_t		blkno,
	uint			len,
	ushort			flags)
{
1699 1700
	struct list_head	*bucket;
	struct xfs_buf_cancel	*bcp;
L
Linus Torvalds 已提交
1701 1702 1703 1704 1705 1706

	if (log->l_buf_cancel_table == NULL) {
		/*
		 * There is nothing in the table built in pass one,
		 * so this buffer must not be cancelled.
		 */
1707
		ASSERT(!(flags & XFS_BLF_CANCEL));
L
Linus Torvalds 已提交
1708 1709 1710 1711
		return 0;
	}

	/*
1712
	 * Search for an entry in the  cancel table that matches our buffer.
L
Linus Torvalds 已提交
1713
	 */
1714 1715 1716 1717
	bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno);
	list_for_each_entry(bcp, bucket, bc_list) {
		if (bcp->bc_blkno == blkno && bcp->bc_len == len)
			goto found;
L
Linus Torvalds 已提交
1718
	}
1719

L
Linus Torvalds 已提交
1720
	/*
1721 1722
	 * We didn't find a corresponding entry in the table, so return 0 so
	 * that the buffer is NOT cancelled.
L
Linus Torvalds 已提交
1723
	 */
1724
	ASSERT(!(flags & XFS_BLF_CANCEL));
L
Linus Torvalds 已提交
1725
	return 0;
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740

found:
	/*
	 * We've go a match, so return 1 so that the recovery of this buffer
	 * is cancelled.  If this buffer is actually a buffer cancel log
	 * item, then decrement the refcount on the one in the table and
	 * remove it if this is the last reference.
	 */
	if (flags & XFS_BLF_CANCEL) {
		if (--bcp->bc_refcount == 0) {
			list_del(&bcp->bc_list);
			kmem_free(bcp);
		}
	}
	return 1;
L
Linus Torvalds 已提交
1741 1742 1743
}

/*
1744 1745 1746 1747 1748
 * Perform recovery for a buffer full of inodes.  In these buffers, the only
 * data which should be recovered is that which corresponds to the
 * di_next_unlinked pointers in the on disk inode structures.  The rest of the
 * data for the inodes is always logged through the inodes themselves rather
 * than the inode buffer and is recovered in xlog_recover_inode_pass2().
L
Linus Torvalds 已提交
1749
 *
1750 1751 1752 1753
 * The only time when buffers full of inodes are fully recovered is when the
 * buffer is full of newly allocated inodes.  In this case the buffer will
 * not be marked as an inode buffer and so will be sent to
 * xlog_recover_do_reg_buffer() below during recovery.
L
Linus Torvalds 已提交
1754 1755 1756
 */
STATIC int
xlog_recover_do_inode_buffer(
1757
	struct xfs_mount	*mp,
L
Linus Torvalds 已提交
1758
	xlog_recover_item_t	*item,
1759
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
1760 1761 1762
	xfs_buf_log_format_t	*buf_f)
{
	int			i;
1763 1764 1765 1766 1767
	int			item_index = 0;
	int			bit = 0;
	int			nbits = 0;
	int			reg_buf_offset = 0;
	int			reg_buf_bytes = 0;
L
Linus Torvalds 已提交
1768 1769 1770 1771 1772
	int			next_unlinked_offset;
	int			inodes_per_buf;
	xfs_agino_t		*logged_nextp;
	xfs_agino_t		*buffer_nextp;

1773 1774
	trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);

L
Linus Torvalds 已提交
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
	inodes_per_buf = XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog;
	for (i = 0; i < inodes_per_buf; i++) {
		next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
			offsetof(xfs_dinode_t, di_next_unlinked);

		while (next_unlinked_offset >=
		       (reg_buf_offset + reg_buf_bytes)) {
			/*
			 * The next di_next_unlinked field is beyond
			 * the current logged region.  Find the next
			 * logged region that contains or is beyond
			 * the current di_next_unlinked field.
			 */
			bit += nbits;
1789 1790
			bit = xfs_next_bit(buf_f->blf_data_map,
					   buf_f->blf_map_size, bit);
L
Linus Torvalds 已提交
1791 1792 1793 1794 1795

			/*
			 * If there are no more logged regions in the
			 * buffer, then we're done.
			 */
1796
			if (bit == -1)
L
Linus Torvalds 已提交
1797 1798
				return 0;

1799 1800
			nbits = xfs_contig_bits(buf_f->blf_data_map,
						buf_f->blf_map_size, bit);
L
Linus Torvalds 已提交
1801
			ASSERT(nbits > 0);
1802 1803
			reg_buf_offset = bit << XFS_BLF_SHIFT;
			reg_buf_bytes = nbits << XFS_BLF_SHIFT;
L
Linus Torvalds 已提交
1804 1805 1806 1807 1808 1809 1810 1811
			item_index++;
		}

		/*
		 * If the current logged region starts after the current
		 * di_next_unlinked field, then move on to the next
		 * di_next_unlinked field.
		 */
1812
		if (next_unlinked_offset < reg_buf_offset)
L
Linus Torvalds 已提交
1813 1814 1815
			continue;

		ASSERT(item->ri_buf[item_index].i_addr != NULL);
1816
		ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
L
Linus Torvalds 已提交
1817 1818 1819 1820 1821 1822 1823
		ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp));

		/*
		 * The current logged region contains a copy of the
		 * current di_next_unlinked field.  Extract its value
		 * and copy it to the buffer copy.
		 */
1824 1825
		logged_nextp = item->ri_buf[item_index].i_addr +
				next_unlinked_offset - reg_buf_offset;
L
Linus Torvalds 已提交
1826
		if (unlikely(*logged_nextp == 0)) {
1827 1828 1829
			xfs_alert(mp,
		"Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). "
		"Trying to replay bad (0) inode di_next_unlinked field.",
L
Linus Torvalds 已提交
1830 1831 1832 1833 1834 1835 1836 1837
				item, bp);
			XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
					 XFS_ERRLEVEL_LOW, mp);
			return XFS_ERROR(EFSCORRUPTED);
		}

		buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
					      next_unlinked_offset);
1838
		*buffer_nextp = *logged_nextp;
L
Linus Torvalds 已提交
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
	}

	return 0;
}

/*
 * Perform a 'normal' buffer recovery.  Each logged region of the
 * buffer should be copied over the corresponding region in the
 * given buffer.  The bitmap in the buf log format structure indicates
 * where to place the logged data.
 */
STATIC void
xlog_recover_do_reg_buffer(
1852
	struct xfs_mount	*mp,
L
Linus Torvalds 已提交
1853
	xlog_recover_item_t	*item,
1854
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
1855 1856 1857 1858 1859 1860 1861
	xfs_buf_log_format_t	*buf_f)
{
	int			i;
	int			bit;
	int			nbits;
	int                     error;

1862 1863
	trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);

L
Linus Torvalds 已提交
1864 1865 1866
	bit = 0;
	i = 1;  /* 0 is the buf format structure */
	while (1) {
1867 1868
		bit = xfs_next_bit(buf_f->blf_data_map,
				   buf_f->blf_map_size, bit);
L
Linus Torvalds 已提交
1869 1870
		if (bit == -1)
			break;
1871 1872
		nbits = xfs_contig_bits(buf_f->blf_data_map,
					buf_f->blf_map_size, bit);
L
Linus Torvalds 已提交
1873
		ASSERT(nbits > 0);
1874
		ASSERT(item->ri_buf[i].i_addr != NULL);
1875
		ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
L
Linus Torvalds 已提交
1876
		ASSERT(XFS_BUF_COUNT(bp) >=
1877
		       ((uint)bit << XFS_BLF_SHIFT)+(nbits<<XFS_BLF_SHIFT));
L
Linus Torvalds 已提交
1878 1879 1880 1881 1882 1883 1884

		/*
		 * Do a sanity check if this is a dquot buffer. Just checking
		 * the first dquot in the buffer should do. XXXThis is
		 * probably a good thing to do for other buf types also.
		 */
		error = 0;
1885
		if (buf_f->blf_flags &
1886
		   (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
1887
			if (item->ri_buf[i].i_addr == NULL) {
1888
				xfs_alert(mp,
1889 1890 1891
					"XFS: NULL dquot in %s.", __func__);
				goto next;
			}
1892
			if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
1893
				xfs_alert(mp,
1894 1895 1896 1897
					"XFS: dquot too small (%d) in %s.",
					item->ri_buf[i].i_len, __func__);
				goto next;
			}
1898
			error = xfs_qm_dqcheck(mp, item->ri_buf[i].i_addr,
L
Linus Torvalds 已提交
1899 1900
					       -1, 0, XFS_QMOPT_DOWARN,
					       "dquot_buf_recover");
1901 1902
			if (error)
				goto next;
L
Linus Torvalds 已提交
1903
		}
1904 1905

		memcpy(xfs_buf_offset(bp,
1906
			(uint)bit << XFS_BLF_SHIFT),	/* dest */
1907
			item->ri_buf[i].i_addr,		/* source */
1908
			nbits<<XFS_BLF_SHIFT);		/* length */
1909
 next:
L
Linus Torvalds 已提交
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
		i++;
		bit += nbits;
	}

	/* Shouldn't be any more regions */
	ASSERT(i == item->ri_total);
}

/*
 * Do some primitive error checking on ondisk dquot data structures.
 */
int
xfs_qm_dqcheck(
1923
	struct xfs_mount *mp,
L
Linus Torvalds 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
	xfs_disk_dquot_t *ddq,
	xfs_dqid_t	 id,
	uint		 type,	  /* used only when IO_dorepair is true */
	uint		 flags,
	char		 *str)
{
	xfs_dqblk_t	 *d = (xfs_dqblk_t *)ddq;
	int		errs = 0;

	/*
	 * We can encounter an uninitialized dquot buffer for 2 reasons:
	 * 1. If we crash while deleting the quotainode(s), and those blks got
	 *    used for user data. This is because we take the path of regular
	 *    file deletion; however, the size field of quotainodes is never
	 *    updated, so all the tricks that we play in itruncate_finish
	 *    don't quite matter.
	 *
	 * 2. We don't play the quota buffers when there's a quotaoff logitem.
	 *    But the allocation will be replayed so we'll end up with an
	 *    uninitialized quota block.
	 *
	 * This is all fine; things are still consistent, and we haven't lost
	 * any quota information. Just don't complain about bad dquot blks.
	 */
1948
	if (ddq->d_magic != cpu_to_be16(XFS_DQUOT_MAGIC)) {
L
Linus Torvalds 已提交
1949
		if (flags & XFS_QMOPT_DOWARN)
1950
			xfs_alert(mp,
L
Linus Torvalds 已提交
1951
			"%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
1952
			str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
L
Linus Torvalds 已提交
1953 1954
		errs++;
	}
1955
	if (ddq->d_version != XFS_DQUOT_VERSION) {
L
Linus Torvalds 已提交
1956
		if (flags & XFS_QMOPT_DOWARN)
1957
			xfs_alert(mp,
L
Linus Torvalds 已提交
1958
			"%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
1959
			str, id, ddq->d_version, XFS_DQUOT_VERSION);
L
Linus Torvalds 已提交
1960 1961 1962
		errs++;
	}

1963 1964 1965
	if (ddq->d_flags != XFS_DQ_USER &&
	    ddq->d_flags != XFS_DQ_PROJ &&
	    ddq->d_flags != XFS_DQ_GROUP) {
L
Linus Torvalds 已提交
1966
		if (flags & XFS_QMOPT_DOWARN)
1967
			xfs_alert(mp,
L
Linus Torvalds 已提交
1968
			"%s : XFS dquot ID 0x%x, unknown flags 0x%x",
1969
			str, id, ddq->d_flags);
L
Linus Torvalds 已提交
1970 1971 1972
		errs++;
	}

1973
	if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
L
Linus Torvalds 已提交
1974
		if (flags & XFS_QMOPT_DOWARN)
1975
			xfs_alert(mp,
L
Linus Torvalds 已提交
1976 1977
			"%s : ondisk-dquot 0x%p, ID mismatch: "
			"0x%x expected, found id 0x%x",
1978
			str, ddq, id, be32_to_cpu(ddq->d_id));
L
Linus Torvalds 已提交
1979 1980 1981 1982
		errs++;
	}

	if (!errs && ddq->d_id) {
1983
		if (ddq->d_blk_softlimit &&
1984
		    be64_to_cpu(ddq->d_bcount) >
1985
				be64_to_cpu(ddq->d_blk_softlimit)) {
L
Linus Torvalds 已提交
1986 1987
			if (!ddq->d_btimer) {
				if (flags & XFS_QMOPT_DOWARN)
1988 1989
					xfs_alert(mp,
			"%s : Dquot ID 0x%x (0x%p) BLK TIMER NOT STARTED",
1990
					str, (int)be32_to_cpu(ddq->d_id), ddq);
L
Linus Torvalds 已提交
1991 1992 1993
				errs++;
			}
		}
1994
		if (ddq->d_ino_softlimit &&
1995
		    be64_to_cpu(ddq->d_icount) >
1996
				be64_to_cpu(ddq->d_ino_softlimit)) {
L
Linus Torvalds 已提交
1997 1998
			if (!ddq->d_itimer) {
				if (flags & XFS_QMOPT_DOWARN)
1999 2000
					xfs_alert(mp,
			"%s : Dquot ID 0x%x (0x%p) INODE TIMER NOT STARTED",
2001
					str, (int)be32_to_cpu(ddq->d_id), ddq);
L
Linus Torvalds 已提交
2002 2003 2004
				errs++;
			}
		}
2005
		if (ddq->d_rtb_softlimit &&
2006
		    be64_to_cpu(ddq->d_rtbcount) >
2007
				be64_to_cpu(ddq->d_rtb_softlimit)) {
L
Linus Torvalds 已提交
2008 2009
			if (!ddq->d_rtbtimer) {
				if (flags & XFS_QMOPT_DOWARN)
2010 2011
					xfs_alert(mp,
			"%s : Dquot ID 0x%x (0x%p) RTBLK TIMER NOT STARTED",
2012
					str, (int)be32_to_cpu(ddq->d_id), ddq);
L
Linus Torvalds 已提交
2013 2014 2015 2016 2017 2018 2019 2020 2021
				errs++;
			}
		}
	}

	if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
		return errs;

	if (flags & XFS_QMOPT_DOWARN)
2022
		xfs_notice(mp, "Re-initializing dquot ID 0x%x", id);
L
Linus Torvalds 已提交
2023 2024 2025 2026 2027 2028 2029

	/*
	 * Typically, a repair is only requested by quotacheck.
	 */
	ASSERT(id != -1);
	ASSERT(flags & XFS_QMOPT_DQREPAIR);
	memset(d, 0, sizeof(xfs_dqblk_t));
2030 2031 2032 2033 2034

	d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
	d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
	d->dd_diskdq.d_flags = type;
	d->dd_diskdq.d_id = cpu_to_be32(id);
L
Linus Torvalds 已提交
2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054

	return errs;
}

/*
 * Perform a dquot buffer recovery.
 * Simple algorithm: if we have found a QUOTAOFF logitem of the same type
 * (ie. USR or GRP), then just toss this buffer away; don't recover it.
 * Else, treat it as a regular buffer and do recovery.
 */
STATIC void
xlog_recover_do_dquot_buffer(
	xfs_mount_t		*mp,
	xlog_t			*log,
	xlog_recover_item_t	*item,
	xfs_buf_t		*bp,
	xfs_buf_log_format_t	*buf_f)
{
	uint			type;

2055 2056
	trace_xfs_log_recover_buf_dquot_buf(log, buf_f);

L
Linus Torvalds 已提交
2057 2058 2059 2060 2061 2062 2063 2064
	/*
	 * Filesystems are required to send in quota flags at mount time.
	 */
	if (mp->m_qflags == 0) {
		return;
	}

	type = 0;
2065
	if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
L
Linus Torvalds 已提交
2066
		type |= XFS_DQ_USER;
2067
	if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
2068
		type |= XFS_DQ_PROJ;
2069
	if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
L
Linus Torvalds 已提交
2070 2071 2072 2073 2074 2075 2076
		type |= XFS_DQ_GROUP;
	/*
	 * This type of quotas was turned off, so ignore this buffer
	 */
	if (log->l_quotaoffs_flag & type)
		return;

2077
	xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
L
Linus Torvalds 已提交
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
}

/*
 * This routine replays a modification made to a buffer at runtime.
 * There are actually two types of buffer, regular and inode, which
 * are handled differently.  Inode buffers are handled differently
 * in that we only recover a specific set of data from them, namely
 * the inode di_next_unlinked fields.  This is because all other inode
 * data is actually logged via inode records and any data we replay
 * here which overlaps that may be stale.
 *
 * When meta-data buffers are freed at run time we log a buffer item
2090
 * with the XFS_BLF_CANCEL bit set to indicate that previous copies
L
Linus Torvalds 已提交
2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
 * of the buffer in the log should not be replayed at recovery time.
 * This is so that if the blocks covered by the buffer are reused for
 * file data before we crash we don't end up replaying old, freed
 * meta-data into a user's file.
 *
 * To handle the cancellation of buffer log items, we make two passes
 * over the log during recovery.  During the first we build a table of
 * those buffers which have been cancelled, and during the second we
 * only replay those buffers which do not have corresponding cancel
 * records in the table.  See xlog_recover_do_buffer_pass[1,2] above
 * for more details on the implementation of the table of cancel records.
 */
STATIC int
2104
xlog_recover_buffer_pass2(
L
Linus Torvalds 已提交
2105
	xlog_t			*log,
2106
	xlog_recover_item_t	*item)
L
Linus Torvalds 已提交
2107
{
2108
	xfs_buf_log_format_t	*buf_f = item->ri_buf[0].i_addr;
2109
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2110 2111
	xfs_buf_t		*bp;
	int			error;
2112
	uint			buf_flags;
L
Linus Torvalds 已提交
2113

2114 2115 2116 2117 2118 2119 2120
	/*
	 * In this pass we only want to recover all the buffers which have
	 * not been cancelled and are not cancellation buffers themselves.
	 */
	if (xlog_check_buffer_cancelled(log, buf_f->blf_blkno,
			buf_f->blf_len, buf_f->blf_flags)) {
		trace_xfs_log_recover_buf_cancel(log, buf_f);
L
Linus Torvalds 已提交
2121 2122
		return 0;
	}
2123

2124
	trace_xfs_log_recover_buf_recover(log, buf_f);
L
Linus Torvalds 已提交
2125

2126
	buf_flags = XBF_LOCK;
2127
	if (!(buf_f->blf_flags & XFS_BLF_INODE_BUF))
2128
		buf_flags |= XBF_MAPPED;
2129

2130 2131
	bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
			  buf_flags);
2132 2133
	if (!bp)
		return XFS_ERROR(ENOMEM);
2134
	error = bp->b_error;
2135
	if (error) {
2136
		xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
L
Linus Torvalds 已提交
2137 2138 2139 2140
		xfs_buf_relse(bp);
		return error;
	}

2141
	if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
L
Linus Torvalds 已提交
2142
		error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
2143
	} else if (buf_f->blf_flags &
2144
		  (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
L
Linus Torvalds 已提交
2145 2146
		xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
	} else {
2147
		xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
L
Linus Torvalds 已提交
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
	}
	if (error)
		return XFS_ERROR(error);

	/*
	 * Perform delayed write on the buffer.  Asynchronous writes will be
	 * slower when taking into account all the buffers to be flushed.
	 *
	 * Also make sure that only inode buffers with good sizes stay in
	 * the buffer cache.  The kernel moves inodes in buffers of 1 block
	 * or XFS_INODE_CLUSTER_SIZE bytes, whichever is bigger.  The inode
	 * buffers in the log can be a different size if the log was generated
	 * by an older kernel using unclustered inode buffers or a newer kernel
	 * running with a different inode cluster size.  Regardless, if the
	 * the inode buffer size isn't MAX(blocksize, XFS_INODE_CLUSTER_SIZE)
	 * for *our* value of XFS_INODE_CLUSTER_SIZE, then we need to keep
	 * the buffer out of the buffer cache so that the buffer won't
	 * overlap with future reads of those inodes.
	 */
	if (XFS_DINODE_MAGIC ==
2168
	    be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
L
Linus Torvalds 已提交
2169 2170
	    (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
			(__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
2171
		xfs_buf_stale(bp);
2172
		error = xfs_bwrite(bp);
L
Linus Torvalds 已提交
2173
	} else {
2174
		ASSERT(bp->b_target->bt_mount == mp);
2175
		bp->b_iodone = xlog_recover_iodone;
2176
		xfs_buf_delwri_queue(bp);
L
Linus Torvalds 已提交
2177 2178
	}

2179 2180
	xfs_buf_relse(bp);
	return error;
L
Linus Torvalds 已提交
2181 2182 2183
}

STATIC int
2184
xlog_recover_inode_pass2(
L
Linus Torvalds 已提交
2185
	xlog_t			*log,
2186
	xlog_recover_item_t	*item)
L
Linus Torvalds 已提交
2187 2188
{
	xfs_inode_log_format_t	*in_f;
2189
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2190 2191 2192 2193 2194 2195 2196 2197
	xfs_buf_t		*bp;
	xfs_dinode_t		*dip;
	int			len;
	xfs_caddr_t		src;
	xfs_caddr_t		dest;
	int			error;
	int			attr_index;
	uint			fields;
2198
	xfs_icdinode_t		*dicp;
2199
	int			need_free = 0;
L
Linus Torvalds 已提交
2200

2201
	if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
2202
		in_f = item->ri_buf[0].i_addr;
2203
	} else {
2204
		in_f = kmem_alloc(sizeof(xfs_inode_log_format_t), KM_SLEEP);
2205 2206 2207 2208 2209
		need_free = 1;
		error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
		if (error)
			goto error;
	}
L
Linus Torvalds 已提交
2210 2211 2212 2213 2214

	/*
	 * Inode buffers can be freed, look out for it,
	 * and do not replay the inode.
	 */
2215 2216
	if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
					in_f->ilf_len, 0)) {
2217
		error = 0;
2218
		trace_xfs_log_recover_inode_cancel(log, in_f);
2219 2220
		goto error;
	}
2221
	trace_xfs_log_recover_inode_recover(log, in_f);
L
Linus Torvalds 已提交
2222

2223
	bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len,
2224
			  XBF_LOCK);
2225 2226 2227 2228
	if (!bp) {
		error = ENOMEM;
		goto error;
	}
2229
	error = bp->b_error;
2230
	if (error) {
2231
		xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
L
Linus Torvalds 已提交
2232
		xfs_buf_relse(bp);
2233
		goto error;
L
Linus Torvalds 已提交
2234 2235
	}
	ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
2236
	dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
L
Linus Torvalds 已提交
2237 2238 2239 2240 2241

	/*
	 * Make sure the place we're flushing out to really looks
	 * like an inode!
	 */
2242
	if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) {
L
Linus Torvalds 已提交
2243
		xfs_buf_relse(bp);
2244 2245 2246
		xfs_alert(mp,
	"%s: Bad inode magic number, dip = 0x%p, dino bp = 0x%p, ino = %Ld",
			__func__, dip, bp, in_f->ilf_ino);
2247
		XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
L
Linus Torvalds 已提交
2248
				 XFS_ERRLEVEL_LOW, mp);
2249 2250
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2251
	}
2252
	dicp = item->ri_buf[1].i_addr;
L
Linus Torvalds 已提交
2253 2254
	if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
		xfs_buf_relse(bp);
2255 2256 2257
		xfs_alert(mp,
			"%s: Bad inode log record, rec ptr 0x%p, ino %Ld",
			__func__, item, in_f->ilf_ino);
2258
		XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
L
Linus Torvalds 已提交
2259
				 XFS_ERRLEVEL_LOW, mp);
2260 2261
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2262 2263 2264
	}

	/* Skip replay when the on disk inode is newer than the log one */
C
Christoph Hellwig 已提交
2265
	if (dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
L
Linus Torvalds 已提交
2266 2267 2268 2269
		/*
		 * Deal with the wrap case, DI_MAX_FLUSH is less
		 * than smaller numbers
		 */
C
Christoph Hellwig 已提交
2270
		if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
2271
		    dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
L
Linus Torvalds 已提交
2272 2273 2274
			/* do nothing */
		} else {
			xfs_buf_relse(bp);
2275
			trace_xfs_log_recover_inode_skip(log, in_f);
2276 2277
			error = 0;
			goto error;
L
Linus Torvalds 已提交
2278 2279 2280 2281 2282
		}
	}
	/* Take the opportunity to reset the flush iteration count */
	dicp->di_flushiter = 0;

2283
	if (unlikely(S_ISREG(dicp->di_mode))) {
L
Linus Torvalds 已提交
2284 2285
		if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
		    (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
2286
			XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
L
Linus Torvalds 已提交
2287 2288
					 XFS_ERRLEVEL_LOW, mp, dicp);
			xfs_buf_relse(bp);
2289 2290 2291 2292
			xfs_alert(mp,
		"%s: Bad regular inode log record, rec ptr 0x%p, "
		"ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
				__func__, item, dip, bp, in_f->ilf_ino);
2293 2294
			error = EFSCORRUPTED;
			goto error;
L
Linus Torvalds 已提交
2295
		}
2296
	} else if (unlikely(S_ISDIR(dicp->di_mode))) {
L
Linus Torvalds 已提交
2297 2298 2299
		if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
		    (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
		    (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
2300
			XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
L
Linus Torvalds 已提交
2301 2302
					     XFS_ERRLEVEL_LOW, mp, dicp);
			xfs_buf_relse(bp);
2303 2304 2305 2306
			xfs_alert(mp,
		"%s: Bad dir inode log record, rec ptr 0x%p, "
		"ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
				__func__, item, dip, bp, in_f->ilf_ino);
2307 2308
			error = EFSCORRUPTED;
			goto error;
L
Linus Torvalds 已提交
2309 2310 2311
		}
	}
	if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
2312
		XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
L
Linus Torvalds 已提交
2313 2314
				     XFS_ERRLEVEL_LOW, mp, dicp);
		xfs_buf_relse(bp);
2315 2316 2317 2318
		xfs_alert(mp,
	"%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
	"dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
			__func__, item, dip, bp, in_f->ilf_ino,
L
Linus Torvalds 已提交
2319 2320
			dicp->di_nextents + dicp->di_anextents,
			dicp->di_nblocks);
2321 2322
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2323 2324
	}
	if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
2325
		XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
L
Linus Torvalds 已提交
2326 2327
				     XFS_ERRLEVEL_LOW, mp, dicp);
		xfs_buf_relse(bp);
2328 2329 2330
		xfs_alert(mp,
	"%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
	"dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
2331
			item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
2332 2333
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2334
	}
C
Christoph Hellwig 已提交
2335
	if (unlikely(item->ri_buf[1].i_len > sizeof(struct xfs_icdinode))) {
2336
		XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
L
Linus Torvalds 已提交
2337 2338
				     XFS_ERRLEVEL_LOW, mp, dicp);
		xfs_buf_relse(bp);
2339 2340 2341
		xfs_alert(mp,
			"%s: Bad inode log record length %d, rec ptr 0x%p",
			__func__, item->ri_buf[1].i_len, item);
2342 2343
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2344 2345 2346
	}

	/* The core is in in-core format */
2347
	xfs_dinode_to_disk(dip, item->ri_buf[1].i_addr);
L
Linus Torvalds 已提交
2348 2349

	/* the rest is in on-disk format */
C
Christoph Hellwig 已提交
2350 2351 2352 2353
	if (item->ri_buf[1].i_len > sizeof(struct xfs_icdinode)) {
		memcpy((xfs_caddr_t) dip + sizeof(struct xfs_icdinode),
			item->ri_buf[1].i_addr + sizeof(struct xfs_icdinode),
			item->ri_buf[1].i_len  - sizeof(struct xfs_icdinode));
L
Linus Torvalds 已提交
2354 2355 2356 2357 2358
	}

	fields = in_f->ilf_fields;
	switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
	case XFS_ILOG_DEV:
C
Christoph Hellwig 已提交
2359
		xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
L
Linus Torvalds 已提交
2360 2361
		break;
	case XFS_ILOG_UUID:
C
Christoph Hellwig 已提交
2362 2363 2364
		memcpy(XFS_DFORK_DPTR(dip),
		       &in_f->ilf_u.ilfu_uuid,
		       sizeof(uuid_t));
L
Linus Torvalds 已提交
2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
		break;
	}

	if (in_f->ilf_size == 2)
		goto write_inode_buffer;
	len = item->ri_buf[2].i_len;
	src = item->ri_buf[2].i_addr;
	ASSERT(in_f->ilf_size <= 4);
	ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
	ASSERT(!(fields & XFS_ILOG_DFORK) ||
	       (len == in_f->ilf_dsize));

	switch (fields & XFS_ILOG_DFORK) {
	case XFS_ILOG_DDATA:
	case XFS_ILOG_DEXT:
C
Christoph Hellwig 已提交
2380
		memcpy(XFS_DFORK_DPTR(dip), src, len);
L
Linus Torvalds 已提交
2381 2382 2383
		break;

	case XFS_ILOG_DBROOT:
2384
		xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
C
Christoph Hellwig 已提交
2385
				 (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
L
Linus Torvalds 已提交
2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421
				 XFS_DFORK_DSIZE(dip, mp));
		break;

	default:
		/*
		 * There are no data fork flags set.
		 */
		ASSERT((fields & XFS_ILOG_DFORK) == 0);
		break;
	}

	/*
	 * If we logged any attribute data, recover it.  There may or
	 * may not have been any other non-core data logged in this
	 * transaction.
	 */
	if (in_f->ilf_fields & XFS_ILOG_AFORK) {
		if (in_f->ilf_fields & XFS_ILOG_DFORK) {
			attr_index = 3;
		} else {
			attr_index = 2;
		}
		len = item->ri_buf[attr_index].i_len;
		src = item->ri_buf[attr_index].i_addr;
		ASSERT(len == in_f->ilf_asize);

		switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
		case XFS_ILOG_ADATA:
		case XFS_ILOG_AEXT:
			dest = XFS_DFORK_APTR(dip);
			ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
			memcpy(dest, src, len);
			break;

		case XFS_ILOG_ABROOT:
			dest = XFS_DFORK_APTR(dip);
2422 2423
			xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
					 len, (xfs_bmdr_block_t*)dest,
L
Linus Torvalds 已提交
2424 2425 2426 2427
					 XFS_DFORK_ASIZE(dip, mp));
			break;

		default:
2428
			xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
L
Linus Torvalds 已提交
2429 2430
			ASSERT(0);
			xfs_buf_relse(bp);
2431 2432
			error = EIO;
			goto error;
L
Linus Torvalds 已提交
2433 2434 2435 2436
		}
	}

write_inode_buffer:
2437
	ASSERT(bp->b_target->bt_mount == mp);
2438
	bp->b_iodone = xlog_recover_iodone;
2439 2440
	xfs_buf_delwri_queue(bp);
	xfs_buf_relse(bp);
2441 2442
error:
	if (need_free)
2443
		kmem_free(in_f);
2444
	return XFS_ERROR(error);
L
Linus Torvalds 已提交
2445 2446 2447 2448 2449 2450 2451 2452
}

/*
 * Recover QUOTAOFF records. We simply make a note of it in the xlog_t
 * structure, so that we know not to do any dquot item or dquot buffer recovery,
 * of that type.
 */
STATIC int
2453
xlog_recover_quotaoff_pass1(
L
Linus Torvalds 已提交
2454
	xlog_t			*log,
2455
	xlog_recover_item_t	*item)
L
Linus Torvalds 已提交
2456
{
2457
	xfs_qoff_logformat_t	*qoff_f = item->ri_buf[0].i_addr;
L
Linus Torvalds 已提交
2458 2459 2460 2461
	ASSERT(qoff_f);

	/*
	 * The logitem format's flag tells us if this was user quotaoff,
2462
	 * group/project quotaoff or both.
L
Linus Torvalds 已提交
2463 2464 2465
	 */
	if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
		log->l_quotaoffs_flag |= XFS_DQ_USER;
2466 2467
	if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
		log->l_quotaoffs_flag |= XFS_DQ_PROJ;
L
Linus Torvalds 已提交
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477
	if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
		log->l_quotaoffs_flag |= XFS_DQ_GROUP;

	return (0);
}

/*
 * Recover a dquot record
 */
STATIC int
2478
xlog_recover_dquot_pass2(
L
Linus Torvalds 已提交
2479
	xlog_t			*log,
2480
	xlog_recover_item_t	*item)
L
Linus Torvalds 已提交
2481
{
2482
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495
	xfs_buf_t		*bp;
	struct xfs_disk_dquot	*ddq, *recddq;
	int			error;
	xfs_dq_logformat_t	*dq_f;
	uint			type;


	/*
	 * Filesystems are required to send in quota flags at mount time.
	 */
	if (mp->m_qflags == 0)
		return (0);

2496 2497
	recddq = item->ri_buf[1].i_addr;
	if (recddq == NULL) {
2498
		xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
2499 2500
		return XFS_ERROR(EIO);
	}
2501
	if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
2502
		xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
2503 2504 2505 2506
			item->ri_buf[1].i_len, __func__);
		return XFS_ERROR(EIO);
	}

L
Linus Torvalds 已提交
2507 2508 2509
	/*
	 * This type of quotas was turned off, so ignore this record.
	 */
2510
	type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
L
Linus Torvalds 已提交
2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524
	ASSERT(type);
	if (log->l_quotaoffs_flag & type)
		return (0);

	/*
	 * At this point we know that quota was _not_ turned off.
	 * Since the mount flags are not indicating to us otherwise, this
	 * must mean that quota is on, and the dquot needs to be replayed.
	 * Remember that we may not have fully recovered the superblock yet,
	 * so we can't do the usual trick of looking at the SB quota bits.
	 *
	 * The other possibility, of course, is that the quota subsystem was
	 * removed since the last mount - ENOSYS.
	 */
2525
	dq_f = item->ri_buf[0].i_addr;
L
Linus Torvalds 已提交
2526
	ASSERT(dq_f);
2527 2528 2529
	error = xfs_qm_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
			   "xlog_recover_dquot_pass2 (log copy)");
	if (error)
L
Linus Torvalds 已提交
2530 2531 2532 2533 2534 2535 2536 2537
		return XFS_ERROR(EIO);
	ASSERT(dq_f->qlf_len == 1);

	error = xfs_read_buf(mp, mp->m_ddev_targp,
			     dq_f->qlf_blkno,
			     XFS_FSB_TO_BB(mp, dq_f->qlf_len),
			     0, &bp);
	if (error) {
2538
		xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#3)");
L
Linus Torvalds 已提交
2539 2540 2541 2542 2543 2544 2545 2546 2547 2548
		return error;
	}
	ASSERT(bp);
	ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);

	/*
	 * At least the magic num portion should be on disk because this
	 * was among a chunk of dquots created earlier, and we did some
	 * minimal initialization then.
	 */
2549 2550 2551
	error = xfs_qm_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
			   "xlog_recover_dquot_pass2");
	if (error) {
L
Linus Torvalds 已提交
2552 2553 2554 2555 2556 2557 2558
		xfs_buf_relse(bp);
		return XFS_ERROR(EIO);
	}

	memcpy(ddq, recddq, item->ri_buf[1].i_len);

	ASSERT(dq_f->qlf_size == 2);
2559
	ASSERT(bp->b_target->bt_mount == mp);
2560
	bp->b_iodone = xlog_recover_iodone;
2561 2562
	xfs_buf_delwri_queue(bp);
	xfs_buf_relse(bp);
L
Linus Torvalds 已提交
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573

	return (0);
}

/*
 * This routine is called to create an in-core extent free intent
 * item from the efi format structure which was logged on disk.
 * It allocates an in-core efi, copies the extents from the format
 * structure into it, and adds the efi to the AIL with the given
 * LSN.
 */
2574
STATIC int
2575
xlog_recover_efi_pass2(
L
Linus Torvalds 已提交
2576 2577
	xlog_t			*log,
	xlog_recover_item_t	*item,
2578
	xfs_lsn_t		lsn)
L
Linus Torvalds 已提交
2579
{
2580
	int			error;
2581
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2582 2583 2584
	xfs_efi_log_item_t	*efip;
	xfs_efi_log_format_t	*efi_formatp;

2585
	efi_formatp = item->ri_buf[0].i_addr;
L
Linus Torvalds 已提交
2586 2587

	efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
2588 2589 2590 2591 2592
	if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
					 &(efip->efi_format)))) {
		xfs_efi_item_free(efip);
		return error;
	}
2593
	atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
L
Linus Torvalds 已提交
2594

2595
	spin_lock(&log->l_ailp->xa_lock);
L
Linus Torvalds 已提交
2596
	/*
2597
	 * xfs_trans_ail_update() drops the AIL lock.
L
Linus Torvalds 已提交
2598
	 */
2599
	xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn);
2600
	return 0;
L
Linus Torvalds 已提交
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611
}


/*
 * This routine is called when an efd format structure is found in
 * a committed transaction in the log.  It's purpose is to cancel
 * the corresponding efi if it was still in the log.  To do this
 * it searches the AIL for the efi with an id equal to that in the
 * efd format structure.  If we find it, we remove the efi from the
 * AIL and free it.
 */
2612 2613
STATIC int
xlog_recover_efd_pass2(
L
Linus Torvalds 已提交
2614
	xlog_t			*log,
2615
	xlog_recover_item_t	*item)
L
Linus Torvalds 已提交
2616 2617 2618 2619 2620
{
	xfs_efd_log_format_t	*efd_formatp;
	xfs_efi_log_item_t	*efip = NULL;
	xfs_log_item_t		*lip;
	__uint64_t		efi_id;
2621
	struct xfs_ail_cursor	cur;
2622
	struct xfs_ail		*ailp = log->l_ailp;
L
Linus Torvalds 已提交
2623

2624
	efd_formatp = item->ri_buf[0].i_addr;
2625 2626 2627 2628
	ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
		((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
	       (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
		((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
L
Linus Torvalds 已提交
2629 2630 2631 2632 2633 2634
	efi_id = efd_formatp->efd_efi_id;

	/*
	 * Search for the efi with the id in the efd format structure
	 * in the AIL.
	 */
2635 2636
	spin_lock(&ailp->xa_lock);
	lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
L
Linus Torvalds 已提交
2637 2638 2639 2640 2641
	while (lip != NULL) {
		if (lip->li_type == XFS_LI_EFI) {
			efip = (xfs_efi_log_item_t *)lip;
			if (efip->efi_format.efi_id == efi_id) {
				/*
2642
				 * xfs_trans_ail_delete() drops the
L
Linus Torvalds 已提交
2643 2644
				 * AIL lock.
				 */
2645
				xfs_trans_ail_delete(ailp, lip);
2646
				xfs_efi_item_free(efip);
2647
				spin_lock(&ailp->xa_lock);
2648
				break;
L
Linus Torvalds 已提交
2649 2650
			}
		}
2651
		lip = xfs_trans_ail_cursor_next(ailp, &cur);
L
Linus Torvalds 已提交
2652
	}
2653 2654
	xfs_trans_ail_cursor_done(ailp, &cur);
	spin_unlock(&ailp->xa_lock);
2655 2656

	return 0;
L
Linus Torvalds 已提交
2657 2658 2659 2660 2661 2662 2663 2664 2665
}

/*
 * Free up any resources allocated by the transaction
 *
 * Remember that EFIs, EFDs, and IUNLINKs are handled later.
 */
STATIC void
xlog_recover_free_trans(
2666
	struct xlog_recover	*trans)
L
Linus Torvalds 已提交
2667
{
2668
	xlog_recover_item_t	*item, *n;
L
Linus Torvalds 已提交
2669 2670
	int			i;

2671 2672 2673 2674 2675
	list_for_each_entry_safe(item, n, &trans->r_itemq, ri_list) {
		/* Free the regions in the item. */
		list_del(&item->ri_list);
		for (i = 0; i < item->ri_cnt; i++)
			kmem_free(item->ri_buf[i].i_addr);
L
Linus Torvalds 已提交
2676
		/* Free the item itself */
2677 2678 2679
		kmem_free(item->ri_buf);
		kmem_free(item);
	}
L
Linus Torvalds 已提交
2680
	/* Free the transaction recover structure */
2681
	kmem_free(trans);
L
Linus Torvalds 已提交
2682 2683
}

2684
STATIC int
2685
xlog_recover_commit_pass1(
2686 2687
	struct log		*log,
	struct xlog_recover	*trans,
2688
	xlog_recover_item_t	*item)
2689
{
2690
	trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
2691 2692 2693

	switch (ITEM_TYPE(item)) {
	case XFS_LI_BUF:
2694 2695 2696
		return xlog_recover_buffer_pass1(log, item);
	case XFS_LI_QUOTAOFF:
		return xlog_recover_quotaoff_pass1(log, item);
2697 2698 2699
	case XFS_LI_INODE:
	case XFS_LI_EFI:
	case XFS_LI_EFD:
2700 2701
	case XFS_LI_DQUOT:
		/* nothing to do in pass 1 */
2702
		return 0;
2703
	default:
2704 2705
		xfs_warn(log->l_mp, "%s: invalid item type (%d)",
			__func__, ITEM_TYPE(item));
2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727
		ASSERT(0);
		return XFS_ERROR(EIO);
	}
}

STATIC int
xlog_recover_commit_pass2(
	struct log		*log,
	struct xlog_recover	*trans,
	xlog_recover_item_t	*item)
{
	trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);

	switch (ITEM_TYPE(item)) {
	case XFS_LI_BUF:
		return xlog_recover_buffer_pass2(log, item);
	case XFS_LI_INODE:
		return xlog_recover_inode_pass2(log, item);
	case XFS_LI_EFI:
		return xlog_recover_efi_pass2(log, item, trans->r_lsn);
	case XFS_LI_EFD:
		return xlog_recover_efd_pass2(log, item);
2728
	case XFS_LI_DQUOT:
2729
		return xlog_recover_dquot_pass2(log, item);
2730
	case XFS_LI_QUOTAOFF:
2731 2732
		/* nothing to do in pass2 */
		return 0;
2733
	default:
2734 2735
		xfs_warn(log->l_mp, "%s: invalid item type (%d)",
			__func__, ITEM_TYPE(item));
2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746
		ASSERT(0);
		return XFS_ERROR(EIO);
	}
}

/*
 * Perform the transaction.
 *
 * If the transaction modifies a buffer or inode, do it now.  Otherwise,
 * EFIs and EFDs get queued up by adding entries into the AIL for them.
 */
L
Linus Torvalds 已提交
2747 2748
STATIC int
xlog_recover_commit_trans(
2749 2750
	struct log		*log,
	struct xlog_recover	*trans,
L
Linus Torvalds 已提交
2751 2752
	int			pass)
{
2753 2754
	int			error = 0;
	xlog_recover_item_t	*item;
L
Linus Torvalds 已提交
2755

2756
	hlist_del(&trans->r_list);
2757 2758 2759

	error = xlog_recover_reorder_trans(log, trans, pass);
	if (error)
L
Linus Torvalds 已提交
2760
		return error;
2761 2762

	list_for_each_entry(item, &trans->r_itemq, ri_list) {
2763 2764 2765 2766
		if (pass == XLOG_RECOVER_PASS1)
			error = xlog_recover_commit_pass1(log, trans, item);
		else
			error = xlog_recover_commit_pass2(log, trans, item);
2767 2768 2769 2770 2771
		if (error)
			return error;
	}

	xlog_recover_free_trans(trans);
L
Linus Torvalds 已提交
2772 2773 2774 2775 2776
	return 0;
}

STATIC int
xlog_recover_unmount_trans(
2777
	struct log		*log,
L
Linus Torvalds 已提交
2778 2779 2780
	xlog_recover_t		*trans)
{
	/* Do nothing now */
2781
	xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
L
Linus Torvalds 已提交
2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796
	return 0;
}

/*
 * There are two valid states of the r_state field.  0 indicates that the
 * transaction structure is in a normal state.  We have either seen the
 * start of the transaction or the last operation we added was not a partial
 * operation.  If the last operation we added to the transaction was a
 * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
 *
 * NOTE: skip LRs with 0 data length.
 */
STATIC int
xlog_recover_process_data(
	xlog_t			*log,
2797
	struct hlist_head	rhash[],
L
Linus Torvalds 已提交
2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810
	xlog_rec_header_t	*rhead,
	xfs_caddr_t		dp,
	int			pass)
{
	xfs_caddr_t		lp;
	int			num_logops;
	xlog_op_header_t	*ohead;
	xlog_recover_t		*trans;
	xlog_tid_t		tid;
	int			error;
	unsigned long		hash;
	uint			flags;

2811 2812
	lp = dp + be32_to_cpu(rhead->h_len);
	num_logops = be32_to_cpu(rhead->h_num_logops);
L
Linus Torvalds 已提交
2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823

	/* check the log format matches our own - else we can't recover */
	if (xlog_header_check_recover(log->l_mp, rhead))
		return (XFS_ERROR(EIO));

	while ((dp < lp) && num_logops) {
		ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
		ohead = (xlog_op_header_t *)dp;
		dp += sizeof(xlog_op_header_t);
		if (ohead->oh_clientid != XFS_TRANSACTION &&
		    ohead->oh_clientid != XFS_LOG) {
2824 2825
			xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
					__func__, ohead->oh_clientid);
L
Linus Torvalds 已提交
2826 2827 2828
			ASSERT(0);
			return (XFS_ERROR(EIO));
		}
2829
		tid = be32_to_cpu(ohead->oh_tid);
L
Linus Torvalds 已提交
2830
		hash = XLOG_RHASH(tid);
2831
		trans = xlog_recover_find_tid(&rhash[hash], tid);
L
Linus Torvalds 已提交
2832 2833 2834
		if (trans == NULL) {		   /* not found; add new tid */
			if (ohead->oh_flags & XLOG_START_TRANS)
				xlog_recover_new_tid(&rhash[hash], tid,
2835
					be64_to_cpu(rhead->h_lsn));
L
Linus Torvalds 已提交
2836
		} else {
2837
			if (dp + be32_to_cpu(ohead->oh_len) > lp) {
2838 2839
				xfs_warn(log->l_mp, "%s: bad length 0x%x",
					__func__, be32_to_cpu(ohead->oh_len));
2840 2841 2842
				WARN_ON(1);
				return (XFS_ERROR(EIO));
			}
L
Linus Torvalds 已提交
2843 2844 2845 2846 2847 2848
			flags = ohead->oh_flags & ~XLOG_END_TRANS;
			if (flags & XLOG_WAS_CONT_TRANS)
				flags &= ~XLOG_CONTINUE_TRANS;
			switch (flags) {
			case XLOG_COMMIT_TRANS:
				error = xlog_recover_commit_trans(log,
2849
								trans, pass);
L
Linus Torvalds 已提交
2850 2851
				break;
			case XLOG_UNMOUNT_TRANS:
2852
				error = xlog_recover_unmount_trans(log, trans);
L
Linus Torvalds 已提交
2853 2854
				break;
			case XLOG_WAS_CONT_TRANS:
2855 2856 2857
				error = xlog_recover_add_to_cont_trans(log,
						trans, dp,
						be32_to_cpu(ohead->oh_len));
L
Linus Torvalds 已提交
2858 2859
				break;
			case XLOG_START_TRANS:
2860 2861
				xfs_warn(log->l_mp, "%s: bad transaction",
					__func__);
L
Linus Torvalds 已提交
2862 2863 2864 2865 2866
				ASSERT(0);
				error = XFS_ERROR(EIO);
				break;
			case 0:
			case XLOG_CONTINUE_TRANS:
2867
				error = xlog_recover_add_to_trans(log, trans,
2868
						dp, be32_to_cpu(ohead->oh_len));
L
Linus Torvalds 已提交
2869 2870
				break;
			default:
2871 2872
				xfs_warn(log->l_mp, "%s: bad flag 0x%x",
					__func__, flags);
L
Linus Torvalds 已提交
2873 2874 2875 2876 2877 2878 2879
				ASSERT(0);
				error = XFS_ERROR(EIO);
				break;
			}
			if (error)
				return error;
		}
2880
		dp += be32_to_cpu(ohead->oh_len);
L
Linus Torvalds 已提交
2881 2882 2883 2884 2885 2886 2887 2888 2889
		num_logops--;
	}
	return 0;
}

/*
 * Process an extent free intent item that was recovered from
 * the log.  We need to free the extents that it describes.
 */
2890
STATIC int
L
Linus Torvalds 已提交
2891 2892 2893 2894 2895 2896 2897
xlog_recover_process_efi(
	xfs_mount_t		*mp,
	xfs_efi_log_item_t	*efip)
{
	xfs_efd_log_item_t	*efdp;
	xfs_trans_t		*tp;
	int			i;
2898
	int			error = 0;
L
Linus Torvalds 已提交
2899 2900 2901
	xfs_extent_t		*extp;
	xfs_fsblock_t		startblock_fsb;

2902
	ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
L
Linus Torvalds 已提交
2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921

	/*
	 * First check the validity of the extents described by the
	 * EFI.  If any are bad, then assume that all are bad and
	 * just toss the EFI.
	 */
	for (i = 0; i < efip->efi_format.efi_nextents; i++) {
		extp = &(efip->efi_format.efi_extents[i]);
		startblock_fsb = XFS_BB_TO_FSB(mp,
				   XFS_FSB_TO_DADDR(mp, extp->ext_start));
		if ((startblock_fsb == 0) ||
		    (extp->ext_len == 0) ||
		    (startblock_fsb >= mp->m_sb.sb_dblocks) ||
		    (extp->ext_len >= mp->m_sb.sb_agblocks)) {
			/*
			 * This will pull the EFI from the AIL and
			 * free the memory associated with it.
			 */
			xfs_efi_release(efip, efip->efi_format.efi_nextents);
2922
			return XFS_ERROR(EIO);
L
Linus Torvalds 已提交
2923 2924 2925 2926
		}
	}

	tp = xfs_trans_alloc(mp, 0);
2927
	error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, 0, 0);
2928 2929
	if (error)
		goto abort_error;
L
Linus Torvalds 已提交
2930 2931 2932 2933
	efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);

	for (i = 0; i < efip->efi_format.efi_nextents; i++) {
		extp = &(efip->efi_format.efi_extents[i]);
2934 2935 2936
		error = xfs_free_extent(tp, extp->ext_start, extp->ext_len);
		if (error)
			goto abort_error;
L
Linus Torvalds 已提交
2937 2938 2939 2940
		xfs_trans_log_efd_extent(tp, efdp, extp->ext_start,
					 extp->ext_len);
	}

2941
	set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
2942
	error = xfs_trans_commit(tp, 0);
2943
	return error;
2944 2945 2946 2947

abort_error:
	xfs_trans_cancel(tp, XFS_TRANS_ABORT);
	return error;
L
Linus Torvalds 已提交
2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
}

/*
 * When this is called, all of the EFIs which did not have
 * corresponding EFDs should be in the AIL.  What we do now
 * is free the extents associated with each one.
 *
 * Since we process the EFIs in normal transactions, they
 * will be removed at some point after the commit.  This prevents
 * us from just walking down the list processing each one.
 * We'll use a flag in the EFI to skip those that we've already
 * processed and use the AIL iteration mechanism's generation
 * count to try to speed this up at least a bit.
 *
 * When we start, we know that the EFIs are the only things in
 * the AIL.  As we process them, however, other items are added
 * to the AIL.  Since everything added to the AIL must come after
 * everything already in the AIL, we stop processing as soon as
 * we see something other than an EFI in the AIL.
 */
2968
STATIC int
L
Linus Torvalds 已提交
2969 2970 2971 2972 2973
xlog_recover_process_efis(
	xlog_t			*log)
{
	xfs_log_item_t		*lip;
	xfs_efi_log_item_t	*efip;
2974
	int			error = 0;
2975
	struct xfs_ail_cursor	cur;
2976
	struct xfs_ail		*ailp;
L
Linus Torvalds 已提交
2977

2978 2979 2980
	ailp = log->l_ailp;
	spin_lock(&ailp->xa_lock);
	lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
L
Linus Torvalds 已提交
2981 2982 2983
	while (lip != NULL) {
		/*
		 * We're done when we see something other than an EFI.
2984
		 * There should be no EFIs left in the AIL now.
L
Linus Torvalds 已提交
2985 2986
		 */
		if (lip->li_type != XFS_LI_EFI) {
2987
#ifdef DEBUG
2988
			for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
2989 2990
				ASSERT(lip->li_type != XFS_LI_EFI);
#endif
L
Linus Torvalds 已提交
2991 2992 2993 2994 2995 2996 2997
			break;
		}

		/*
		 * Skip EFIs that we've already processed.
		 */
		efip = (xfs_efi_log_item_t *)lip;
2998
		if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) {
2999
			lip = xfs_trans_ail_cursor_next(ailp, &cur);
L
Linus Torvalds 已提交
3000 3001 3002
			continue;
		}

3003 3004 3005
		spin_unlock(&ailp->xa_lock);
		error = xlog_recover_process_efi(log->l_mp, efip);
		spin_lock(&ailp->xa_lock);
3006 3007
		if (error)
			goto out;
3008
		lip = xfs_trans_ail_cursor_next(ailp, &cur);
L
Linus Torvalds 已提交
3009
	}
3010
out:
3011 3012
	xfs_trans_ail_cursor_done(ailp, &cur);
	spin_unlock(&ailp->xa_lock);
3013
	return error;
L
Linus Torvalds 已提交
3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032
}

/*
 * This routine performs a transaction to null out a bad inode pointer
 * in an agi unlinked inode hash bucket.
 */
STATIC void
xlog_recover_clear_agi_bucket(
	xfs_mount_t	*mp,
	xfs_agnumber_t	agno,
	int		bucket)
{
	xfs_trans_t	*tp;
	xfs_agi_t	*agi;
	xfs_buf_t	*agibp;
	int		offset;
	int		error;

	tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET);
3033 3034
	error = xfs_trans_reserve(tp, 0, XFS_CLEAR_AGI_BUCKET_LOG_RES(mp),
				  0, 0, 0);
3035 3036
	if (error)
		goto out_abort;
L
Linus Torvalds 已提交
3037

3038 3039
	error = xfs_read_agi(mp, tp, agno, &agibp);
	if (error)
3040
		goto out_abort;
L
Linus Torvalds 已提交
3041

3042
	agi = XFS_BUF_TO_AGI(agibp);
3043
	agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
L
Linus Torvalds 已提交
3044 3045 3046 3047 3048
	offset = offsetof(xfs_agi_t, agi_unlinked) +
		 (sizeof(xfs_agino_t) * bucket);
	xfs_trans_log_buf(tp, agibp, offset,
			  (offset + sizeof(xfs_agino_t) - 1));

3049 3050 3051 3052 3053 3054 3055 3056
	error = xfs_trans_commit(tp, 0);
	if (error)
		goto out_error;
	return;

out_abort:
	xfs_trans_cancel(tp, XFS_TRANS_ABORT);
out_error:
3057
	xfs_warn(mp, "%s: failed to clear agi %d. Continuing.", __func__, agno);
3058
	return;
L
Linus Torvalds 已提交
3059 3060
}

3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074
STATIC xfs_agino_t
xlog_recover_process_one_iunlink(
	struct xfs_mount		*mp,
	xfs_agnumber_t			agno,
	xfs_agino_t			agino,
	int				bucket)
{
	struct xfs_buf			*ibp;
	struct xfs_dinode		*dip;
	struct xfs_inode		*ip;
	xfs_ino_t			ino;
	int				error;

	ino = XFS_AGINO_TO_INO(mp, agno, agino);
3075
	error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
3076 3077 3078 3079 3080 3081
	if (error)
		goto fail;

	/*
	 * Get the on disk inode to find the next inode in the bucket.
	 */
3082
	error = xfs_itobp(mp, NULL, ip, &dip, &ibp, XBF_LOCK);
3083
	if (error)
3084
		goto fail_iput;
3085 3086

	ASSERT(ip->i_d.di_nlink == 0);
3087
	ASSERT(ip->i_d.di_mode != 0);
3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098

	/* setup for the next pass */
	agino = be32_to_cpu(dip->di_next_unlinked);
	xfs_buf_relse(ibp);

	/*
	 * Prevent any DMAPI event from being sent when the reference on
	 * the inode is dropped.
	 */
	ip->i_d.di_dmevmask = 0;

3099
	IRELE(ip);
3100 3101
	return agino;

3102 3103
 fail_iput:
	IRELE(ip);
3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116
 fail:
	/*
	 * We can't read in the inode this bucket points to, or this inode
	 * is messed up.  Just ditch this bucket of inodes.  We will lose
	 * some inodes and space, but at least we won't hang.
	 *
	 * Call xlog_recover_clear_agi_bucket() to perform a transaction to
	 * clear the inode pointer in the bucket.
	 */
	xlog_recover_clear_agi_bucket(mp, agno, bucket);
	return NULLAGINO;
}

L
Linus Torvalds 已提交
3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128
/*
 * xlog_iunlink_recover
 *
 * This is called during recovery to process any inodes which
 * we unlinked but not freed when the system crashed.  These
 * inodes will be on the lists in the AGI blocks.  What we do
 * here is scan all the AGIs and fully truncate and free any
 * inodes found on the lists.  Each inode is removed from the
 * lists when it has been fully truncated and is freed.  The
 * freeing of the inode and its removal from the list must be
 * atomic.
 */
3129
STATIC void
L
Linus Torvalds 已提交
3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153
xlog_recover_process_iunlinks(
	xlog_t		*log)
{
	xfs_mount_t	*mp;
	xfs_agnumber_t	agno;
	xfs_agi_t	*agi;
	xfs_buf_t	*agibp;
	xfs_agino_t	agino;
	int		bucket;
	int		error;
	uint		mp_dmevmask;

	mp = log->l_mp;

	/*
	 * Prevent any DMAPI event from being sent while in this function.
	 */
	mp_dmevmask = mp->m_dmevmask;
	mp->m_dmevmask = 0;

	for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
		/*
		 * Find the agi for this ag.
		 */
3154 3155 3156 3157 3158 3159 3160 3161 3162
		error = xfs_read_agi(mp, NULL, agno, &agibp);
		if (error) {
			/*
			 * AGI is b0rked. Don't process it.
			 *
			 * We should probably mark the filesystem as corrupt
			 * after we've recovered all the ag's we can....
			 */
			continue;
L
Linus Torvalds 已提交
3163 3164 3165 3166
		}
		agi = XFS_BUF_TO_AGI(agibp);

		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
3167
			agino = be32_to_cpu(agi->agi_unlinked[bucket]);
L
Linus Torvalds 已提交
3168 3169 3170 3171 3172 3173 3174 3175
			while (agino != NULLAGINO) {
				/*
				 * Release the agi buffer so that it can
				 * be acquired in the normal course of the
				 * transaction to truncate and free the inode.
				 */
				xfs_buf_relse(agibp);

3176 3177
				agino = xlog_recover_process_one_iunlink(mp,
							agno, agino, bucket);
L
Linus Torvalds 已提交
3178 3179 3180

				/*
				 * Reacquire the agibuffer and continue around
3181 3182
				 * the loop. This should never fail as we know
				 * the buffer was good earlier on.
L
Linus Torvalds 已提交
3183
				 */
3184 3185
				error = xfs_read_agi(mp, NULL, agno, &agibp);
				ASSERT(error == 0);
L
Linus Torvalds 已提交
3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
				agi = XFS_BUF_TO_AGI(agibp);
			}
		}

		/*
		 * Release the buffer for the current agi so we can
		 * go on to the next one.
		 */
		xfs_buf_relse(agibp);
	}

	mp->m_dmevmask = mp_dmevmask;
}


#ifdef DEBUG
STATIC void
xlog_pack_data_checksum(
	xlog_t		*log,
	xlog_in_core_t	*iclog,
	int		size)
{
	int		i;
3209
	__be32		*up;
L
Linus Torvalds 已提交
3210 3211
	uint		chksum = 0;

3212
	up = (__be32 *)iclog->ic_datap;
L
Linus Torvalds 已提交
3213 3214
	/* divide length by 4 to get # words */
	for (i = 0; i < (size >> 2); i++) {
3215
		chksum ^= be32_to_cpu(*up);
L
Linus Torvalds 已提交
3216 3217
		up++;
	}
3218
	iclog->ic_header.h_chksum = cpu_to_be32(chksum);
L
Linus Torvalds 已提交
3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234
}
#else
#define xlog_pack_data_checksum(log, iclog, size)
#endif

/*
 * Stamp cycle number in every block
 */
void
xlog_pack_data(
	xlog_t			*log,
	xlog_in_core_t		*iclog,
	int			roundoff)
{
	int			i, j, k;
	int			size = iclog->ic_offset + roundoff;
3235
	__be32			cycle_lsn;
L
Linus Torvalds 已提交
3236 3237 3238 3239 3240 3241 3242 3243 3244
	xfs_caddr_t		dp;

	xlog_pack_data_checksum(log, iclog, size);

	cycle_lsn = CYCLE_LSN_DISK(iclog->ic_header.h_lsn);

	dp = iclog->ic_datap;
	for (i = 0; i < BTOBB(size) &&
		i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
3245 3246
		iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp;
		*(__be32 *)dp = cycle_lsn;
L
Linus Torvalds 已提交
3247 3248 3249
		dp += BBSIZE;
	}

3250
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
3251 3252
		xlog_in_core_2_t *xhdr = iclog->ic_data;

L
Linus Torvalds 已提交
3253 3254 3255
		for ( ; i < BTOBB(size); i++) {
			j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
			k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3256 3257
			xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp;
			*(__be32 *)dp = cycle_lsn;
L
Linus Torvalds 已提交
3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274
			dp += BBSIZE;
		}

		for (i = 1; i < log->l_iclog_heads; i++) {
			xhdr[i].hic_xheader.xh_cycle = cycle_lsn;
		}
	}
}

STATIC void
xlog_unpack_data(
	xlog_rec_header_t	*rhead,
	xfs_caddr_t		dp,
	xlog_t			*log)
{
	int			i, j, k;

3275
	for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
L
Linus Torvalds 已提交
3276
		  i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
3277
		*(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
L
Linus Torvalds 已提交
3278 3279 3280
		dp += BBSIZE;
	}

3281
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
3282
		xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
3283
		for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
L
Linus Torvalds 已提交
3284 3285
			j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
			k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3286
			*(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
L
Linus Torvalds 已提交
3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299
			dp += BBSIZE;
		}
	}
}

STATIC int
xlog_valid_rec_header(
	xlog_t			*log,
	xlog_rec_header_t	*rhead,
	xfs_daddr_t		blkno)
{
	int			hlen;

3300
	if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
L
Linus Torvalds 已提交
3301 3302 3303 3304 3305 3306
		XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
				XFS_ERRLEVEL_LOW, log->l_mp);
		return XFS_ERROR(EFSCORRUPTED);
	}
	if (unlikely(
	    (!rhead->h_version ||
3307
	    (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
3308
		xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
3309
			__func__, be32_to_cpu(rhead->h_version));
L
Linus Torvalds 已提交
3310 3311 3312 3313
		return XFS_ERROR(EIO);
	}

	/* LR body must have data or it wouldn't have been written */
3314
	hlen = be32_to_cpu(rhead->h_len);
L
Linus Torvalds 已提交
3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344
	if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
		XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
				XFS_ERRLEVEL_LOW, log->l_mp);
		return XFS_ERROR(EFSCORRUPTED);
	}
	if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
		XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
				XFS_ERRLEVEL_LOW, log->l_mp);
		return XFS_ERROR(EFSCORRUPTED);
	}
	return 0;
}

/*
 * Read the log from tail to head and process the log records found.
 * Handle the two cases where the tail and head are in the same cycle
 * and where the active portion of the log wraps around the end of
 * the physical log separately.  The pass parameter is passed through
 * to the routines called to process the data and is not looked at
 * here.
 */
STATIC int
xlog_do_recovery_pass(
	xlog_t			*log,
	xfs_daddr_t		head_blk,
	xfs_daddr_t		tail_blk,
	int			pass)
{
	xlog_rec_header_t	*rhead;
	xfs_daddr_t		blk_no;
3345
	xfs_caddr_t		offset;
L
Linus Torvalds 已提交
3346 3347 3348 3349
	xfs_buf_t		*hbp, *dbp;
	int			error = 0, h_size;
	int			bblks, split_bblks;
	int			hblks, split_hblks, wrapped_hblks;
3350
	struct hlist_head	rhash[XLOG_RHASH_SIZE];
L
Linus Torvalds 已提交
3351 3352 3353 3354 3355 3356 3357

	ASSERT(head_blk != tail_blk);

	/*
	 * Read the header of the tail block and get the iclog buffer size from
	 * h_size.  Use this to tell how many sectors make up the log header.
	 */
3358
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
L
Linus Torvalds 已提交
3359 3360 3361 3362 3363 3364 3365 3366
		/*
		 * When using variable length iclogs, read first sector of
		 * iclog header and extract the header size from it.  Get a
		 * new hbp that is the correct size.
		 */
		hbp = xlog_get_bp(log, 1);
		if (!hbp)
			return ENOMEM;
C
Christoph Hellwig 已提交
3367 3368 3369

		error = xlog_bread(log, tail_blk, 1, hbp, &offset);
		if (error)
L
Linus Torvalds 已提交
3370
			goto bread_err1;
C
Christoph Hellwig 已提交
3371

L
Linus Torvalds 已提交
3372 3373 3374 3375
		rhead = (xlog_rec_header_t *)offset;
		error = xlog_valid_rec_header(log, rhead, tail_blk);
		if (error)
			goto bread_err1;
3376 3377
		h_size = be32_to_cpu(rhead->h_size);
		if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
L
Linus Torvalds 已提交
3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
		    (h_size > XLOG_HEADER_CYCLE_SIZE)) {
			hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
			if (h_size % XLOG_HEADER_CYCLE_SIZE)
				hblks++;
			xlog_put_bp(hbp);
			hbp = xlog_get_bp(log, hblks);
		} else {
			hblks = 1;
		}
	} else {
3388
		ASSERT(log->l_sectBBsize == 1);
L
Linus Torvalds 已提交
3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404
		hblks = 1;
		hbp = xlog_get_bp(log, 1);
		h_size = XLOG_BIG_RECORD_BSIZE;
	}

	if (!hbp)
		return ENOMEM;
	dbp = xlog_get_bp(log, BTOBB(h_size));
	if (!dbp) {
		xlog_put_bp(hbp);
		return ENOMEM;
	}

	memset(rhash, 0, sizeof(rhash));
	if (tail_blk <= head_blk) {
		for (blk_no = tail_blk; blk_no < head_blk; ) {
C
Christoph Hellwig 已提交
3405 3406
			error = xlog_bread(log, blk_no, hblks, hbp, &offset);
			if (error)
L
Linus Torvalds 已提交
3407
				goto bread_err2;
C
Christoph Hellwig 已提交
3408

L
Linus Torvalds 已提交
3409 3410 3411 3412 3413 3414
			rhead = (xlog_rec_header_t *)offset;
			error = xlog_valid_rec_header(log, rhead, blk_no);
			if (error)
				goto bread_err2;

			/* blocks in data section */
3415
			bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
C
Christoph Hellwig 已提交
3416 3417
			error = xlog_bread(log, blk_no + hblks, bblks, dbp,
					   &offset);
L
Linus Torvalds 已提交
3418 3419
			if (error)
				goto bread_err2;
C
Christoph Hellwig 已提交
3420

L
Linus Torvalds 已提交
3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437
			xlog_unpack_data(rhead, offset, log);
			if ((error = xlog_recover_process_data(log,
						rhash, rhead, offset, pass)))
				goto bread_err2;
			blk_no += bblks + hblks;
		}
	} else {
		/*
		 * Perform recovery around the end of the physical log.
		 * When the head is not on the same cycle number as the tail,
		 * we can't do a sequential recovery as above.
		 */
		blk_no = tail_blk;
		while (blk_no < log->l_logBBsize) {
			/*
			 * Check for header wrapping around physical end-of-log
			 */
3438
			offset = hbp->b_addr;
L
Linus Torvalds 已提交
3439 3440 3441 3442
			split_hblks = 0;
			wrapped_hblks = 0;
			if (blk_no + hblks <= log->l_logBBsize) {
				/* Read header in one read */
C
Christoph Hellwig 已提交
3443 3444
				error = xlog_bread(log, blk_no, hblks, hbp,
						   &offset);
L
Linus Torvalds 已提交
3445 3446 3447 3448 3449 3450 3451 3452 3453
				if (error)
					goto bread_err2;
			} else {
				/* This LR is split across physical log end */
				if (blk_no != log->l_logBBsize) {
					/* some data before physical log end */
					ASSERT(blk_no <= INT_MAX);
					split_hblks = log->l_logBBsize - (int)blk_no;
					ASSERT(split_hblks > 0);
C
Christoph Hellwig 已提交
3454 3455 3456 3457
					error = xlog_bread(log, blk_no,
							   split_hblks, hbp,
							   &offset);
					if (error)
L
Linus Torvalds 已提交
3458 3459
						goto bread_err2;
				}
C
Christoph Hellwig 已提交
3460

L
Linus Torvalds 已提交
3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472
				/*
				 * Note: this black magic still works with
				 * large sector sizes (non-512) only because:
				 * - we increased the buffer size originally
				 *   by 1 sector giving us enough extra space
				 *   for the second read;
				 * - the log start is guaranteed to be sector
				 *   aligned;
				 * - we read the log end (LR header start)
				 *   _first_, then the log start (LR header end)
				 *   - order is important.
				 */
3473
				wrapped_hblks = hblks - split_hblks;
3474 3475 3476
				error = xlog_bread_offset(log, 0,
						wrapped_hblks, hbp,
						offset + BBTOB(split_hblks));
L
Linus Torvalds 已提交
3477 3478 3479 3480 3481 3482 3483 3484 3485
				if (error)
					goto bread_err2;
			}
			rhead = (xlog_rec_header_t *)offset;
			error = xlog_valid_rec_header(log, rhead,
						split_hblks ? blk_no : 0);
			if (error)
				goto bread_err2;

3486
			bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
L
Linus Torvalds 已提交
3487 3488 3489 3490
			blk_no += hblks;

			/* Read in data for log record */
			if (blk_no + bblks <= log->l_logBBsize) {
C
Christoph Hellwig 已提交
3491 3492
				error = xlog_bread(log, blk_no, bblks, dbp,
						   &offset);
L
Linus Torvalds 已提交
3493 3494 3495 3496 3497
				if (error)
					goto bread_err2;
			} else {
				/* This log record is split across the
				 * physical end of log */
3498
				offset = dbp->b_addr;
L
Linus Torvalds 已提交
3499 3500 3501 3502 3503 3504 3505 3506 3507
				split_bblks = 0;
				if (blk_no != log->l_logBBsize) {
					/* some data is before the physical
					 * end of log */
					ASSERT(!wrapped_hblks);
					ASSERT(blk_no <= INT_MAX);
					split_bblks =
						log->l_logBBsize - (int)blk_no;
					ASSERT(split_bblks > 0);
C
Christoph Hellwig 已提交
3508 3509 3510 3511
					error = xlog_bread(log, blk_no,
							split_bblks, dbp,
							&offset);
					if (error)
L
Linus Torvalds 已提交
3512 3513
						goto bread_err2;
				}
C
Christoph Hellwig 已提交
3514

L
Linus Torvalds 已提交
3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526
				/*
				 * Note: this black magic still works with
				 * large sector sizes (non-512) only because:
				 * - we increased the buffer size originally
				 *   by 1 sector giving us enough extra space
				 *   for the second read;
				 * - the log start is guaranteed to be sector
				 *   aligned;
				 * - we read the log end (LR header start)
				 *   _first_, then the log start (LR header end)
				 *   - order is important.
				 */
3527 3528 3529
				error = xlog_bread_offset(log, 0,
						bblks - split_bblks, hbp,
						offset + BBTOB(split_bblks));
C
Christoph Hellwig 已提交
3530 3531
				if (error)
					goto bread_err2;
L
Linus Torvalds 已提交
3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544
			}
			xlog_unpack_data(rhead, offset, log);
			if ((error = xlog_recover_process_data(log, rhash,
							rhead, offset, pass)))
				goto bread_err2;
			blk_no += bblks;
		}

		ASSERT(blk_no >= log->l_logBBsize);
		blk_no -= log->l_logBBsize;

		/* read first part of physical log */
		while (blk_no < head_blk) {
C
Christoph Hellwig 已提交
3545 3546
			error = xlog_bread(log, blk_no, hblks, hbp, &offset);
			if (error)
L
Linus Torvalds 已提交
3547
				goto bread_err2;
C
Christoph Hellwig 已提交
3548

L
Linus Torvalds 已提交
3549 3550 3551 3552
			rhead = (xlog_rec_header_t *)offset;
			error = xlog_valid_rec_header(log, rhead, blk_no);
			if (error)
				goto bread_err2;
C
Christoph Hellwig 已提交
3553

3554
			bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
C
Christoph Hellwig 已提交
3555 3556 3557
			error = xlog_bread(log, blk_no+hblks, bblks, dbp,
					   &offset);
			if (error)
L
Linus Torvalds 已提交
3558
				goto bread_err2;
C
Christoph Hellwig 已提交
3559

L
Linus Torvalds 已提交
3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
			xlog_unpack_data(rhead, offset, log);
			if ((error = xlog_recover_process_data(log, rhash,
							rhead, offset, pass)))
				goto bread_err2;
			blk_no += bblks + hblks;
		}
	}

 bread_err2:
	xlog_put_bp(dbp);
 bread_err1:
	xlog_put_bp(hbp);
	return error;
}

/*
 * Do the recovery of the log.  We actually do this in two phases.
 * The two passes are necessary in order to implement the function
 * of cancelling a record written into the log.  The first pass
 * determines those things which have been cancelled, and the
 * second pass replays log items normally except for those which
 * have been cancelled.  The handling of the replay and cancellations
 * takes place in the log item type specific routines.
 *
 * The table of items which have cancel records in the log is allocated
 * and freed at this level, since only here do we know when all of
 * the log recovery has been completed.
 */
STATIC int
xlog_do_log_recovery(
	xlog_t		*log,
	xfs_daddr_t	head_blk,
	xfs_daddr_t	tail_blk)
{
3594
	int		error, i;
L
Linus Torvalds 已提交
3595 3596 3597 3598 3599 3600 3601

	ASSERT(head_blk != tail_blk);

	/*
	 * First do a pass to find all of the cancelled buf log items.
	 * Store them in the buf_cancel_table for use in the second pass.
	 */
3602 3603
	log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE *
						 sizeof(struct list_head),
L
Linus Torvalds 已提交
3604
						 KM_SLEEP);
3605 3606 3607
	for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
		INIT_LIST_HEAD(&log->l_buf_cancel_table[i]);

L
Linus Torvalds 已提交
3608 3609 3610
	error = xlog_do_recovery_pass(log, head_blk, tail_blk,
				      XLOG_RECOVER_PASS1);
	if (error != 0) {
3611
		kmem_free(log->l_buf_cancel_table);
L
Linus Torvalds 已提交
3612 3613 3614 3615 3616 3617 3618 3619 3620 3621
		log->l_buf_cancel_table = NULL;
		return error;
	}
	/*
	 * Then do a second pass to actually recover the items in the log.
	 * When it is complete free the table of buf cancel items.
	 */
	error = xlog_do_recovery_pass(log, head_blk, tail_blk,
				      XLOG_RECOVER_PASS2);
#ifdef DEBUG
3622
	if (!error) {
L
Linus Torvalds 已提交
3623 3624 3625
		int	i;

		for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
3626
			ASSERT(list_empty(&log->l_buf_cancel_table[i]));
L
Linus Torvalds 已提交
3627 3628 3629
	}
#endif	/* DEBUG */

3630
	kmem_free(log->l_buf_cancel_table);
L
Linus Torvalds 已提交
3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656
	log->l_buf_cancel_table = NULL;

	return error;
}

/*
 * Do the actual recovery
 */
STATIC int
xlog_do_recover(
	xlog_t		*log,
	xfs_daddr_t	head_blk,
	xfs_daddr_t	tail_blk)
{
	int		error;
	xfs_buf_t	*bp;
	xfs_sb_t	*sbp;

	/*
	 * First replay the images in the log.
	 */
	error = xlog_do_log_recovery(log, head_blk, tail_blk);
	if (error) {
		return error;
	}

C
Christoph Hellwig 已提交
3657
	xfs_flush_buftarg(log->l_mp->m_ddev_targp, 1);
L
Linus Torvalds 已提交
3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682

	/*
	 * If IO errors happened during recovery, bail out.
	 */
	if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
		return (EIO);
	}

	/*
	 * We now update the tail_lsn since much of the recovery has completed
	 * and there may be space available to use.  If there were no extent
	 * or iunlinks, we can free up the entire log and set the tail_lsn to
	 * be the last_sync_lsn.  This was set in xlog_find_tail to be the
	 * lsn of the last known good LR on disk.  If there are extent frees
	 * or iunlinks they will have some entries in the AIL; so we look at
	 * the AIL to determine how to set the tail_lsn.
	 */
	xlog_assign_tail_lsn(log->l_mp);

	/*
	 * Now that we've finished replaying all buffer and inode
	 * updates, re-read in the superblock.
	 */
	bp = xfs_getsb(log->l_mp, 0);
	XFS_BUF_UNDONE(bp);
3683 3684
	ASSERT(!(XFS_BUF_ISWRITE(bp)));
	ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
L
Linus Torvalds 已提交
3685
	XFS_BUF_READ(bp);
3686
	XFS_BUF_UNASYNC(bp);
L
Linus Torvalds 已提交
3687
	xfsbdstrat(log->l_mp, bp);
C
Christoph Hellwig 已提交
3688
	error = xfs_buf_iowait(bp);
3689
	if (error) {
3690
		xfs_buf_ioerror_alert(bp, __func__);
L
Linus Torvalds 已提交
3691 3692 3693 3694 3695 3696 3697
		ASSERT(0);
		xfs_buf_relse(bp);
		return error;
	}

	/* Convert superblock from on-disk format */
	sbp = &log->l_mp->m_sb;
3698
	xfs_sb_from_disk(log->l_mp, XFS_BUF_TO_SBP(bp));
L
Linus Torvalds 已提交
3699
	ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
3700
	ASSERT(xfs_sb_good_version(sbp));
L
Linus Torvalds 已提交
3701 3702
	xfs_buf_relse(bp);

3703 3704 3705
	/* We've re-read the superblock so re-initialize per-cpu counters */
	xfs_icsb_reinit_counters(log->l_mp);

L
Linus Torvalds 已提交
3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719
	xlog_recover_check_summary(log);

	/* Normal transactions can now occur */
	log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
	return 0;
}

/*
 * Perform recovery and re-initialize some log variables in xlog_find_tail.
 *
 * Return error or zero.
 */
int
xlog_recover(
3720
	xlog_t		*log)
L
Linus Torvalds 已提交
3721 3722 3723 3724 3725
{
	xfs_daddr_t	head_blk, tail_blk;
	int		error;

	/* find the tail of the log */
3726
	if ((error = xlog_find_tail(log, &head_blk, &tail_blk)))
L
Linus Torvalds 已提交
3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740
		return error;

	if (tail_blk != head_blk) {
		/* There used to be a comment here:
		 *
		 * disallow recovery on read-only mounts.  note -- mount
		 * checks for ENOSPC and turns it into an intelligent
		 * error message.
		 * ...but this is no longer true.  Now, unless you specify
		 * NORECOVERY (in which case this function would never be
		 * called), we just go ahead and recover.  We do this all
		 * under the vfs layer, so we can get away with it unless
		 * the device itself is read-only, in which case we fail.
		 */
3741
		if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
L
Linus Torvalds 已提交
3742 3743 3744
			return error;
		}

3745 3746 3747
		xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
				log->l_mp->m_logname ? log->l_mp->m_logname
						     : "internal");
L
Linus Torvalds 已提交
3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765

		error = xlog_do_recover(log, head_blk, tail_blk);
		log->l_flags |= XLOG_RECOVERY_NEEDED;
	}
	return error;
}

/*
 * In the first part of recovery we replay inodes and buffers and build
 * up the list of extent free items which need to be processed.  Here
 * we process the extent free items and clean up the on disk unlinked
 * inode lists.  This is separated from the first part of recovery so
 * that the root and real-time bitmap inodes can be read in from disk in
 * between the two stages.  This is necessary so that we can free space
 * in the real-time portion of the file system.
 */
int
xlog_recover_finish(
C
Christoph Hellwig 已提交
3766
	xlog_t		*log)
L
Linus Torvalds 已提交
3767 3768 3769 3770 3771 3772 3773 3774 3775 3776
{
	/*
	 * Now we're ready to do the transactions needed for the
	 * rest of recovery.  Start with completing all the extent
	 * free intent records and then process the unlinked inode
	 * lists.  At this point, we essentially run in normal mode
	 * except that we're still performing recovery actions
	 * rather than accepting new requests.
	 */
	if (log->l_flags & XLOG_RECOVERY_NEEDED) {
3777 3778 3779
		int	error;
		error = xlog_recover_process_efis(log);
		if (error) {
3780
			xfs_alert(log->l_mp, "Failed to recover EFIs");
3781 3782
			return error;
		}
L
Linus Torvalds 已提交
3783 3784 3785 3786 3787 3788
		/*
		 * Sync the log to get all the EFIs out of the AIL.
		 * This isn't absolutely necessary, but it helps in
		 * case the unlink transactions would have problems
		 * pushing the EFIs out of the way.
		 */
3789
		xfs_log_force(log->l_mp, XFS_LOG_SYNC);
L
Linus Torvalds 已提交
3790

C
Christoph Hellwig 已提交
3791
		xlog_recover_process_iunlinks(log);
L
Linus Torvalds 已提交
3792 3793 3794

		xlog_recover_check_summary(log);

3795 3796 3797
		xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
				log->l_mp->m_logname ? log->l_mp->m_logname
						     : "internal");
L
Linus Torvalds 已提交
3798 3799
		log->l_flags &= ~XLOG_RECOVERY_NEEDED;
	} else {
3800
		xfs_info(log->l_mp, "Ending clean mount");
L
Linus Torvalds 已提交
3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822
	}
	return 0;
}


#if defined(DEBUG)
/*
 * Read all of the agf and agi counters and check that they
 * are consistent with the superblock counters.
 */
void
xlog_recover_check_summary(
	xlog_t		*log)
{
	xfs_mount_t	*mp;
	xfs_agf_t	*agfp;
	xfs_buf_t	*agfbp;
	xfs_buf_t	*agibp;
	xfs_agnumber_t	agno;
	__uint64_t	freeblks;
	__uint64_t	itotal;
	__uint64_t	ifree;
3823
	int		error;
L
Linus Torvalds 已提交
3824 3825 3826 3827 3828 3829 3830

	mp = log->l_mp;

	freeblks = 0LL;
	itotal = 0LL;
	ifree = 0LL;
	for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
3831 3832
		error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
		if (error) {
3833 3834
			xfs_alert(mp, "%s agf read failed agno %d error %d",
						__func__, agno, error);
3835 3836 3837 3838 3839
		} else {
			agfp = XFS_BUF_TO_AGF(agfbp);
			freeblks += be32_to_cpu(agfp->agf_freeblks) +
				    be32_to_cpu(agfp->agf_flcount);
			xfs_buf_relse(agfbp);
L
Linus Torvalds 已提交
3840 3841
		}

3842
		error = xfs_read_agi(mp, NULL, agno, &agibp);
3843 3844 3845 3846
		if (error) {
			xfs_alert(mp, "%s agi read failed agno %d error %d",
						__func__, agno, error);
		} else {
3847
			struct xfs_agi	*agi = XFS_BUF_TO_AGI(agibp);
3848

3849 3850 3851 3852
			itotal += be32_to_cpu(agi->agi_count);
			ifree += be32_to_cpu(agi->agi_freecount);
			xfs_buf_relse(agibp);
		}
L
Linus Torvalds 已提交
3853 3854 3855
	}
}
#endif /* DEBUG */