xfs_log_recover.c 118.4 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"
20
#include "xfs_format.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"
32
#include "xfs_btree.h"
L
Linus Torvalds 已提交
33 34
#include "xfs_dinode.h"
#include "xfs_inode.h"
35 36
#include "xfs_inode_item.h"
#include "xfs_alloc.h"
L
Linus Torvalds 已提交
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"
C
Christoph Hellwig 已提交
44
#include "xfs_cksum.h"
C
Christoph Hellwig 已提交
45
#include "xfs_trace.h"
D
Dave Chinner 已提交
46
#include "xfs_icache.h"
D
Dave Chinner 已提交
47
#include "xfs_icreate_item.h"
48 49

/* Need all the magic numbers and buffer ops structures from these headers */
50
#include "xfs_symlink.h"
51 52
#include "xfs_da_btree.h"
#include "xfs_dir2_format.h"
53
#include "xfs_dir2.h"
54 55
#include "xfs_attr_leaf.h"
#include "xfs_attr_remote.h"
L
Linus Torvalds 已提交
56

57 58
#define BLK_AVG(blk1, blk2)	((blk1+blk2) >> 1)

M
Mark Tinguely 已提交
59 60 61 62 63 64 65 66
STATIC int
xlog_find_zeroed(
	struct xlog	*,
	xfs_daddr_t	*);
STATIC int
xlog_clear_stale_blocks(
	struct xlog	*,
	xfs_lsn_t);
L
Linus Torvalds 已提交
67
#if defined(DEBUG)
M
Mark Tinguely 已提交
68 69 70
STATIC void
xlog_recover_check_summary(
	struct xlog *);
L
Linus Torvalds 已提交
71 72 73 74
#else
#define	xlog_recover_check_summary(log)
#endif

75 76 77 78 79 80 81 82 83 84 85
/*
 * 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 已提交
86 87 88 89
/*
 * Sector aligned buffer routines for buffer create/read/write/access
 */

90 91 92 93 94 95 96 97
/*
 * 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(
M
Mark Tinguely 已提交
98
	struct xlog	*log,
99 100 101 102 103
	int		bbcount)
{
	return bbcount > 0 && bbcount <= log->l_logBBsize;
}

104 105 106 107 108
/*
 * 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.
 */
109
STATIC xfs_buf_t *
L
Linus Torvalds 已提交
110
xlog_get_bp(
M
Mark Tinguely 已提交
111
	struct xlog	*log,
112
	int		nbblks)
L
Linus Torvalds 已提交
113
{
114 115
	struct xfs_buf	*bp;

116
	if (!xlog_buf_bbcount_valid(log, nbblks)) {
117
		xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
118 119
			nbblks);
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
120 121
		return NULL;
	}
L
Linus Torvalds 已提交
122

123 124 125
	/*
	 * 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 已提交
126
	 * requested size to accommodate the basic blocks required
127 128 129 130 131 132 133 134 135 136
	 * 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 已提交
137
	 * there's space to accommodate this possibility.
138
	 */
139 140 141
	if (nbblks > 1 && log->l_sectBBsize > 1)
		nbblks += log->l_sectBBsize;
	nbblks = round_up(nbblks, log->l_sectBBsize);
142

143
	bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0);
144 145 146
	if (bp)
		xfs_buf_unlock(bp);
	return bp;
L
Linus Torvalds 已提交
147 148
}

149
STATIC void
L
Linus Torvalds 已提交
150 151 152 153 154 155
xlog_put_bp(
	xfs_buf_t	*bp)
{
	xfs_buf_free(bp);
}

A
Alex Elder 已提交
156 157 158 159
/*
 * 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 已提交
160 161
STATIC xfs_caddr_t
xlog_align(
M
Mark Tinguely 已提交
162
	struct xlog	*log,
C
Christoph Hellwig 已提交
163 164
	xfs_daddr_t	blk_no,
	int		nbblks,
M
Mark Tinguely 已提交
165
	struct xfs_buf	*bp)
C
Christoph Hellwig 已提交
166
{
C
Christoph Hellwig 已提交
167
	xfs_daddr_t	offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
C
Christoph Hellwig 已提交
168

169
	ASSERT(offset + nbblks <= bp->b_length);
170
	return bp->b_addr + BBTOB(offset);
C
Christoph Hellwig 已提交
171 172
}

L
Linus Torvalds 已提交
173 174 175 176

/*
 * nbblks should be uint, but oh well.  Just want to catch that 32-bit length.
 */
C
Christoph Hellwig 已提交
177 178
STATIC int
xlog_bread_noalign(
M
Mark Tinguely 已提交
179
	struct xlog	*log,
L
Linus Torvalds 已提交
180 181
	xfs_daddr_t	blk_no,
	int		nbblks,
M
Mark Tinguely 已提交
182
	struct xfs_buf	*bp)
L
Linus Torvalds 已提交
183 184 185
{
	int		error;

186
	if (!xlog_buf_bbcount_valid(log, nbblks)) {
187
		xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
188 189
			nbblks);
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
190 191 192
		return EFSCORRUPTED;
	}

193 194
	blk_no = round_down(blk_no, log->l_sectBBsize);
	nbblks = round_up(nbblks, log->l_sectBBsize);
L
Linus Torvalds 已提交
195 196

	ASSERT(nbblks > 0);
197
	ASSERT(nbblks <= bp->b_length);
L
Linus Torvalds 已提交
198 199 200

	XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
	XFS_BUF_READ(bp);
201
	bp->b_io_length = nbblks;
202
	bp->b_error = 0;
L
Linus Torvalds 已提交
203 204

	xfsbdstrat(log->l_mp, bp);
C
Christoph Hellwig 已提交
205
	error = xfs_buf_iowait(bp);
206
	if (error)
207
		xfs_buf_ioerror_alert(bp, __func__);
L
Linus Torvalds 已提交
208 209 210
	return error;
}

C
Christoph Hellwig 已提交
211 212
STATIC int
xlog_bread(
M
Mark Tinguely 已提交
213
	struct xlog	*log,
C
Christoph Hellwig 已提交
214 215
	xfs_daddr_t	blk_no,
	int		nbblks,
M
Mark Tinguely 已提交
216
	struct xfs_buf	*bp,
C
Christoph Hellwig 已提交
217 218 219 220 221 222 223 224 225 226 227 228
	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;
}

229 230 231 232 233 234
/*
 * 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(
M
Mark Tinguely 已提交
235
	struct xlog	*log,
236 237
	xfs_daddr_t	blk_no,		/* block to read from */
	int		nbblks,		/* blocks to read */
M
Mark Tinguely 已提交
238
	struct xfs_buf	*bp,
239 240
	xfs_caddr_t	offset)
{
241
	xfs_caddr_t	orig_offset = bp->b_addr;
242
	int		orig_len = BBTOB(bp->b_length);
243 244
	int		error, error2;

245
	error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
246 247 248 249 250 251
	if (error)
		return error;

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

	/* must reset buffer pointer even on error */
252
	error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
253 254 255 256 257
	if (error)
		return error;
	return error2;
}

L
Linus Torvalds 已提交
258 259 260 261 262
/*
 * 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.
 */
263
STATIC int
L
Linus Torvalds 已提交
264
xlog_bwrite(
M
Mark Tinguely 已提交
265
	struct xlog	*log,
L
Linus Torvalds 已提交
266 267
	xfs_daddr_t	blk_no,
	int		nbblks,
M
Mark Tinguely 已提交
268
	struct xfs_buf	*bp)
L
Linus Torvalds 已提交
269 270 271
{
	int		error;

272
	if (!xlog_buf_bbcount_valid(log, nbblks)) {
273
		xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
274 275
			nbblks);
		XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
276 277 278
		return EFSCORRUPTED;
	}

279 280
	blk_no = round_down(blk_no, log->l_sectBBsize);
	nbblks = round_up(nbblks, log->l_sectBBsize);
L
Linus Torvalds 已提交
281 282

	ASSERT(nbblks > 0);
283
	ASSERT(nbblks <= bp->b_length);
L
Linus Torvalds 已提交
284 285 286

	XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
	XFS_BUF_ZEROFLAGS(bp);
287
	xfs_buf_hold(bp);
288
	xfs_buf_lock(bp);
289
	bp->b_io_length = nbblks;
290
	bp->b_error = 0;
L
Linus Torvalds 已提交
291

292
	error = xfs_bwrite(bp);
293 294
	if (error)
		xfs_buf_ioerror_alert(bp, __func__);
295
	xfs_buf_relse(bp);
L
Linus Torvalds 已提交
296 297 298 299 300 301 302 303 304 305 306 307
	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)
{
308
	xfs_debug(mp, "%s:  SB : uuid = %pU, fmt = %d\n",
309
		__func__, &mp->m_sb.sb_uuid, XLOG_FMT);
310
	xfs_debug(mp, "    log : uuid = %pU, fmt = %d\n",
311
		&head->h_fs_uuid, be32_to_cpu(head->h_fmt));
L
Linus Torvalds 已提交
312 313 314 315 316 317 318 319 320 321 322 323 324
}
#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)
{
325
	ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
L
Linus Torvalds 已提交
326 327 328 329 330 331

	/*
	 * 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.
	 */
332
	if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
333 334
		xfs_warn(mp,
	"dirty log written in incompatible format - can't recover");
L
Linus Torvalds 已提交
335 336 337 338 339
		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))) {
340 341
		xfs_warn(mp,
	"dirty log entry has mismatched uuid - can't recover");
L
Linus Torvalds 已提交
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
		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)
{
358
	ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
L
Linus Torvalds 已提交
359 360 361 362 363 364 365

	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.
		 */
366
		xfs_warn(mp, "nil uuid in log - IRIX style log");
L
Linus Torvalds 已提交
367
	} else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
368
		xfs_warn(mp, "log has mismatched uuid - can't recover");
L
Linus Torvalds 已提交
369 370 371 372 373 374 375 376 377 378 379 380
		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)
{
381
	if (bp->b_error) {
L
Linus Torvalds 已提交
382 383 384 385
		/*
		 * We're not going to bother about retrying
		 * this during recovery. One strike!
		 */
386
		xfs_buf_ioerror_alert(bp, __func__);
387 388
		xfs_force_shutdown(bp->b_target->bt_mount,
					SHUTDOWN_META_IO_ERROR);
L
Linus Torvalds 已提交
389
	}
390
	bp->b_iodone = NULL;
C
Christoph Hellwig 已提交
391
	xfs_buf_ioend(bp, 0);
L
Linus Torvalds 已提交
392 393 394 395 396 397 398 399
}

/*
 * 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 已提交
400
STATIC int
L
Linus Torvalds 已提交
401
xlog_find_cycle_start(
M
Mark Tinguely 已提交
402 403
	struct xlog	*log,
	struct xfs_buf	*bp,
L
Linus Torvalds 已提交
404 405 406 407 408 409
	xfs_daddr_t	first_blk,
	xfs_daddr_t	*last_blk,
	uint		cycle)
{
	xfs_caddr_t	offset;
	xfs_daddr_t	mid_blk;
410
	xfs_daddr_t	end_blk;
L
Linus Torvalds 已提交
411 412 413
	uint		mid_cycle;
	int		error;

414 415 416
	end_blk = *last_blk;
	mid_blk = BLK_AVG(first_blk, end_blk);
	while (mid_blk != first_blk && mid_blk != end_blk) {
C
Christoph Hellwig 已提交
417 418
		error = xlog_bread(log, mid_blk, 1, bp, &offset);
		if (error)
L
Linus Torvalds 已提交
419
			return error;
420
		mid_cycle = xlog_get_cycle(offset);
421 422 423 424 425
		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 已提交
426
	}
427 428 429 430
	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 已提交
431 432 433 434 435

	return 0;
}

/*
436 437 438 439 440 441
 * 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 已提交
442 443 444
 */
STATIC int
xlog_find_verify_cycle(
M
Mark Tinguely 已提交
445
	struct xlog	*log,
L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453 454 455 456 457
	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;

458 459 460 461 462 463
	/*
	 * 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 已提交
464
	bufblks = 1 << ffs(nbblks);
465 466
	while (bufblks > log->l_logBBsize)
		bufblks >>= 1;
L
Linus Torvalds 已提交
467 468
	while (!(bp = xlog_get_bp(log, bufblks))) {
		bufblks >>= 1;
469
		if (bufblks < log->l_sectBBsize)
L
Linus Torvalds 已提交
470 471 472 473 474 475 476 477
			return ENOMEM;
	}

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

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

C
Christoph Hellwig 已提交
478 479
		error = xlog_bread(log, i, bcount, bp, &buf);
		if (error)
L
Linus Torvalds 已提交
480 481 482
			goto out;

		for (j = 0; j < bcount; j++) {
483
			cycle = xlog_get_cycle(buf);
L
Linus Torvalds 已提交
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 511 512 513
			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(
M
Mark Tinguely 已提交
514
	struct xlog		*log,
L
Linus Torvalds 已提交
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
	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 已提交
535 536
		error = xlog_bread(log, start_blk, num_blks, bp, &offset);
		if (error)
L
Linus Torvalds 已提交
537 538 539 540 541 542 543
			goto out;
		offset += ((num_blks - 1) << BBSHIFT);
	}

	for (i = (*last_blk) - 1; i >= 0; i--) {
		if (i < start_blk) {
			/* valid log record not found */
544 545
			xfs_warn(log->l_mp,
		"Log inconsistent (didn't find previous header)");
L
Linus Torvalds 已提交
546 547 548 549 550 551
			ASSERT(0);
			error = XFS_ERROR(EIO);
			goto out;
		}

		if (smallmem) {
C
Christoph Hellwig 已提交
552 553
			error = xlog_bread(log, i, 1, bp, &offset);
			if (error)
L
Linus Torvalds 已提交
554 555 556 557 558
				goto out;
		}

		head = (xlog_rec_header_t *)offset;

