blob: d1dba7ce75aefeb2af92ded16d8d944f452a7a1e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Tim Shimmin87c199c2006-06-09 14:56:16 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110023#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_trans.h"
Nathan Scotta844f452005-11-02 14:38:42 +110025#include "xfs_sb.h"
26#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_mount.h"
28#include "xfs_error.h"
29#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_alloc_btree.h"
31#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_dinode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110034#include "xfs_inode_item.h"
Nathan Scotta844f452005-11-02 14:38:42 +110035#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_ialloc.h"
37#include "xfs_log_priv.h"
38#include "xfs_buf_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_log_recover.h"
40#include "xfs_extfree_item.h"
41#include "xfs_trans_priv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "xfs_quota.h"
Christoph Hellwig43355092008-03-27 18:01:08 +110043#include "xfs_utils.h"
Christoph Hellwig0e446be2012-11-12 22:54:24 +110044#include "xfs_cksum.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000045#include "xfs_trace.h"
Dave Chinner33479e02012-10-08 21:56:11 +110046#include "xfs_icache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -050048STATIC int
49xlog_find_zeroed(
50 struct xlog *,
51 xfs_daddr_t *);
52STATIC int
53xlog_clear_stale_blocks(
54 struct xlog *,
55 xfs_lsn_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#if defined(DEBUG)
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -050057STATIC void
58xlog_recover_check_summary(
59 struct xlog *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#else
61#define xlog_recover_check_summary(log)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#endif
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064/*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +000065 * This structure is used during recovery to record the buf log items which
66 * have been canceled and should not be replayed.
67 */
68struct xfs_buf_cancel {
69 xfs_daddr_t bc_blkno;
70 uint bc_len;
71 int bc_refcount;
72 struct list_head bc_list;
73};
74
75/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 * Sector aligned buffer routines for buffer create/read/write/access
77 */
78
Alex Elderff30a622010-04-13 15:22:58 +100079/*
80 * Verify the given count of basic blocks is valid number of blocks
81 * to specify for an operation involving the given XFS log buffer.
82 * Returns nonzero if the count is valid, 0 otherwise.
83 */
84
85static inline int
86xlog_buf_bbcount_valid(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -050087 struct xlog *log,
Alex Elderff30a622010-04-13 15:22:58 +100088 int bbcount)
89{
90 return bbcount > 0 && bbcount <= log->l_logBBsize;
91}
92
Alex Elder36adecf2010-04-13 15:21:13 +100093/*
94 * Allocate a buffer to hold log data. The buffer needs to be able
95 * to map to a range of nbblks basic blocks at any valid (basic
96 * block) offset within the log.
97 */
Eric Sandeen5d77c0d2009-11-19 15:52:00 +000098STATIC xfs_buf_t *
Linus Torvalds1da177e2005-04-16 15:20:36 -070099xlog_get_bp(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500100 struct xlog *log,
Dave Chinner32281492009-01-22 15:37:47 +1100101 int nbblks)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
Christoph Hellwigc8da0fa2011-07-08 14:36:25 +0200103 struct xfs_buf *bp;
104
Alex Elderff30a622010-04-13 15:22:58 +1000105 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100106 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000107 nbblks);
108 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100109 return NULL;
110 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111
Alex Elder36adecf2010-04-13 15:21:13 +1000112 /*
113 * We do log I/O in units of log sectors (a power-of-2
114 * multiple of the basic block size), so we round up the
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300115 * requested size to accommodate the basic blocks required
Alex Elder36adecf2010-04-13 15:21:13 +1000116 * for complete log sectors.
117 *
118 * In addition, the buffer may be used for a non-sector-
119 * aligned block offset, in which case an I/O of the
120 * requested size could extend beyond the end of the
121 * buffer. If the requested size is only 1 basic block it
122 * will never straddle a sector boundary, so this won't be
123 * an issue. Nor will this be a problem if the log I/O is
124 * done in basic blocks (sector size 1). But otherwise we
125 * extend the buffer by one extra log sector to ensure
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300126 * there's space to accommodate this possibility.
Alex Elder36adecf2010-04-13 15:21:13 +1000127 */
Alex Elder69ce58f2010-04-20 17:09:59 +1000128 if (nbblks > 1 && log->l_sectBBsize > 1)
129 nbblks += log->l_sectBBsize;
130 nbblks = round_up(nbblks, log->l_sectBBsize);
Alex Elder36adecf2010-04-13 15:21:13 +1000131
Dave Chinnere70b73f2012-04-23 15:58:49 +1000132 bp = xfs_buf_get_uncached(log->l_mp->m_logdev_targp, nbblks, 0);
Christoph Hellwigc8da0fa2011-07-08 14:36:25 +0200133 if (bp)
134 xfs_buf_unlock(bp);
135 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
Eric Sandeen5d77c0d2009-11-19 15:52:00 +0000138STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139xlog_put_bp(
140 xfs_buf_t *bp)
141{
142 xfs_buf_free(bp);
143}
144
Alex Elder48389ef2010-04-20 17:10:21 +1000145/*
146 * Return the address of the start of the given block number's data
147 * in a log buffer. The buffer covers a log sector-aligned region.
148 */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100149STATIC xfs_caddr_t
150xlog_align(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500151 struct xlog *log,
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100152 xfs_daddr_t blk_no,
153 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500154 struct xfs_buf *bp)
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100155{
Christoph Hellwigfdc07f42010-05-10 17:28:14 +0000156 xfs_daddr_t offset = blk_no & ((xfs_daddr_t)log->l_sectBBsize - 1);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100157
Dave Chinner4e94b712012-04-23 15:58:51 +1000158 ASSERT(offset + nbblks <= bp->b_length);
Chandra Seetharaman62926042011-07-22 23:40:15 +0000159 return bp->b_addr + BBTOB(offset);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100160}
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163/*
164 * nbblks should be uint, but oh well. Just want to catch that 32-bit length.
165 */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100166STATIC int
167xlog_bread_noalign(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500168 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 xfs_daddr_t blk_no,
170 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500171 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172{
173 int error;
174
Alex Elderff30a622010-04-13 15:22:58 +1000175 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100176 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000177 nbblks);
178 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100179 return EFSCORRUPTED;
180 }
181
Alex Elder69ce58f2010-04-20 17:09:59 +1000182 blk_no = round_down(blk_no, log->l_sectBBsize);
183 nbblks = round_up(nbblks, log->l_sectBBsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185 ASSERT(nbblks > 0);
Dave Chinner4e94b712012-04-23 15:58:51 +1000186 ASSERT(nbblks <= bp->b_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
189 XFS_BUF_READ(bp);
Dave Chinneraa0e8832012-04-23 15:58:52 +1000190 bp->b_io_length = nbblks;
Dave Chinner0e95f192012-04-23 15:58:46 +1000191 bp->b_error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193 xfsbdstrat(log->l_mp, bp);
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000194 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +1000195 if (error)
Christoph Hellwig901796a2011-10-10 16:52:49 +0000196 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return error;
198}
199
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100200STATIC int
201xlog_bread(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500202 struct xlog *log,
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100203 xfs_daddr_t blk_no,
204 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500205 struct xfs_buf *bp,
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100206 xfs_caddr_t *offset)
207{
208 int error;
209
210 error = xlog_bread_noalign(log, blk_no, nbblks, bp);
211 if (error)
212 return error;
213
214 *offset = xlog_align(log, blk_no, nbblks, bp);
215 return 0;
216}
217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218/*
Dave Chinner44396472011-04-21 09:34:27 +0000219 * Read at an offset into the buffer. Returns with the buffer in it's original
220 * state regardless of the result of the read.
221 */
222STATIC int
223xlog_bread_offset(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500224 struct xlog *log,
Dave Chinner44396472011-04-21 09:34:27 +0000225 xfs_daddr_t blk_no, /* block to read from */
226 int nbblks, /* blocks to read */
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500227 struct xfs_buf *bp,
Dave Chinner44396472011-04-21 09:34:27 +0000228 xfs_caddr_t offset)
229{
Chandra Seetharaman62926042011-07-22 23:40:15 +0000230 xfs_caddr_t orig_offset = bp->b_addr;
Dave Chinner4e94b712012-04-23 15:58:51 +1000231 int orig_len = BBTOB(bp->b_length);
Dave Chinner44396472011-04-21 09:34:27 +0000232 int error, error2;
233
Chandra Seetharaman02fe03d2011-07-22 23:40:22 +0000234 error = xfs_buf_associate_memory(bp, offset, BBTOB(nbblks));
Dave Chinner44396472011-04-21 09:34:27 +0000235 if (error)
236 return error;
237
238 error = xlog_bread_noalign(log, blk_no, nbblks, bp);
239
240 /* must reset buffer pointer even on error */
Chandra Seetharaman02fe03d2011-07-22 23:40:22 +0000241 error2 = xfs_buf_associate_memory(bp, orig_offset, orig_len);
Dave Chinner44396472011-04-21 09:34:27 +0000242 if (error)
243 return error;
244 return error2;
245}
246
247/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 * Write out the buffer at the given block for the given number of blocks.
249 * The buffer is kept locked across the write and is returned locked.
250 * This can only be used for synchronous log writes.
251 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000252STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253xlog_bwrite(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500254 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 xfs_daddr_t blk_no,
256 int nbblks,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500257 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258{
259 int error;
260
Alex Elderff30a622010-04-13 15:22:58 +1000261 if (!xlog_buf_bbcount_valid(log, nbblks)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100262 xfs_warn(log->l_mp, "Invalid block length (0x%x) for buffer",
Alex Elderff30a622010-04-13 15:22:58 +1000263 nbblks);
264 XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_HIGH, log->l_mp);
Dave Chinner32281492009-01-22 15:37:47 +1100265 return EFSCORRUPTED;
266 }
267
Alex Elder69ce58f2010-04-20 17:09:59 +1000268 blk_no = round_down(blk_no, log->l_sectBBsize);
269 nbblks = round_up(nbblks, log->l_sectBBsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 ASSERT(nbblks > 0);
Dave Chinner4e94b712012-04-23 15:58:51 +1000272 ASSERT(nbblks <= bp->b_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 XFS_BUF_SET_ADDR(bp, log->l_logBBstart + blk_no);
275 XFS_BUF_ZEROFLAGS(bp);
Chandra Seetharaman72790aa2011-07-22 23:40:04 +0000276 xfs_buf_hold(bp);
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200277 xfs_buf_lock(bp);
Dave Chinneraa0e8832012-04-23 15:58:52 +1000278 bp->b_io_length = nbblks;
Dave Chinner0e95f192012-04-23 15:58:46 +1000279 bp->b_error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000281 error = xfs_bwrite(bp);
Christoph Hellwig901796a2011-10-10 16:52:49 +0000282 if (error)
283 xfs_buf_ioerror_alert(bp, __func__);
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000284 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return error;
286}
287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288#ifdef DEBUG
289/*
290 * dump debug superblock and log record information
291 */
292STATIC void
293xlog_header_check_dump(
294 xfs_mount_t *mp,
295 xlog_rec_header_t *head)
296{
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100297 xfs_debug(mp, "%s: SB : uuid = %pU, fmt = %d\n",
Joe Perches03daa572009-12-14 18:01:10 -0800298 __func__, &mp->m_sb.sb_uuid, XLOG_FMT);
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100299 xfs_debug(mp, " log : uuid = %pU, fmt = %d\n",
Joe Perches03daa572009-12-14 18:01:10 -0800300 &head->h_fs_uuid, be32_to_cpu(head->h_fmt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301}
302#else
303#define xlog_header_check_dump(mp, head)
304#endif
305
306/*
307 * check log record header for recovery
308 */
309STATIC int
310xlog_header_check_recover(
311 xfs_mount_t *mp,
312 xlog_rec_header_t *head)
313{
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200314 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
316 /*
317 * IRIX doesn't write the h_fmt field and leaves it zeroed
318 * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
319 * a dirty log created in IRIX.
320 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200321 if (unlikely(head->h_fmt != cpu_to_be32(XLOG_FMT))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100322 xfs_warn(mp,
323 "dirty log written in incompatible format - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 xlog_header_check_dump(mp, head);
325 XFS_ERROR_REPORT("xlog_header_check_recover(1)",
326 XFS_ERRLEVEL_HIGH, mp);
327 return XFS_ERROR(EFSCORRUPTED);
328 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100329 xfs_warn(mp,
330 "dirty log entry has mismatched uuid - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 xlog_header_check_dump(mp, head);
332 XFS_ERROR_REPORT("xlog_header_check_recover(2)",
333 XFS_ERRLEVEL_HIGH, mp);
334 return XFS_ERROR(EFSCORRUPTED);
335 }
336 return 0;
337}
338
339/*
340 * read the head block of the log and check the header
341 */
342STATIC int
343xlog_header_check_mount(
344 xfs_mount_t *mp,
345 xlog_rec_header_t *head)
346{
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200347 ASSERT(head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 if (uuid_is_nil(&head->h_fs_uuid)) {
350 /*
351 * IRIX doesn't write the h_fs_uuid or h_fmt fields. If
352 * h_fs_uuid is nil, we assume this log was last mounted
353 * by IRIX and continue.
354 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100355 xfs_warn(mp, "nil uuid in log - IRIX style log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 } else if (unlikely(!uuid_equal(&mp->m_sb.sb_uuid, &head->h_fs_uuid))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100357 xfs_warn(mp, "log has mismatched uuid - can't recover");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 xlog_header_check_dump(mp, head);
359 XFS_ERROR_REPORT("xlog_header_check_mount",
360 XFS_ERRLEVEL_HIGH, mp);
361 return XFS_ERROR(EFSCORRUPTED);
362 }
363 return 0;
364}
365
366STATIC void
367xlog_recover_iodone(
368 struct xfs_buf *bp)
369{
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000370 if (bp->b_error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 /*
372 * We're not going to bother about retrying
373 * this during recovery. One strike!
374 */
Christoph Hellwig901796a2011-10-10 16:52:49 +0000375 xfs_buf_ioerror_alert(bp, __func__);
Dave Chinnerebad8612010-09-22 10:47:20 +1000376 xfs_force_shutdown(bp->b_target->bt_mount,
377 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 }
Christoph Hellwigcb669ca2011-07-13 13:43:49 +0200379 bp->b_iodone = NULL;
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000380 xfs_buf_ioend(bp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381}
382
383/*
384 * This routine finds (to an approximation) the first block in the physical
385 * log which contains the given cycle. It uses a binary search algorithm.
386 * Note that the algorithm can not be perfect because the disk will not
387 * necessarily be perfect.
388 */
David Chinnera8272ce2007-11-23 16:28:09 +1100389STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390xlog_find_cycle_start(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500391 struct xlog *log,
392 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 xfs_daddr_t first_blk,
394 xfs_daddr_t *last_blk,
395 uint cycle)
396{
397 xfs_caddr_t offset;
398 xfs_daddr_t mid_blk;
Alex Eldere3bb2e32010-04-15 18:17:30 +0000399 xfs_daddr_t end_blk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 uint mid_cycle;
401 int error;
402
Alex Eldere3bb2e32010-04-15 18:17:30 +0000403 end_blk = *last_blk;
404 mid_blk = BLK_AVG(first_blk, end_blk);
405 while (mid_blk != first_blk && mid_blk != end_blk) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100406 error = xlog_bread(log, mid_blk, 1, bp, &offset);
407 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 return error;
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000409 mid_cycle = xlog_get_cycle(offset);
Alex Eldere3bb2e32010-04-15 18:17:30 +0000410 if (mid_cycle == cycle)
411 end_blk = mid_blk; /* last_half_cycle == mid_cycle */
412 else
413 first_blk = mid_blk; /* first_half_cycle == mid_cycle */
414 mid_blk = BLK_AVG(first_blk, end_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
Alex Eldere3bb2e32010-04-15 18:17:30 +0000416 ASSERT((mid_blk == first_blk && mid_blk+1 == end_blk) ||
417 (mid_blk == end_blk && mid_blk-1 == first_blk));
418
419 *last_blk = end_blk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 return 0;
422}
423
424/*
Alex Elder3f943d82010-04-15 18:17:34 +0000425 * Check that a range of blocks does not contain stop_on_cycle_no.
426 * Fill in *new_blk with the block offset where such a block is
427 * found, or with -1 (an invalid block number) if there is no such
428 * block in the range. The scan needs to occur from front to back
429 * and the pointer into the region must be updated since a later
430 * routine will need to perform another test.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 */
432STATIC int
433xlog_find_verify_cycle(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500434 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 xfs_daddr_t start_blk,
436 int nbblks,
437 uint stop_on_cycle_no,
438 xfs_daddr_t *new_blk)
439{
440 xfs_daddr_t i, j;
441 uint cycle;
442 xfs_buf_t *bp;
443 xfs_daddr_t bufblks;
444 xfs_caddr_t buf = NULL;
445 int error = 0;
446
Alex Elder6881a222010-04-13 15:22:29 +1000447 /*
448 * Greedily allocate a buffer big enough to handle the full
449 * range of basic blocks we'll be examining. If that fails,
450 * try a smaller size. We need to be able to read at least
451 * a log sector, or we're out of luck.
452 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 bufblks = 1 << ffs(nbblks);
Dave Chinner81158e02012-04-27 19:45:22 +1000454 while (bufblks > log->l_logBBsize)
455 bufblks >>= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 while (!(bp = xlog_get_bp(log, bufblks))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 bufblks >>= 1;
Alex Elder69ce58f2010-04-20 17:09:59 +1000458 if (bufblks < log->l_sectBBsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return ENOMEM;
460 }
461
462 for (i = start_blk; i < start_blk + nbblks; i += bufblks) {
463 int bcount;
464
465 bcount = min(bufblks, (start_blk + nbblks - i));
466
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100467 error = xlog_bread(log, i, bcount, bp, &buf);
468 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 goto out;
470
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 for (j = 0; j < bcount; j++) {
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000472 cycle = xlog_get_cycle(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (cycle == stop_on_cycle_no) {
474 *new_blk = i+j;
475 goto out;
476 }
477
478 buf += BBSIZE;
479 }
480 }
481
482 *new_blk = -1;
483
484out:
485 xlog_put_bp(bp);
486 return error;
487}
488
489/*
490 * Potentially backup over partial log record write.
491 *
492 * In the typical case, last_blk is the number of the block directly after
493 * a good log record. Therefore, we subtract one to get the block number
494 * of the last block in the given buffer. extra_bblks contains the number
495 * of blocks we would have read on a previous read. This happens when the
496 * last log record is split over the end of the physical log.
497 *
498 * extra_bblks is the number of blocks potentially verified on a previous
499 * call to this routine.
500 */
501STATIC int
502xlog_find_verify_log_record(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500503 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 xfs_daddr_t start_blk,
505 xfs_daddr_t *last_blk,
506 int extra_bblks)
507{
508 xfs_daddr_t i;
509 xfs_buf_t *bp;
510 xfs_caddr_t offset = NULL;
511 xlog_rec_header_t *head = NULL;
512 int error = 0;
513 int smallmem = 0;
514 int num_blks = *last_blk - start_blk;
515 int xhdrs;
516
517 ASSERT(start_blk != 0 || *last_blk != start_blk);
518
519 if (!(bp = xlog_get_bp(log, num_blks))) {
520 if (!(bp = xlog_get_bp(log, 1)))
521 return ENOMEM;
522 smallmem = 1;
523 } else {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100524 error = xlog_bread(log, start_blk, num_blks, bp, &offset);
525 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 offset += ((num_blks - 1) << BBSHIFT);
528 }
529
530 for (i = (*last_blk) - 1; i >= 0; i--) {
531 if (i < start_blk) {
532 /* valid log record not found */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100533 xfs_warn(log->l_mp,
534 "Log inconsistent (didn't find previous header)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 ASSERT(0);
536 error = XFS_ERROR(EIO);
537 goto out;
538 }
539
540 if (smallmem) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100541 error = xlog_bread(log, i, 1, bp, &offset);
542 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 }
545
546 head = (xlog_rec_header_t *)offset;
547
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200548 if (head->h_magicno == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 break;
550
551 if (!smallmem)
552 offset -= BBSIZE;
553 }
554
555 /*
556 * We hit the beginning of the physical log & still no header. Return
557 * to caller. If caller can handle a return of -1, then this routine
558 * will be called again for the end of the physical log.
559 */
560 if (i == -1) {
561 error = -1;
562 goto out;
563 }
564
565 /*
566 * We have the final block of the good log (the first block
567 * of the log record _before_ the head. So we check the uuid.
568 */
569 if ((error = xlog_header_check_mount(log->l_mp, head)))
570 goto out;
571
572 /*
573 * We may have found a log record header before we expected one.
574 * last_blk will be the 1st block # with a given cycle #. We may end
575 * up reading an entire log record. In this case, we don't want to
576 * reset last_blk. Only when last_blk points in the middle of a log
577 * record do we update last_blk.
578 */
Eric Sandeen62118702008-03-06 13:44:28 +1100579 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000580 uint h_size = be32_to_cpu(head->h_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
583 if (h_size % XLOG_HEADER_CYCLE_SIZE)
584 xhdrs++;
585 } else {
586 xhdrs = 1;
587 }
588
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000589 if (*last_blk - i + extra_bblks !=
590 BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 *last_blk = i;
592
593out:
594 xlog_put_bp(bp);
595 return error;
596}
597
598/*
599 * Head is defined to be the point of the log where the next log write
600 * write could go. This means that incomplete LR writes at the end are
601 * eliminated when calculating the head. We aren't guaranteed that previous
602 * LR have complete transactions. We only know that a cycle number of
603 * current cycle number -1 won't be present in the log if we start writing
604 * from our current block number.
605 *
606 * last_blk contains the block number of the first block with a given
607 * cycle number.
608 *
609 * Return: zero if normal, non-zero if error.
610 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000611STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612xlog_find_head(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500613 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 xfs_daddr_t *return_head_blk)
615{
616 xfs_buf_t *bp;
617 xfs_caddr_t offset;
618 xfs_daddr_t new_blk, first_blk, start_blk, last_blk, head_blk;
619 int num_scan_bblks;
620 uint first_half_cycle, last_half_cycle;
621 uint stop_on_cycle;
622 int error, log_bbnum = log->l_logBBsize;
623
624 /* Is the end of the log device zeroed? */
625 if ((error = xlog_find_zeroed(log, &first_blk)) == -1) {
626 *return_head_blk = first_blk;
627
628 /* Is the whole lot zeroed? */
629 if (!first_blk) {
630 /* Linux XFS shouldn't generate totally zeroed logs -
631 * mkfs etc write a dummy unmount record to a fresh
632 * log so we can store the uuid in there
633 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100634 xfs_warn(log->l_mp, "totally zeroed log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 }
636
637 return 0;
638 } else if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100639 xfs_warn(log->l_mp, "empty log check failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 return error;
641 }
642
643 first_blk = 0; /* get cycle # of 1st block */
644 bp = xlog_get_bp(log, 1);
645 if (!bp)
646 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100647
648 error = xlog_bread(log, 0, 1, bp, &offset);
649 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100651
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000652 first_half_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 last_blk = head_blk = log_bbnum - 1; /* get cycle # of last block */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100655 error = xlog_bread(log, last_blk, 1, bp, &offset);
656 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100658
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000659 last_half_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 ASSERT(last_half_cycle != 0);
661
662 /*
663 * If the 1st half cycle number is equal to the last half cycle number,
664 * then the entire log is stamped with the same cycle number. In this
665 * case, head_blk can't be set to zero (which makes sense). The below
666 * math doesn't work out properly with head_blk equal to zero. Instead,
667 * we set it to log_bbnum which is an invalid block number, but this
668 * value makes the math correct. If head_blk doesn't changed through
669 * all the tests below, *head_blk is set to zero at the very end rather
670 * than log_bbnum. In a sense, log_bbnum and zero are the same block
671 * in a circular file.
672 */
673 if (first_half_cycle == last_half_cycle) {
674 /*
675 * In this case we believe that the entire log should have
676 * cycle number last_half_cycle. We need to scan backwards
677 * from the end verifying that there are no holes still
678 * containing last_half_cycle - 1. If we find such a hole,
679 * then the start of that hole will be the new head. The
680 * simple case looks like
681 * x | x ... | x - 1 | x
682 * Another case that fits this picture would be
683 * x | x + 1 | x ... | x
Nathan Scottc41564b2006-03-29 08:55:14 +1000684 * In this case the head really is somewhere at the end of the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 * log, as one of the latest writes at the beginning was
686 * incomplete.
687 * One more case is
688 * x | x + 1 | x ... | x - 1 | x
689 * This is really the combination of the above two cases, and
690 * the head has to end up at the start of the x-1 hole at the
691 * end of the log.
692 *
693 * In the 256k log case, we will read from the beginning to the
694 * end of the log and search for cycle numbers equal to x-1.
695 * We don't worry about the x+1 blocks that we encounter,
696 * because we know that they cannot be the head since the log
697 * started with x.
698 */
699 head_blk = log_bbnum;
700 stop_on_cycle = last_half_cycle - 1;
701 } else {
702 /*
703 * In this case we want to find the first block with cycle
704 * number matching last_half_cycle. We expect the log to be
705 * some variation on
Alex Elder3f943d82010-04-15 18:17:34 +0000706 * x + 1 ... | x ... | x
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 * The first block with cycle number x (last_half_cycle) will
708 * be where the new head belongs. First we do a binary search
709 * for the first occurrence of last_half_cycle. The binary
710 * search may not be totally accurate, so then we scan back
711 * from there looking for occurrences of last_half_cycle before
712 * us. If that backwards scan wraps around the beginning of
713 * the log, then we look for occurrences of last_half_cycle - 1
714 * at the end of the log. The cases we're looking for look
715 * like
Alex Elder3f943d82010-04-15 18:17:34 +0000716 * v binary search stopped here
717 * x + 1 ... | x | x + 1 | x ... | x
718 * ^ but we want to locate this spot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 * or
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 * <---------> less than scan distance
Alex Elder3f943d82010-04-15 18:17:34 +0000721 * x + 1 ... | x ... | x - 1 | x
722 * ^ we want to locate this spot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 */
724 stop_on_cycle = last_half_cycle;
725 if ((error = xlog_find_cycle_start(log, bp, first_blk,
726 &head_blk, last_half_cycle)))
727 goto bp_err;
728 }
729
730 /*
731 * Now validate the answer. Scan back some number of maximum possible
732 * blocks and make sure each one has the expected cycle number. The
733 * maximum is determined by the total possible amount of buffering
734 * in the in-core log. The following number can be made tighter if
735 * we actually look at the block size of the filesystem.
736 */
737 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
738 if (head_blk >= num_scan_bblks) {
739 /*
740 * We are guaranteed that the entire check can be performed
741 * in one buffer.
742 */
743 start_blk = head_blk - num_scan_bblks;
744 if ((error = xlog_find_verify_cycle(log,
745 start_blk, num_scan_bblks,
746 stop_on_cycle, &new_blk)))
747 goto bp_err;
748 if (new_blk != -1)
749 head_blk = new_blk;
750 } else { /* need to read 2 parts of log */
751 /*
752 * We are going to scan backwards in the log in two parts.
753 * First we scan the physical end of the log. In this part
754 * of the log, we are looking for blocks with cycle number
755 * last_half_cycle - 1.
756 * If we find one, then we know that the log starts there, as
757 * we've found a hole that didn't get written in going around
758 * the end of the physical log. The simple case for this is
759 * x + 1 ... | x ... | x - 1 | x
760 * <---------> less than scan distance
761 * If all of the blocks at the end of the log have cycle number
762 * last_half_cycle, then we check the blocks at the start of
763 * the log looking for occurrences of last_half_cycle. If we
764 * find one, then our current estimate for the location of the
765 * first occurrence of last_half_cycle is wrong and we move
766 * back to the hole we've found. This case looks like
767 * x + 1 ... | x | x + 1 | x ...
768 * ^ binary search stopped here
769 * Another case we need to handle that only occurs in 256k
770 * logs is
771 * x + 1 ... | x ... | x+1 | x ...
772 * ^ binary search stops here
773 * In a 256k log, the scan at the end of the log will see the
774 * x + 1 blocks. We need to skip past those since that is
775 * certainly not the head of the log. By searching for
776 * last_half_cycle-1 we accomplish that.
777 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 ASSERT(head_blk <= INT_MAX &&
Alex Elder3f943d82010-04-15 18:17:34 +0000779 (xfs_daddr_t) num_scan_bblks >= head_blk);
780 start_blk = log_bbnum - (num_scan_bblks - head_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if ((error = xlog_find_verify_cycle(log, start_blk,
782 num_scan_bblks - (int)head_blk,
783 (stop_on_cycle - 1), &new_blk)))
784 goto bp_err;
785 if (new_blk != -1) {
786 head_blk = new_blk;
Alex Elder9db127e2010-04-15 18:17:26 +0000787 goto validate_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 }
789
790 /*
791 * Scan beginning of log now. The last part of the physical
792 * log is good. This scan needs to verify that it doesn't find
793 * the last_half_cycle.
794 */
795 start_blk = 0;
796 ASSERT(head_blk <= INT_MAX);
797 if ((error = xlog_find_verify_cycle(log,
798 start_blk, (int)head_blk,
799 stop_on_cycle, &new_blk)))
800 goto bp_err;
801 if (new_blk != -1)
802 head_blk = new_blk;
803 }
804
Alex Elder9db127e2010-04-15 18:17:26 +0000805validate_head:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 /*
807 * Now we need to make sure head_blk is not pointing to a block in
808 * the middle of a log record.
809 */
810 num_scan_bblks = XLOG_REC_SHIFT(log);
811 if (head_blk >= num_scan_bblks) {
812 start_blk = head_blk - num_scan_bblks; /* don't read head_blk */
813
814 /* start ptr at last block ptr before head_blk */
815 if ((error = xlog_find_verify_log_record(log, start_blk,
816 &head_blk, 0)) == -1) {
817 error = XFS_ERROR(EIO);
818 goto bp_err;
819 } else if (error)
820 goto bp_err;
821 } else {
822 start_blk = 0;
823 ASSERT(head_blk <= INT_MAX);
824 if ((error = xlog_find_verify_log_record(log, start_blk,
825 &head_blk, 0)) == -1) {
826 /* We hit the beginning of the log during our search */
Alex Elder3f943d82010-04-15 18:17:34 +0000827 start_blk = log_bbnum - (num_scan_bblks - head_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 new_blk = log_bbnum;
829 ASSERT(start_blk <= INT_MAX &&
830 (xfs_daddr_t) log_bbnum-start_blk >= 0);
831 ASSERT(head_blk <= INT_MAX);
832 if ((error = xlog_find_verify_log_record(log,
833 start_blk, &new_blk,
834 (int)head_blk)) == -1) {
835 error = XFS_ERROR(EIO);
836 goto bp_err;
837 } else if (error)
838 goto bp_err;
839 if (new_blk != log_bbnum)
840 head_blk = new_blk;
841 } else if (error)
842 goto bp_err;
843 }
844
845 xlog_put_bp(bp);
846 if (head_blk == log_bbnum)
847 *return_head_blk = 0;
848 else
849 *return_head_blk = head_blk;
850 /*
851 * When returning here, we have a good block number. Bad block
852 * means that during a previous crash, we didn't have a clean break
853 * from cycle number N to cycle number N-1. In this case, we need
854 * to find the first block with cycle number N-1.
855 */
856 return 0;
857
858 bp_err:
859 xlog_put_bp(bp);
860
861 if (error)
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100862 xfs_warn(log->l_mp, "failed to find log head");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 return error;
864}
865
866/*
867 * Find the sync block number or the tail of the log.
868 *
869 * This will be the block number of the last record to have its
870 * associated buffers synced to disk. Every log record header has
871 * a sync lsn embedded in it. LSNs hold block numbers, so it is easy
872 * to get a sync block number. The only concern is to figure out which
873 * log record header to believe.
874 *
875 * The following algorithm uses the log record header with the largest
876 * lsn. The entire log record does not need to be valid. We only care
877 * that the header is valid.
878 *
879 * We could speed up search by using current head_blk buffer, but it is not
880 * available.
881 */
Eric Sandeen5d77c0d2009-11-19 15:52:00 +0000882STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883xlog_find_tail(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -0500884 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 xfs_daddr_t *head_blk,
Eric Sandeen65be6052006-01-11 15:34:19 +1100886 xfs_daddr_t *tail_blk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887{
888 xlog_rec_header_t *rhead;
889 xlog_op_header_t *op_head;
890 xfs_caddr_t offset = NULL;
891 xfs_buf_t *bp;
892 int error, i, found;
893 xfs_daddr_t umount_data_blk;
894 xfs_daddr_t after_umount_blk;
895 xfs_lsn_t tail_lsn;
896 int hblks;
897
898 found = 0;
899
900 /*
901 * Find previous log record
902 */
903 if ((error = xlog_find_head(log, head_blk)))
904 return error;
905
906 bp = xlog_get_bp(log, 1);
907 if (!bp)
908 return ENOMEM;
909 if (*head_blk == 0) { /* special case */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100910 error = xlog_bread(log, 0, 1, bp, &offset);
911 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000912 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100913
Christoph Hellwig03bea6f2007-10-12 10:58:05 +1000914 if (xlog_get_cycle(offset) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 *tail_blk = 0;
916 /* leave all other log inited values alone */
Alex Elder9db127e2010-04-15 18:17:26 +0000917 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 }
919 }
920
921 /*
922 * Search backwards looking for log record header block
923 */
924 ASSERT(*head_blk < INT_MAX);
925 for (i = (int)(*head_blk) - 1; i >= 0; i--) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100926 error = xlog_bread(log, i, 1, bp, &offset);
927 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000928 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100929
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200930 if (*(__be32 *)offset == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 found = 1;
932 break;
933 }
934 }
935 /*
936 * If we haven't found the log record header block, start looking
937 * again from the end of the physical log. XXXmiken: There should be
938 * a check here to make sure we didn't search more than N blocks in
939 * the previous code.
940 */
941 if (!found) {
942 for (i = log->l_logBBsize - 1; i >= (int)(*head_blk); i--) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100943 error = xlog_bread(log, i, 1, bp, &offset);
944 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +0000945 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +0100946
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200947 if (*(__be32 *)offset ==
948 cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 found = 2;
950 break;
951 }
952 }
953 }
954 if (!found) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100955 xfs_warn(log->l_mp, "%s: couldn't find sync record", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 ASSERT(0);
957 return XFS_ERROR(EIO);
958 }
959
960 /* find blk_no of tail of log */
961 rhead = (xlog_rec_header_t *)offset;
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000962 *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
964 /*
965 * Reset log values according to the state of the log when we
966 * crashed. In the case where head_blk == 0, we bump curr_cycle
967 * one because the next write starts a new cycle rather than
968 * continuing the cycle of the last good log record. At this
969 * point we have guaranteed that all partial log records have been
970 * accounted for. Therefore, we know that the last good log record
971 * written was complete and ended exactly on the end boundary
972 * of the physical log.
973 */
974 log->l_prev_block = i;
975 log->l_curr_block = (int)*head_blk;
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000976 log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 if (found == 2)
978 log->l_curr_cycle++;
Dave Chinner1c3cb9e2010-12-21 12:28:39 +1100979 atomic64_set(&log->l_tail_lsn, be64_to_cpu(rhead->h_tail_lsn));
Dave Chinner84f3c682010-12-03 22:11:29 +1100980 atomic64_set(&log->l_last_sync_lsn, be64_to_cpu(rhead->h_lsn));
Christoph Hellwig28496962012-02-20 02:31:25 +0000981 xlog_assign_grant_head(&log->l_reserve_head.grant, log->l_curr_cycle,
Dave Chinnera69ed032010-12-21 12:08:20 +1100982 BBTOB(log->l_curr_block));
Christoph Hellwig28496962012-02-20 02:31:25 +0000983 xlog_assign_grant_head(&log->l_write_head.grant, log->l_curr_cycle,
Dave Chinnera69ed032010-12-21 12:08:20 +1100984 BBTOB(log->l_curr_block));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
986 /*
987 * Look for unmount record. If we find it, then we know there
988 * was a clean unmount. Since 'i' could be the last block in
989 * the physical log, we convert to a log block before comparing
990 * to the head_blk.
991 *
992 * Save the current tail lsn to use to pass to
993 * xlog_clear_stale_blocks() below. We won't want to clear the
994 * unmount record if there is one, so we pass the lsn of the
995 * unmount record rather than the block after it.
996 */
Eric Sandeen62118702008-03-06 13:44:28 +1100997 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +1000998 int h_size = be32_to_cpu(rhead->h_size);
999 int h_version = be32_to_cpu(rhead->h_version);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 if ((h_version & XLOG_VERSION_2) &&
1002 (h_size > XLOG_HEADER_CYCLE_SIZE)) {
1003 hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
1004 if (h_size % XLOG_HEADER_CYCLE_SIZE)
1005 hblks++;
1006 } else {
1007 hblks = 1;
1008 }
1009 } else {
1010 hblks = 1;
1011 }
1012 after_umount_blk = (i + hblks + (int)
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001013 BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
Dave Chinner1c3cb9e2010-12-21 12:28:39 +11001014 tail_lsn = atomic64_read(&log->l_tail_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 if (*head_blk == after_umount_blk &&
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001016 be32_to_cpu(rhead->h_num_logops) == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 umount_data_blk = (i + hblks) % log->l_logBBsize;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001018 error = xlog_bread(log, umount_data_blk, 1, bp, &offset);
1019 if (error)
Alex Elder9db127e2010-04-15 18:17:26 +00001020 goto done;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 op_head = (xlog_op_header_t *)offset;
1023 if (op_head->oh_flags & XLOG_UNMOUNT_TRANS) {
1024 /*
1025 * Set tail and last sync so that newly written
1026 * log records will point recovery to after the
1027 * current unmount record.
1028 */
Dave Chinner1c3cb9e2010-12-21 12:28:39 +11001029 xlog_assign_atomic_lsn(&log->l_tail_lsn,
1030 log->l_curr_cycle, after_umount_blk);
1031 xlog_assign_atomic_lsn(&log->l_last_sync_lsn,
1032 log->l_curr_cycle, after_umount_blk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 *tail_blk = after_umount_blk;
David Chinner92821e22007-05-24 15:26:31 +10001034
1035 /*
1036 * Note that the unmount was clean. If the unmount
1037 * was not clean, we need to know this to rebuild the
1038 * superblock counters from the perag headers if we
1039 * have a filesystem using non-persistent counters.
1040 */
1041 log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 }
1043 }
1044
1045 /*
1046 * Make sure that there are no blocks in front of the head
1047 * with the same cycle number as the head. This can happen
1048 * because we allow multiple outstanding log writes concurrently,
1049 * and the later writes might make it out before earlier ones.
1050 *
1051 * We use the lsn from before modifying it so that we'll never
1052 * overwrite the unmount record after a clean unmount.
1053 *
1054 * Do this only if we are going to recover the filesystem
1055 *
1056 * NOTE: This used to say "if (!readonly)"
1057 * However on Linux, we can & do recover a read-only filesystem.
1058 * We only skip recovery if NORECOVERY is specified on mount,
1059 * in which case we would not be here.
1060 *
1061 * But... if the -device- itself is readonly, just skip this.
1062 * We can't recover this device anyway, so it won't matter.
1063 */
Alex Elder9db127e2010-04-15 18:17:26 +00001064 if (!xfs_readonly_buftarg(log->l_mp->m_logdev_targp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 error = xlog_clear_stale_blocks(log, tail_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
Alex Elder9db127e2010-04-15 18:17:26 +00001067done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 xlog_put_bp(bp);
1069
1070 if (error)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001071 xfs_warn(log->l_mp, "failed to locate log tail");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 return error;
1073}
1074
1075/*
1076 * Is the log zeroed at all?
1077 *
1078 * The last binary search should be changed to perform an X block read
1079 * once X becomes small enough. You can then search linearly through
1080 * the X blocks. This will cut down on the number of reads we need to do.
1081 *
1082 * If the log is partially zeroed, this routine will pass back the blkno
1083 * of the first block with cycle number 0. It won't have a complete LR
1084 * preceding it.
1085 *
1086 * Return:
1087 * 0 => the log is completely written to
1088 * -1 => use *blk_no as the first block of the log
1089 * >0 => error has occurred
1090 */
David Chinnera8272ce2007-11-23 16:28:09 +11001091STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092xlog_find_zeroed(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001093 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 xfs_daddr_t *blk_no)
1095{
1096 xfs_buf_t *bp;
1097 xfs_caddr_t offset;
1098 uint first_cycle, last_cycle;
1099 xfs_daddr_t new_blk, last_blk, start_blk;
1100 xfs_daddr_t num_scan_bblks;
1101 int error, log_bbnum = log->l_logBBsize;
1102
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10001103 *blk_no = 0;
1104
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 /* check totally zeroed log */
1106 bp = xlog_get_bp(log, 1);
1107 if (!bp)
1108 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001109 error = xlog_bread(log, 0, 1, bp, &offset);
1110 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001112
Christoph Hellwig03bea6f2007-10-12 10:58:05 +10001113 first_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 if (first_cycle == 0) { /* completely zeroed log */
1115 *blk_no = 0;
1116 xlog_put_bp(bp);
1117 return -1;
1118 }
1119
1120 /* check partially zeroed log */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001121 error = xlog_bread(log, log_bbnum-1, 1, bp, &offset);
1122 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 goto bp_err;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001124
Christoph Hellwig03bea6f2007-10-12 10:58:05 +10001125 last_cycle = xlog_get_cycle(offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 if (last_cycle != 0) { /* log completely written to */
1127 xlog_put_bp(bp);
1128 return 0;
1129 } else if (first_cycle != 1) {
1130 /*
1131 * If the cycle of the last block is zero, the cycle of
1132 * the first block must be 1. If it's not, maybe we're
1133 * not looking at a log... Bail out.
1134 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001135 xfs_warn(log->l_mp,
1136 "Log inconsistent or not a log (last==0, first!=1)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 return XFS_ERROR(EINVAL);
1138 }
1139
1140 /* we have a partially zeroed log */
1141 last_blk = log_bbnum-1;
1142 if ((error = xlog_find_cycle_start(log, bp, 0, &last_blk, 0)))
1143 goto bp_err;
1144
1145 /*
1146 * Validate the answer. Because there is no way to guarantee that
1147 * the entire log is made up of log records which are the same size,
1148 * we scan over the defined maximum blocks. At this point, the maximum
1149 * is not chosen to mean anything special. XXXmiken
1150 */
1151 num_scan_bblks = XLOG_TOTAL_REC_SHIFT(log);
1152 ASSERT(num_scan_bblks <= INT_MAX);
1153
1154 if (last_blk < num_scan_bblks)
1155 num_scan_bblks = last_blk;
1156 start_blk = last_blk - num_scan_bblks;
1157
1158 /*
1159 * We search for any instances of cycle number 0 that occur before
1160 * our current estimate of the head. What we're trying to detect is
1161 * 1 ... | 0 | 1 | 0...
1162 * ^ binary search ends here
1163 */
1164 if ((error = xlog_find_verify_cycle(log, start_blk,
1165 (int)num_scan_bblks, 0, &new_blk)))
1166 goto bp_err;
1167 if (new_blk != -1)
1168 last_blk = new_blk;
1169
1170 /*
1171 * Potentially backup over partial log record write. We don't need
1172 * to search the end of the log because we know it is zero.
1173 */
1174 if ((error = xlog_find_verify_log_record(log, start_blk,
1175 &last_blk, 0)) == -1) {
1176 error = XFS_ERROR(EIO);
1177 goto bp_err;
1178 } else if (error)
1179 goto bp_err;
1180
1181 *blk_no = last_blk;
1182bp_err:
1183 xlog_put_bp(bp);
1184 if (error)
1185 return error;
1186 return -1;
1187}
1188
1189/*
1190 * These are simple subroutines used by xlog_clear_stale_blocks() below
1191 * to initialize a buffer full of empty log record headers and write
1192 * them into the log.
1193 */
1194STATIC void
1195xlog_add_record(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001196 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 xfs_caddr_t buf,
1198 int cycle,
1199 int block,
1200 int tail_cycle,
1201 int tail_block)
1202{
1203 xlog_rec_header_t *recp = (xlog_rec_header_t *)buf;
1204
1205 memset(buf, 0, BBSIZE);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001206 recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
1207 recp->h_cycle = cpu_to_be32(cycle);
1208 recp->h_version = cpu_to_be32(
Eric Sandeen62118702008-03-06 13:44:28 +11001209 xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10001210 recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
1211 recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
1212 recp->h_fmt = cpu_to_be32(XLOG_FMT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
1214}
1215
1216STATIC int
1217xlog_write_log_records(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001218 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 int cycle,
1220 int start_block,
1221 int blocks,
1222 int tail_cycle,
1223 int tail_block)
1224{
1225 xfs_caddr_t offset;
1226 xfs_buf_t *bp;
1227 int balign, ealign;
Alex Elder69ce58f2010-04-20 17:09:59 +10001228 int sectbb = log->l_sectBBsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 int end_block = start_block + blocks;
1230 int bufblks;
1231 int error = 0;
1232 int i, j = 0;
1233
Alex Elder6881a222010-04-13 15:22:29 +10001234 /*
1235 * Greedily allocate a buffer big enough to handle the full
1236 * range of basic blocks to be written. If that fails, try
1237 * a smaller size. We need to be able to write at least a
1238 * log sector, or we're out of luck.
1239 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 bufblks = 1 << ffs(blocks);
Dave Chinner81158e02012-04-27 19:45:22 +10001241 while (bufblks > log->l_logBBsize)
1242 bufblks >>= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 while (!(bp = xlog_get_bp(log, bufblks))) {
1244 bufblks >>= 1;
Alex Elder69ce58f2010-04-20 17:09:59 +10001245 if (bufblks < sectbb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 return ENOMEM;
1247 }
1248
1249 /* We may need to do a read at the start to fill in part of
1250 * the buffer in the starting sector not covered by the first
1251 * write below.
1252 */
Alex Elder5c17f532010-04-13 15:22:48 +10001253 balign = round_down(start_block, sectbb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 if (balign != start_block) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001255 error = xlog_bread_noalign(log, start_block, 1, bp);
1256 if (error)
1257 goto out_put_bp;
1258
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 j = start_block - balign;
1260 }
1261
1262 for (i = start_block; i < end_block; i += bufblks) {
1263 int bcount, endcount;
1264
1265 bcount = min(bufblks, end_block - start_block);
1266 endcount = bcount - j;
1267
1268 /* We may need to do a read at the end to fill in part of
1269 * the buffer in the final sector not covered by the write.
1270 * If this is the same sector as the above read, skip it.
1271 */
Alex Elder5c17f532010-04-13 15:22:48 +10001272 ealign = round_down(end_block, sectbb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 if (j == 0 && (start_block + endcount > ealign)) {
Chandra Seetharaman62926042011-07-22 23:40:15 +00001274 offset = bp->b_addr + BBTOB(ealign - start_block);
Dave Chinner44396472011-04-21 09:34:27 +00001275 error = xlog_bread_offset(log, ealign, sectbb,
1276 bp, offset);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001277 if (error)
1278 break;
1279
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
1281
1282 offset = xlog_align(log, start_block, endcount, bp);
1283 for (; j < endcount; j++) {
1284 xlog_add_record(log, offset, cycle, i+j,
1285 tail_cycle, tail_block);
1286 offset += BBSIZE;
1287 }
1288 error = xlog_bwrite(log, start_block, endcount, bp);
1289 if (error)
1290 break;
1291 start_block += endcount;
1292 j = 0;
1293 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01001294
1295 out_put_bp:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 xlog_put_bp(bp);
1297 return error;
1298}
1299
1300/*
1301 * This routine is called to blow away any incomplete log writes out
1302 * in front of the log head. We do this so that we won't become confused
1303 * if we come up, write only a little bit more, and then crash again.
1304 * If we leave the partial log records out there, this situation could
1305 * cause us to think those partial writes are valid blocks since they
1306 * have the current cycle number. We get rid of them by overwriting them
1307 * with empty log records with the old cycle number rather than the
1308 * current one.
1309 *
1310 * The tail lsn is passed in rather than taken from
1311 * the log so that we will not write over the unmount record after a
1312 * clean unmount in a 512 block log. Doing so would leave the log without
1313 * any valid log records in it until a new one was written. If we crashed
1314 * during that time we would not be able to recover.
1315 */
1316STATIC int
1317xlog_clear_stale_blocks(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05001318 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 xfs_lsn_t tail_lsn)
1320{
1321 int tail_cycle, head_cycle;
1322 int tail_block, head_block;
1323 int tail_distance, max_distance;
1324 int distance;
1325 int error;
1326
1327 tail_cycle = CYCLE_LSN(tail_lsn);
1328 tail_block = BLOCK_LSN(tail_lsn);
1329 head_cycle = log->l_curr_cycle;
1330 head_block = log->l_curr_block;
1331
1332 /*
1333 * Figure out the distance between the new head of the log
1334 * and the tail. We want to write over any blocks beyond the
1335 * head that we may have written just before the crash, but
1336 * we don't want to overwrite the tail of the log.
1337 */
1338 if (head_cycle == tail_cycle) {
1339 /*
1340 * The tail is behind the head in the physical log,
1341 * so the distance from the head to the tail is the
1342 * distance from the head to the end of the log plus
1343 * the distance from the beginning of the log to the
1344 * tail.
1345 */
1346 if (unlikely(head_block < tail_block || head_block >= log->l_logBBsize)) {
1347 XFS_ERROR_REPORT("xlog_clear_stale_blocks(1)",
1348 XFS_ERRLEVEL_LOW, log->l_mp);
1349 return XFS_ERROR(EFSCORRUPTED);
1350 }
1351 tail_distance = tail_block + (log->l_logBBsize - head_block);
1352 } else {
1353 /*
1354 * The head is behind the tail in the physical log,
1355 * so the distance from the head to the tail is just
1356 * the tail block minus the head block.
1357 */
1358 if (unlikely(head_block >= tail_block || head_cycle != (tail_cycle + 1))){
1359 XFS_ERROR_REPORT("xlog_clear_stale_blocks(2)",
1360 XFS_ERRLEVEL_LOW, log->l_mp);
1361 return XFS_ERROR(EFSCORRUPTED);
1362 }
1363 tail_distance = tail_block - head_block;
1364 }
1365
1366 /*
1367 * If the head is right up against the tail, we can't clear
1368 * anything.
1369 */
1370 if (tail_distance <= 0) {
1371 ASSERT(tail_distance == 0);
1372 return 0;
1373 }
1374
1375 max_distance = XLOG_TOTAL_REC_SHIFT(log);
1376 /*
1377 * Take the smaller of the maximum amount of outstanding I/O
1378 * we could have and the distance to the tail to clear out.
1379 * We take the smaller so that we don't overwrite the tail and
1380 * we don't waste all day writing from the head to the tail
1381 * for no reason.
1382 */
1383 max_distance = MIN(max_distance, tail_distance);
1384
1385 if ((head_block + max_distance) <= log->l_logBBsize) {
1386 /*
1387 * We can stomp all the blocks we need to without
1388 * wrapping around the end of the log. Just do it
1389 * in a single write. Use the cycle number of the
1390 * current cycle minus one so that the log will look like:
1391 * n ... | n - 1 ...
1392 */
1393 error = xlog_write_log_records(log, (head_cycle - 1),
1394 head_block, max_distance, tail_cycle,
1395 tail_block);
1396 if (error)
1397 return error;
1398 } else {
1399 /*
1400 * We need to wrap around the end of the physical log in
1401 * order to clear all the blocks. Do it in two separate
1402 * I/Os. The first write should be from the head to the
1403 * end of the physical log, and it should use the current
1404 * cycle number minus one just like above.
1405 */
1406 distance = log->l_logBBsize - head_block;
1407 error = xlog_write_log_records(log, (head_cycle - 1),
1408 head_block, distance, tail_cycle,
1409 tail_block);
1410
1411 if (error)
1412 return error;
1413
1414 /*
1415 * Now write the blocks at the start of the physical log.
1416 * This writes the remainder of the blocks we want to clear.
1417 * It uses the current cycle number since we're now on the
1418 * same cycle as the head so that we get:
1419 * n ... n ... | n - 1 ...
1420 * ^^^^^ blocks we're writing
1421 */
1422 distance = max_distance - (log->l_logBBsize - head_block);
1423 error = xlog_write_log_records(log, head_cycle, 0, distance,
1424 tail_cycle, tail_block);
1425 if (error)
1426 return error;
1427 }
1428
1429 return 0;
1430}
1431
1432/******************************************************************************
1433 *
1434 * Log recover routines
1435 *
1436 ******************************************************************************
1437 */
1438
1439STATIC xlog_recover_t *
1440xlog_recover_find_tid(
Dave Chinnerf0a76952010-01-11 11:49:57 +00001441 struct hlist_head *head,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 xlog_tid_t tid)
1443{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001444 xlog_recover_t *trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
Sasha Levinb67bfe02013-02-27 17:06:00 -08001446 hlist_for_each_entry(trans, head, r_list) {
Dave Chinnerf0a76952010-01-11 11:49:57 +00001447 if (trans->r_log_tid == tid)
1448 return trans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001450 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451}
1452
1453STATIC void
Dave Chinnerf0a76952010-01-11 11:49:57 +00001454xlog_recover_new_tid(
1455 struct hlist_head *head,
1456 xlog_tid_t tid,
1457 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001459 xlog_recover_t *trans;
1460
1461 trans = kmem_zalloc(sizeof(xlog_recover_t), KM_SLEEP);
1462 trans->r_log_tid = tid;
1463 trans->r_lsn = lsn;
1464 INIT_LIST_HEAD(&trans->r_itemq);
1465
1466 INIT_HLIST_NODE(&trans->r_list);
1467 hlist_add_head(&trans->r_list, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468}
1469
1470STATIC void
1471xlog_recover_add_item(
Dave Chinnerf0a76952010-01-11 11:49:57 +00001472 struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473{
1474 xlog_recover_item_t *item;
1475
1476 item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001477 INIT_LIST_HEAD(&item->ri_list);
1478 list_add_tail(&item->ri_list, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479}
1480
1481STATIC int
1482xlog_recover_add_to_cont_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001483 struct xlog *log,
1484 struct xlog_recover *trans,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 xfs_caddr_t dp,
1486 int len)
1487{
1488 xlog_recover_item_t *item;
1489 xfs_caddr_t ptr, old_ptr;
1490 int old_len;
1491
Dave Chinnerf0a76952010-01-11 11:49:57 +00001492 if (list_empty(&trans->r_itemq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 /* finish copying rest of trans header */
1494 xlog_recover_add_item(&trans->r_itemq);
1495 ptr = (xfs_caddr_t) &trans->r_theader +
1496 sizeof(xfs_trans_header_t) - len;
1497 memcpy(ptr, dp, len); /* d, s, l */
1498 return 0;
1499 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001500 /* take the tail entry */
1501 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
1503 old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
1504 old_len = item->ri_buf[item->ri_cnt-1].i_len;
1505
Mitsuo Hayasaka45053602012-01-27 06:37:26 +00001506 ptr = kmem_realloc(old_ptr, len+old_len, old_len, KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 memcpy(&ptr[old_len], dp, len); /* d, s, l */
1508 item->ri_buf[item->ri_cnt-1].i_len += len;
1509 item->ri_buf[item->ri_cnt-1].i_addr = ptr;
Dave Chinner9abbc532010-04-13 15:06:46 +10001510 trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 return 0;
1512}
1513
1514/*
1515 * The next region to add is the start of a new region. It could be
1516 * a whole region or it could be the first part of a new region. Because
1517 * of this, the assumption here is that the type and size fields of all
1518 * format structures fit into the first 32 bits of the structure.
1519 *
1520 * This works because all regions must be 32 bit aligned. Therefore, we
1521 * either have both fields or we have neither field. In the case we have
1522 * neither field, the data part of the region is zero length. We only have
1523 * a log_op_header and can throw away the header since a new one will appear
1524 * later. If we have at least 4 bytes, then we can determine how many regions
1525 * will appear in the current log item.
1526 */
1527STATIC int
1528xlog_recover_add_to_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001529 struct xlog *log,
1530 struct xlog_recover *trans,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 xfs_caddr_t dp,
1532 int len)
1533{
1534 xfs_inode_log_format_t *in_f; /* any will do */
1535 xlog_recover_item_t *item;
1536 xfs_caddr_t ptr;
1537
1538 if (!len)
1539 return 0;
Dave Chinnerf0a76952010-01-11 11:49:57 +00001540 if (list_empty(&trans->r_itemq)) {
David Chinner5a792c42008-10-30 17:40:09 +11001541 /* we need to catch log corruptions here */
1542 if (*(uint *)dp != XFS_TRANS_HEADER_MAGIC) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001543 xfs_warn(log->l_mp, "%s: bad header magic number",
1544 __func__);
David Chinner5a792c42008-10-30 17:40:09 +11001545 ASSERT(0);
1546 return XFS_ERROR(EIO);
1547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 if (len == sizeof(xfs_trans_header_t))
1549 xlog_recover_add_item(&trans->r_itemq);
1550 memcpy(&trans->r_theader, dp, len); /* d, s, l */
1551 return 0;
1552 }
1553
1554 ptr = kmem_alloc(len, KM_SLEEP);
1555 memcpy(ptr, dp, len);
1556 in_f = (xfs_inode_log_format_t *)ptr;
1557
Dave Chinnerf0a76952010-01-11 11:49:57 +00001558 /* take the tail entry */
1559 item = list_entry(trans->r_itemq.prev, xlog_recover_item_t, ri_list);
1560 if (item->ri_total != 0 &&
1561 item->ri_total == item->ri_cnt) {
1562 /* tail item is in use, get a new one */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 xlog_recover_add_item(&trans->r_itemq);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001564 item = list_entry(trans->r_itemq.prev,
1565 xlog_recover_item_t, ri_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567
1568 if (item->ri_total == 0) { /* first region to be added */
Christoph Hellwige8fa6b42009-03-03 14:48:36 -05001569 if (in_f->ilf_size == 0 ||
1570 in_f->ilf_size > XLOG_MAX_REGIONS_IN_ITEM) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001571 xfs_warn(log->l_mp,
1572 "bad number of regions (%d) in inode log format",
Christoph Hellwige8fa6b42009-03-03 14:48:36 -05001573 in_f->ilf_size);
1574 ASSERT(0);
1575 return XFS_ERROR(EIO);
1576 }
1577
1578 item->ri_total = in_f->ilf_size;
1579 item->ri_buf =
1580 kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
1581 KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 }
1583 ASSERT(item->ri_total > item->ri_cnt);
1584 /* Description region is ri_buf[0] */
1585 item->ri_buf[item->ri_cnt].i_addr = ptr;
1586 item->ri_buf[item->ri_cnt].i_len = len;
1587 item->ri_cnt++;
Dave Chinner9abbc532010-04-13 15:06:46 +10001588 trace_xfs_log_recover_item_add(log, trans, item, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 return 0;
1590}
1591
Dave Chinnerf0a76952010-01-11 11:49:57 +00001592/*
1593 * Sort the log items in the transaction. Cancelled buffers need
1594 * to be put first so they are processed before any items that might
1595 * modify the buffers. If they are cancelled, then the modifications
1596 * don't need to be replayed.
1597 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598STATIC int
1599xlog_recover_reorder_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001600 struct xlog *log,
1601 struct xlog_recover *trans,
Dave Chinner9abbc532010-04-13 15:06:46 +10001602 int pass)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603{
Dave Chinnerf0a76952010-01-11 11:49:57 +00001604 xlog_recover_item_t *item, *n;
1605 LIST_HEAD(sort_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
Dave Chinnerf0a76952010-01-11 11:49:57 +00001607 list_splice_init(&trans->r_itemq, &sort_list);
1608 list_for_each_entry_safe(item, n, &sort_list, ri_list) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10001609 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Dave Chinnerf0a76952010-01-11 11:49:57 +00001610
1611 switch (ITEM_TYPE(item)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 case XFS_LI_BUF:
Dave Chinnerc1155412010-05-07 11:05:19 +10001613 if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
Dave Chinner9abbc532010-04-13 15:06:46 +10001614 trace_xfs_log_recover_item_reorder_head(log,
1615 trans, item, pass);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001616 list_move(&item->ri_list, &trans->r_itemq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 break;
1618 }
1619 case XFS_LI_INODE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 case XFS_LI_DQUOT:
1621 case XFS_LI_QUOTAOFF:
1622 case XFS_LI_EFD:
1623 case XFS_LI_EFI:
Dave Chinner9abbc532010-04-13 15:06:46 +10001624 trace_xfs_log_recover_item_reorder_tail(log,
1625 trans, item, pass);
Dave Chinnerf0a76952010-01-11 11:49:57 +00001626 list_move_tail(&item->ri_list, &trans->r_itemq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 break;
1628 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001629 xfs_warn(log->l_mp,
1630 "%s: unrecognized type of log operation",
1631 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 ASSERT(0);
1633 return XFS_ERROR(EIO);
1634 }
Dave Chinnerf0a76952010-01-11 11:49:57 +00001635 }
1636 ASSERT(list_empty(&sort_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 return 0;
1638}
1639
1640/*
1641 * Build up the table of buf cancel records so that we don't replay
1642 * cancelled data in the second pass. For buffer records that are
1643 * not cancel records, there is nothing to do here so we just return.
1644 *
1645 * If we get a cancel record which is already in the table, this indicates
1646 * that the buffer was cancelled multiple times. In order to ensure
1647 * that during pass 2 we keep the record in the table until we reach its
1648 * last occurrence in the log, we keep a reference count in the cancel
1649 * record in the table to tell us how many times we expect to see this
1650 * record during the second pass.
1651 */
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001652STATIC int
1653xlog_recover_buffer_pass1(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001654 struct xlog *log,
1655 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001657 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001658 struct list_head *bucket;
1659 struct xfs_buf_cancel *bcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661 /*
1662 * If this isn't a cancel buffer item, then just return.
1663 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001664 if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
Dave Chinner9abbc532010-04-13 15:06:46 +10001665 trace_xfs_log_recover_buf_not_cancel(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001666 return 0;
Dave Chinner9abbc532010-04-13 15:06:46 +10001667 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
1669 /*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001670 * Insert an xfs_buf_cancel record into the hash table of them.
1671 * If there is already an identical record, bump its reference count.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 */
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001673 bucket = XLOG_BUF_CANCEL_BUCKET(log, buf_f->blf_blkno);
1674 list_for_each_entry(bcp, bucket, bc_list) {
1675 if (bcp->bc_blkno == buf_f->blf_blkno &&
1676 bcp->bc_len == buf_f->blf_len) {
1677 bcp->bc_refcount++;
Dave Chinner9abbc532010-04-13 15:06:46 +10001678 trace_xfs_log_recover_buf_cancel_ref_inc(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001679 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 }
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001682
1683 bcp = kmem_alloc(sizeof(struct xfs_buf_cancel), KM_SLEEP);
1684 bcp->bc_blkno = buf_f->blf_blkno;
1685 bcp->bc_len = buf_f->blf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 bcp->bc_refcount = 1;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001687 list_add_tail(&bcp->bc_list, bucket);
1688
Dave Chinner9abbc532010-04-13 15:06:46 +10001689 trace_xfs_log_recover_buf_cancel_add(log, buf_f);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00001690 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691}
1692
1693/*
1694 * Check to see whether the buffer being recovered has a corresponding
1695 * entry in the buffer cancel record table. If it does then return 1
1696 * so that it will be cancelled, otherwise return 0. If the buffer is
Dave Chinnerc1155412010-05-07 11:05:19 +10001697 * actually a buffer cancel item (XFS_BLF_CANCEL is set), then decrement
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 * the refcount on the entry in the table and remove it from the table
1699 * if this is the last reference.
1700 *
1701 * We remove the cancel record from the table when we encounter its
1702 * last occurrence in the log so that if the same buffer is re-used
1703 * again after its last cancellation we actually replay the changes
1704 * made at that point.
1705 */
1706STATIC int
1707xlog_check_buffer_cancelled(
Mark Tinguelyad223e62012-06-14 09:22:15 -05001708 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 xfs_daddr_t blkno,
1710 uint len,
1711 ushort flags)
1712{
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001713 struct list_head *bucket;
1714 struct xfs_buf_cancel *bcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715
1716 if (log->l_buf_cancel_table == NULL) {
1717 /*
1718 * There is nothing in the table built in pass one,
1719 * so this buffer must not be cancelled.
1720 */
Dave Chinnerc1155412010-05-07 11:05:19 +10001721 ASSERT(!(flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 return 0;
1723 }
1724
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001725 /*
1726 * Search for an entry in the cancel table that matches our buffer.
1727 */
1728 bucket = XLOG_BUF_CANCEL_BUCKET(log, blkno);
1729 list_for_each_entry(bcp, bucket, bc_list) {
1730 if (bcp->bc_blkno == blkno && bcp->bc_len == len)
1731 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 }
1733
1734 /*
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001735 * We didn't find a corresponding entry in the table, so return 0 so
1736 * that the buffer is NOT cancelled.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 */
Dave Chinnerc1155412010-05-07 11:05:19 +10001738 ASSERT(!(flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 return 0;
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00001740
1741found:
1742 /*
1743 * We've go a match, so return 1 so that the recovery of this buffer
1744 * is cancelled. If this buffer is actually a buffer cancel log
1745 * item, then decrement the refcount on the one in the table and
1746 * remove it if this is the last reference.
1747 */
1748 if (flags & XFS_BLF_CANCEL) {
1749 if (--bcp->bc_refcount == 0) {
1750 list_del(&bcp->bc_list);
1751 kmem_free(bcp);
1752 }
1753 }
1754 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755}
1756
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757/*
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001758 * Perform recovery for a buffer full of inodes. In these buffers, the only
1759 * data which should be recovered is that which corresponds to the
1760 * di_next_unlinked pointers in the on disk inode structures. The rest of the
1761 * data for the inodes is always logged through the inodes themselves rather
1762 * than the inode buffer and is recovered in xlog_recover_inode_pass2().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 *
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001764 * The only time when buffers full of inodes are fully recovered is when the
1765 * buffer is full of newly allocated inodes. In this case the buffer will
1766 * not be marked as an inode buffer and so will be sent to
1767 * xlog_recover_do_reg_buffer() below during recovery.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 */
1769STATIC int
1770xlog_recover_do_inode_buffer(
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001771 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 xlog_recover_item_t *item,
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001773 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 xfs_buf_log_format_t *buf_f)
1775{
1776 int i;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001777 int item_index = 0;
1778 int bit = 0;
1779 int nbits = 0;
1780 int reg_buf_offset = 0;
1781 int reg_buf_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 int next_unlinked_offset;
1783 int inodes_per_buf;
1784 xfs_agino_t *logged_nextp;
1785 xfs_agino_t *buffer_nextp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786
Dave Chinner9abbc532010-04-13 15:06:46 +10001787 trace_xfs_log_recover_buf_inode_buf(mp->m_log, buf_f);
1788
Dave Chinneraa0e8832012-04-23 15:58:52 +10001789 inodes_per_buf = BBTOB(bp->b_io_length) >> mp->m_sb.sb_inodelog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 for (i = 0; i < inodes_per_buf; i++) {
1791 next_unlinked_offset = (i * mp->m_sb.sb_inodesize) +
1792 offsetof(xfs_dinode_t, di_next_unlinked);
1793
1794 while (next_unlinked_offset >=
1795 (reg_buf_offset + reg_buf_bytes)) {
1796 /*
1797 * The next di_next_unlinked field is beyond
1798 * the current logged region. Find the next
1799 * logged region that contains or is beyond
1800 * the current di_next_unlinked field.
1801 */
1802 bit += nbits;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001803 bit = xfs_next_bit(buf_f->blf_data_map,
1804 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
1806 /*
1807 * If there are no more logged regions in the
1808 * buffer, then we're done.
1809 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001810 if (bit == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001813 nbits = xfs_contig_bits(buf_f->blf_data_map,
1814 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 ASSERT(nbits > 0);
Dave Chinnerc1155412010-05-07 11:05:19 +10001816 reg_buf_offset = bit << XFS_BLF_SHIFT;
1817 reg_buf_bytes = nbits << XFS_BLF_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 item_index++;
1819 }
1820
1821 /*
1822 * If the current logged region starts after the current
1823 * di_next_unlinked field, then move on to the next
1824 * di_next_unlinked field.
1825 */
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001826 if (next_unlinked_offset < reg_buf_offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
1829 ASSERT(item->ri_buf[item_index].i_addr != NULL);
Dave Chinnerc1155412010-05-07 11:05:19 +10001830 ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
Dave Chinneraa0e8832012-04-23 15:58:52 +10001831 ASSERT((reg_buf_offset + reg_buf_bytes) <=
1832 BBTOB(bp->b_io_length));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833
1834 /*
1835 * The current logged region contains a copy of the
1836 * current di_next_unlinked field. Extract its value
1837 * and copy it to the buffer copy.
1838 */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10001839 logged_nextp = item->ri_buf[item_index].i_addr +
1840 next_unlinked_offset - reg_buf_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 if (unlikely(*logged_nextp == 0)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001842 xfs_alert(mp,
1843 "Bad inode buffer log record (ptr = 0x%p, bp = 0x%p). "
1844 "Trying to replay bad (0) inode di_next_unlinked field.",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 item, bp);
1846 XFS_ERROR_REPORT("xlog_recover_do_inode_buf",
1847 XFS_ERRLEVEL_LOW, mp);
1848 return XFS_ERROR(EFSCORRUPTED);
1849 }
1850
1851 buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
1852 next_unlinked_offset);
Tim Shimmin87c199c2006-06-09 14:56:16 +10001853 *buffer_nextp = *logged_nextp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 }
1855
1856 return 0;
1857}
1858
1859/*
1860 * Perform a 'normal' buffer recovery. Each logged region of the
1861 * buffer should be copied over the corresponding region in the
1862 * given buffer. The bitmap in the buf log format structure indicates
1863 * where to place the logged data.
1864 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865STATIC void
1866xlog_recover_do_reg_buffer(
Dave Chinner9abbc532010-04-13 15:06:46 +10001867 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 xlog_recover_item_t *item,
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001869 struct xfs_buf *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 xfs_buf_log_format_t *buf_f)
1871{
1872 int i;
1873 int bit;
1874 int nbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 int error;
1876
Dave Chinner9abbc532010-04-13 15:06:46 +10001877 trace_xfs_log_recover_buf_reg_buf(mp->m_log, buf_f);
1878
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 bit = 0;
1880 i = 1; /* 0 is the buf format structure */
1881 while (1) {
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001882 bit = xfs_next_bit(buf_f->blf_data_map,
1883 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 if (bit == -1)
1885 break;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00001886 nbits = xfs_contig_bits(buf_f->blf_data_map,
1887 buf_f->blf_map_size, bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 ASSERT(nbits > 0);
Christoph Hellwig4b809162007-08-16 15:37:36 +10001889 ASSERT(item->ri_buf[i].i_addr != NULL);
Dave Chinnerc1155412010-05-07 11:05:19 +10001890 ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
Dave Chinneraa0e8832012-04-23 15:58:52 +10001891 ASSERT(BBTOB(bp->b_io_length) >=
1892 ((uint)bit << XFS_BLF_SHIFT) + (nbits << XFS_BLF_SHIFT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
1894 /*
1895 * Do a sanity check if this is a dquot buffer. Just checking
1896 * the first dquot in the buffer should do. XXXThis is
1897 * probably a good thing to do for other buf types also.
1898 */
1899 error = 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001900 if (buf_f->blf_flags &
Dave Chinnerc1155412010-05-07 11:05:19 +10001901 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001902 if (item->ri_buf[i].i_addr == NULL) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001903 xfs_alert(mp,
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001904 "XFS: NULL dquot in %s.", __func__);
1905 goto next;
1906 }
Jan Rekorajski8ec6dba2009-11-16 11:57:02 +00001907 if (item->ri_buf[i].i_len < sizeof(xfs_disk_dquot_t)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001908 xfs_alert(mp,
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001909 "XFS: dquot too small (%d) in %s.",
1910 item->ri_buf[i].i_len, __func__);
1911 goto next;
1912 }
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001913 error = xfs_qm_dqcheck(mp, item->ri_buf[i].i_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 -1, 0, XFS_QMOPT_DOWARN,
1915 "dquot_buf_recover");
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001916 if (error)
1917 goto next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 }
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001919
1920 memcpy(xfs_buf_offset(bp,
Dave Chinnerc1155412010-05-07 11:05:19 +10001921 (uint)bit << XFS_BLF_SHIFT), /* dest */
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001922 item->ri_buf[i].i_addr, /* source */
Dave Chinnerc1155412010-05-07 11:05:19 +10001923 nbits<<XFS_BLF_SHIFT); /* length */
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02001924 next:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 i++;
1926 bit += nbits;
1927 }
1928
1929 /* Shouldn't be any more regions */
1930 ASSERT(i == item->ri_total);
1931}
1932
1933/*
1934 * Do some primitive error checking on ondisk dquot data structures.
1935 */
1936int
1937xfs_qm_dqcheck(
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001938 struct xfs_mount *mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 xfs_disk_dquot_t *ddq,
1940 xfs_dqid_t id,
1941 uint type, /* used only when IO_dorepair is true */
1942 uint flags,
1943 char *str)
1944{
1945 xfs_dqblk_t *d = (xfs_dqblk_t *)ddq;
1946 int errs = 0;
1947
1948 /*
1949 * We can encounter an uninitialized dquot buffer for 2 reasons:
1950 * 1. If we crash while deleting the quotainode(s), and those blks got
1951 * used for user data. This is because we take the path of regular
1952 * file deletion; however, the size field of quotainodes is never
1953 * updated, so all the tricks that we play in itruncate_finish
1954 * don't quite matter.
1955 *
1956 * 2. We don't play the quota buffers when there's a quotaoff logitem.
1957 * But the allocation will be replayed so we'll end up with an
1958 * uninitialized quota block.
1959 *
1960 * This is all fine; things are still consistent, and we haven't lost
1961 * any quota information. Just don't complain about bad dquot blks.
1962 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001963 if (ddq->d_magic != cpu_to_be16(XFS_DQUOT_MAGIC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001965 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 "%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001967 str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 errs++;
1969 }
Christoph Hellwig1149d962005-11-02 15:01:12 +11001970 if (ddq->d_version != XFS_DQUOT_VERSION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001972 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 "%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001974 str, id, ddq->d_version, XFS_DQUOT_VERSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 errs++;
1976 }
1977
Christoph Hellwig1149d962005-11-02 15:01:12 +11001978 if (ddq->d_flags != XFS_DQ_USER &&
1979 ddq->d_flags != XFS_DQ_PROJ &&
1980 ddq->d_flags != XFS_DQ_GROUP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001982 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 "%s : XFS dquot ID 0x%x, unknown flags 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001984 str, id, ddq->d_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 errs++;
1986 }
1987
Christoph Hellwig1149d962005-11-02 15:01:12 +11001988 if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11001990 xfs_alert(mp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 "%s : ondisk-dquot 0x%p, ID mismatch: "
1992 "0x%x expected, found id 0x%x",
Christoph Hellwig1149d962005-11-02 15:01:12 +11001993 str, ddq, id, be32_to_cpu(ddq->d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 errs++;
1995 }
1996
1997 if (!errs && ddq->d_id) {
Christoph Hellwig1149d962005-11-02 15:01:12 +11001998 if (ddq->d_blk_softlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +00001999 be64_to_cpu(ddq->d_bcount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +11002000 be64_to_cpu(ddq->d_blk_softlimit)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 if (!ddq->d_btimer) {
2002 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002003 xfs_alert(mp,
2004 "%s : Dquot ID 0x%x (0x%p) BLK TIMER NOT STARTED",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002005 str, (int)be32_to_cpu(ddq->d_id), ddq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 errs++;
2007 }
2008 }
Christoph Hellwig1149d962005-11-02 15:01:12 +11002009 if (ddq->d_ino_softlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +00002010 be64_to_cpu(ddq->d_icount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +11002011 be64_to_cpu(ddq->d_ino_softlimit)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 if (!ddq->d_itimer) {
2013 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002014 xfs_alert(mp,
2015 "%s : Dquot ID 0x%x (0x%p) INODE TIMER NOT STARTED",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002016 str, (int)be32_to_cpu(ddq->d_id), ddq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 errs++;
2018 }
2019 }
Christoph Hellwig1149d962005-11-02 15:01:12 +11002020 if (ddq->d_rtb_softlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +00002021 be64_to_cpu(ddq->d_rtbcount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +11002022 be64_to_cpu(ddq->d_rtb_softlimit)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 if (!ddq->d_rtbtimer) {
2024 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002025 xfs_alert(mp,
2026 "%s : Dquot ID 0x%x (0x%p) RTBLK TIMER NOT STARTED",
Christoph Hellwig1149d962005-11-02 15:01:12 +11002027 str, (int)be32_to_cpu(ddq->d_id), ddq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 errs++;
2029 }
2030 }
2031 }
2032
2033 if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
2034 return errs;
2035
2036 if (flags & XFS_QMOPT_DOWARN)
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002037 xfs_notice(mp, "Re-initializing dquot ID 0x%x", id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038
2039 /*
2040 * Typically, a repair is only requested by quotacheck.
2041 */
2042 ASSERT(id != -1);
2043 ASSERT(flags & XFS_QMOPT_DQREPAIR);
2044 memset(d, 0, sizeof(xfs_dqblk_t));
Christoph Hellwig1149d962005-11-02 15:01:12 +11002045
2046 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
2047 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
2048 d->dd_diskdq.d_flags = type;
2049 d->dd_diskdq.d_id = cpu_to_be32(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050
2051 return errs;
2052}
2053
2054/*
2055 * Perform a dquot buffer recovery.
2056 * Simple algorithm: if we have found a QUOTAOFF logitem of the same type
2057 * (ie. USR or GRP), then just toss this buffer away; don't recover it.
2058 * Else, treat it as a regular buffer and do recovery.
2059 */
2060STATIC void
2061xlog_recover_do_dquot_buffer(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002062 struct xfs_mount *mp,
2063 struct xlog *log,
2064 struct xlog_recover_item *item,
2065 struct xfs_buf *bp,
2066 struct xfs_buf_log_format *buf_f)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067{
2068 uint type;
2069
Dave Chinner9abbc532010-04-13 15:06:46 +10002070 trace_xfs_log_recover_buf_dquot_buf(log, buf_f);
2071
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 /*
2073 * Filesystems are required to send in quota flags at mount time.
2074 */
2075 if (mp->m_qflags == 0) {
2076 return;
2077 }
2078
2079 type = 0;
Dave Chinnerc1155412010-05-07 11:05:19 +10002080 if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 type |= XFS_DQ_USER;
Dave Chinnerc1155412010-05-07 11:05:19 +10002082 if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002083 type |= XFS_DQ_PROJ;
Dave Chinnerc1155412010-05-07 11:05:19 +10002084 if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 type |= XFS_DQ_GROUP;
2086 /*
2087 * This type of quotas was turned off, so ignore this buffer
2088 */
2089 if (log->l_quotaoffs_flag & type)
2090 return;
2091
Dave Chinner9abbc532010-04-13 15:06:46 +10002092 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093}
2094
2095/*
2096 * This routine replays a modification made to a buffer at runtime.
2097 * There are actually two types of buffer, regular and inode, which
2098 * are handled differently. Inode buffers are handled differently
2099 * in that we only recover a specific set of data from them, namely
2100 * the inode di_next_unlinked fields. This is because all other inode
2101 * data is actually logged via inode records and any data we replay
2102 * here which overlaps that may be stale.
2103 *
2104 * When meta-data buffers are freed at run time we log a buffer item
Dave Chinnerc1155412010-05-07 11:05:19 +10002105 * with the XFS_BLF_CANCEL bit set to indicate that previous copies
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 * of the buffer in the log should not be replayed at recovery time.
2107 * This is so that if the blocks covered by the buffer are reused for
2108 * file data before we crash we don't end up replaying old, freed
2109 * meta-data into a user's file.
2110 *
2111 * To handle the cancellation of buffer log items, we make two passes
2112 * over the log during recovery. During the first we build a table of
2113 * those buffers which have been cancelled, and during the second we
2114 * only replay those buffers which do not have corresponding cancel
2115 * records in the table. See xlog_recover_do_buffer_pass[1,2] above
2116 * for more details on the implementation of the table of cancel records.
2117 */
2118STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002119xlog_recover_buffer_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002120 struct xlog *log,
2121 struct list_head *buffer_list,
2122 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123{
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002124 xfs_buf_log_format_t *buf_f = item->ri_buf[0].i_addr;
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002125 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 xfs_buf_t *bp;
2127 int error;
Christoph Hellwig6ad112b2009-11-24 18:02:23 +00002128 uint buf_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002130 /*
2131 * In this pass we only want to recover all the buffers which have
2132 * not been cancelled and are not cancellation buffers themselves.
2133 */
2134 if (xlog_check_buffer_cancelled(log, buf_f->blf_blkno,
2135 buf_f->blf_len, buf_f->blf_flags)) {
2136 trace_xfs_log_recover_buf_cancel(log, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 }
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002139
Dave Chinner9abbc532010-04-13 15:06:46 +10002140 trace_xfs_log_recover_buf_recover(log, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141
Dave Chinnera8acad72012-04-23 15:58:54 +10002142 buf_flags = 0;
Dave Chinner611c9942012-04-23 15:59:07 +10002143 if (buf_f->blf_flags & XFS_BLF_INODE_BUF)
2144 buf_flags |= XBF_UNMAPPED;
Christoph Hellwig6ad112b2009-11-24 18:02:23 +00002145
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002146 bp = xfs_buf_read(mp->m_ddev_targp, buf_f->blf_blkno, buf_f->blf_len,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +11002147 buf_flags, NULL);
Chandra Seetharamanac4d6882011-08-03 02:18:29 +00002148 if (!bp)
2149 return XFS_ERROR(ENOMEM);
Chandra Seetharamane5702802011-08-03 02:18:34 +00002150 error = bp->b_error;
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00002151 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00002152 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 xfs_buf_relse(bp);
2154 return error;
2155 }
2156
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002157 if (buf_f->blf_flags & XFS_BLF_INODE_BUF) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
Christoph Hellwige2714bf2010-12-01 22:06:21 +00002159 } else if (buf_f->blf_flags &
Dave Chinnerc1155412010-05-07 11:05:19 +10002160 (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
2162 } else {
Dave Chinner9abbc532010-04-13 15:06:46 +10002163 xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 }
2165 if (error)
2166 return XFS_ERROR(error);
2167
2168 /*
2169 * Perform delayed write on the buffer. Asynchronous writes will be
2170 * slower when taking into account all the buffers to be flushed.
2171 *
2172 * Also make sure that only inode buffers with good sizes stay in
2173 * the buffer cache. The kernel moves inodes in buffers of 1 block
2174 * or XFS_INODE_CLUSTER_SIZE bytes, whichever is bigger. The inode
2175 * buffers in the log can be a different size if the log was generated
2176 * by an older kernel using unclustered inode buffers or a newer kernel
2177 * running with a different inode cluster size. Regardless, if the
2178 * the inode buffer size isn't MAX(blocksize, XFS_INODE_CLUSTER_SIZE)
2179 * for *our* value of XFS_INODE_CLUSTER_SIZE, then we need to keep
2180 * the buffer out of the buffer cache so that the buffer won't
2181 * overlap with future reads of those inodes.
2182 */
2183 if (XFS_DINODE_MAGIC ==
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002184 be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
Dave Chinneraa0e8832012-04-23 15:58:52 +10002185 (BBTOB(bp->b_io_length) != MAX(log->l_mp->m_sb.sb_blocksize,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
Christoph Hellwigc867cb62011-10-10 16:52:46 +00002187 xfs_buf_stale(bp);
Christoph Hellwigc2b006c2011-08-23 08:28:07 +00002188 error = xfs_bwrite(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 } else {
Dave Chinnerebad8612010-09-22 10:47:20 +10002190 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002191 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002192 xfs_buf_delwri_queue(bp, buffer_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 }
2194
Christoph Hellwigc2b006c2011-08-23 08:28:07 +00002195 xfs_buf_relse(bp);
2196 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197}
2198
2199STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002200xlog_recover_inode_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002201 struct xlog *log,
2202 struct list_head *buffer_list,
2203 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204{
2205 xfs_inode_log_format_t *in_f;
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002206 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 xfs_buf_t *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 xfs_dinode_t *dip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 int len;
2210 xfs_caddr_t src;
2211 xfs_caddr_t dest;
2212 int error;
2213 int attr_index;
2214 uint fields;
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002215 xfs_icdinode_t *dicp;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002216 int need_free = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217
Tim Shimmin6d192a92006-06-09 14:55:38 +10002218 if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002219 in_f = item->ri_buf[0].i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002220 } else {
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002221 in_f = kmem_alloc(sizeof(xfs_inode_log_format_t), KM_SLEEP);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002222 need_free = 1;
2223 error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
2224 if (error)
2225 goto error;
2226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227
2228 /*
2229 * Inode buffers can be freed, look out for it,
2230 * and do not replay the inode.
2231 */
Christoph Hellwiga1941892008-11-28 14:23:40 +11002232 if (xlog_check_buffer_cancelled(log, in_f->ilf_blkno,
2233 in_f->ilf_len, 0)) {
Tim Shimmin6d192a92006-06-09 14:55:38 +10002234 error = 0;
Dave Chinner9abbc532010-04-13 15:06:46 +10002235 trace_xfs_log_recover_inode_cancel(log, in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002236 goto error;
2237 }
Dave Chinner9abbc532010-04-13 15:06:46 +10002238 trace_xfs_log_recover_inode_recover(log, in_f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239
Dave Chinnerc3f8fc72012-11-12 22:54:01 +11002240 bp = xfs_buf_read(mp->m_ddev_targp, in_f->ilf_blkno, in_f->ilf_len, 0,
2241 NULL);
Chandra Seetharamanac4d6882011-08-03 02:18:29 +00002242 if (!bp) {
2243 error = ENOMEM;
2244 goto error;
2245 }
Chandra Seetharamane5702802011-08-03 02:18:34 +00002246 error = bp->b_error;
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00002247 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00002248 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 xfs_buf_relse(bp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002250 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
Christoph Hellwiga1941892008-11-28 14:23:40 +11002253 dip = (xfs_dinode_t *)xfs_buf_offset(bp, in_f->ilf_boffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254
2255 /*
2256 * Make sure the place we're flushing out to really looks
2257 * like an inode!
2258 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +02002259 if (unlikely(dip->di_magic != cpu_to_be16(XFS_DINODE_MAGIC))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002261 xfs_alert(mp,
2262 "%s: Bad inode magic number, dip = 0x%p, dino bp = 0x%p, ino = %Ld",
2263 __func__, dip, bp, in_f->ilf_ino);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002264 XFS_ERROR_REPORT("xlog_recover_inode_pass2(1)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 XFS_ERRLEVEL_LOW, mp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002266 error = EFSCORRUPTED;
2267 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 }
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002269 dicp = item->ri_buf[1].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
2271 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002272 xfs_alert(mp,
2273 "%s: Bad inode log record, rec ptr 0x%p, ino %Ld",
2274 __func__, item, in_f->ilf_ino);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002275 XFS_ERROR_REPORT("xlog_recover_inode_pass2(2)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 XFS_ERRLEVEL_LOW, mp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002277 error = EFSCORRUPTED;
2278 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 }
2280
2281 /* Skip replay when the on disk inode is newer than the log one */
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002282 if (dicp->di_flushiter < be16_to_cpu(dip->di_flushiter)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 /*
2284 * Deal with the wrap case, DI_MAX_FLUSH is less
2285 * than smaller numbers
2286 */
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002287 if (be16_to_cpu(dip->di_flushiter) == DI_MAX_FLUSH &&
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002288 dicp->di_flushiter < (DI_MAX_FLUSH >> 1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 /* do nothing */
2290 } else {
2291 xfs_buf_relse(bp);
Dave Chinner9abbc532010-04-13 15:06:46 +10002292 trace_xfs_log_recover_inode_skip(log, in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002293 error = 0;
2294 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 }
2296 }
2297 /* Take the opportunity to reset the flush iteration count */
2298 dicp->di_flushiter = 0;
2299
Al Viroabbede12011-07-26 02:31:30 -04002300 if (unlikely(S_ISREG(dicp->di_mode))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2302 (dicp->di_format != XFS_DINODE_FMT_BTREE)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002303 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(3)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 XFS_ERRLEVEL_LOW, mp, dicp);
2305 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002306 xfs_alert(mp,
2307 "%s: Bad regular inode log record, rec ptr 0x%p, "
2308 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2309 __func__, item, dip, bp, in_f->ilf_ino);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002310 error = EFSCORRUPTED;
2311 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 }
Al Viroabbede12011-07-26 02:31:30 -04002313 } else if (unlikely(S_ISDIR(dicp->di_mode))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
2315 (dicp->di_format != XFS_DINODE_FMT_BTREE) &&
2316 (dicp->di_format != XFS_DINODE_FMT_LOCAL)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002317 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(4)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 XFS_ERRLEVEL_LOW, mp, dicp);
2319 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002320 xfs_alert(mp,
2321 "%s: Bad dir inode log record, rec ptr 0x%p, "
2322 "ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
2323 __func__, item, dip, bp, in_f->ilf_ino);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002324 error = EFSCORRUPTED;
2325 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 }
2327 }
2328 if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002329 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(5)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 XFS_ERRLEVEL_LOW, mp, dicp);
2331 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002332 xfs_alert(mp,
2333 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
2334 "dino bp 0x%p, ino %Ld, total extents = %d, nblocks = %Ld",
2335 __func__, item, dip, bp, in_f->ilf_ino,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 dicp->di_nextents + dicp->di_anextents,
2337 dicp->di_nblocks);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002338 error = EFSCORRUPTED;
2339 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 }
2341 if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002342 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(6)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 XFS_ERRLEVEL_LOW, mp, dicp);
2344 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002345 xfs_alert(mp,
2346 "%s: Bad inode log record, rec ptr 0x%p, dino ptr 0x%p, "
2347 "dino bp 0x%p, ino %Ld, forkoff 0x%x", __func__,
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002348 item, dip, bp, in_f->ilf_ino, dicp->di_forkoff);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002349 error = EFSCORRUPTED;
2350 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 }
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002352 if (unlikely(item->ri_buf[1].i_len > sizeof(struct xfs_icdinode))) {
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002353 XFS_CORRUPTION_ERROR("xlog_recover_inode_pass2(7)",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 XFS_ERRLEVEL_LOW, mp, dicp);
2355 xfs_buf_relse(bp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002356 xfs_alert(mp,
2357 "%s: Bad inode log record length %d, rec ptr 0x%p",
2358 __func__, item->ri_buf[1].i_len, item);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002359 error = EFSCORRUPTED;
2360 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361 }
2362
2363 /* The core is in in-core format */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002364 xfs_dinode_to_disk(dip, item->ri_buf[1].i_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365
2366 /* the rest is in on-disk format */
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002367 if (item->ri_buf[1].i_len > sizeof(struct xfs_icdinode)) {
2368 memcpy((xfs_caddr_t) dip + sizeof(struct xfs_icdinode),
2369 item->ri_buf[1].i_addr + sizeof(struct xfs_icdinode),
2370 item->ri_buf[1].i_len - sizeof(struct xfs_icdinode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 }
2372
2373 fields = in_f->ilf_fields;
2374 switch (fields & (XFS_ILOG_DEV | XFS_ILOG_UUID)) {
2375 case XFS_ILOG_DEV:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002376 xfs_dinode_put_rdev(dip, in_f->ilf_u.ilfu_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 break;
2378 case XFS_ILOG_UUID:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002379 memcpy(XFS_DFORK_DPTR(dip),
2380 &in_f->ilf_u.ilfu_uuid,
2381 sizeof(uuid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382 break;
2383 }
2384
2385 if (in_f->ilf_size == 2)
2386 goto write_inode_buffer;
2387 len = item->ri_buf[2].i_len;
2388 src = item->ri_buf[2].i_addr;
2389 ASSERT(in_f->ilf_size <= 4);
2390 ASSERT((in_f->ilf_size == 3) || (fields & XFS_ILOG_AFORK));
2391 ASSERT(!(fields & XFS_ILOG_DFORK) ||
2392 (len == in_f->ilf_dsize));
2393
2394 switch (fields & XFS_ILOG_DFORK) {
2395 case XFS_ILOG_DDATA:
2396 case XFS_ILOG_DEXT:
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002397 memcpy(XFS_DFORK_DPTR(dip), src, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 break;
2399
2400 case XFS_ILOG_DBROOT:
Christoph Hellwig7cc95a82008-10-30 17:14:34 +11002401 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src, len,
Christoph Hellwig81591fe2008-11-28 14:23:39 +11002402 (xfs_bmdr_block_t *)XFS_DFORK_DPTR(dip),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 XFS_DFORK_DSIZE(dip, mp));
2404 break;
2405
2406 default:
2407 /*
2408 * There are no data fork flags set.
2409 */
2410 ASSERT((fields & XFS_ILOG_DFORK) == 0);
2411 break;
2412 }
2413
2414 /*
2415 * If we logged any attribute data, recover it. There may or
2416 * may not have been any other non-core data logged in this
2417 * transaction.
2418 */
2419 if (in_f->ilf_fields & XFS_ILOG_AFORK) {
2420 if (in_f->ilf_fields & XFS_ILOG_DFORK) {
2421 attr_index = 3;
2422 } else {
2423 attr_index = 2;
2424 }
2425 len = item->ri_buf[attr_index].i_len;
2426 src = item->ri_buf[attr_index].i_addr;
2427 ASSERT(len == in_f->ilf_asize);
2428
2429 switch (in_f->ilf_fields & XFS_ILOG_AFORK) {
2430 case XFS_ILOG_ADATA:
2431 case XFS_ILOG_AEXT:
2432 dest = XFS_DFORK_APTR(dip);
2433 ASSERT(len <= XFS_DFORK_ASIZE(dip, mp));
2434 memcpy(dest, src, len);
2435 break;
2436
2437 case XFS_ILOG_ABROOT:
2438 dest = XFS_DFORK_APTR(dip);
Christoph Hellwig7cc95a82008-10-30 17:14:34 +11002439 xfs_bmbt_to_bmdr(mp, (struct xfs_btree_block *)src,
2440 len, (xfs_bmdr_block_t*)dest,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 XFS_DFORK_ASIZE(dip, mp));
2442 break;
2443
2444 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002445 xfs_warn(log->l_mp, "%s: Invalid flag", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 ASSERT(0);
2447 xfs_buf_relse(bp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002448 error = EIO;
2449 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 }
2451 }
2452
2453write_inode_buffer:
Dave Chinnerebad8612010-09-22 10:47:20 +10002454 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002455 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002456 xfs_buf_delwri_queue(bp, buffer_list);
Christoph Hellwig61551f12011-08-23 08:28:06 +00002457 xfs_buf_relse(bp);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002458error:
2459 if (need_free)
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002460 kmem_free(in_f);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002461 return XFS_ERROR(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462}
2463
2464/*
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002465 * Recover QUOTAOFF records. We simply make a note of it in the xlog
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 * structure, so that we know not to do any dquot item or dquot buffer recovery,
2467 * of that type.
2468 */
2469STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002470xlog_recover_quotaoff_pass1(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002471 struct xlog *log,
2472 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002474 xfs_qoff_logformat_t *qoff_f = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 ASSERT(qoff_f);
2476
2477 /*
2478 * The logitem format's flag tells us if this was user quotaoff,
Nathan Scott77a7cce2006-01-11 15:35:57 +11002479 * group/project quotaoff or both.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 */
2481 if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
2482 log->l_quotaoffs_flag |= XFS_DQ_USER;
Nathan Scott77a7cce2006-01-11 15:35:57 +11002483 if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
2484 log->l_quotaoffs_flag |= XFS_DQ_PROJ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
2486 log->l_quotaoffs_flag |= XFS_DQ_GROUP;
2487
2488 return (0);
2489}
2490
2491/*
2492 * Recover a dquot record
2493 */
2494STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002495xlog_recover_dquot_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002496 struct xlog *log,
2497 struct list_head *buffer_list,
2498 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002500 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 xfs_buf_t *bp;
2502 struct xfs_disk_dquot *ddq, *recddq;
2503 int error;
2504 xfs_dq_logformat_t *dq_f;
2505 uint type;
2506
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507
2508 /*
2509 * Filesystems are required to send in quota flags at mount time.
2510 */
2511 if (mp->m_qflags == 0)
2512 return (0);
2513
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002514 recddq = item->ri_buf[1].i_addr;
2515 if (recddq == NULL) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002516 xfs_alert(log->l_mp, "NULL dquot in %s.", __func__);
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002517 return XFS_ERROR(EIO);
2518 }
Jan Rekorajski8ec6dba2009-11-16 11:57:02 +00002519 if (item->ri_buf[1].i_len < sizeof(xfs_disk_dquot_t)) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002520 xfs_alert(log->l_mp, "dquot too small (%d) in %s.",
Christoph Hellwig0c5e1ce2009-06-08 15:33:21 +02002521 item->ri_buf[1].i_len, __func__);
2522 return XFS_ERROR(EIO);
2523 }
2524
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 /*
2526 * This type of quotas was turned off, so ignore this record.
2527 */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002528 type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529 ASSERT(type);
2530 if (log->l_quotaoffs_flag & type)
2531 return (0);
2532
2533 /*
2534 * At this point we know that quota was _not_ turned off.
2535 * Since the mount flags are not indicating to us otherwise, this
2536 * must mean that quota is on, and the dquot needs to be replayed.
2537 * Remember that we may not have fully recovered the superblock yet,
2538 * so we can't do the usual trick of looking at the SB quota bits.
2539 *
2540 * The other possibility, of course, is that the quota subsystem was
2541 * removed since the last mount - ENOSYS.
2542 */
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002543 dq_f = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 ASSERT(dq_f);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002545 error = xfs_qm_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
2546 "xlog_recover_dquot_pass2 (log copy)");
2547 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 return XFS_ERROR(EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549 ASSERT(dq_f->qlf_len == 1);
2550
Dave Chinner7ca790a2012-04-23 15:58:55 +10002551 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dq_f->qlf_blkno,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +11002552 XFS_FSB_TO_BB(mp, dq_f->qlf_len), 0, &bp,
2553 NULL);
Dave Chinner7ca790a2012-04-23 15:58:55 +10002554 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 return error;
Dave Chinner7ca790a2012-04-23 15:58:55 +10002556
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 ASSERT(bp);
2558 ddq = (xfs_disk_dquot_t *)xfs_buf_offset(bp, dq_f->qlf_boffset);
2559
2560 /*
2561 * At least the magic num portion should be on disk because this
2562 * was among a chunk of dquots created earlier, and we did some
2563 * minimal initialization then.
2564 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002565 error = xfs_qm_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
2566 "xlog_recover_dquot_pass2");
2567 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 xfs_buf_relse(bp);
2569 return XFS_ERROR(EIO);
2570 }
2571
2572 memcpy(ddq, recddq, item->ri_buf[1].i_len);
2573
2574 ASSERT(dq_f->qlf_size == 2);
Dave Chinnerebad8612010-09-22 10:47:20 +10002575 ASSERT(bp->b_target->bt_mount == mp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02002576 bp->b_iodone = xlog_recover_iodone;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002577 xfs_buf_delwri_queue(bp, buffer_list);
Christoph Hellwig61551f12011-08-23 08:28:06 +00002578 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579
2580 return (0);
2581}
2582
2583/*
2584 * This routine is called to create an in-core extent free intent
2585 * item from the efi format structure which was logged on disk.
2586 * It allocates an in-core efi, copies the extents from the format
2587 * structure into it, and adds the efi to the AIL with the given
2588 * LSN.
2589 */
Tim Shimmin6d192a92006-06-09 14:55:38 +10002590STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002591xlog_recover_efi_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002592 struct xlog *log,
2593 struct xlog_recover_item *item,
2594 xfs_lsn_t lsn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595{
Tim Shimmin6d192a92006-06-09 14:55:38 +10002596 int error;
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002597 xfs_mount_t *mp = log->l_mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 xfs_efi_log_item_t *efip;
2599 xfs_efi_log_format_t *efi_formatp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002601 efi_formatp = item->ri_buf[0].i_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002604 if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
2605 &(efip->efi_format)))) {
2606 xfs_efi_item_free(efip);
2607 return error;
2608 }
Dave Chinnerb199c8a2010-12-20 11:59:49 +11002609 atomic_set(&efip->efi_next_extent, efi_formatp->efi_nextents);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610
David Chinnera9c21c12008-10-30 17:39:35 +11002611 spin_lock(&log->l_ailp->xa_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 /*
David Chinner783a2f62008-10-30 17:39:58 +11002613 * xfs_trans_ail_update() drops the AIL lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 */
Dave Chinnere6059942010-12-20 12:34:26 +11002615 xfs_trans_ail_update(log->l_ailp, &efip->efi_item, lsn);
Tim Shimmin6d192a92006-06-09 14:55:38 +10002616 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617}
2618
2619
2620/*
2621 * This routine is called when an efd format structure is found in
2622 * a committed transaction in the log. It's purpose is to cancel
2623 * the corresponding efi if it was still in the log. To do this
2624 * it searches the AIL for the efi with an id equal to that in the
2625 * efd format structure. If we find it, we remove the efi from the
2626 * AIL and free it.
2627 */
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002628STATIC int
2629xlog_recover_efd_pass2(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002630 struct xlog *log,
2631 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 xfs_efd_log_format_t *efd_formatp;
2634 xfs_efi_log_item_t *efip = NULL;
2635 xfs_log_item_t *lip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 __uint64_t efi_id;
David Chinner27d8d5f2008-10-30 17:38:39 +11002637 struct xfs_ail_cursor cur;
David Chinner783a2f62008-10-30 17:39:58 +11002638 struct xfs_ail *ailp = log->l_ailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639
Christoph Hellwig4e0d5f92010-06-23 18:11:15 +10002640 efd_formatp = item->ri_buf[0].i_addr;
Tim Shimmin6d192a92006-06-09 14:55:38 +10002641 ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
2642 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
2643 (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
2644 ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 efi_id = efd_formatp->efd_efi_id;
2646
2647 /*
2648 * Search for the efi with the id in the efd format structure
2649 * in the AIL.
2650 */
David Chinnera9c21c12008-10-30 17:39:35 +11002651 spin_lock(&ailp->xa_lock);
2652 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 while (lip != NULL) {
2654 if (lip->li_type == XFS_LI_EFI) {
2655 efip = (xfs_efi_log_item_t *)lip;
2656 if (efip->efi_format.efi_id == efi_id) {
2657 /*
David Chinner783a2f62008-10-30 17:39:58 +11002658 * xfs_trans_ail_delete() drops the
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 * AIL lock.
2660 */
Dave Chinner04913fd2012-04-23 15:58:41 +10002661 xfs_trans_ail_delete(ailp, lip,
2662 SHUTDOWN_CORRUPT_INCORE);
David Chinner8ae2c0f2007-11-23 16:28:17 +11002663 xfs_efi_item_free(efip);
David Chinnera9c21c12008-10-30 17:39:35 +11002664 spin_lock(&ailp->xa_lock);
David Chinner27d8d5f2008-10-30 17:38:39 +11002665 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666 }
2667 }
David Chinnera9c21c12008-10-30 17:39:35 +11002668 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 }
David Chinnera9c21c12008-10-30 17:39:35 +11002670 xfs_trans_ail_cursor_done(ailp, &cur);
2671 spin_unlock(&ailp->xa_lock);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002672
2673 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674}
2675
2676/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677 * Free up any resources allocated by the transaction
2678 *
2679 * Remember that EFIs, EFDs, and IUNLINKs are handled later.
2680 */
2681STATIC void
2682xlog_recover_free_trans(
Christoph Hellwigd0450942010-12-01 22:06:23 +00002683 struct xlog_recover *trans)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684{
Dave Chinnerf0a76952010-01-11 11:49:57 +00002685 xlog_recover_item_t *item, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 int i;
2687
Dave Chinnerf0a76952010-01-11 11:49:57 +00002688 list_for_each_entry_safe(item, n, &trans->r_itemq, ri_list) {
2689 /* Free the regions in the item. */
2690 list_del(&item->ri_list);
2691 for (i = 0; i < item->ri_cnt; i++)
2692 kmem_free(item->ri_buf[i].i_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 /* Free the item itself */
Dave Chinnerf0a76952010-01-11 11:49:57 +00002694 kmem_free(item->ri_buf);
2695 kmem_free(item);
2696 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 /* Free the transaction recover structure */
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002698 kmem_free(trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699}
2700
2701STATIC int
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002702xlog_recover_commit_pass1(
Mark Tinguelyad223e62012-06-14 09:22:15 -05002703 struct xlog *log,
2704 struct xlog_recover *trans,
2705 struct xlog_recover_item *item)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706{
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002707 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
Christoph Hellwigd0450942010-12-01 22:06:23 +00002708
2709 switch (ITEM_TYPE(item)) {
2710 case XFS_LI_BUF:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002711 return xlog_recover_buffer_pass1(log, item);
Christoph Hellwigd0450942010-12-01 22:06:23 +00002712 case XFS_LI_QUOTAOFF:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002713 return xlog_recover_quotaoff_pass1(log, item);
2714 case XFS_LI_INODE:
2715 case XFS_LI_EFI:
2716 case XFS_LI_EFD:
2717 case XFS_LI_DQUOT:
2718 /* nothing to do in pass 1 */
2719 return 0;
Christoph Hellwigd0450942010-12-01 22:06:23 +00002720 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002721 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
2722 __func__, ITEM_TYPE(item));
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002723 ASSERT(0);
2724 return XFS_ERROR(EIO);
2725 }
2726}
2727
2728STATIC int
2729xlog_recover_commit_pass2(
Mark Tinguelyad223e62012-06-14 09:22:15 -05002730 struct xlog *log,
2731 struct xlog_recover *trans,
2732 struct list_head *buffer_list,
2733 struct xlog_recover_item *item)
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002734{
2735 trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);
2736
2737 switch (ITEM_TYPE(item)) {
2738 case XFS_LI_BUF:
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002739 return xlog_recover_buffer_pass2(log, buffer_list, item);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002740 case XFS_LI_INODE:
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002741 return xlog_recover_inode_pass2(log, buffer_list, item);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002742 case XFS_LI_EFI:
2743 return xlog_recover_efi_pass2(log, item, trans->r_lsn);
2744 case XFS_LI_EFD:
2745 return xlog_recover_efd_pass2(log, item);
2746 case XFS_LI_DQUOT:
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002747 return xlog_recover_dquot_pass2(log, buffer_list, item);
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002748 case XFS_LI_QUOTAOFF:
2749 /* nothing to do in pass2 */
2750 return 0;
2751 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002752 xfs_warn(log->l_mp, "%s: invalid item type (%d)",
2753 __func__, ITEM_TYPE(item));
Christoph Hellwigd0450942010-12-01 22:06:23 +00002754 ASSERT(0);
2755 return XFS_ERROR(EIO);
2756 }
2757}
2758
2759/*
2760 * Perform the transaction.
2761 *
2762 * If the transaction modifies a buffer or inode, do it now. Otherwise,
2763 * EFIs and EFDs get queued up by adding entries into the AIL for them.
2764 */
2765STATIC int
2766xlog_recover_commit_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05002767 struct xlog *log,
Christoph Hellwigd0450942010-12-01 22:06:23 +00002768 struct xlog_recover *trans,
2769 int pass)
2770{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002771 int error = 0, error2;
Christoph Hellwigd0450942010-12-01 22:06:23 +00002772 xlog_recover_item_t *item;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002773 LIST_HEAD (buffer_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774
Dave Chinnerf0a76952010-01-11 11:49:57 +00002775 hlist_del(&trans->r_list);
Christoph Hellwigd0450942010-12-01 22:06:23 +00002776
2777 error = xlog_recover_reorder_trans(log, trans, pass);
2778 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 return error;
Christoph Hellwigd0450942010-12-01 22:06:23 +00002780
2781 list_for_each_entry(item, &trans->r_itemq, ri_list) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002782 switch (pass) {
2783 case XLOG_RECOVER_PASS1:
Christoph Hellwigc9f71f52010-12-01 22:06:24 +00002784 error = xlog_recover_commit_pass1(log, trans, item);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002785 break;
2786 case XLOG_RECOVER_PASS2:
2787 error = xlog_recover_commit_pass2(log, trans,
2788 &buffer_list, item);
2789 break;
2790 default:
2791 ASSERT(0);
2792 }
2793
Christoph Hellwigd0450942010-12-01 22:06:23 +00002794 if (error)
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002795 goto out;
Christoph Hellwigd0450942010-12-01 22:06:23 +00002796 }
2797
2798 xlog_recover_free_trans(trans);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10002799
2800out:
2801 error2 = xfs_buf_delwri_submit(&buffer_list);
2802 return error ? error : error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803}
2804
2805STATIC int
2806xlog_recover_unmount_trans(
Mark Tinguelyad223e62012-06-14 09:22:15 -05002807 struct xlog *log,
2808 struct xlog_recover *trans)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809{
2810 /* Do nothing now */
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002811 xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812 return 0;
2813}
2814
2815/*
2816 * There are two valid states of the r_state field. 0 indicates that the
2817 * transaction structure is in a normal state. We have either seen the
2818 * start of the transaction or the last operation we added was not a partial
2819 * operation. If the last operation we added to the transaction was a
2820 * partial operation, we need to mark r_state with XLOG_WAS_CONT_TRANS.
2821 *
2822 * NOTE: skip LRs with 0 data length.
2823 */
2824STATIC int
2825xlog_recover_process_data(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002826 struct xlog *log,
Dave Chinnerf0a76952010-01-11 11:49:57 +00002827 struct hlist_head rhash[],
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05002828 struct xlog_rec_header *rhead,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 xfs_caddr_t dp,
2830 int pass)
2831{
2832 xfs_caddr_t lp;
2833 int num_logops;
2834 xlog_op_header_t *ohead;
2835 xlog_recover_t *trans;
2836 xlog_tid_t tid;
2837 int error;
2838 unsigned long hash;
2839 uint flags;
2840
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002841 lp = dp + be32_to_cpu(rhead->h_len);
2842 num_logops = be32_to_cpu(rhead->h_num_logops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843
2844 /* check the log format matches our own - else we can't recover */
2845 if (xlog_header_check_recover(log->l_mp, rhead))
2846 return (XFS_ERROR(EIO));
2847
2848 while ((dp < lp) && num_logops) {
2849 ASSERT(dp + sizeof(xlog_op_header_t) <= lp);
2850 ohead = (xlog_op_header_t *)dp;
2851 dp += sizeof(xlog_op_header_t);
2852 if (ohead->oh_clientid != XFS_TRANSACTION &&
2853 ohead->oh_clientid != XFS_LOG) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002854 xfs_warn(log->l_mp, "%s: bad clientid 0x%x",
2855 __func__, ohead->oh_clientid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 ASSERT(0);
2857 return (XFS_ERROR(EIO));
2858 }
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10002859 tid = be32_to_cpu(ohead->oh_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 hash = XLOG_RHASH(tid);
Dave Chinnerf0a76952010-01-11 11:49:57 +00002861 trans = xlog_recover_find_tid(&rhash[hash], tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 if (trans == NULL) { /* not found; add new tid */
2863 if (ohead->oh_flags & XLOG_START_TRANS)
2864 xlog_recover_new_tid(&rhash[hash], tid,
Christoph Hellwigb53e6752007-10-12 10:59:34 +10002865 be64_to_cpu(rhead->h_lsn));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 } else {
Lachlan McIlroy9742bb92008-01-10 16:43:36 +11002867 if (dp + be32_to_cpu(ohead->oh_len) > lp) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002868 xfs_warn(log->l_mp, "%s: bad length 0x%x",
2869 __func__, be32_to_cpu(ohead->oh_len));
Lachlan McIlroy9742bb92008-01-10 16:43:36 +11002870 WARN_ON(1);
2871 return (XFS_ERROR(EIO));
2872 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 flags = ohead->oh_flags & ~XLOG_END_TRANS;
2874 if (flags & XLOG_WAS_CONT_TRANS)
2875 flags &= ~XLOG_CONTINUE_TRANS;
2876 switch (flags) {
2877 case XLOG_COMMIT_TRANS:
2878 error = xlog_recover_commit_trans(log,
Dave Chinnerf0a76952010-01-11 11:49:57 +00002879 trans, pass);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 break;
2881 case XLOG_UNMOUNT_TRANS:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002882 error = xlog_recover_unmount_trans(log, trans);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 break;
2884 case XLOG_WAS_CONT_TRANS:
Dave Chinner9abbc532010-04-13 15:06:46 +10002885 error = xlog_recover_add_to_cont_trans(log,
2886 trans, dp,
2887 be32_to_cpu(ohead->oh_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888 break;
2889 case XLOG_START_TRANS:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002890 xfs_warn(log->l_mp, "%s: bad transaction",
2891 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 ASSERT(0);
2893 error = XFS_ERROR(EIO);
2894 break;
2895 case 0:
2896 case XLOG_CONTINUE_TRANS:
Dave Chinner9abbc532010-04-13 15:06:46 +10002897 error = xlog_recover_add_to_trans(log, trans,
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10002898 dp, be32_to_cpu(ohead->oh_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 break;
2900 default:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11002901 xfs_warn(log->l_mp, "%s: bad flag 0x%x",
2902 __func__, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 ASSERT(0);
2904 error = XFS_ERROR(EIO);
2905 break;
2906 }
2907 if (error)
2908 return error;
2909 }
Christoph Hellwig67fcb7b2007-10-12 10:58:59 +10002910 dp += be32_to_cpu(ohead->oh_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 num_logops--;
2912 }
2913 return 0;
2914}
2915
2916/*
2917 * Process an extent free intent item that was recovered from
2918 * the log. We need to free the extents that it describes.
2919 */
David Chinner3c1e2bb2008-04-10 12:21:11 +10002920STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002921xlog_recover_process_efi(
2922 xfs_mount_t *mp,
2923 xfs_efi_log_item_t *efip)
2924{
2925 xfs_efd_log_item_t *efdp;
2926 xfs_trans_t *tp;
2927 int i;
David Chinner3c1e2bb2008-04-10 12:21:11 +10002928 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 xfs_extent_t *extp;
2930 xfs_fsblock_t startblock_fsb;
2931
Dave Chinnerb199c8a2010-12-20 11:59:49 +11002932 ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002933
2934 /*
2935 * First check the validity of the extents described by the
2936 * EFI. If any are bad, then assume that all are bad and
2937 * just toss the EFI.
2938 */
2939 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
2940 extp = &(efip->efi_format.efi_extents[i]);
2941 startblock_fsb = XFS_BB_TO_FSB(mp,
2942 XFS_FSB_TO_DADDR(mp, extp->ext_start));
2943 if ((startblock_fsb == 0) ||
2944 (extp->ext_len == 0) ||
2945 (startblock_fsb >= mp->m_sb.sb_dblocks) ||
2946 (extp->ext_len >= mp->m_sb.sb_agblocks)) {
2947 /*
2948 * This will pull the EFI from the AIL and
2949 * free the memory associated with it.
2950 */
2951 xfs_efi_release(efip, efip->efi_format.efi_nextents);
David Chinner3c1e2bb2008-04-10 12:21:11 +10002952 return XFS_ERROR(EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953 }
2954 }
2955
2956 tp = xfs_trans_alloc(mp, 0);
David Chinner3c1e2bb2008-04-10 12:21:11 +10002957 error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, 0, 0);
David Chinnerfc6149d2008-04-10 12:21:53 +10002958 if (error)
2959 goto abort_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
2961
2962 for (i = 0; i < efip->efi_format.efi_nextents; i++) {
2963 extp = &(efip->efi_format.efi_extents[i]);
David Chinnerfc6149d2008-04-10 12:21:53 +10002964 error = xfs_free_extent(tp, extp->ext_start, extp->ext_len);
2965 if (error)
2966 goto abort_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967 xfs_trans_log_efd_extent(tp, efdp, extp->ext_start,
2968 extp->ext_len);
2969 }
2970
Dave Chinnerb199c8a2010-12-20 11:59:49 +11002971 set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
David Chinnere5720ee2008-04-10 12:21:18 +10002972 error = xfs_trans_commit(tp, 0);
David Chinner3c1e2bb2008-04-10 12:21:11 +10002973 return error;
David Chinnerfc6149d2008-04-10 12:21:53 +10002974
2975abort_error:
2976 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
2977 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002978}
2979
2980/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981 * When this is called, all of the EFIs which did not have
2982 * corresponding EFDs should be in the AIL. What we do now
2983 * is free the extents associated with each one.
2984 *
2985 * Since we process the EFIs in normal transactions, they
2986 * will be removed at some point after the commit. This prevents
2987 * us from just walking down the list processing each one.
2988 * We'll use a flag in the EFI to skip those that we've already
2989 * processed and use the AIL iteration mechanism's generation
2990 * count to try to speed this up at least a bit.
2991 *
2992 * When we start, we know that the EFIs are the only things in
2993 * the AIL. As we process them, however, other items are added
2994 * to the AIL. Since everything added to the AIL must come after
2995 * everything already in the AIL, we stop processing as soon as
2996 * we see something other than an EFI in the AIL.
2997 */
David Chinner3c1e2bb2008-04-10 12:21:11 +10002998STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999xlog_recover_process_efis(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003000 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001{
3002 xfs_log_item_t *lip;
3003 xfs_efi_log_item_t *efip;
David Chinner3c1e2bb2008-04-10 12:21:11 +10003004 int error = 0;
David Chinner27d8d5f2008-10-30 17:38:39 +11003005 struct xfs_ail_cursor cur;
David Chinnera9c21c12008-10-30 17:39:35 +11003006 struct xfs_ail *ailp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007
David Chinnera9c21c12008-10-30 17:39:35 +11003008 ailp = log->l_ailp;
3009 spin_lock(&ailp->xa_lock);
3010 lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011 while (lip != NULL) {
3012 /*
3013 * We're done when we see something other than an EFI.
David Chinner27d8d5f2008-10-30 17:38:39 +11003014 * There should be no EFIs left in the AIL now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 */
3016 if (lip->li_type != XFS_LI_EFI) {
David Chinner27d8d5f2008-10-30 17:38:39 +11003017#ifdef DEBUG
David Chinnera9c21c12008-10-30 17:39:35 +11003018 for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
David Chinner27d8d5f2008-10-30 17:38:39 +11003019 ASSERT(lip->li_type != XFS_LI_EFI);
3020#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 break;
3022 }
3023
3024 /*
3025 * Skip EFIs that we've already processed.
3026 */
3027 efip = (xfs_efi_log_item_t *)lip;
Dave Chinnerb199c8a2010-12-20 11:59:49 +11003028 if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) {
David Chinnera9c21c12008-10-30 17:39:35 +11003029 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 continue;
3031 }
3032
David Chinnera9c21c12008-10-30 17:39:35 +11003033 spin_unlock(&ailp->xa_lock);
3034 error = xlog_recover_process_efi(log->l_mp, efip);
3035 spin_lock(&ailp->xa_lock);
David Chinner27d8d5f2008-10-30 17:38:39 +11003036 if (error)
3037 goto out;
David Chinnera9c21c12008-10-30 17:39:35 +11003038 lip = xfs_trans_ail_cursor_next(ailp, &cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 }
David Chinner27d8d5f2008-10-30 17:38:39 +11003040out:
David Chinnera9c21c12008-10-30 17:39:35 +11003041 xfs_trans_ail_cursor_done(ailp, &cur);
3042 spin_unlock(&ailp->xa_lock);
David Chinner3c1e2bb2008-04-10 12:21:11 +10003043 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003044}
3045
3046/*
3047 * This routine performs a transaction to null out a bad inode pointer
3048 * in an agi unlinked inode hash bucket.
3049 */
3050STATIC void
3051xlog_recover_clear_agi_bucket(
3052 xfs_mount_t *mp,
3053 xfs_agnumber_t agno,
3054 int bucket)
3055{
3056 xfs_trans_t *tp;
3057 xfs_agi_t *agi;
3058 xfs_buf_t *agibp;
3059 int offset;
3060 int error;
3061
3062 tp = xfs_trans_alloc(mp, XFS_TRANS_CLEAR_AGI_BUCKET);
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003063 error = xfs_trans_reserve(tp, 0, XFS_CLEAR_AGI_BUCKET_LOG_RES(mp),
3064 0, 0, 0);
David Chinnere5720ee2008-04-10 12:21:18 +10003065 if (error)
3066 goto out_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003068 error = xfs_read_agi(mp, tp, agno, &agibp);
3069 if (error)
David Chinnere5720ee2008-04-10 12:21:18 +10003070 goto out_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003072 agi = XFS_BUF_TO_AGI(agibp);
Christoph Hellwig16259e72005-11-02 15:11:25 +11003073 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 offset = offsetof(xfs_agi_t, agi_unlinked) +
3075 (sizeof(xfs_agino_t) * bucket);
3076 xfs_trans_log_buf(tp, agibp, offset,
3077 (offset + sizeof(xfs_agino_t) - 1));
3078
David Chinnere5720ee2008-04-10 12:21:18 +10003079 error = xfs_trans_commit(tp, 0);
3080 if (error)
3081 goto out_error;
3082 return;
3083
3084out_abort:
3085 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
3086out_error:
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003087 xfs_warn(mp, "%s: failed to clear agi %d. Continuing.", __func__, agno);
David Chinnere5720ee2008-04-10 12:21:18 +10003088 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003089}
3090
Christoph Hellwig23fac502008-11-28 14:23:40 +11003091STATIC xfs_agino_t
3092xlog_recover_process_one_iunlink(
3093 struct xfs_mount *mp,
3094 xfs_agnumber_t agno,
3095 xfs_agino_t agino,
3096 int bucket)
3097{
3098 struct xfs_buf *ibp;
3099 struct xfs_dinode *dip;
3100 struct xfs_inode *ip;
3101 xfs_ino_t ino;
3102 int error;
3103
3104 ino = XFS_AGINO_TO_INO(mp, agno, agino);
Dave Chinner7b6259e2010-06-24 11:35:17 +10003105 error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003106 if (error)
3107 goto fail;
3108
3109 /*
3110 * Get the on disk inode to find the next inode in the bucket.
3111 */
Christoph Hellwig475ee412012-07-03 12:21:22 -04003112 error = xfs_imap_to_bp(mp, NULL, &ip->i_imap, &dip, &ibp, 0, 0);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003113 if (error)
Christoph Hellwig0e446672008-11-28 14:23:42 +11003114 goto fail_iput;
Christoph Hellwig23fac502008-11-28 14:23:40 +11003115
Christoph Hellwig23fac502008-11-28 14:23:40 +11003116 ASSERT(ip->i_d.di_nlink == 0);
Christoph Hellwig0e446672008-11-28 14:23:42 +11003117 ASSERT(ip->i_d.di_mode != 0);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003118
3119 /* setup for the next pass */
3120 agino = be32_to_cpu(dip->di_next_unlinked);
3121 xfs_buf_relse(ibp);
3122
3123 /*
3124 * Prevent any DMAPI event from being sent when the reference on
3125 * the inode is dropped.
3126 */
3127 ip->i_d.di_dmevmask = 0;
3128
Christoph Hellwig0e446672008-11-28 14:23:42 +11003129 IRELE(ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003130 return agino;
3131
Christoph Hellwig0e446672008-11-28 14:23:42 +11003132 fail_iput:
3133 IRELE(ip);
Christoph Hellwig23fac502008-11-28 14:23:40 +11003134 fail:
3135 /*
3136 * We can't read in the inode this bucket points to, or this inode
3137 * is messed up. Just ditch this bucket of inodes. We will lose
3138 * some inodes and space, but at least we won't hang.
3139 *
3140 * Call xlog_recover_clear_agi_bucket() to perform a transaction to
3141 * clear the inode pointer in the bucket.
3142 */
3143 xlog_recover_clear_agi_bucket(mp, agno, bucket);
3144 return NULLAGINO;
3145}
3146
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147/*
3148 * xlog_iunlink_recover
3149 *
3150 * This is called during recovery to process any inodes which
3151 * we unlinked but not freed when the system crashed. These
3152 * inodes will be on the lists in the AGI blocks. What we do
3153 * here is scan all the AGIs and fully truncate and free any
3154 * inodes found on the lists. Each inode is removed from the
3155 * lists when it has been fully truncated and is freed. The
3156 * freeing of the inode and its removal from the list must be
3157 * atomic.
3158 */
Eric Sandeend96f8f82009-07-02 00:09:33 -05003159STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160xlog_recover_process_iunlinks(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003161 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162{
3163 xfs_mount_t *mp;
3164 xfs_agnumber_t agno;
3165 xfs_agi_t *agi;
3166 xfs_buf_t *agibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 xfs_agino_t agino;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003168 int bucket;
3169 int error;
3170 uint mp_dmevmask;
3171
3172 mp = log->l_mp;
3173
3174 /*
3175 * Prevent any DMAPI event from being sent while in this function.
3176 */
3177 mp_dmevmask = mp->m_dmevmask;
3178 mp->m_dmevmask = 0;
3179
3180 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
3181 /*
3182 * Find the agi for this ag.
3183 */
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003184 error = xfs_read_agi(mp, NULL, agno, &agibp);
3185 if (error) {
3186 /*
3187 * AGI is b0rked. Don't process it.
3188 *
3189 * We should probably mark the filesystem as corrupt
3190 * after we've recovered all the ag's we can....
3191 */
3192 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 }
Jan Karad97d32e2012-03-15 09:34:02 +00003194 /*
3195 * Unlock the buffer so that it can be acquired in the normal
3196 * course of the transaction to truncate and free each inode.
3197 * Because we are not racing with anyone else here for the AGI
3198 * buffer, we don't even need to hold it locked to read the
3199 * initial unlinked bucket entries out of the buffer. We keep
3200 * buffer reference though, so that it stays pinned in memory
3201 * while we need the buffer.
3202 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 agi = XFS_BUF_TO_AGI(agibp);
Jan Karad97d32e2012-03-15 09:34:02 +00003204 xfs_buf_unlock(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205
3206 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) {
Christoph Hellwig16259e72005-11-02 15:11:25 +11003207 agino = be32_to_cpu(agi->agi_unlinked[bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003208 while (agino != NULLAGINO) {
Christoph Hellwig23fac502008-11-28 14:23:40 +11003209 agino = xlog_recover_process_one_iunlink(mp,
3210 agno, agino, bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211 }
3212 }
Jan Karad97d32e2012-03-15 09:34:02 +00003213 xfs_buf_rele(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003214 }
3215
3216 mp->m_dmevmask = mp_dmevmask;
3217}
3218
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219/*
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003220 * Upack the log buffer data and crc check it. If the check fails, issue a
3221 * warning if and only if the CRC in the header is non-zero. This makes the
3222 * check an advisory warning, and the zero CRC check will prevent failure
3223 * warnings from being emitted when upgrading the kernel from one that does not
3224 * add CRCs by default.
3225 *
3226 * When filesystems are CRC enabled, this CRC mismatch becomes a fatal log
3227 * corruption failure
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228 */
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003229STATIC int
3230xlog_unpack_data_crc(
3231 struct xlog_rec_header *rhead,
3232 xfs_caddr_t dp,
3233 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234{
Dave Chinnerf9668a02012-11-28 13:01:03 +11003235 __le32 crc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003237 crc = xlog_cksum(log, rhead, dp, be32_to_cpu(rhead->h_len));
3238 if (crc != rhead->h_crc) {
3239 if (rhead->h_crc || xfs_sb_version_hascrc(&log->l_mp->m_sb)) {
3240 xfs_alert(log->l_mp,
3241 "log record CRC mismatch: found 0x%x, expected 0x%x.\n",
Dave Chinnerf9668a02012-11-28 13:01:03 +11003242 le32_to_cpu(rhead->h_crc),
3243 le32_to_cpu(crc));
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003244 xfs_hex_dump(dp, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003245 }
3246
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003247 /*
3248 * If we've detected a log record corruption, then we can't
3249 * recover past this point. Abort recovery if we are enforcing
3250 * CRC protection by punting an error back up the stack.
3251 */
3252 if (xfs_sb_version_hascrc(&log->l_mp->m_sb))
3253 return EFSCORRUPTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 }
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003255
3256 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257}
3258
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003259STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260xlog_unpack_data(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003261 struct xlog_rec_header *rhead,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262 xfs_caddr_t dp,
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003263 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264{
3265 int i, j, k;
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003266 int error;
3267
3268 error = xlog_unpack_data_crc(rhead, dp, log);
3269 if (error)
3270 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003272 for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003274 *(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003275 dp += BBSIZE;
3276 }
3277
Eric Sandeen62118702008-03-06 13:44:28 +11003278 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Christoph Hellwigb28708d2008-11-28 14:23:38 +11003279 xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003280 for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281 j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
3282 k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003283 *(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284 dp += BBSIZE;
3285 }
3286 }
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003287
3288 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289}
3290
3291STATIC int
3292xlog_valid_rec_header(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003293 struct xlog *log,
3294 struct xlog_rec_header *rhead,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295 xfs_daddr_t blkno)
3296{
3297 int hlen;
3298
Christoph Hellwig69ef9212011-07-08 14:36:05 +02003299 if (unlikely(rhead->h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003300 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
3301 XFS_ERRLEVEL_LOW, log->l_mp);
3302 return XFS_ERROR(EFSCORRUPTED);
3303 }
3304 if (unlikely(
3305 (!rhead->h_version ||
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003306 (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003307 xfs_warn(log->l_mp, "%s: unrecognised log version (%d).",
Harvey Harrison34a622b2008-04-10 12:19:21 +10003308 __func__, be32_to_cpu(rhead->h_version));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309 return XFS_ERROR(EIO);
3310 }
3311
3312 /* LR body must have data or it wouldn't have been written */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003313 hlen = be32_to_cpu(rhead->h_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
3315 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
3316 XFS_ERRLEVEL_LOW, log->l_mp);
3317 return XFS_ERROR(EFSCORRUPTED);
3318 }
3319 if (unlikely( blkno > log->l_logBBsize || blkno > INT_MAX )) {
3320 XFS_ERROR_REPORT("xlog_valid_rec_header(3)",
3321 XFS_ERRLEVEL_LOW, log->l_mp);
3322 return XFS_ERROR(EFSCORRUPTED);
3323 }
3324 return 0;
3325}
3326
3327/*
3328 * Read the log from tail to head and process the log records found.
3329 * Handle the two cases where the tail and head are in the same cycle
3330 * and where the active portion of the log wraps around the end of
3331 * the physical log separately. The pass parameter is passed through
3332 * to the routines called to process the data and is not looked at
3333 * here.
3334 */
3335STATIC int
3336xlog_do_recovery_pass(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003337 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003338 xfs_daddr_t head_blk,
3339 xfs_daddr_t tail_blk,
3340 int pass)
3341{
3342 xlog_rec_header_t *rhead;
3343 xfs_daddr_t blk_no;
Andy Polingfc5bc4c2009-11-03 17:26:47 +00003344 xfs_caddr_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003345 xfs_buf_t *hbp, *dbp;
3346 int error = 0, h_size;
3347 int bblks, split_bblks;
3348 int hblks, split_hblks, wrapped_hblks;
Dave Chinnerf0a76952010-01-11 11:49:57 +00003349 struct hlist_head rhash[XLOG_RHASH_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003350
3351 ASSERT(head_blk != tail_blk);
3352
3353 /*
3354 * Read the header of the tail block and get the iclog buffer size from
3355 * h_size. Use this to tell how many sectors make up the log header.
3356 */
Eric Sandeen62118702008-03-06 13:44:28 +11003357 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358 /*
3359 * When using variable length iclogs, read first sector of
3360 * iclog header and extract the header size from it. Get a
3361 * new hbp that is the correct size.
3362 */
3363 hbp = xlog_get_bp(log, 1);
3364 if (!hbp)
3365 return ENOMEM;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003366
3367 error = xlog_bread(log, tail_blk, 1, hbp, &offset);
3368 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369 goto bread_err1;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003370
Linus Torvalds1da177e2005-04-16 15:20:36 -07003371 rhead = (xlog_rec_header_t *)offset;
3372 error = xlog_valid_rec_header(log, rhead, tail_blk);
3373 if (error)
3374 goto bread_err1;
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003375 h_size = be32_to_cpu(rhead->h_size);
3376 if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377 (h_size > XLOG_HEADER_CYCLE_SIZE)) {
3378 hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
3379 if (h_size % XLOG_HEADER_CYCLE_SIZE)
3380 hblks++;
3381 xlog_put_bp(hbp);
3382 hbp = xlog_get_bp(log, hblks);
3383 } else {
3384 hblks = 1;
3385 }
3386 } else {
Alex Elder69ce58f2010-04-20 17:09:59 +10003387 ASSERT(log->l_sectBBsize == 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388 hblks = 1;
3389 hbp = xlog_get_bp(log, 1);
3390 h_size = XLOG_BIG_RECORD_BSIZE;
3391 }
3392
3393 if (!hbp)
3394 return ENOMEM;
3395 dbp = xlog_get_bp(log, BTOBB(h_size));
3396 if (!dbp) {
3397 xlog_put_bp(hbp);
3398 return ENOMEM;
3399 }
3400
3401 memset(rhash, 0, sizeof(rhash));
3402 if (tail_blk <= head_blk) {
3403 for (blk_no = tail_blk; blk_no < head_blk; ) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003404 error = xlog_bread(log, blk_no, hblks, hbp, &offset);
3405 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003407
Linus Torvalds1da177e2005-04-16 15:20:36 -07003408 rhead = (xlog_rec_header_t *)offset;
3409 error = xlog_valid_rec_header(log, rhead, blk_no);
3410 if (error)
3411 goto bread_err2;
3412
3413 /* blocks in data section */
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003414 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003415 error = xlog_bread(log, blk_no + hblks, bblks, dbp,
3416 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417 if (error)
3418 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003419
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003420 error = xlog_unpack_data(rhead, offset, log);
3421 if (error)
3422 goto bread_err2;
3423
3424 error = xlog_recover_process_data(log,
3425 rhash, rhead, offset, pass);
3426 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427 goto bread_err2;
3428 blk_no += bblks + hblks;
3429 }
3430 } else {
3431 /*
3432 * Perform recovery around the end of the physical log.
3433 * When the head is not on the same cycle number as the tail,
3434 * we can't do a sequential recovery as above.
3435 */
3436 blk_no = tail_blk;
3437 while (blk_no < log->l_logBBsize) {
3438 /*
3439 * Check for header wrapping around physical end-of-log
3440 */
Chandra Seetharaman62926042011-07-22 23:40:15 +00003441 offset = hbp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003442 split_hblks = 0;
3443 wrapped_hblks = 0;
3444 if (blk_no + hblks <= log->l_logBBsize) {
3445 /* Read header in one read */
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003446 error = xlog_bread(log, blk_no, hblks, hbp,
3447 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448 if (error)
3449 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003450 } else {
3451 /* This LR is split across physical log end */
3452 if (blk_no != log->l_logBBsize) {
3453 /* some data before physical log end */
3454 ASSERT(blk_no <= INT_MAX);
3455 split_hblks = log->l_logBBsize - (int)blk_no;
3456 ASSERT(split_hblks > 0);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003457 error = xlog_bread(log, blk_no,
3458 split_hblks, hbp,
3459 &offset);
3460 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003463
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464 /*
3465 * Note: this black magic still works with
3466 * large sector sizes (non-512) only because:
3467 * - we increased the buffer size originally
3468 * by 1 sector giving us enough extra space
3469 * for the second read;
3470 * - the log start is guaranteed to be sector
3471 * aligned;
3472 * - we read the log end (LR header start)
3473 * _first_, then the log start (LR header end)
3474 * - order is important.
3475 */
David Chinner234f56a2008-04-10 12:24:24 +10003476 wrapped_hblks = hblks - split_hblks;
Dave Chinner44396472011-04-21 09:34:27 +00003477 error = xlog_bread_offset(log, 0,
3478 wrapped_hblks, hbp,
3479 offset + BBTOB(split_hblks));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480 if (error)
3481 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482 }
3483 rhead = (xlog_rec_header_t *)offset;
3484 error = xlog_valid_rec_header(log, rhead,
3485 split_hblks ? blk_no : 0);
3486 if (error)
3487 goto bread_err2;
3488
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003489 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003490 blk_no += hblks;
3491
3492 /* Read in data for log record */
3493 if (blk_no + bblks <= log->l_logBBsize) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003494 error = xlog_bread(log, blk_no, bblks, dbp,
3495 &offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496 if (error)
3497 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498 } else {
3499 /* This log record is split across the
3500 * physical end of log */
Chandra Seetharaman62926042011-07-22 23:40:15 +00003501 offset = dbp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502 split_bblks = 0;
3503 if (blk_no != log->l_logBBsize) {
3504 /* some data is before the physical
3505 * end of log */
3506 ASSERT(!wrapped_hblks);
3507 ASSERT(blk_no <= INT_MAX);
3508 split_bblks =
3509 log->l_logBBsize - (int)blk_no;
3510 ASSERT(split_bblks > 0);
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003511 error = xlog_bread(log, blk_no,
3512 split_bblks, dbp,
3513 &offset);
3514 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516 }
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003517
Linus Torvalds1da177e2005-04-16 15:20:36 -07003518 /*
3519 * Note: this black magic still works with
3520 * large sector sizes (non-512) only because:
3521 * - we increased the buffer size originally
3522 * by 1 sector giving us enough extra space
3523 * for the second read;
3524 * - the log start is guaranteed to be sector
3525 * aligned;
3526 * - we read the log end (LR header start)
3527 * _first_, then the log start (LR header end)
3528 * - order is important.
3529 */
Dave Chinner44396472011-04-21 09:34:27 +00003530 error = xlog_bread_offset(log, 0,
Dave Chinner009507b2012-11-02 11:38:44 +11003531 bblks - split_bblks, dbp,
Dave Chinner44396472011-04-21 09:34:27 +00003532 offset + BBTOB(split_bblks));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003533 if (error)
3534 goto bread_err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003535 }
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003536
3537 error = xlog_unpack_data(rhead, offset, log);
3538 if (error)
3539 goto bread_err2;
3540
3541 error = xlog_recover_process_data(log, rhash,
3542 rhead, offset, pass);
3543 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544 goto bread_err2;
3545 blk_no += bblks;
3546 }
3547
3548 ASSERT(blk_no >= log->l_logBBsize);
3549 blk_no -= log->l_logBBsize;
3550
3551 /* read first part of physical log */
3552 while (blk_no < head_blk) {
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003553 error = xlog_bread(log, blk_no, hblks, hbp, &offset);
3554 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003556
Linus Torvalds1da177e2005-04-16 15:20:36 -07003557 rhead = (xlog_rec_header_t *)offset;
3558 error = xlog_valid_rec_header(log, rhead, blk_no);
3559 if (error)
3560 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003561
Christoph Hellwigb53e6752007-10-12 10:59:34 +10003562 bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003563 error = xlog_bread(log, blk_no+hblks, bblks, dbp,
3564 &offset);
3565 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566 goto bread_err2;
Christoph Hellwig076e6ac2009-03-16 08:24:13 +01003567
Christoph Hellwig0e446be2012-11-12 22:54:24 +11003568 error = xlog_unpack_data(rhead, offset, log);
3569 if (error)
3570 goto bread_err2;
3571
3572 error = xlog_recover_process_data(log, rhash,
3573 rhead, offset, pass);
3574 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003575 goto bread_err2;
3576 blk_no += bblks + hblks;
3577 }
3578 }
3579
3580 bread_err2:
3581 xlog_put_bp(dbp);
3582 bread_err1:
3583 xlog_put_bp(hbp);
3584 return error;
3585}
3586
3587/*
3588 * Do the recovery of the log. We actually do this in two phases.
3589 * The two passes are necessary in order to implement the function
3590 * of cancelling a record written into the log. The first pass
3591 * determines those things which have been cancelled, and the
3592 * second pass replays log items normally except for those which
3593 * have been cancelled. The handling of the replay and cancellations
3594 * takes place in the log item type specific routines.
3595 *
3596 * The table of items which have cancel records in the log is allocated
3597 * and freed at this level, since only here do we know when all of
3598 * the log recovery has been completed.
3599 */
3600STATIC int
3601xlog_do_log_recovery(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003602 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603 xfs_daddr_t head_blk,
3604 xfs_daddr_t tail_blk)
3605{
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003606 int error, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607
3608 ASSERT(head_blk != tail_blk);
3609
3610 /*
3611 * First do a pass to find all of the cancelled buf log items.
3612 * Store them in the buf_cancel_table for use in the second pass.
3613 */
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003614 log->l_buf_cancel_table = kmem_zalloc(XLOG_BC_TABLE_SIZE *
3615 sizeof(struct list_head),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003616 KM_SLEEP);
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003617 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
3618 INIT_LIST_HEAD(&log->l_buf_cancel_table[i]);
3619
Linus Torvalds1da177e2005-04-16 15:20:36 -07003620 error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3621 XLOG_RECOVER_PASS1);
3622 if (error != 0) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10003623 kmem_free(log->l_buf_cancel_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003624 log->l_buf_cancel_table = NULL;
3625 return error;
3626 }
3627 /*
3628 * Then do a second pass to actually recover the items in the log.
3629 * When it is complete free the table of buf cancel items.
3630 */
3631 error = xlog_do_recovery_pass(log, head_blk, tail_blk,
3632 XLOG_RECOVER_PASS2);
3633#ifdef DEBUG
Tim Shimmin6d192a92006-06-09 14:55:38 +10003634 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003635 int i;
3636
3637 for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
Christoph Hellwigd5689ea2010-12-01 22:06:22 +00003638 ASSERT(list_empty(&log->l_buf_cancel_table[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639 }
3640#endif /* DEBUG */
3641
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10003642 kmem_free(log->l_buf_cancel_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643 log->l_buf_cancel_table = NULL;
3644
3645 return error;
3646}
3647
3648/*
3649 * Do the actual recovery
3650 */
3651STATIC int
3652xlog_do_recover(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003653 struct xlog *log,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654 xfs_daddr_t head_blk,
3655 xfs_daddr_t tail_blk)
3656{
3657 int error;
3658 xfs_buf_t *bp;
3659 xfs_sb_t *sbp;
3660
3661 /*
3662 * First replay the images in the log.
3663 */
3664 error = xlog_do_log_recovery(log, head_blk, tail_blk);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10003665 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003667
3668 /*
3669 * If IO errors happened during recovery, bail out.
3670 */
3671 if (XFS_FORCED_SHUTDOWN(log->l_mp)) {
3672 return (EIO);
3673 }
3674
3675 /*
3676 * We now update the tail_lsn since much of the recovery has completed
3677 * and there may be space available to use. If there were no extent
3678 * or iunlinks, we can free up the entire log and set the tail_lsn to
3679 * be the last_sync_lsn. This was set in xlog_find_tail to be the
3680 * lsn of the last known good LR on disk. If there are extent frees
3681 * or iunlinks they will have some entries in the AIL; so we look at
3682 * the AIL to determine how to set the tail_lsn.
3683 */
3684 xlog_assign_tail_lsn(log->l_mp);
3685
3686 /*
3687 * Now that we've finished replaying all buffer and inode
Dave Chinner98021822012-11-12 22:54:03 +11003688 * updates, re-read in the superblock and reverify it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003689 */
3690 bp = xfs_getsb(log->l_mp, 0);
3691 XFS_BUF_UNDONE(bp);
Lachlan McIlroybebf9632007-10-15 13:18:02 +10003692 ASSERT(!(XFS_BUF_ISWRITE(bp)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003693 XFS_BUF_READ(bp);
Lachlan McIlroybebf9632007-10-15 13:18:02 +10003694 XFS_BUF_UNASYNC(bp);
Dave Chinner1813dd62012-11-14 17:54:40 +11003695 bp->b_ops = &xfs_sb_buf_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003696 xfsbdstrat(log->l_mp, bp);
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +00003697 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +10003698 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +00003699 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700 ASSERT(0);
3701 xfs_buf_relse(bp);
3702 return error;
3703 }
3704
3705 /* Convert superblock from on-disk format */
3706 sbp = &log->l_mp->m_sb;
Dave Chinner98021822012-11-12 22:54:03 +11003707 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003708 ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
Eric Sandeen62118702008-03-06 13:44:28 +11003709 ASSERT(xfs_sb_good_version(sbp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003710 xfs_buf_relse(bp);
3711
Lachlan McIlroy5478eea2007-02-10 18:36:29 +11003712 /* We've re-read the superblock so re-initialize per-cpu counters */
3713 xfs_icsb_reinit_counters(log->l_mp);
3714
Linus Torvalds1da177e2005-04-16 15:20:36 -07003715 xlog_recover_check_summary(log);
3716
3717 /* Normal transactions can now occur */
3718 log->l_flags &= ~XLOG_ACTIVE_RECOVERY;
3719 return 0;
3720}
3721
3722/*
3723 * Perform recovery and re-initialize some log variables in xlog_find_tail.
3724 *
3725 * Return error or zero.
3726 */
3727int
3728xlog_recover(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003729 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730{
3731 xfs_daddr_t head_blk, tail_blk;
3732 int error;
3733
3734 /* find the tail of the log */
Eric Sandeen65be6052006-01-11 15:34:19 +11003735 if ((error = xlog_find_tail(log, &head_blk, &tail_blk)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003736 return error;
3737
3738 if (tail_blk != head_blk) {
3739 /* There used to be a comment here:
3740 *
3741 * disallow recovery on read-only mounts. note -- mount
3742 * checks for ENOSPC and turns it into an intelligent
3743 * error message.
3744 * ...but this is no longer true. Now, unless you specify
3745 * NORECOVERY (in which case this function would never be
3746 * called), we just go ahead and recover. We do this all
3747 * under the vfs layer, so we can get away with it unless
3748 * the device itself is read-only, in which case we fail.
3749 */
Utako Kusaka3a02ee12007-05-08 13:50:06 +10003750 if ((error = xfs_dev_is_read_only(log->l_mp, "recovery"))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751 return error;
3752 }
3753
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003754 xfs_notice(log->l_mp, "Starting recovery (logdev: %s)",
3755 log->l_mp->m_logname ? log->l_mp->m_logname
3756 : "internal");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003757
3758 error = xlog_do_recover(log, head_blk, tail_blk);
3759 log->l_flags |= XLOG_RECOVERY_NEEDED;
3760 }
3761 return error;
3762}
3763
3764/*
3765 * In the first part of recovery we replay inodes and buffers and build
3766 * up the list of extent free items which need to be processed. Here
3767 * we process the extent free items and clean up the on disk unlinked
3768 * inode lists. This is separated from the first part of recovery so
3769 * that the root and real-time bitmap inodes can be read in from disk in
3770 * between the two stages. This is necessary so that we can free space
3771 * in the real-time portion of the file system.
3772 */
3773int
3774xlog_recover_finish(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003775 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776{
3777 /*
3778 * Now we're ready to do the transactions needed for the
3779 * rest of recovery. Start with completing all the extent
3780 * free intent records and then process the unlinked inode
3781 * lists. At this point, we essentially run in normal mode
3782 * except that we're still performing recovery actions
3783 * rather than accepting new requests.
3784 */
3785 if (log->l_flags & XLOG_RECOVERY_NEEDED) {
David Chinner3c1e2bb2008-04-10 12:21:11 +10003786 int error;
3787 error = xlog_recover_process_efis(log);
3788 if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003789 xfs_alert(log->l_mp, "Failed to recover EFIs");
David Chinner3c1e2bb2008-04-10 12:21:11 +10003790 return error;
3791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003792 /*
3793 * Sync the log to get all the EFIs out of the AIL.
3794 * This isn't absolutely necessary, but it helps in
3795 * case the unlink transactions would have problems
3796 * pushing the EFIs out of the way.
3797 */
Christoph Hellwiga14a3482010-01-19 09:56:46 +00003798 xfs_log_force(log->l_mp, XFS_LOG_SYNC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003799
Christoph Hellwig42490232008-08-13 16:49:32 +10003800 xlog_recover_process_iunlinks(log);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003801
3802 xlog_recover_check_summary(log);
3803
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003804 xfs_notice(log->l_mp, "Ending recovery (logdev: %s)",
3805 log->l_mp->m_logname ? log->l_mp->m_logname
3806 : "internal");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807 log->l_flags &= ~XLOG_RECOVERY_NEEDED;
3808 } else {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003809 xfs_info(log->l_mp, "Ending clean mount");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003810 }
3811 return 0;
3812}
3813
3814
3815#if defined(DEBUG)
3816/*
3817 * Read all of the agf and agi counters and check that they
3818 * are consistent with the superblock counters.
3819 */
3820void
3821xlog_recover_check_summary(
Mark Tinguely9a8d2fd2012-06-14 09:22:16 -05003822 struct xlog *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003823{
3824 xfs_mount_t *mp;
3825 xfs_agf_t *agfp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003826 xfs_buf_t *agfbp;
3827 xfs_buf_t *agibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003828 xfs_agnumber_t agno;
3829 __uint64_t freeblks;
3830 __uint64_t itotal;
3831 __uint64_t ifree;
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003832 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833
3834 mp = log->l_mp;
3835
3836 freeblks = 0LL;
3837 itotal = 0LL;
3838 ifree = 0LL;
3839 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
From: Christoph Hellwig48056212008-11-28 14:23:38 +11003840 error = xfs_read_agf(mp, NULL, agno, 0, &agfbp);
3841 if (error) {
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003842 xfs_alert(mp, "%s agf read failed agno %d error %d",
3843 __func__, agno, error);
From: Christoph Hellwig48056212008-11-28 14:23:38 +11003844 } else {
3845 agfp = XFS_BUF_TO_AGF(agfbp);
3846 freeblks += be32_to_cpu(agfp->agf_freeblks) +
3847 be32_to_cpu(agfp->agf_flcount);
3848 xfs_buf_relse(agfbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003851 error = xfs_read_agi(mp, NULL, agno, &agibp);
Dave Chinnera0fa2b62011-03-07 10:01:35 +11003852 if (error) {
3853 xfs_alert(mp, "%s agi read failed agno %d error %d",
3854 __func__, agno, error);
3855 } else {
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003856 struct xfs_agi *agi = XFS_BUF_TO_AGI(agibp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003857
Christoph Hellwig5e1be0f2008-11-28 14:23:37 +11003858 itotal += be32_to_cpu(agi->agi_count);
3859 ifree += be32_to_cpu(agi->agi_freecount);
3860 xfs_buf_relse(agibp);
3861 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003862 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003863}
3864#endif /* DEBUG */