559
		if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
L
Linus Torvalds 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
			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.
	 */
590
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
591
		uint	h_size = be32_to_cpu(head->h_size);
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599

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

600 601
	if (*last_blk - i + extra_bblks !=
	    BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
L
Linus Torvalds 已提交
602 603 604 605 606 607 608 609 610
		*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
611
 * could go.  This means that incomplete LR writes at the end are
L
Linus Torvalds 已提交
612 613 614 615 616 617 618 619 620 621
 * 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.
 */
622
STATIC int
L
Linus Torvalds 已提交
623
xlog_find_head(
M
Mark Tinguely 已提交
624
	struct xlog	*log,
L
Linus Torvalds 已提交
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
	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
			 */
645
			xfs_warn(log->l_mp, "totally zeroed log");
L
Linus Torvalds 已提交
646 647 648 649
		}

		return 0;
	} else if (error) {
650
		xfs_warn(log->l_mp, "empty log check failed");
L
Linus Torvalds 已提交
651 652 653 654 655 656 657
		return error;
	}

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

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

663
	first_half_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
664 665

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

670
	last_half_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
	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
695
		 * In this case the head really is somewhere at the end of the
L
Linus Torvalds 已提交
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
		 * 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
717
		 *        x + 1 ... | x ... | x
L
Linus Torvalds 已提交
718 719 720 721 722 723 724 725 726
		 * 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
727 728 729
		 *                               v binary search stopped here
		 *        x + 1 ... | x | x + 1 | x ... | x
		 *                   ^ but we want to locate this spot
L
Linus Torvalds 已提交
730 731
		 * or
		 *        <---------> less than scan distance
732 733
		 *        x + 1 ... | x ... | x - 1 | x
		 *                           ^ we want to locate this spot
L
Linus Torvalds 已提交
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 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
		 */
		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 &&
790 791
			(xfs_daddr_t) num_scan_bblks >= head_blk);
		start_blk = log_bbnum - (num_scan_bblks - head_blk);
L
Linus Torvalds 已提交
792 793 794 795 796 797
		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;
798
			goto validate_head;
L
Linus Torvalds 已提交
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
		}

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

816
validate_head:
L
Linus Torvalds 已提交
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
	/*
	 * 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 */
838
			start_blk = log_bbnum - (num_scan_bblks - head_blk);
L
Linus Torvalds 已提交
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
			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)
873
		xfs_warn(log->l_mp, "failed to find log head");
L
Linus Torvalds 已提交
874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
	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.
 */
893
STATIC int
L
Linus Torvalds 已提交
894
xlog_find_tail(
M
Mark Tinguely 已提交
895
	struct xlog		*log,
L
Linus Torvalds 已提交
896
	xfs_daddr_t		*head_blk,
897
	xfs_daddr_t		*tail_blk)
L
Linus Torvalds 已提交
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
{
	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 已提交
921 922
		error = xlog_bread(log, 0, 1, bp, &offset);
		if (error)
923
			goto done;
C
Christoph Hellwig 已提交
924

925
		if (xlog_get_cycle(offset) == 0) {
L
Linus Torvalds 已提交
926 927
			*tail_blk = 0;
			/* leave all other log inited values alone */
928
			goto done;
L
Linus Torvalds 已提交
929 930 931 932 933 934 935 936
		}
	}

	/*
	 * 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 已提交
937 938
		error = xlog_bread(log, i, 1, bp, &offset);
		if (error)
939
			goto done;
C
Christoph Hellwig 已提交
940

941
		if (*(__be32 *)offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
L
Linus Torvalds 已提交
942 943 944 945 946 947 948 949 950 951 952 953
			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 已提交
954 955
			error = xlog_bread(log, i, 1, bp, &offset);
			if (error)
956
				goto done;
C
Christoph Hellwig 已提交
957

958 959
			if (*(__be32 *)offset ==
			    cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
L
Linus Torvalds 已提交
960 961 962 963 964 965
				found = 2;
				break;
			}
		}
	}
	if (!found) {
966
		xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
967
		xlog_put_bp(bp);
L
Linus Torvalds 已提交
968 969 970 971 972 973
		ASSERT(0);
		return XFS_ERROR(EIO);
	}

	/* find blk_no of tail of log */
	rhead = (xlog_rec_header_t *)offset;
974
	*tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
L
Linus Torvalds 已提交
975 976 977 978 979 980 981 982 983 984 985 986 987

	/*
	 * 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;
988
	log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
L
Linus Torvalds 已提交
989 990
	if (found == 2)
		log->l_curr_cycle++;
991
	atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn));
992
	atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn));
993
	xlog_assign_grant_head(&log->l_reserve_head.grant, log->l_curr_cycle,
994
					BBTOB(log->l_curr_block));
995
	xlog_assign_grant_head(&log->l_write_head.grant, log->l_curr_cycle,
996
					BBTOB(log->l_curr_block));
L
Linus Torvalds 已提交
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008

	/*
	 * 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.
	 */
1009
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
1010 1011
		int	h_size = be32_to_cpu(rhead->h_size);
		int	h_version = be32_to_cpu(rhead->h_version);
L
Linus Torvalds 已提交
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024

		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)
1025
		BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
1026
	tail_lsn = atomic64_read(&log->l_tail_lsn);
L
Linus Torvalds 已提交
1027
	if (*head_blk == after_umount_blk &&
1028
	    be32_to_cpu(rhead->h_num_logops) == 1) {
L
Linus Torvalds 已提交
1029
		umount_data_blk = (i + hblks) % log->l_logBBsize;
C
Christoph Hellwig 已提交
1030 1031
		error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
		if (error)
1032
			goto done;
C
Christoph Hellwig 已提交
1033

L
Linus Torvalds 已提交
1034 1035 1036 1037 1038 1039 1040
		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.
			 */
1041 1042 1043 1044
			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 已提交
1045
			*tail_blk = after_umount_blk;
D
David Chinner 已提交
1046 1047 1048 1049 1050 1051 1052 1053

			/*
			 * 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 已提交
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
		}
	}

	/*
	 * 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.
	 */
1076
	if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
L
Linus Torvalds 已提交
1077 1078
		error = xlog_clear_stale_blocks(log, tail_lsn);

1079
done:
L
Linus Torvalds 已提交
1080 1081 1082
	xlog_put_bp(bp);

	if (error)
1083
		xfs_warn(log->l_mp, "failed to locate log tail");
L
Linus Torvalds 已提交
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
	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 已提交
1103
STATIC int
L
Linus Torvalds 已提交
1104
xlog_find_zeroed(
M
Mark Tinguely 已提交
1105
	struct xlog	*log,
L
Linus Torvalds 已提交
1106 1107 1108 1109 1110 1111 1112 1113 1114
	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;

1115 1116
	*blk_no = 0;

L
Linus Torvalds 已提交
1117 1118 1119 1120
	/* check totally zeroed log */
	bp = xlog_get_bp(log, 1);
	if (!bp)
		return ENOMEM;
C
Christoph Hellwig 已提交
1121 1122
	error = xlog_bread(log, 0, 1, bp, &offset);
	if (error)
L
Linus Torvalds 已提交
1123
		goto bp_err;
C
Christoph Hellwig 已提交
1124

1125
	first_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
1126 1127 1128 1129 1130 1131 1132
	if (first_cycle == 0) {		/* completely zeroed log */
		*blk_no = 0;
		xlog_put_bp(bp);
		return -1;
	}

	/* check partially zeroed log */
C
Christoph Hellwig 已提交
1133 1134
	error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
	if (error)
L
Linus Torvalds 已提交
1135
		goto bp_err;
C
Christoph Hellwig 已提交
1136

1137
	last_cycle = xlog_get_cycle(offset);
L
Linus Torvalds 已提交
1138 1139 1140 1141 1142 1143 1144 1145 1146
	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.
		 */
1147 1148
		xfs_warn(log->l_mp,
			"Log inconsistent or not a log (last==0, first!=1)");
1149 1150
		error = XFS_ERROR(EINVAL);
		goto bp_err;
L
Linus Torvalds 已提交
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 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
	}

	/* 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(
M
Mark Tinguely 已提交
1209
	struct xlog		*log,
L
Linus Torvalds 已提交
1210 1211 1212 1213 1214 1215 1216 1217 1218
	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);
1219 1220 1221
	recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
	recp->h_cycle = cpu_to_be32(cycle);
	recp->h_version = cpu_to_be32(
1222
			xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
1223 1224 1225
	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 已提交
1226 1227 1228 1229 1230
	memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
}

STATIC int
xlog_write_log_records(
M
Mark Tinguely 已提交
1231
	struct xlog	*log,
L
Linus Torvalds 已提交
1232 1233 1234 1235 1236 1237 1238 1239 1240
	int		cycle,
	int		start_block,
	int		blocks,
	int		tail_cycle,
	int		tail_block)
{
	xfs_caddr_t	offset;
	xfs_buf_t	*bp;
	int		balign, ealign;
1241
	int		sectbb = log->l_sectBBsize;
L
Linus Torvalds 已提交
1242 1243 1244 1245 1246
	int		end_block = start_block + blocks;
	int		bufblks;
	int		error = 0;
	int		i, j = 0;

1247 1248 1249 1250 1251 1252
	/*
	 * 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 已提交
1253
	bufblks = 1 << ffs(blocks);
1254 1255
	while (bufblks > log->l_logBBsize)
		bufblks >>= 1;
L
Linus Torvalds 已提交
1256 1257
	while (!(bp = xlog_get_bp(log, bufblks))) {
		bufblks >>= 1;
1258
		if (bufblks < sectbb)
L
Linus Torvalds 已提交
1259 1260 1261 1262 1263 1264 1265
			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 已提交
1266
	balign = round_down(start_block, sectbb);
L
Linus Torvalds 已提交
1267
	if (balign != start_block) {
C
Christoph Hellwig 已提交
1268 1269 1270 1271
		error = xlog_bread_noalign(log, start_block, 1, bp);
		if (error)
			goto out_put_bp;

L
Linus Torvalds 已提交
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
		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 已提交
1285
		ealign = round_down(end_block, sectbb);
L
Linus Torvalds 已提交
1286
		if (j == 0 && (start_block + endcount > ealign)) {
1287
			offset = bp->b_addr + BBTOB(ealign - start_block);
1288 1289
			error = xlog_bread_offset(log, ealign, sectbb,
							bp, offset);
C
Christoph Hellwig 已提交
1290 1291 1292
			if (error)
				break;

L
Linus Torvalds 已提交
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
		}

		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 已提交
1307 1308

 out_put_bp:
L
Linus Torvalds 已提交
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
	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(
M
Mark Tinguely 已提交
1331
	struct xlog	*log,
L
Linus Torvalds 已提交
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 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
	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(
1454
	struct hlist_head	*head,
L
Linus Torvalds 已提交
1455 1456
	xlog_tid_t		tid)
{
1457
	xlog_recover_t		*trans;
L
Linus Torvalds 已提交
1458

1459
	hlist_for_each_entry(trans, head, r_list) {
1460 1461
		if (trans->r_log_tid == tid)
			return trans;
L
Linus Torvalds 已提交
1462
	}
1463
	return NULL;
L
Linus Torvalds 已提交
1464 1465 1466
}

STATIC void
1467 1468 1469 1470
xlog_recover_new_tid(
	struct hlist_head	*head,
	xlog_tid_t		tid,
	xfs_lsn_t		lsn)
L
Linus Torvalds 已提交
1471
{
1472 1473 1474 1475 1476 1477 1478 1479 1480
	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 已提交
1481 1482 1483 1484
}

STATIC void
xlog_recover_add_item(
1485
	struct list_head	*head)
L
Linus Torvalds 已提交
1486 1487 1488 1489
{
	xlog_recover_item_t	*item;

	item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
1490 1491
	INIT_LIST_HEAD(&item->ri_list);
	list_add_tail(&item->ri_list, head);
L
Linus Torvalds 已提交
1492 1493 1494 1495
}

STATIC int
xlog_recover_add_to_cont_trans(
1496 1497
	struct xlog		*log,
	struct xlog_recover	*trans,
L
Linus Torvalds 已提交
1498 1499 1500 1501 1502 1503 1504
	xfs_caddr_t		dp,
	int			len)
{
	xlog_recover_item_t	*item;
	xfs_caddr_t		ptr, old_ptr;
	int			old_len;

1505
	if (list_empty(&trans->r_itemq)) {
L
Linus Torvalds 已提交
1506 1507 1508 1509 1510 1511 1512
		/* 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;
	}
1513 1514
	/* take the tail entry */
	item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
L
Linus Torvalds 已提交
1515 1516 1517 1518

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

1519
	ptr = kmem_realloc(old_ptr, len+old_len, old_len, KM_SLEEP);
L
Linus Torvalds 已提交
1520 1521 1522
	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;
1523
	trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
L
Linus Torvalds 已提交
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
	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(
1542 1543
	struct xlog		*log,
	struct xlog_recover	*trans,
L
Linus Torvalds 已提交
1544 1545 1546 1547 1548 1549 1550 1551 1552
	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;
1553
	if (list_empty(&trans->r_itemq)) {
1554 1555
		/* we need to catch log corruptions here */
		if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
1556 1557
			xfs_warn(log->l_mp, "%s: bad header magic number",
				__func__);
1558 1559 1560
			ASSERT(0);
			return XFS_ERROR(EIO);
		}
L
Linus Torvalds 已提交
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
		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;

1571 1572 1573 1574 1575
	/* 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 已提交
1576
		xlog_recover_add_item(&trans->r_itemq);
1577 1578
		item = list_entry(trans->r_itemq.prev,
					xlog_recover_item_t, ri_list);
L
Linus Torvalds 已提交
1579 1580 1581
	}

	if (item->ri_total == 0) {		/* first region to be added */
1582 1583
		if (in_f->ilf_size == 0 ||
		    in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
1584 1585
			xfs_warn(log->l_mp,
		"bad number of regions (%d) in inode log format",
1586 1587 1588 1589 1590 1591 1592 1593 1594
				  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 已提交
1595 1596 1597 1598 1599 1600
	}
	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++;
1601
	trace_xfs_log_recover_item_add(log, trans, item, 0);
L
Linus Torvalds 已提交
1602 1603 1604
	return 0;
}

1605
/*
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
 * Sort the log items in the transaction.
 *
 * The ordering constraints are defined by the inode allocation and unlink
 * behaviour. The rules are:
 *
 *	1. Every item is only logged once in a given transaction. Hence it
 *	   represents the last logged state of the item. Hence ordering is
 *	   dependent on the order in which operations need to be performed so
 *	   required initial conditions are always met.
 *
 *	2. Cancelled buffers are recorded in pass 1 in a separate table and
 *	   there's nothing to replay from them so we can simply cull them
 *	   from the transaction. However, we can't do that until after we've
 *	   replayed all the other items because they may be dependent on the
 *	   cancelled buffer and replaying the cancelled buffer can remove it
 *	   form the cancelled buffer table. Hence they have tobe done last.
 *
 *	3. Inode allocation buffers must be replayed before inode items that
D
Dave Chinner 已提交
1624 1625 1626 1627
 *	   read the buffer and replay changes into it. For filesystems using the
 *	   ICREATE transactions, this means XFS_LI_ICREATE objects need to get
 *	   treated the same as inode allocation buffers as they create and
 *	   initialise the buffers directly.
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
 *
 *	4. Inode unlink buffers must be replayed after inode items are replayed.
 *	   This ensures that inodes are completely flushed to the inode buffer
 *	   in a "free" state before we remove the unlinked inode list pointer.
 *
 * Hence the ordering needs to be inode allocation buffers first, inode items
 * second, inode unlink buffers third and cancelled buffers last.
 *
 * But there's a problem with that - we can't tell an inode allocation buffer
 * apart from a regular buffer, so we can't separate them. We can, however,
 * tell an inode unlink buffer from the others, and so we can separate them out
 * from all the other buffers and move them to last.
 *
 * Hence, 4 lists, in order from head to tail:
D
Dave Chinner 已提交
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
 *	- buffer_list for all buffers except cancelled/inode unlink buffers
 *	- item_list for all non-buffer items
 *	- inode_buffer_list for inode unlink buffers
 *	- cancel_list for the cancelled buffers
 *
 * Note that we add objects to the tail of the lists so that first-to-last
 * ordering is preserved within the lists. Adding objects to the head of the
 * list means when we traverse from the head we walk them in last-to-first
 * order. For cancelled buffers and inode unlink buffers this doesn't matter,
 * but for all other items there may be specific ordering that we need to
 * preserve.
1653
 */
L
Linus Torvalds 已提交
1654 1655
STATIC int
xlog_recover_reorder_trans(
1656 1657
	struct xlog		*log,
	struct xlog_recover	*trans,
1658
	int			pass)
L
Linus Torvalds 已提交
1659
{
1660 1661
	xlog_recover_item_t	*item, *n;
	LIST_HEAD(sort_list);
1662 1663 1664 1665
	LIST_HEAD(cancel_list);
	LIST_HEAD(buffer_list);
	LIST_HEAD(inode_buffer_list);
	LIST_HEAD(inode_list);
1666 1667 1668

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

1671
		switch (ITEM_TYPE(item)) {
D
Dave Chinner 已提交
1672 1673 1674
		case XFS_LI_ICREATE:
			list_move_tail(&item->ri_list, &buffer_list);
			break;
L
Linus Torvalds 已提交
1675
		case XFS_LI_BUF:
1676
			if (buf_f->blf_flags & XFS_BLF_CANCEL) {
1677 1678
				trace_xfs_log_recover_item_reorder_head(log,
							trans, item, pass);
1679
				list_move(&item->ri_list, &cancel_list);
L
Linus Torvalds 已提交
1680 1681
				break;
			}
1682 1683 1684 1685 1686 1687
			if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
				list_move(&item->ri_list, &inode_buffer_list);
				break;
			}
			list_move_tail(&item->ri_list, &buffer_list);
			break;
L
Linus Torvalds 已提交
1688 1689 1690 1691 1692
		case XFS_LI_INODE:
		case XFS_LI_DQUOT:
		case XFS_LI_QUOTAOFF:
		case XFS_LI_EFD:
		case XFS_LI_EFI:
1693 1694
			trace_xfs_log_recover_item_reorder_tail(log,
							trans, item, pass);
1695
			list_move_tail(&item->ri_list, &inode_list);
L
Linus Torvalds 已提交
1696 1697
			break;
		default:
1698 1699 1700
			xfs_warn(log->l_mp,
				"%s: unrecognized type of log operation",
				__func__);
L
Linus Torvalds 已提交
1701 1702 1703
			ASSERT(0);
			return XFS_ERROR(EIO);
		}
1704 1705
	}
	ASSERT(list_empty(&sort_list));
1706 1707 1708 1709 1710 1711 1712 1713
	if (!list_empty(&buffer_list))
		list_splice(&buffer_list, &trans->r_itemq);
	if (!list_empty(&inode_list))
		list_splice_tail(&inode_list, &trans->r_itemq);
	if (!list_empty(&inode_buffer_list))
		list_splice_tail(&inode_buffer_list, &trans->r_itemq);
	if (!list_empty(&cancel_list))
		list_splice_tail(&cancel_list, &trans->r_itemq);
L
Linus Torvalds 已提交
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
	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.
 */
1729 1730
STATIC int
xlog_recover_buffer_pass1(
1731 1732
	struct xlog			*log,
	struct xlog_recover_item	*item)
L
Linus Torvalds 已提交
1733
{
1734
	xfs_buf_log_format_t	*buf_f = item->ri_buf[0].i_addr;
1735 1736
	struct list_head	*bucket;
	struct xfs_buf_cancel	*bcp;
L
Linus Torvalds 已提交
1737 1738 1739 1740

	/*
	 * If this isn't a cancel buffer item, then just return.
	 */
1741
	if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
1742
		trace_xfs_log_recover_buf_not_cancel(log, buf_f);
1743
		return 0;
1744
	}
L
Linus Torvalds 已提交
1745 1746

	/*
1747 1748
	 * 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 已提交
1749
	 */
1750 1751 1752 1753 1754
	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++;
1755
			trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f);
1756
			return 0;
L
Linus Torvalds 已提交
1757
		}
1758 1759 1760 1761 1762
	}

	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 已提交
1763
	bcp->bc_refcount = 1;
1764 1765
	list_add_tail(&bcp->bc_list, bucket);

1766
	trace_xfs_log_recover_buf_cancel_add(log, buf_f);
1767
	return 0;
L
Linus Torvalds 已提交
1768 1769 1770 1771 1772 1773
}

/*
 * 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
1774
 * actually a buffer cancel item (XFS_BLF_CANCEL is set), then decrement
L
Linus Torvalds 已提交
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
 * 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(
1785
	struct xlog		*log,
L
Linus Torvalds 已提交
1786 1787 1788 1789
	xfs_daddr_t		blkno,
	uint			len,
	ushort			flags)
{
1790 1791
	struct list_head	*bucket;
	struct xfs_buf_cancel	*bcp;
L
Linus Torvalds 已提交
1792 1793 1794 1795 1796 1797

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

	/*
1803
	 * Search for an entry in the  cancel table that matches our buffer.
L
Linus Torvalds 已提交
1804
	 */
1805 1806 1807 1808
	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 已提交
1809
	}
1810

L
Linus Torvalds 已提交
1811
	/*
1812 1813
	 * We didn't find a corresponding entry in the table, so return 0 so
	 * that the buffer is NOT cancelled.
L
Linus Torvalds 已提交
1814
	 */
1815
	ASSERT(!(flags & XFS_BLF_CANCEL));
L
Linus Torvalds 已提交
1816
	return 0;
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831

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 已提交
1832 1833 1834
}

/*
1835 1836 1837 1838 1839
 * 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 已提交
1840
 *
1841 1842 1843 1844
 * 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 已提交
1845 1846 1847
 */
STATIC int
xlog_recover_do_inode_buffer(
1848
	struct xfs_mount	*mp,
L
Linus Torvalds 已提交
1849
	xlog_recover_item_t	*item,
1850
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
1851 1852 1853
	xfs_buf_log_format_t	*buf_f)
{
	int			i;
1854 1855 1856 1857 1858
	int			item_index = 0;
	int			bit = 0;
	int			nbits = 0;
	int			reg_buf_offset = 0;
	int			reg_buf_bytes = 0;
L
Linus Torvalds 已提交
1859 1860 1861 1862 1863
	int			next_unlinked_offset;
	int			inodes_per_buf;
	xfs_agino_t		*logged_nextp;
	xfs_agino_t		*buffer_nextp;

1864
	trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);
1865 1866 1867 1868 1869 1870 1871

	/*
	 * Post recovery validation only works properly on CRC enabled
	 * filesystems.
	 */
	if (xfs_sb_version_hascrc(&mp->m_sb))
		bp->b_ops = &xfs_inode_buf_ops;
1872

1873
	inodes_per_buf = BBTOB(bp->b_io_length) >> mp->m_sb.sb_inodelog;
L
Linus Torvalds 已提交
1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
	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;
1887 1888
			bit = xfs_next_bit(buf_f->blf_data_map,
					   buf_f->blf_map_size, bit);
L
Linus Torvalds 已提交
1889 1890 1891 1892 1893

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

1897 1898
			nbits = xfs_contig_bits(buf_f->blf_data_map,
						buf_f->blf_map_size, bit);
L
Linus Torvalds 已提交
1899
			ASSERT(nbits > 0);
1900 1901
			reg_buf_offset = bit << XFS_BLF_SHIFT;
			reg_buf_bytes = nbits << XFS_BLF_SHIFT;
L
Linus Torvalds 已提交
1902 1903 1904 1905 1906 1907 1908 1909
			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.
		 */
1910
		if (next_unlinked_offset < reg_buf_offset)
L
Linus Torvalds 已提交
1911 1912 1913
			continue;

		ASSERT(item->ri_buf[item_index].i_addr != NULL);
1914
		ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
1915 1916
		ASSERT((reg_buf_offset + reg_buf_bytes) <=
							BBTOB(bp->b_io_length));
L
Linus Torvalds 已提交
1917 1918 1919 1920 1921 1922

		/*
		 * The current logged region contains a copy of the
		 * current di_next_unlinked field.  Extract its value
		 * and copy it to the buffer copy.
		 */
1923 1924
		logged_nextp = item->ri_buf[item_index].i_addr +
				next_unlinked_offset - reg_buf_offset;
L
Linus Torvalds 已提交
1925
		if (unlikely(*logged_nextp == 0)) {
1926 1927 1928
			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 已提交
1929 1930 1931 1932 1933 1934 1935 1936
				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);
1937
		*buffer_nextp = *logged_nextp;
1938 1939 1940 1941 1942 1943 1944 1945 1946

		/*
		 * If necessary, recalculate the CRC in the on-disk inode. We
		 * have to leave the inode in a consistent state for whoever
		 * reads it next....
		 */
		xfs_dinode_calc_crc(mp, (struct xfs_dinode *)
				xfs_buf_offset(bp, i * mp->m_sb.sb_inodesize));

L
Linus Torvalds 已提交
1947 1948 1949 1950 1951 1952
	}

	return 0;
}

/*
1953 1954 1955 1956 1957 1958
 * Validate the recovered buffer is of the correct type and attach the
 * appropriate buffer operations to them for writeback. Magic numbers are in a
 * few places:
 *	the first 16 bits of the buffer (inode buffer, dquot buffer),
 *	the first 32 bits of the buffer (most blocks),
 *	inside a struct xfs_da_blkinfo at the start of the buffer.
L
Linus Torvalds 已提交
1959
 */
1960 1961
static void
xlog_recovery_validate_buf_type(
1962
	struct xfs_mount	*mp,
1963
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
1964 1965
	xfs_buf_log_format_t	*buf_f)
{
1966 1967 1968 1969 1970 1971 1972 1973
	struct xfs_da_blkinfo	*info = bp->b_addr;
	__uint32_t		magic32;
	__uint16_t		magic16;
	__uint16_t		magicda;

	magic32 = be32_to_cpu(*(__be32 *)bp->b_addr);
	magic16 = be16_to_cpu(*(__be16*)bp->b_addr);
	magicda = be16_to_cpu(info->magic);
1974 1975
	switch (xfs_blft_from_flags(buf_f)) {
	case XFS_BLFT_BTREE_BUF:
1976
		switch (magic32) {
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
		case XFS_ABTB_CRC_MAGIC:
		case XFS_ABTC_CRC_MAGIC:
		case XFS_ABTB_MAGIC:
		case XFS_ABTC_MAGIC:
			bp->b_ops = &xfs_allocbt_buf_ops;
			break;
		case XFS_IBT_CRC_MAGIC:
		case XFS_IBT_MAGIC:
			bp->b_ops = &xfs_inobt_buf_ops;
			break;
		case XFS_BMAP_CRC_MAGIC:
		case XFS_BMAP_MAGIC:
			bp->b_ops = &xfs_bmbt_buf_ops;
			break;
		default:
			xfs_warn(mp, "Bad btree block magic!");
			ASSERT(0);
			break;
		}
		break;
1997
	case XFS_BLFT_AGF_BUF:
1998
		if (magic32 != XFS_AGF_MAGIC) {
D
Dave Chinner 已提交
1999 2000 2001 2002 2003 2004
			xfs_warn(mp, "Bad AGF block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_agf_buf_ops;
		break;
2005
	case XFS_BLFT_AGFL_BUF:
2006 2007
		if (!xfs_sb_version_hascrc(&mp->m_sb))
			break;
2008
		if (magic32 != XFS_AGFL_MAGIC) {
2009 2010 2011 2012 2013 2014
			xfs_warn(mp, "Bad AGFL block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_agfl_buf_ops;
		break;
2015
	case XFS_BLFT_AGI_BUF:
2016
		if (magic32 != XFS_AGI_MAGIC) {
D
Dave Chinner 已提交
2017 2018 2019 2020 2021 2022
			xfs_warn(mp, "Bad AGI block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_agi_buf_ops;
		break;
2023 2024 2025
	case XFS_BLFT_UDQUOT_BUF:
	case XFS_BLFT_PDQUOT_BUF:
	case XFS_BLFT_GDQUOT_BUF:
2026
#ifdef CONFIG_XFS_QUOTA
2027
		if (magic16 != XFS_DQUOT_MAGIC) {
2028 2029 2030 2031 2032
			xfs_warn(mp, "Bad DQUOT block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_dquot_buf_ops;
2033 2034 2035 2036 2037
#else
		xfs_alert(mp,
	"Trying to recover dquots without QUOTA support built in!");
		ASSERT(0);
#endif
2038
		break;
2039
	case XFS_BLFT_DINO_BUF:
2040 2041 2042 2043
		/*
		 * we get here with inode allocation buffers, not buffers that
		 * track unlinked list changes.
		 */
2044
		if (magic16 != XFS_DINODE_MAGIC) {
2045 2046 2047 2048 2049 2050
			xfs_warn(mp, "Bad INODE block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_inode_buf_ops;
		break;
2051
	case XFS_BLFT_SYMLINK_BUF:
2052
		if (magic32 != XFS_SYMLINK_MAGIC) {
2053 2054 2055 2056 2057 2058
			xfs_warn(mp, "Bad symlink block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_symlink_buf_ops;
		break;
2059
	case XFS_BLFT_DIR_BLOCK_BUF:
2060 2061 2062 2063 2064 2065 2066 2067
		if (magic32 != XFS_DIR2_BLOCK_MAGIC &&
		    magic32 != XFS_DIR3_BLOCK_MAGIC) {
			xfs_warn(mp, "Bad dir block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_dir3_block_buf_ops;
		break;
2068
	case XFS_BLFT_DIR_DATA_BUF:
2069 2070 2071 2072 2073 2074 2075 2076
		if (magic32 != XFS_DIR2_DATA_MAGIC &&
		    magic32 != XFS_DIR3_DATA_MAGIC) {
			xfs_warn(mp, "Bad dir data magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_dir3_data_buf_ops;
		break;
2077
	case XFS_BLFT_DIR_FREE_BUF:
2078 2079 2080 2081 2082 2083 2084 2085
		if (magic32 != XFS_DIR2_FREE_MAGIC &&
		    magic32 != XFS_DIR3_FREE_MAGIC) {
			xfs_warn(mp, "Bad dir3 free magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_dir3_free_buf_ops;
		break;
2086
	case XFS_BLFT_DIR_LEAF1_BUF:
2087 2088 2089 2090 2091 2092 2093 2094
		if (magicda != XFS_DIR2_LEAF1_MAGIC &&
		    magicda != XFS_DIR3_LEAF1_MAGIC) {
			xfs_warn(mp, "Bad dir leaf1 magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_dir3_leaf1_buf_ops;
		break;
2095
	case XFS_BLFT_DIR_LEAFN_BUF:
2096 2097 2098 2099 2100 2101 2102 2103
		if (magicda != XFS_DIR2_LEAFN_MAGIC &&
		    magicda != XFS_DIR3_LEAFN_MAGIC) {
			xfs_warn(mp, "Bad dir leafn magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_dir3_leafn_buf_ops;
		break;
2104
	case XFS_BLFT_DA_NODE_BUF:
2105 2106 2107 2108 2109 2110 2111 2112
		if (magicda != XFS_DA_NODE_MAGIC &&
		    magicda != XFS_DA3_NODE_MAGIC) {
			xfs_warn(mp, "Bad da node magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_da3_node_buf_ops;
		break;
2113
	case XFS_BLFT_ATTR_LEAF_BUF:
2114 2115 2116 2117 2118 2119 2120 2121
		if (magicda != XFS_ATTR_LEAF_MAGIC &&
		    magicda != XFS_ATTR3_LEAF_MAGIC) {
			xfs_warn(mp, "Bad attr leaf magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_attr3_leaf_buf_ops;
		break;
2122
	case XFS_BLFT_ATTR_RMT_BUF:
2123 2124
		if (!xfs_sb_version_hascrc(&mp->m_sb))
			break;
2125
		if (magic32 != XFS_ATTR3_RMT_MAGIC) {
2126 2127 2128 2129 2130 2131
			xfs_warn(mp, "Bad attr remote magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_attr3_rmt_buf_ops;
		break;
2132 2133 2134 2135 2136 2137 2138 2139
	case XFS_BLFT_SB_BUF:
		if (magic32 != XFS_SB_MAGIC) {
			xfs_warn(mp, "Bad SB block magic!");
			ASSERT(0);
			break;
		}
		bp->b_ops = &xfs_sb_buf_ops;
		break;
2140
	default:
2141 2142
		xfs_warn(mp, "Unknown buffer type %d!",
			 xfs_blft_from_flags(buf_f));
2143 2144
		break;
	}
L
Linus Torvalds 已提交
2145 2146
}

2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181
/*
 * 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(
	struct xfs_mount	*mp,
	xlog_recover_item_t	*item,
	struct xfs_buf		*bp,
	xfs_buf_log_format_t	*buf_f)
{
	int			i;
	int			bit;
	int			nbits;
	int                     error;

	trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);

	bit = 0;
	i = 1;  /* 0 is the buf format structure */
	while (1) {
		bit = xfs_next_bit(buf_f->blf_data_map,
				   buf_f->blf_map_size, bit);
		if (bit == -1)
			break;
		nbits = xfs_contig_bits(buf_f->blf_data_map,
					buf_f->blf_map_size, bit);
		ASSERT(nbits > 0);
		ASSERT(item->ri_buf[i].i_addr != NULL);
		ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
		ASSERT(BBTOB(bp->b_io_length) >=
		       ((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT));

2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192
		/*
		 * The dirty regions logged in the buffer, even though
		 * contiguous, may span multiple chunks. This is because the
		 * dirty region may span a physical page boundary in a buffer
		 * and hence be split into two separate vectors for writing into
		 * the log. Hence we need to trim nbits back to the length of
		 * the current region being copied out of the log.
		 */
		if (item->ri_buf[i].i_len < (nbits << XFS_BLF_SHIFT))
			nbits = item->ri_buf[i].i_len >> XFS_BLF_SHIFT;

2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230
		/*
		 * 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;
		if (buf_f->blf_flags &
		   (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
			if (item->ri_buf[i].i_addr == NULL) {
				xfs_alert(mp,
					"XFS: NULL dquot in %s.", __func__);
				goto next;
			}
			if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
				xfs_alert(mp,
					"XFS: dquot too small (%d) in %s.",
					item->ri_buf[i].i_len, __func__);
				goto next;
			}
			error = xfs_qm_dqcheck(mp, item->ri_buf[i].i_addr,
					       -1, 0, XFS_QMOPT_DOWARN,
					       "dquot_buf_recover");
			if (error)
				goto next;
		}

		memcpy(xfs_buf_offset(bp,
			(uint)bit << XFS_BLF_SHIFT),	/* dest */
			item->ri_buf[i].i_addr,		/* source */
			nbits<<XFS_BLF_SHIFT);		/* length */
 next:
		i++;
		bit += nbits;
	}

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

2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
	/*
	 * We can only do post recovery validation on items on CRC enabled
	 * fielsystems as we need to know when the buffer was written to be able
	 * to determine if we should have replayed the item. If we replay old
	 * metadata over a newer buffer, then it will enter a temporarily
	 * inconsistent state resulting in verification failures. Hence for now
	 * just avoid the verification stage for non-crc filesystems
	 */
	if (xfs_sb_version_hascrc(&mp->m_sb))
		xlog_recovery_validate_buf_type(mp, bp, buf_f);
2241 2242
}

L
Linus Torvalds 已提交
2243 2244 2245 2246 2247
/*
 * Do some primitive error checking on ondisk dquot data structures.
 */
int
xfs_qm_dqcheck(
2248
	struct xfs_mount *mp,
L
Linus Torvalds 已提交
2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272
	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.
	 */
2273
	if (ddq->d_magic != cpu_to_be16(XFS_DQUOT_MAGIC)) {
L
Linus Torvalds 已提交
2274
		if (flags & XFS_QMOPT_DOWARN)
2275
			xfs_alert(mp,
L
Linus Torvalds 已提交
2276
			"%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
2277
			str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
L
Linus Torvalds 已提交
2278 2279
		errs++;
	}
2280
	if (ddq->d_version != XFS_DQUOT_VERSION) {
L
Linus Torvalds 已提交
2281
		if (flags & XFS_QMOPT_DOWARN)
2282
			xfs_alert(mp,
L
Linus Torvalds 已提交
2283
			"%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
2284
			str, id, ddq->d_version, XFS_DQUOT_VERSION);
L
Linus Torvalds 已提交
2285 2286 2287
		errs++;
	}

2288 2289 2290
	if (ddq->d_flags != XFS_DQ_USER &&
	    ddq->d_flags != XFS_DQ_PROJ &&
	    ddq->d_flags != XFS_DQ_GROUP) {
L
Linus Torvalds 已提交
2291
		if (flags & XFS_QMOPT_DOWARN)
2292
			xfs_alert(mp,
L
Linus Torvalds 已提交
2293
			"%s : XFS dquot ID 0x%x, unknown flags 0x%x",
2294
			str, id, ddq->d_flags);
L
Linus Torvalds 已提交
2295 2296 2297
		errs++;
	}

2298
	if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
L
Linus Torvalds 已提交
2299
		if (flags & XFS_QMOPT_DOWARN)
2300
			xfs_alert(mp,
L
Linus Torvalds 已提交
2301 2302
			"%s : ondisk-dquot 0x%p, ID mismatch: "
			"0x%x expected, found id 0x%x",
2303
			str, ddq, id, be32_to_cpu(ddq->d_id));
L
Linus Torvalds 已提交
2304 2305 2306 2307
		errs++;
	}

	if (!errs && ddq->d_id) {
2308
		if (ddq->d_blk_softlimit &&
2309
		    be64_to_cpu(ddq->d_bcount) >
2310
				be64_to_cpu(ddq->d_blk_softlimit)) {
L
Linus Torvalds 已提交
2311 2312
			if (!ddq->d_btimer) {
				if (flags & XFS_QMOPT_DOWARN)
2313 2314
					xfs_alert(mp,
			"%s : Dquot ID 0x%x (0x%p) BLK TIMER NOT STARTED",
2315
					str, (int)be32_to_cpu(ddq->d_id), ddq);
L
Linus Torvalds 已提交
2316 2317 2318
				errs++;
			}
		}
2319
		if (ddq->d_ino_softlimit &&
2320
		    be64_to_cpu(ddq->d_icount) >
2321
				be64_to_cpu(ddq->d_ino_softlimit)) {
L
Linus Torvalds 已提交
2322 2323
			if (!ddq->d_itimer) {
				if (flags & XFS_QMOPT_DOWARN)
2324 2325
					xfs_alert(mp,
			"%s : Dquot ID 0x%x (0x%p) INODE TIMER NOT STARTED",
2326
					str, (int)be32_to_cpu(ddq->d_id), ddq);
L
Linus Torvalds 已提交
2327 2328 2329
				errs++;
			}
		}
2330
		if (ddq->d_rtb_softlimit &&
2331
		    be64_to_cpu(ddq->d_rtbcount) >
2332
				be64_to_cpu(ddq->d_rtb_softlimit)) {
L
Linus Torvalds 已提交
2333 2334
			if (!ddq->d_rtbtimer) {
				if (flags & XFS_QMOPT_DOWARN)
2335 2336
					xfs_alert(mp,
			"%s : Dquot ID 0x%x (0x%p) RTBLK TIMER NOT STARTED",
2337
					str, (int)be32_to_cpu(ddq->d_id), ddq);
L
Linus Torvalds 已提交
2338 2339 2340 2341 2342 2343 2344 2345 2346
				errs++;
			}
		}
	}

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

	if (flags & XFS_QMOPT_DOWARN)
2347
		xfs_notice(mp, "Re-initializing dquot ID 0x%x", id);
L
Linus Torvalds 已提交
2348 2349 2350 2351 2352 2353 2354

	/*
	 * Typically, a repair is only requested by quotacheck.
	 */
	ASSERT(id != -1);
	ASSERT(flags & XFS_QMOPT_DQREPAIR);
	memset(d, 0, sizeof(xfs_dqblk_t));
2355 2356 2357 2358 2359

	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 已提交
2360

D
Dave Chinner 已提交
2361 2362 2363 2364 2365 2366
	if (xfs_sb_version_hascrc(&mp->m_sb)) {
		uuid_copy(&d->dd_uuid, &mp->m_sb.sb_uuid);
		xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
				 XFS_DQUOT_CRC_OFF);
	}

L
Linus Torvalds 已提交
2367 2368 2369 2370 2371
	return errs;
}

/*
 * Perform a dquot buffer recovery.
2372
 * Simple algorithm: if we have found a QUOTAOFF log item of the same type
L
Linus Torvalds 已提交
2373 2374 2375 2376 2377
 * (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(
M
Mark Tinguely 已提交
2378 2379 2380 2381 2382
	struct xfs_mount		*mp,
	struct xlog			*log,
	struct xlog_recover_item	*item,
	struct xfs_buf			*bp,
	struct xfs_buf_log_format	*buf_f)
L
Linus Torvalds 已提交
2383 2384 2385
{
	uint			type;

2386 2387
	trace_xfs_log_recover_buf_dquot_buf(log, buf_f);

L
Linus Torvalds 已提交
2388 2389 2390 2391 2392 2393 2394 2395
	/*
	 * Filesystems are required to send in quota flags at mount time.
	 */
	if (mp->m_qflags == 0) {
		return;
	}

	type = 0;
2396
	if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
L
Linus Torvalds 已提交
2397
		type |= XFS_DQ_USER;
2398
	if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
2399
		type |= XFS_DQ_PROJ;
2400
	if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
L
Linus Torvalds 已提交
2401 2402 2403 2404 2405 2406 2407
		type |= XFS_DQ_GROUP;
	/*
	 * This type of quotas was turned off, so ignore this buffer
	 */
	if (log->l_quotaoffs_flag & type)
		return;

2408
	xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
L
Linus Torvalds 已提交
2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
}

/*
 * 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
2421
 * with the XFS_BLF_CANCEL bit set to indicate that previous copies
L
Linus Torvalds 已提交
2422 2423 2424 2425 2426 2427 2428 2429 2430
 * 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
2431
 * records in the table.  See xlog_recover_buffer_pass[1,2] above
L
Linus Torvalds 已提交
2432 2433 2434
 * for more details on the implementation of the table of cancel records.
 */
STATIC int
2435
xlog_recover_buffer_pass2(
M
Mark Tinguely 已提交
2436 2437 2438
	struct xlog			*log,
	struct list_head		*buffer_list,
	struct xlog_recover_item	*item)
L
Linus Torvalds 已提交
2439
{
2440
	xfs_buf_log_format_t	*buf_f = item->ri_buf[0].i_addr;
2441
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2442 2443
	xfs_buf_t		*bp;
	int			error;
2444
	uint			buf_flags;
L
Linus Torvalds 已提交
2445

2446 2447 2448 2449 2450 2451 2452
	/*
	 * 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 已提交
2453 2454
		return 0;
	}
2455

2456
	trace_xfs_log_recover_buf_recover(log, buf_f);
L
Linus Torvalds 已提交
2457

D
Dave Chinner 已提交
2458
	buf_flags = 0;
2459 2460
	if (buf_f->blf_flags & XFS_BLF_INODE_BUF)
		buf_flags |= XBF_UNMAPPED;
2461

2462
	bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
2463
			  buf_flags, NULL);
2464 2465
	if (!bp)
		return XFS_ERROR(ENOMEM);
2466
	error = bp->b_error;
2467
	if (error) {
2468
		xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
L
Linus Torvalds 已提交
2469 2470 2471 2472
		xfs_buf_relse(bp);
		return error;
	}

2473
	if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
L
Linus Torvalds 已提交
2474
		error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
2475
	} else if (buf_f->blf_flags &
2476
		  (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
L
Linus Torvalds 已提交
2477 2478
		xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
	} else {
2479
		xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
L
Linus Torvalds 已提交
2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499
	}
	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 ==
2500
	    be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
2501
	    (BBTOB(bp->b_io_length) != MAX(log->l_mp->m_sb.sb_blocksize,
L
Linus Torvalds 已提交
2502
			(__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
2503
		xfs_buf_stale(bp);
2504
		error = xfs_bwrite(bp);
L
Linus Torvalds 已提交
2505
	} else {
2506
		ASSERT(bp->b_target->bt_mount == mp);
2507
		bp->b_iodone = xlog_recover_iodone;
2508
		xfs_buf_delwri_queue(bp, buffer_list);
L
Linus Torvalds 已提交
2509 2510
	}

2511 2512
	xfs_buf_relse(bp);
	return error;
L
Linus Torvalds 已提交
2513 2514 2515
}

STATIC int
2516
xlog_recover_inode_pass2(
M
Mark Tinguely 已提交
2517 2518 2519
	struct xlog			*log,
	struct list_head		*buffer_list,
	struct xlog_recover_item	*item)
L
Linus Torvalds 已提交
2520 2521
{
	xfs_inode_log_format_t	*in_f;
2522
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2523 2524 2525 2526 2527 2528 2529 2530
	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;
2531
	xfs_icdinode_t		*dicp;
2532
	uint			isize;
2533
	int			need_free = 0;
L
Linus Torvalds 已提交
2534

2535
	if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
2536
		in_f = item->ri_buf[0].i_addr;
2537
	} else {
2538
		in_f = kmem_alloc(sizeof(xfs_inode_log_format_t), KM_SLEEP);
2539 2540 2541 2542 2543
		need_free = 1;
		error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
		if (error)
			goto error;
	}
L
Linus Torvalds 已提交
2544 2545 2546 2547 2548

	/*
	 * Inode buffers can be freed, look out for it,
	 * and do not replay the inode.
	 */
2549 2550
	if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
					in_f->ilf_len, 0)) {
2551
		error = 0;
2552
		trace_xfs_log_recover_inode_cancel(log, in_f);
2553 2554
		goto error;
	}
2555
	trace_xfs_log_recover_inode_recover(log, in_f);
L
Linus Torvalds 已提交
2556

2557
	bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0,
2558
			  &xfs_inode_buf_ops);
2559 2560 2561 2562
	if (!bp) {
		error = ENOMEM;
		goto error;
	}
2563
	error = bp->b_error;
2564
	if (error) {
2565
		xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
L
Linus Torvalds 已提交
2566
		xfs_buf_relse(bp);
2567
		goto error;
L
Linus Torvalds 已提交
2568 2569
	}
	ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
2570
	dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
L
Linus Torvalds 已提交
2571 2572 2573 2574 2575

	/*
	 * Make sure the place we're flushing out to really looks
	 * like an inode!
	 */
2576
	if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) {
L
Linus Torvalds 已提交
2577
		xfs_buf_relse(bp);
2578 2579 2580
		xfs_alert(mp,
	"%s: Bad inode magic number, dip = 0x%p, dino bp = 0x%p, ino = %Ld",
			__func__, dip, bp, in_f->ilf_ino);
2581
		XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
L
Linus Torvalds 已提交
2582
				 XFS_ERRLEVEL_LOW, mp);
2583 2584
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2585
	}
2586
	dicp = item->ri_buf[1].i_addr;
L
Linus Torvalds 已提交
2587 2588
	if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
		xfs_buf_relse(bp);
2589 2590 2591
		xfs_alert(mp,
			"%s: Bad inode log record, rec ptr 0x%p, ino %Ld",
			__func__, item, in_f->ilf_ino);
2592
		XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
L
Linus Torvalds 已提交
2593
				 XFS_ERRLEVEL_LOW, mp);
2594 2595
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2596 2597
	}

2598 2599 2600 2601 2602 2603 2604 2605 2606 2607
	/*
	 * di_flushiter is only valid for v1/2 inodes. All changes for v3 inodes
	 * are transactional and if ordering is necessary we can determine that
	 * more accurately by the LSN field in the V3 inode core. Don't trust
	 * the inode versions we might be changing them here - use the
	 * superblock flag to determine whether we need to look at di_flushiter
	 * to skip replay when the on disk inode is newer than the log one
	 */
	if (!xfs_sb_version_hascrc(&mp->m_sb) &&
	    dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
L
Linus Torvalds 已提交
2608 2609 2610 2611
		/*
		 * Deal with the wrap case, DI_MAX_FLUSH is less
		 * than smaller numbers
		 */
C
Christoph Hellwig 已提交
2612
		if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
2613
		    dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
L
Linus Torvalds 已提交
2614 2615 2616
			/* do nothing */
		} else {
			xfs_buf_relse(bp);
2617
			trace_xfs_log_recover_inode_skip(log, in_f);
2618 2619
			error = 0;
			goto error;
L
Linus Torvalds 已提交
2620 2621
		}
	}
2622

L
Linus Torvalds 已提交
2623 2624 2625
	/* Take the opportunity to reset the flush iteration count */
	dicp->di_flushiter = 0;

2626
	if (unlikely(S_ISREG(dicp->di_mode))) {
L
Linus Torvalds 已提交
2627 2628
		if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
		    (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
2629
			XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
L
Linus Torvalds 已提交
2630 2631
					 XFS_ERRLEVEL_LOW, mp, dicp);
			xfs_buf_relse(bp);
2632 2633 2634 2635
			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);
2636 2637
			error = EFSCORRUPTED;
			goto error;
L
Linus Torvalds 已提交
2638
		}
2639
	} else if (unlikely(S_ISDIR(dicp->di_mode))) {
L
Linus Torvalds 已提交
2640 2641 2642
		if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
		    (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
		    (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
2643
			XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
L
Linus Torvalds 已提交
2644 2645
					     XFS_ERRLEVEL_LOW, mp, dicp);
			xfs_buf_relse(bp);
2646 2647 2648 2649
			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);
2650 2651
			error = EFSCORRUPTED;
			goto error;
L
Linus Torvalds 已提交
2652 2653 2654
		}
	}
	if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
2655
		XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
L
Linus Torvalds 已提交
2656 2657
				     XFS_ERRLEVEL_LOW, mp, dicp);
		xfs_buf_relse(bp);
2658 2659 2660 2661
		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 已提交
2662 2663
			dicp->di_nextents + dicp->di_anextents,
			dicp->di_nblocks);
2664 2665
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2666 2667
	}
	if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
2668
		XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
L
Linus Torvalds 已提交
2669 2670
				     XFS_ERRLEVEL_LOW, mp, dicp);
		xfs_buf_relse(bp);
2671 2672 2673
		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__,
2674
			item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
2675 2676
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2677
	}
2678 2679
	isize = xfs_icdinode_size(dicp->di_version);
	if (unlikely(item->ri_buf[1].i_len > isize)) {
2680
		XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
L
Linus Torvalds 已提交
2681 2682
				     XFS_ERRLEVEL_LOW, mp, dicp);
		xfs_buf_relse(bp);
2683 2684 2685
		xfs_alert(mp,
			"%s: Bad inode log record length %d, rec ptr 0x%p",
			__func__, item->ri_buf[1].i_len, item);
2686 2687
		error = EFSCORRUPTED;
		goto error;
L
Linus Torvalds 已提交
2688 2689 2690
	}

	/* The core is in in-core format */
2691
	xfs_dinode_to_disk(dip, dicp);
L
Linus Torvalds 已提交
2692 2693

	/* the rest is in on-disk format */
2694 2695 2696 2697
	if (item->ri_buf[1].i_len > isize) {
		memcpy((char *)dip + isize,
			item->ri_buf[1].i_addr + isize,
			item->ri_buf[1].i_len - isize);
L
Linus Torvalds 已提交
2698 2699 2700 2701 2702
	}

	fields = in_f->ilf_fields;
	switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
	case XFS_ILOG_DEV:
C
Christoph Hellwig 已提交
2703
		xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
L
Linus Torvalds 已提交
2704 2705
		break;
	case XFS_ILOG_UUID:
C
Christoph Hellwig 已提交
2706 2707 2708
		memcpy(XFS_DFORK_DPTR(dip),
		       &in_f->ilf_u.ilfu_uuid,
		       sizeof(uuid_t));
L
Linus Torvalds 已提交
2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723
		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 已提交
2724
		memcpy(XFS_DFORK_DPTR(dip), src, len);
L
Linus Torvalds 已提交
2725 2726 2727
		break;

	case XFS_ILOG_DBROOT:
2728
		xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
C
Christoph Hellwig 已提交
2729
				 (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
L
Linus Torvalds 已提交
2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765
				 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);
2766 2767
			xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
					 len, (xfs_bmdr_block_t*)dest,
L
Linus Torvalds 已提交
2768 2769 2770 2771
					 XFS_DFORK_ASIZE(dip, mp));
			break;

		default:
2772
			xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
L
Linus Torvalds 已提交
2773 2774
			ASSERT(0);
			xfs_buf_relse(bp);
2775 2776
			error = EIO;
			goto error;
L
Linus Torvalds 已提交
2777 2778 2779 2780
		}
	}

write_inode_buffer:
2781 2782 2783
	/* re-generate the checksum. */
	xfs_dinode_calc_crc(log->l_mp, dip);

2784
	ASSERT(bp->b_target->bt_mount == mp);
2785
	bp->b_iodone = xlog_recover_iodone;
2786
	xfs_buf_delwri_queue(bp, buffer_list);
2787
	xfs_buf_relse(bp);
2788 2789
error:
	if (need_free)
2790
		kmem_free(in_f);
2791
	return XFS_ERROR(error);
L
Linus Torvalds 已提交
2792 2793 2794
}

/*
M
Mark Tinguely 已提交
2795
 * Recover QUOTAOFF records. We simply make a note of it in the xlog
L
Linus Torvalds 已提交
2796 2797 2798 2799
 * structure, so that we know not to do any dquot item or dquot buffer recovery,
 * of that type.
 */
STATIC int
2800
xlog_recover_quotaoff_pass1(
M
Mark Tinguely 已提交
2801 2802
	struct xlog			*log,
	struct xlog_recover_item	*item)
L
Linus Torvalds 已提交
2803
{
2804
	xfs_qoff_logformat_t	*qoff_f = item->ri_buf[0].i_addr;
L
Linus Torvalds 已提交
2805 2806 2807 2808
	ASSERT(qoff_f);

	/*
	 * The logitem format's flag tells us if this was user quotaoff,
2809
	 * group/project quotaoff or both.
L
Linus Torvalds 已提交
2810 2811 2812
	 */
	if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
		log->l_quotaoffs_flag |= XFS_DQ_USER;
2813 2814
	if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
		log->l_quotaoffs_flag |= XFS_DQ_PROJ;
L
Linus Torvalds 已提交
2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
	if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
		log->l_quotaoffs_flag |= XFS_DQ_GROUP;

	return (0);
}

/*
 * Recover a dquot record
 */
STATIC int
2825
xlog_recover_dquot_pass2(
M
Mark Tinguely 已提交
2826 2827 2828
	struct xlog			*log,
	struct list_head		*buffer_list,
	struct xlog_recover_item	*item)
L
Linus Torvalds 已提交
2829
{
2830
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843
	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);

2844 2845
	recddq = item->ri_buf[1].i_addr;
	if (recddq == NULL) {
2846
		xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
2847 2848
		return XFS_ERROR(EIO);
	}
2849
	if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
2850
		xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
2851 2852 2853 2854
			item->ri_buf[1].i_len, __func__);
		return XFS_ERROR(EIO);
	}

L
Linus Torvalds 已提交
2855 2856 2857
	/*
	 * This type of quotas was turned off, so ignore this record.
	 */
2858
	type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
L
Linus Torvalds 已提交
2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872
	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.
	 */
2873
	dq_f = item->ri_buf[0].i_addr;
L
Linus Torvalds 已提交
2874
	ASSERT(dq_f);
2875 2876 2877
	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 已提交
2878 2879 2880
		return XFS_ERROR(EIO);
	ASSERT(dq_f->qlf_len == 1);

D
Dave Chinner 已提交
2881
	error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
2882 2883
				   XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp,
				   NULL);
D
Dave Chinner 已提交
2884
	if (error)
L
Linus Torvalds 已提交
2885
		return error;
D
Dave Chinner 已提交
2886

L
Linus Torvalds 已提交
2887 2888 2889 2890 2891 2892 2893 2894
	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.
	 */
2895 2896 2897
	error = xfs_qm_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
			   "xlog_recover_dquot_pass2");
	if (error) {
L
Linus Torvalds 已提交
2898 2899 2900 2901 2902
		xfs_buf_relse(bp);
		return XFS_ERROR(EIO);
	}

	memcpy(ddq, recddq, item->ri_buf[1].i_len);
D
Dave Chinner 已提交
2903 2904 2905 2906
	if (xfs_sb_version_hascrc(&mp->m_sb)) {
		xfs_update_cksum((char *)ddq, sizeof(struct xfs_dqblk),
				 XFS_DQUOT_CRC_OFF);
	}
L
Linus Torvalds 已提交
2907 2908

	ASSERT(dq_f->qlf_size == 2);
2909
	ASSERT(bp->b_target->bt_mount == mp);
2910
	bp->b_iodone = xlog_recover_iodone;
2911
	xfs_buf_delwri_queue(bp, buffer_list);
2912
	xfs_buf_relse(bp);
L
Linus Torvalds 已提交
2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923

	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.
 */
2924
STATIC int
2925
xlog_recover_efi_pass2(
M
Mark Tinguely 已提交
2926 2927 2928
	struct xlog			*log,
	struct xlog_recover_item	*item,
	xfs_lsn_t			lsn)
L
Linus Torvalds 已提交
2929
{
2930
	int			error;
2931
	xfs_mount_t		*mp = log->l_mp;
L
Linus Torvalds 已提交
2932 2933 2934
	xfs_efi_log_item_t	*efip;
	xfs_efi_log_format_t	*efi_formatp;

2935
	efi_formatp = item->ri_buf[0].i_addr;
L
Linus Torvalds 已提交
2936 2937

	efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
2938 2939 2940 2941 2942
	if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
					 &(efip->efi_format)))) {
		xfs_efi_item_free(efip);
		return error;
	}
2943
	atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
L
Linus Torvalds 已提交
2944

2945
	spin_lock(&log->l_ailp->xa_lock);
L
Linus Torvalds 已提交
2946
	/*
2947
	 * xfs_trans_ail_update() drops the AIL lock.
L
Linus Torvalds 已提交
2948
	 */
2949
	xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn);
2950
	return 0;
L
Linus Torvalds 已提交
2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
}


/*
 * 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.
 */
2962 2963
STATIC int
xlog_recover_efd_pass2(
M
Mark Tinguely 已提交
2964 2965
	struct xlog			*log,
	struct xlog_recover_item	*item)
L
Linus Torvalds 已提交
2966 2967 2968 2969 2970
{
	xfs_efd_log_format_t	*efd_formatp;
	xfs_efi_log_item_t	*efip = NULL;
	xfs_log_item_t		*lip;
	__uint64_t		efi_id;
2971
	struct xfs_ail_cursor	cur;
2972
	struct xfs_ail		*ailp = log->l_ailp;
L
Linus Torvalds 已提交
2973

2974
	efd_formatp = item->ri_buf[0].i_addr;
2975 2976 2977 2978
	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 已提交
2979 2980 2981 2982 2983 2984
	efi_id = efd_formatp->efd_efi_id;

	/*
	 * Search for the efi with the id in the efd format structure
	 * in the AIL.
	 */
2985 2986
	spin_lock(&ailp->xa_lock);
	lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
L
Linus Torvalds 已提交
2987 2988 2989 2990 2991
	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) {
				/*
2992
				 * xfs_trans_ail_delete() drops the
L
Linus Torvalds 已提交
2993 2994
				 * AIL lock.
				 */
2995 2996
				xfs_trans_ail_delete(ailp, lip,
						     SHUTDOWN_CORRUPT_INCORE);
2997
				xfs_efi_item_free(efip);
2998
				spin_lock(&ailp->xa_lock);
2999
				break;
L
Linus Torvalds 已提交
3000 3001
			}
		}
3002
		lip = xfs_trans_ail_cursor_next(ailp, &cur);
L
Linus Torvalds 已提交
3003
	}
3004 3005
	xfs_trans_ail_cursor_done(ailp, &cur);
	spin_unlock(&ailp->xa_lock);
3006 3007

	return 0;
L
Linus Torvalds 已提交
3008 3009
}

D
Dave Chinner 已提交
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
/*
 * This routine is called when an inode create format structure is found in a
 * committed transaction in the log.  It's purpose is to initialise the inodes
 * being allocated on disk. This requires us to get inode cluster buffers that
 * match the range to be intialised, stamped with inode templates and written
 * by delayed write so that subsequent modifications will hit the cached buffer
 * and only need writing out at the end of recovery.
 */
STATIC int
xlog_recover_do_icreate_pass2(
	struct xlog		*log,
	struct list_head	*buffer_list,
	xlog_recover_item_t	*item)
{
	struct xfs_mount	*mp = log->l_mp;
	struct xfs_icreate_log	*icl;
	xfs_agnumber_t		agno;
	xfs_agblock_t		agbno;
	unsigned int		count;
	unsigned int		isize;
	xfs_agblock_t		length;

	icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
	if (icl->icl_type != XFS_LI_ICREATE) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad type");
		return EINVAL;
	}

	if (icl->icl_size != 1) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad icl size");
		return EINVAL;
	}

	agno = be32_to_cpu(icl->icl_ag);
	if (agno >= mp->m_sb.sb_agcount) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agno");
		return EINVAL;
	}
	agbno = be32_to_cpu(icl->icl_agbno);
	if (!agbno || agbno == NULLAGBLOCK || agbno >= mp->m_sb.sb_agblocks) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad agbno");
		return EINVAL;
	}
	isize = be32_to_cpu(icl->icl_isize);
	if (isize != mp->m_sb.sb_inodesize) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad isize");
		return EINVAL;
	}
	count = be32_to_cpu(icl->icl_count);
	if (!count) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count");
		return EINVAL;
	}
	length = be32_to_cpu(icl->icl_length);
	if (!length || length >= mp->m_sb.sb_agblocks) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad length");
		return EINVAL;
	}

	/* existing allocation is fixed value */
	ASSERT(count == XFS_IALLOC_INODES(mp));
	ASSERT(length == XFS_IALLOC_BLOCKS(mp));
	if (count != XFS_IALLOC_INODES(mp) ||
	     length != XFS_IALLOC_BLOCKS(mp)) {
		xfs_warn(log->l_mp, "xlog_recover_do_icreate_trans: bad count 2");
		return EINVAL;
	}

	/*
	 * Inode buffers can be freed. Do not replay the inode initialisation as
	 * we could be overwriting something written after this inode buffer was
	 * cancelled.
	 *
	 * XXX: we need to iterate all buffers and only init those that are not
	 * cancelled. I think that a more fine grained factoring of
	 * xfs_ialloc_inode_init may be appropriate here to enable this to be
	 * done easily.
	 */
	if (xlog_check_buffer_cancelled(log,
			XFS_AGB_TO_DADDR(mp, agno, agbno), length, 0))
		return 0;

	xfs_ialloc_inode_init(mp, NULL, buffer_list, agno, agbno, length,
					be32_to_cpu(icl->icl_gen));
	return 0;
}

L
Linus Torvalds 已提交
3097 3098 3099 3100 3101 3102 3103
/*
 * Free up any resources allocated by the transaction
 *
 * Remember that EFIs, EFDs, and IUNLINKs are handled later.
 */
STATIC void
xlog_recover_free_trans(
3104
	struct xlog_recover	*trans)
L
Linus Torvalds 已提交
3105
{
3106
	xlog_recover_item_t	*item, *n;
L
Linus Torvalds 已提交
3107 3108
	int			i;

3109 3110 3111 3112 3113
	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 已提交
3114
		/* Free the item itself */
3115 3116 3117
		kmem_free(item->ri_buf);
		kmem_free(item);
	}
L
Linus Torvalds 已提交
3118
	/* Free the transaction recover structure */
3119
	kmem_free(trans);
L
Linus Torvalds 已提交
3120 3121
}

3122
STATIC int
3123
xlog_recover_commit_pass1(
3124 3125 3126
	struct xlog			*log,
	struct xlog_recover		*trans,
	struct xlog_recover_item	*item)
3127
{
3128
	trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
3129 3130 3131

	switch (ITEM_TYPE(item)) {
	case XFS_LI_BUF:
3132 3133 3134
		return xlog_recover_buffer_pass1(log, item);
	case XFS_LI_QUOTAOFF:
		return xlog_recover_quotaoff_pass1(log, item);
3135 3136 3137
	case XFS_LI_INODE:
	case XFS_LI_EFI:
	case XFS_LI_EFD:
3138
	case XFS_LI_DQUOT:
D
Dave Chinner 已提交
3139
	case XFS_LI_ICREATE:
3140
		/* nothing to do in pass 1 */
3141
		return 0;
3142
	default:
3143 3144
		xfs_warn(log->l_mp, "%s: invalid item type (%d)",
			__func__, ITEM_TYPE(item));
3145 3146 3147 3148 3149 3150 3151
		ASSERT(0);
		return XFS_ERROR(EIO);
	}
}

STATIC int
xlog_recover_commit_pass2(
3152 3153 3154 3155
	struct xlog			*log,
	struct xlog_recover		*trans,
	struct list_head		*buffer_list,
	struct xlog_recover_item	*item)
3156 3157 3158 3159 3160
{
	trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);

	switch (ITEM_TYPE(item)) {
	case XFS_LI_BUF:
3161
		return xlog_recover_buffer_pass2(log, buffer_list, item);
3162
	case XFS_LI_INODE:
3163
		return xlog_recover_inode_pass2(log, buffer_list, item);
3164 3165 3166 3167
	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);
3168
	case XFS_LI_DQUOT:
3169
		return xlog_recover_dquot_pass2(log, buffer_list, item);
D
Dave Chinner 已提交
3170 3171
	case XFS_LI_ICREATE:
		return xlog_recover_do_icreate_pass2(log, buffer_list, item);
3172
	case XFS_LI_QUOTAOFF:
3173 3174
		/* nothing to do in pass2 */
		return 0;
3175
	default:
3176 3177
		xfs_warn(log->l_mp, "%s: invalid item type (%d)",
			__func__, ITEM_TYPE(item));
3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188
		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 已提交
3189 3190
STATIC int
xlog_recover_commit_trans(
3191
	struct xlog		*log,
3192
	struct xlog_recover	*trans,
L
Linus Torvalds 已提交
3193 3194
	int			pass)
{
3195
	int			error = 0, error2;
3196
	xlog_recover_item_t	*item;
3197
	LIST_HEAD		(buffer_list);
L
Linus Torvalds 已提交
3198

3199
	hlist_del(&trans->r_list);
3200 3201 3202

	error = xlog_recover_reorder_trans(log, trans, pass);
	if (error)
L
Linus Torvalds 已提交
3203
		return error;
3204 3205

	list_for_each_entry(item, &trans->r_itemq, ri_list) {
3206 3207
		switch (pass) {
		case XLOG_RECOVER_PASS1:
3208
			error = xlog_recover_commit_pass1(log, trans, item);
3209 3210 3211 3212 3213 3214 3215 3216 3217
			break;
		case XLOG_RECOVER_PASS2:
			error = xlog_recover_commit_pass2(log, trans,
							  &buffer_list, item);
			break;
		default:
			ASSERT(0);
		}

3218
		if (error)
3219
			goto out;
3220 3221 3222
	}

	xlog_recover_free_trans(trans);
3223 3224 3225 3226

out:
	error2 = xfs_buf_delwri_submit(&buffer_list);
	return error ? error : error2;
L
Linus Torvalds 已提交
3227 3228 3229 3230
}

STATIC int
xlog_recover_unmount_trans(
3231 3232
	struct xlog		*log,
	struct xlog_recover	*trans)
L
Linus Torvalds 已提交
3233 3234
{
	/* Do nothing now */
3235
	xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
L
Linus Torvalds 已提交
3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249
	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(
M
Mark Tinguely 已提交
3250
	struct xlog		*log,
3251
	struct hlist_head	rhash[],
M
Mark Tinguely 已提交
3252
	struct xlog_rec_header	*rhead,
L
Linus Torvalds 已提交
3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
	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;

3265 3266
	lp = dp + be32_to_cpu(rhead->h_len);
	num_logops = be32_to_cpu(rhead->h_num_logops);
L
Linus Torvalds 已提交
3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277

	/* 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) {
3278 3279
			xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
					__func__, ohead->oh_clientid);
L
Linus Torvalds 已提交
3280 3281 3282
			ASSERT(0);
			return (XFS_ERROR(EIO));
		}
3283
		tid = be32_to_cpu(ohead->oh_tid);
L
Linus Torvalds 已提交
3284
		hash = XLOG_RHASH(tid);
3285
		trans = xlog_recover_find_tid(&rhash[hash], tid);
L
Linus Torvalds 已提交
3286 3287 3288
		if (trans == NULL) {		   /* not found; add new tid */
			if (ohead->oh_flags & XLOG_START_TRANS)
				xlog_recover_new_tid(&rhash[hash], tid,
3289
					be64_to_cpu(rhead->h_lsn));
L
Linus Torvalds 已提交
3290
		} else {
3291
			if (dp + be32_to_cpu(ohead->oh_len) > lp) {
3292 3293
				xfs_warn(log->l_mp, "%s: bad length 0x%x",
					__func__, be32_to_cpu(ohead->oh_len));
3294 3295 3296
				WARN_ON(1);
				return (XFS_ERROR(EIO));
			}
L
Linus Torvalds 已提交
3297 3298 3299 3300 3301 3302
			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,
3303
								trans, pass);
L
Linus Torvalds 已提交
3304 3305
				break;
			case XLOG_UNMOUNT_TRANS:
3306
				error = xlog_recover_unmount_trans(log, trans);
L
Linus Torvalds 已提交
3307 3308
				break;
			case XLOG_WAS_CONT_TRANS:
3309 3310 3311
				error = xlog_recover_add_to_cont_trans(log,
						trans, dp,
						be32_to_cpu(ohead->oh_len));
L
Linus Torvalds 已提交
3312 3313
				break;
			case XLOG_START_TRANS:
3314 3315
				xfs_warn(log->l_mp, "%s: bad transaction",
					__func__);
L
Linus Torvalds 已提交
3316 3317 3318 3319 3320
				ASSERT(0);
				error = XFS_ERROR(EIO);
				break;
			case 0:
			case XLOG_CONTINUE_TRANS:
3321
				error = xlog_recover_add_to_trans(log, trans,
3322
						dp, be32_to_cpu(ohead->oh_len));
L
Linus Torvalds 已提交
3323 3324
				break;
			default:
3325 3326
				xfs_warn(log->l_mp, "%s: bad flag 0x%x",
					__func__, flags);
L
Linus Torvalds 已提交
3327 3328 3329 3330 3331 3332 3333
				ASSERT(0);
				error = XFS_ERROR(EIO);
				break;
			}
			if (error)
				return error;
		}
3334
		dp += be32_to_cpu(ohead->oh_len);
L
Linus Torvalds 已提交
3335 3336 3337 3338 3339 3340 3341 3342 3343
		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.
 */
3344
STATIC int
L
Linus Torvalds 已提交
3345 3346 3347 3348 3349 3350 3351
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;
3352
	int			error = 0;
L
Linus Torvalds 已提交
3353 3354 3355
	xfs_extent_t		*extp;
	xfs_fsblock_t		startblock_fsb;

3356
	ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
L
Linus Torvalds 已提交
3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374

	/*
	 * 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.
			 */
3375
			set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
L
Linus Torvalds 已提交
3376
			xfs_efi_release(efip, efip->efi_format.efi_nextents);
3377
			return XFS_ERROR(EIO);
L
Linus Torvalds 已提交
3378 3379 3380 3381
		}
	}

	tp = xfs_trans_alloc(mp, 0);
3382
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
3383 3384
	if (error)
		goto abort_error;
L
Linus Torvalds 已提交
3385 3386 3387 3388
	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]);
3389 3390 3391
		error = xfs_free_extent(tp, extp->ext_start, extp->ext_len);
		if (error)
			goto abort_error;
L
Linus Torvalds 已提交
3392 3393 3394 3395
		xfs_trans_log_efd_extent(tp, efdp, extp->ext_start,
					 extp->ext_len);
	}

3396
	set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
3397
	error = xfs_trans_commit(tp, 0);
3398
	return error;
3399 3400 3401 3402

abort_error:
	xfs_trans_cancel(tp, XFS_TRANS_ABORT);
	return error;
L
Linus Torvalds 已提交
3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422
}

/*
 * 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.
 */
3423
STATIC int
L
Linus Torvalds 已提交
3424
xlog_recover_process_efis(
M
Mark Tinguely 已提交
3425
	struct xlog	*log)
L
Linus Torvalds 已提交
3426 3427 3428
{
	xfs_log_item_t		*lip;
	xfs_efi_log_item_t	*efip;
3429
	int			error = 0;
3430
	struct xfs_ail_cursor	cur;
3431
	struct xfs_ail		*ailp;
L
Linus Torvalds 已提交
3432

3433 3434 3435
	ailp = log->l_ailp;
	spin_lock(&ailp->xa_lock);
	lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
L
Linus Torvalds 已提交
3436 3437 3438
	while (lip != NULL) {
		/*
		 * We're done when we see something other than an EFI.
3439
		 * There should be no EFIs left in the AIL now.
L
Linus Torvalds 已提交
3440 3441
		 */
		if (lip->li_type != XFS_LI_EFI) {
3442
#ifdef DEBUG
3443
			for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
3444 3445
				ASSERT(lip->li_type != XFS_LI_EFI);
#endif
L
Linus Torvalds 已提交
3446 3447 3448 3449 3450 3451 3452
			break;
		}

		/*
		 * Skip EFIs that we've already processed.
		 */
		efip = (xfs_efi_log_item_t *)lip;
3453
		if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) {
3454
			lip = xfs_trans_ail_cursor_next(ailp, &cur);
L
Linus Torvalds 已提交
3455 3456 3457
			continue;
		}

3458 3459 3460
		spin_unlock(&ailp->xa_lock);
		error = xlog_recover_process_efi(log->l_mp, efip);
		spin_lock(&ailp->xa_lock);
3461 3462
		if (error)
			goto out;
3463
		lip = xfs_trans_ail_cursor_next(ailp, &cur);
L
Linus Torvalds 已提交
3464
	}
3465
out:
3466 3467
	xfs_trans_ail_cursor_done(ailp, &cur);
	spin_unlock(&ailp->xa_lock);
3468
	return error;
L
Linus Torvalds 已提交
3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487
}

/*
 * 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);
3488
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_clearagi, 0, 0);
3489 3490
	if (error)
		goto out_abort;
L
Linus Torvalds 已提交
3491

3492 3493
	error = xfs_read_agi(mp, tp, agno, &agibp);
	if (error)
3494
		goto out_abort;
L
Linus Torvalds 已提交
3495

3496
	agi = XFS_BUF_TO_AGI(agibp);
3497
	agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
L
Linus Torvalds 已提交
3498 3499 3500 3501 3502
	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));

3503 3504 3505 3506 3507 3508 3509 3510
	error = xfs_trans_commit(tp, 0);
	if (error)
		goto out_error;
	return;

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

3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528
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);
3529
	error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
3530 3531 3532 3533 3534 3535
	if (error)
		goto fail;

	/*
	 * Get the on disk inode to find the next inode in the bucket.
	 */
3536
	error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &ibp, 0, 0);
3537
	if (error)
3538
		goto fail_iput;
3539 3540

	ASSERT(ip->i_d.di_nlink == 0);
3541
	ASSERT(ip->i_d.di_mode != 0);
3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552

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

3553
	IRELE(ip);
3554 3555
	return agino;

3556 3557
 fail_iput:
	IRELE(ip);
3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570
 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 已提交
3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582
/*
 * 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.
 */
3583
STATIC void
L
Linus Torvalds 已提交
3584
xlog_recover_process_iunlinks(
M
Mark Tinguely 已提交
3585
	struct xlog	*log)
L
Linus Torvalds 已提交
3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607
{
	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.
		 */
3608 3609 3610 3611 3612 3613 3614 3615 3616
		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 已提交
3617
		}
3618 3619 3620 3621 3622 3623 3624 3625 3626
		/*
		 * Unlock the buffer so that it can be acquired in the normal
		 * course of the transaction to truncate and free each inode.
		 * Because we are not racing with anyone else here for the AGI
		 * buffer, we don't even need to hold it locked to read the
		 * initial unlinked bucket entries out of the buffer. We keep
		 * buffer reference though, so that it stays pinned in memory
		 * while we need the buffer.
		 */
L
Linus Torvalds 已提交
3627
		agi = XFS_BUF_TO_AGI(agibp);
3628
		xfs_buf_unlock(agibp);
L
Linus Torvalds 已提交
3629 3630

		for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
3631
			agino = be32_to_cpu(agi->agi_unlinked[bucket]);
L
Linus Torvalds 已提交
3632
			while (agino != NULLAGINO) {
3633 3634
				agino = xlog_recover_process_one_iunlink(mp,
							agno, agino, bucket);
L
Linus Torvalds 已提交
3635 3636
			}
		}
3637
		xfs_buf_rele(agibp);
L
Linus Torvalds 已提交
3638 3639 3640 3641 3642 3643
	}

	mp->m_dmevmask = mp_dmevmask;
}

/*
C
Christoph Hellwig 已提交
3644 3645 3646 3647 3648 3649 3650 3651
 * Upack the log buffer data and crc check it. If the check fails, issue a
 * warning if and only if the CRC in the header is non-zero. This makes the
 * check an advisory warning, and the zero CRC check will prevent failure
 * warnings from being emitted when upgrading the kernel from one that does not
 * add CRCs by default.
 *
 * When filesystems are CRC enabled, this CRC mismatch becomes a fatal log
 * corruption failure
L
Linus Torvalds 已提交
3652
 */
C
Christoph Hellwig 已提交
3653 3654 3655 3656 3657
STATIC int
xlog_unpack_data_crc(
	struct xlog_rec_header	*rhead,
	xfs_caddr_t		dp,
	struct xlog		*log)
L
Linus Torvalds 已提交
3658
{
3659
	__le32			crc;
C
Christoph Hellwig 已提交
3660 3661 3662 3663 3664 3665

	crc = xlog_cksum(log, rhead, dp, be32_to_cpu(rhead->h_len));
	if (crc != rhead->h_crc) {
		if (rhead->h_crc || xfs_sb_version_hascrc(&log->l_mp->m_sb)) {
			xfs_alert(log->l_mp,
		"log record CRC mismatch: found 0x%x, expected 0x%x.\n",
3666 3667
					le32_to_cpu(rhead->h_crc),
					le32_to_cpu(crc));
C
Christoph Hellwig 已提交
3668
			xfs_hex_dump(dp, 32);
L
Linus Torvalds 已提交
3669 3670
		}

C
Christoph Hellwig 已提交
3671 3672 3673 3674 3675 3676 3677
		/*
		 * If we've detected a log record corruption, then we can't
		 * recover past this point. Abort recovery if we are enforcing
		 * CRC protection by punting an error back up the stack.
		 */
		if (xfs_sb_version_hascrc(&log->l_mp->m_sb))
			return EFSCORRUPTED;
L
Linus Torvalds 已提交
3678
	}
C
Christoph Hellwig 已提交
3679 3680

	return 0;
L
Linus Torvalds 已提交
3681 3682
}

C
Christoph Hellwig 已提交
3683
STATIC int
L
Linus Torvalds 已提交
3684
xlog_unpack_data(
M
Mark Tinguely 已提交
3685
	struct xlog_rec_header	*rhead,
L
Linus Torvalds 已提交
3686
	xfs_caddr_t		dp,
M
Mark Tinguely 已提交
3687
	struct xlog		*log)
L
Linus Torvalds 已提交
3688 3689
{
	int			i, j, k;
C
Christoph Hellwig 已提交
3690 3691 3692 3693 3694
	int			error;

	error = xlog_unpack_data_crc(rhead, dp, log);
	if (error)
		return error;
L
Linus Torvalds 已提交
3695

3696
	for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
L
Linus Torvalds 已提交
3697
		  i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
3698
		*(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
L
Linus Torvalds 已提交
3699 3700 3701
		dp += BBSIZE;
	}

3702
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
3703
		xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
3704
		for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
L
Linus Torvalds 已提交
3705 3706
			j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
			k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3707
			*(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
L
Linus Torvalds 已提交
3708 3709 3710
			dp += BBSIZE;
		}
	}
C
Christoph Hellwig 已提交
3711 3712

	return 0;
L
Linus Torvalds 已提交
3713 3714 3715 3716
}

STATIC int
xlog_valid_rec_header(
M
Mark Tinguely 已提交
3717 3718
	struct xlog		*log,
	struct xlog_rec_header	*rhead,
L
Linus Torvalds 已提交
3719 3720 3721 3722
	xfs_daddr_t		blkno)
{
	int			hlen;

3723
	if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
L
Linus Torvalds 已提交
3724 3725 3726 3727 3728 3729
		XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
				XFS_ERRLEVEL_LOW, log->l_mp);
		return XFS_ERROR(EFSCORRUPTED);
	}
	if (unlikely(
	    (!rhead->h_version ||
3730
	    (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
3731
		xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
3732
			__func__, be32_to_cpu(rhead->h_version));
L
Linus Torvalds 已提交
3733 3734 3735 3736
		return XFS_ERROR(EIO);
	}

	/* LR body must have data or it wouldn't have been written */
3737
	hlen = be32_to_cpu(rhead->h_len);
L
Linus Torvalds 已提交
3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760
	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(
M
Mark Tinguely 已提交
3761
	struct xlog		*log,
L
Linus Torvalds 已提交
3762 3763 3764 3765 3766 3767
	xfs_daddr_t		head_blk,
	xfs_daddr_t		tail_blk,
	int			pass)
{
	xlog_rec_header_t	*rhead;
	xfs_daddr_t		blk_no;
3768
	xfs_caddr_t		offset;
L
Linus Torvalds 已提交
3769 3770 3771 3772
	xfs_buf_t		*hbp, *dbp;
	int			error = 0, h_size;
	int			bblks, split_bblks;
	int			hblks, split_hblks, wrapped_hblks;
3773
	struct hlist_head	rhash[XLOG_RHASH_SIZE];
L
Linus Torvalds 已提交
3774 3775 3776 3777 3778 3779 3780

	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.
	 */
3781
	if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
L
Linus Torvalds 已提交
3782 3783 3784 3785 3786 3787 3788 3789
		/*
		 * 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 已提交
3790 3791 3792

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

L
Linus Torvalds 已提交
3795 3796 3797 3798
		rhead = (xlog_rec_header_t *)offset;
		error = xlog_valid_rec_header(log, rhead, tail_blk);
		if (error)
			goto bread_err1;
3799 3800
		h_size = be32_to_cpu(rhead->h_size);
		if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
L
Linus Torvalds 已提交
3801 3802 3803 3804 3805 3806 3807 3808 3809 3810
		    (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 {
3811
		ASSERT(log->l_sectBBsize == 1);
L
Linus Torvalds 已提交
3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827
		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 已提交
3828 3829
			error = xlog_bread(log, blk_no, hblks, hbp, &offset);
			if (error)
L
Linus Torvalds 已提交
3830
				goto bread_err2;
C
Christoph Hellwig 已提交
3831

L
Linus Torvalds 已提交
3832 3833 3834 3835 3836 3837
			rhead = (xlog_rec_header_t *)offset;
			error = xlog_valid_rec_header(log, rhead, blk_no);
			if (error)
				goto bread_err2;

			/* blocks in data section */
3838
			bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
C
Christoph Hellwig 已提交
3839 3840
			error = xlog_bread(log, blk_no + hblks, bblks, dbp,
					   &offset);
L
Linus Torvalds 已提交
3841 3842
			if (error)
				goto bread_err2;
C
Christoph Hellwig 已提交
3843

C
Christoph Hellwig 已提交
3844 3845 3846 3847 3848 3849 3850
			error = xlog_unpack_data(rhead, offset, log);
			if (error)
				goto bread_err2;

			error = xlog_recover_process_data(log,
						rhash, rhead, offset, pass);
			if (error)
L
Linus Torvalds 已提交
3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864
				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
			 */
3865
			offset = hbp->b_addr;
L
Linus Torvalds 已提交
3866 3867 3868 3869
			split_hblks = 0;
			wrapped_hblks = 0;
			if (blk_no + hblks <= log->l_logBBsize) {
				/* Read header in one read */
C
Christoph Hellwig 已提交
3870 3871
				error = xlog_bread(log, blk_no, hblks, hbp,
						   &offset);
L
Linus Torvalds 已提交
3872 3873 3874 3875 3876 3877 3878 3879 3880
				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 已提交
3881 3882 3883 3884
					error = xlog_bread(log, blk_no,
							   split_hblks, hbp,
							   &offset);
					if (error)
L
Linus Torvalds 已提交
3885 3886
						goto bread_err2;
				}
C
Christoph Hellwig 已提交
3887

L
Linus Torvalds 已提交
3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899
				/*
				 * 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.
				 */
3900
				wrapped_hblks = hblks - split_hblks;
3901 3902 3903
				error = xlog_bread_offset(log, 0,
						wrapped_hblks, hbp,
						offset + BBTOB(split_hblks));
L
Linus Torvalds 已提交
3904 3905 3906 3907 3908 3909 3910 3911 3912
				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;

3913
			bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
L
Linus Torvalds 已提交
3914 3915 3916 3917
			blk_no += hblks;

			/* Read in data for log record */
			if (blk_no + bblks <= log->l_logBBsize) {
C
Christoph Hellwig 已提交
3918 3919
				error = xlog_bread(log, blk_no, bblks, dbp,
						   &offset);
L
Linus Torvalds 已提交
3920 3921 3922 3923 3924
				if (error)
					goto bread_err2;
			} else {
				/* This log record is split across the
				 * physical end of log */
3925
				offset = dbp->b_addr;
L
Linus Torvalds 已提交
3926 3927 3928 3929 3930 3931 3932 3933 3934
				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 已提交
3935 3936 3937 3938
					error = xlog_bread(log, blk_no,
							split_bblks, dbp,
							&offset);
					if (error)
L
Linus Torvalds 已提交
3939 3940
						goto bread_err2;
				}
C
Christoph Hellwig 已提交
3941

L
Linus Torvalds 已提交
3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
				/*
				 * 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.
				 */
3954
				error = xlog_bread_offset(log, 0,
3955
						bblks - split_bblks, dbp,
3956
						offset + BBTOB(split_bblks));
C
Christoph Hellwig 已提交
3957 3958
				if (error)
					goto bread_err2;
L
Linus Torvalds 已提交
3959
			}
C
Christoph Hellwig 已提交
3960 3961 3962 3963 3964 3965 3966 3967

			error = xlog_unpack_data(rhead, offset, log);
			if (error)
				goto bread_err2;

			error = xlog_recover_process_data(log, rhash,
							rhead, offset, pass);
			if (error)
L
Linus Torvalds 已提交
3968 3969 3970 3971 3972 3973 3974 3975 3976
				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 已提交
3977 3978
			error = xlog_bread(log, blk_no, hblks, hbp, &offset);
			if (error)
L
Linus Torvalds 已提交
3979
				goto bread_err2;
C
Christoph Hellwig 已提交
3980

L
Linus Torvalds 已提交
3981 3982 3983 3984
			rhead = (xlog_rec_header_t *)offset;
			error = xlog_valid_rec_header(log, rhead, blk_no);
			if (error)
				goto bread_err2;
C
Christoph Hellwig 已提交
3985

3986
			bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
C
Christoph Hellwig 已提交
3987 3988 3989
			error = xlog_bread(log, blk_no+hblks, bblks, dbp,
					   &offset);
			if (error)
L
Linus Torvalds 已提交
3990
				goto bread_err2;
C
Christoph Hellwig 已提交
3991

C
Christoph Hellwig 已提交
3992 3993 3994 3995 3996 3997 3998
			error = xlog_unpack_data(rhead, offset, log);
			if (error)
				goto bread_err2;

			error = xlog_recover_process_data(log, rhash,
							rhead, offset, pass);
			if (error)
L
Linus Torvalds 已提交
3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025
				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(
M
Mark Tinguely 已提交
4026
	struct xlog	*log,
L
Linus Torvalds 已提交
4027 4028 4029
	xfs_daddr_t	head_blk,
	xfs_daddr_t	tail_blk)
{
4030
	int		error, i;
L
Linus Torvalds 已提交
4031 4032 4033 4034 4035 4036 4037

	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.
	 */
4038 4039
	log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE *
						 sizeof(struct list_head),
L
Linus Torvalds 已提交
4040
						 KM_SLEEP);
4041 4042 4043
	for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
		INIT_LIST_HEAD(&log->l_buf_cancel_table[i]);

L
Linus Torvalds 已提交
4044 4045 4046
	error = xlog_do_recovery_pass(log, head_blk, tail_blk,
				      XLOG_RECOVER_PASS1);
	if (error != 0) {
4047
		kmem_free(log->l_buf_cancel_table);
L
Linus Torvalds 已提交
4048 4049 4050 4051 4052 4053 4054 4055 4056 4057
		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
4058
	if (!error) {
L
Linus Torvalds 已提交
4059 4060 4061
		int	i;

		for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
4062
			ASSERT(list_empty(&log->l_buf_cancel_table[i]));
L
Linus Torvalds 已提交
4063 4064 4065
	}
#endif	/* DEBUG */

4066
	kmem_free(log->l_buf_cancel_table);
L
Linus Torvalds 已提交
4067 4068 4069 4070 4071 4072 4073 4074 4075 4076
	log->l_buf_cancel_table = NULL;

	return error;
}

/*
 * Do the actual recovery
 */
STATIC int
xlog_do_recover(
M
Mark Tinguely 已提交
4077
	struct xlog	*log,
L
Linus Torvalds 已提交
4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088
	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);
4089
	if (error)
L
Linus Torvalds 已提交
4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111
		return error;

	/*
	 * 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
4112
	 * updates, re-read in the superblock and reverify it.
L
Linus Torvalds 已提交
4113 4114 4115
	 */
	bp = xfs_getsb(log->l_mp, 0);
	XFS_BUF_UNDONE(bp);
4116
	ASSERT(!(XFS_BUF_ISWRITE(bp)));
L
Linus Torvalds 已提交
4117
	XFS_BUF_READ(bp);
4118
	XFS_BUF_UNASYNC(bp);
4119
	bp->b_ops = &xfs_sb_buf_ops;
L
Linus Torvalds 已提交
4120
	xfsbdstrat(log->l_mp, bp);
C
Christoph Hellwig 已提交
4121
	error = xfs_buf_iowait(bp);
4122
	if (error) {
4123
		xfs_buf_ioerror_alert(bp, __func__);
L
Linus Torvalds 已提交
4124 4125 4126 4127 4128 4129 4130
		ASSERT(0);
		xfs_buf_relse(bp);
		return error;
	}

	/* Convert superblock from on-disk format */
	sbp = &log->l_mp->m_sb;
4131
	xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
L
Linus Torvalds 已提交
4132
	ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
4133
	ASSERT(xfs_sb_good_version(sbp));
L
Linus Torvalds 已提交
4134 4135
	xfs_buf_relse(bp);

4136 4137 4138
	/* We've re-read the superblock so re-initialize per-cpu counters */
	xfs_icsb_reinit_counters(log->l_mp);

L
Linus Torvalds 已提交
4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152
	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(
M
Mark Tinguely 已提交
4153
	struct xlog	*log)
L
Linus Torvalds 已提交
4154 4155 4156 4157 4158
{
	xfs_daddr_t	head_blk, tail_blk;
	int		error;

	/* find the tail of the log */
4159
	if ((error = xlog_find_tail(log, &head_blk, &tail_blk)))
L
Linus Torvalds 已提交
4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173
		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.
		 */
4174
		if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
L
Linus Torvalds 已提交
4175 4176 4177
			return error;
		}

4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196
		/*
		 * Version 5 superblock log feature mask validation. We know the
		 * log is dirty so check if there are any unknown log features
		 * in what we need to recover. If there are unknown features
		 * (e.g. unsupported transactions, then simply reject the
		 * attempt at recovery before touching anything.
		 */
		if (XFS_SB_VERSION_NUM(&log->l_mp->m_sb) == XFS_SB_VERSION_5 &&
		    xfs_sb_has_incompat_log_feature(&log->l_mp->m_sb,
					XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)) {
			xfs_warn(log->l_mp,
"Superblock has unknown incompatible log features (0x%x) enabled.\n"
"The log can not be fully and/or safely recovered by this kernel.\n"
"Please recover the log on a kernel that supports the unknown features.",
				(log->l_mp->m_sb.sb_features_log_incompat &
					XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));
			return EINVAL;
		}

4197 4198 4199
		xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
				log->l_mp->m_logname ? log->l_mp->m_logname
						     : "internal");
L
Linus Torvalds 已提交
4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217

		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(
M
Mark Tinguely 已提交
4218
	struct xlog	*log)
L
Linus Torvalds 已提交
4219 4220 4221 4222 4223 4224 4225 4226 4227 4228
{
	/*
	 * 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) {
4229 4230 4231
		int	error;
		error = xlog_recover_process_efis(log);
		if (error) {
4232
			xfs_alert(log->l_mp, "Failed to recover EFIs");
4233 4234
			return error;
		}
L
Linus Torvalds 已提交
4235 4236 4237 4238 4239 4240
		/*
		 * 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.
		 */
4241
		xfs_log_force(log->l_mp, XFS_LOG_SYNC);
L
Linus Torvalds 已提交
4242

C
Christoph Hellwig 已提交
4243
		xlog_recover_process_iunlinks(log);
L
Linus Torvalds 已提交
4244 4245 4246

		xlog_recover_check_summary(log);

4247 4248 4249
		xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
				log->l_mp->m_logname ? log->l_mp->m_logname
						     : "internal");
L
Linus Torvalds 已提交
4250 4251
		log->l_flags &= ~XLOG_RECOVERY_NEEDED;
	} else {
4252
		xfs_info(log->l_mp, "Ending clean mount");
L
Linus Torvalds 已提交
4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264
	}
	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(
M
Mark Tinguely 已提交
4265
	struct xlog	*log)
L
Linus Torvalds 已提交
4266 4267 4268 4269 4270 4271 4272 4273 4274
{
	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;
4275
	int		error;
L
Linus Torvalds 已提交
4276 4277 4278 4279 4280 4281 4282

	mp = log->l_mp;

	freeblks = 0LL;
	itotal = 0LL;
	ifree = 0LL;
	for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
4283 4284
		error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
		if (error) {
4285 4286
			xfs_alert(mp, "%s agf read failed agno %d error %d",
						__func__, agno, error);
4287 4288 4289 4290 4291
		} 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 已提交
4292 4293
		}

4294
		error = xfs_read_agi(mp, NULL, agno, &agibp);
4295 4296 4297 4298
		if (error) {
			xfs_alert(mp, "%s agi read failed agno %d error %d",
						__func__, agno, error);
		} else {
4299
			struct xfs_agi	*agi = XFS_BUF_TO_AGI(agibp);
4300

4301 4302 4303 4304
			itotal += be32_to_cpu(agi->agi_count);
			ifree += be32_to_cpu(agi->agi_freecount);
			xfs_buf_relse(agibp);
		}
L
Linus Torvalds 已提交
4305 4306 4307
	}
}
#endif /* DEBUG */